bobbias

Members
  • Content count

    134
  • Joined

  • Last visited

Community Reputation

120 Neutral

About bobbias

  • Rank
    Member
  1. Moving on with Java

    It's actually a GIGANTIC pain to find anything showing you modern OpenGL :/ I had a hard time finding too much useful code. [url="http://www.lwjgl.org/wiki/index.php?title=Using_Vertex_Buffer_Objects_(VBO)"]http://www.lwjgl.org/wiki/index.php?title=Using_Vertex_Buffer_Objects_(VBO)[/url] This should give you an idea of modern opengl. lwjgl is pretty much the same as using opengl in C++ (there are a few differences, but overall the API is about as close as you can get in java). The biggest thing about using modern opengl is that you need to do all your matrix manipulation yourself, and if you don't supply it with custom shaders, it'll fall back on the fixed pipeline to render things (which is bad, since fixed pipeline is not modern opengl).
  2. Attack Scripting?

    You could create an XML based system. There are plenty of XML tools available (meaning you won't have to write your own parser) and it's pretty trivial to write something to extract your information from the XML.
  3. SDL simple rotation?

    I just wanted to point out that you really should learn how rotation matrixes work, if you haven't already. It's really handy to understand how they work (especially if you plan on moving to 3D in the future).
  4. [quote name='jefferytitan' timestamp='1339735309' post='4949430'] Hmmm, it could be generation on-demand, it could be bad LOD code, or it could be no LOD (e.g. rendering a squillion polygon planet when you are in space). [/quote] Yeah, I was just trying to point out that if it's slowing down that badly, there's something wrong with what he's doing. I can understand something like a temporary slowdown for on-demand generation, but a permanent slowdown would suggest no LOD or bad LOD code, both of which are a bad idea and should be dealt with. I was trying to point out that there's no good reason for procedurally generated planets to permanently slow the game down like that.
  5. 3D model format nightmare

    There are quite a few benefits to writing your own format. You can reduce space y not including things you don't need or can generate on the fly. You don't need to wrap your head around some other format. You don't need to rely on code someone else wrote which may or may not work properly. There are downsides, but I'd say those don't outweigh the benefits. Of course, the other benefit is that it's even harder for someone to mess with your assets (assuming you're releasing as a commercial game). It's certainly not impossible to map someone's custom object format, but it's certainly harder than when your assets are in a well known format (this does make modding harder though). [url="http://www.gamedev.net/page/resources/_/technical/apis-and-tools/how-to-write-a-simple-maya-model-exporter-r1906"]http://www.gamedev.net/page/resources/_/technical/apis-and-tools/how-to-write-a-simple-maya-model-exporter-r1906[/url] might be useful.
  6. What are you doing that would cause the FPS to drop like that? The planet should be procedurally generated once, or once per increase in LOD, not every frame or anything crazy like that.
  7. Creating a camera class

    The best choice is to avoid the org.lwjgl.util classes and go with the vector classes from javax.vecmath which is part of the java3d package. The lwjgl util package is slated for removal because the vector and matrix classes there are crippled compared to those defined in the javax.vecmath package. Most of the time you'll be passing either float arrays or FloatBuffers to lwjgl functions anyway, vector2f/vector3f etc. are really just used for convenience.
  8. Spaceship Movement

    VBLab, quaternions solve a number of problems, and if you have a working implementation you can actually treat them as a black box object that just does what you need it to do. It's not hard to construct a rotation matrix on the fly form a quaternion, even by hand. The problem that quaternions solve is [url="http://en.wikipedia.org/wiki/Gimbal_lock"]http://en.wikipedia.org/wiki/Gimbal_lock[/url] which can cause your movements to end up not working correctly.
  9. How viable is Java for GameDev?

    [quote name='argoneus' timestamp='1338896480' post='4946397'] I see. How is Slick2D? [/quote] I've been dabbling with lwjgl and slick2d lately. For lwjgl it' basically the same thing as writing opengl code for C++. Slick2D is written on top of lwjgl and provides a nice way to create 2D games. From what I can tell Slick2D is a pretty damn good library. Another library you might want to look into is [url="http://twl.l33tlabs.org/"]TWL[/url] for creating some GUI elements.
  10. Reducing Bitmap Object size

    There's also the option of using his own compression on a normal BMP file. Huffman coding would likely provide decent compression compared to RLE, and is not terribly difficult to program.
  11. Where do i start :(

    Object Oriented Programming refers to the way of using the language. For instance, you can get away with programming an entire program inside your main function in C# without ever using another class. That would still be procedural programming, despite the fact that C# is object oriented. What he means is that you need to understand the concepts of objects, inheritance, etc. Do you know what it means that something is an object? Do you understand inheritance? If you don't know what those mean, you should go read up about that before you go further. As for linear algebra, think about this. When you draw things to the screen in 2D, your you need to describe where things are on the screen. To do that you need to understand cartesian coordinates. Here's an example of where you need to know linear algebra: You have a ball being drawn on the screen in 2D. You want to make that ball move on an angle that isn't just up/down or left/right. Say the ball needs to move at a degree angle up and to the right. You need to know how to convert an angle and a distance to the X/Y coordinates on the screen that the ball will end up.
  12. Like everyone's said, technically, it is possible. You could figure out how your driver communicates with the DirectX or OpenGL and write your own API to handle the driver calls, but it's largely pointless, because it would be a MASSIVE project, and I can guarantee your code would be a worse library than either OpenGL or DirectX
  13. [quote name='BornToCode' timestamp='1337047893' post='4940268'] It is all about concepts. Once you know the concept an Api is just an Api. [/quote] Agreed. I'm learning opengl because I want to write games that are capable of being played on many different platforms, but I suppose that once I've really gotten a grasp on the fundamentals, a switch over the D3D shouldn't be too difficult.
  14. I'm working on a game in Java using lwjgl for opengl. I'm working on designing my general "model" representation and I'm stuck trying to decide how I want to represent the heading/velocity of a model. Opengl uses Cartesian coordinates, but I' wondering if there's any reason I should store the model information natively as spherical coordinates... I can't figure out the pros and cons to it. So I guess what I'm asking is, how does everyone else store the heading/velocity data for your models and why do you store it that way?
  15. OpenGL Streaming image to a texture?

    You might want to look into using the GPU for the raycasting. You can accelerate that sort of thing by a massive amount using the GPU for your heavy lifting. On something like this it's not like raycasting on the GPU is going to be cutting into other GPU accelerated stuff. I just did a quick search and saw this: [url="http://www.daimi.au.dk/~trier/?page_id=98"]http://www.daimi.au.dk/~trier/?page_id=98[/url] Not entirely the same thing, but probably helpful. Some googling provides these links: [url="http://www.cg.tuwien.ac.at/hostings/cescg/CESCG-2005/papers/VRVis-Scharsach-Henning.pdf"]http://www.cg.tuwien.ac.at/hostings/cescg/CESCG-2005/papers/VRVis-Scharsach-Henning.pdf[/url] [url="http://www.virtualglobebook.com/3DEngineDesignForVirtualGlobesSection43.pdf"]http://www.virtualglobebook.com/3DEngineDesignForVirtualGlobesSection43.pdf[/url] [url="http://www.it.ubi.pt/17epcg/Actas/artigos/17epcg_submission_8.pdf"]http://www.it.ubi.pt/17epcg/Actas/artigos/17epcg_submission_8.pdf[/url] No idea how useful these would be, but there might be some techniques in those that help.