• Announcements

    • khawk

      Download the Game Design and Indie Game Marketing Freebook   07/19/17

      GameDev.net and CRC Press have teamed up to bring a free ebook of content curated from top titles published by CRC Press. The freebook, Practices of Game Design & Indie Game Marketing, includes chapters from The Art of Game Design: A Book of Lenses, A Practical Guide to Indie Game Marketing, and An Architectural Approach to Level Design. The GameDev.net FreeBook is relevant to game designers, developers, and those interested in learning more about the challenges in game development. We know game development can be a tough discipline and business, so we picked several chapters from CRC Press titles that we thought would be of interest to you, the GameDev.net audience, in your journey to design, develop, and market your next game. The free ebook is available through CRC Press by clicking here. The Curated Books The Art of Game Design: A Book of Lenses, Second Edition, by Jesse Schell Presents 100+ sets of questions, or different lenses, for viewing a game’s design, encompassing diverse fields such as psychology, architecture, music, film, software engineering, theme park design, mathematics, anthropology, and more. Written by one of the world's top game designers, this book describes the deepest and most fundamental principles of game design, demonstrating how tactics used in board, card, and athletic games also work in video games. It provides practical instruction on creating world-class games that will be played again and again. View it here. A Practical Guide to Indie Game Marketing, by Joel Dreskin Marketing is an essential but too frequently overlooked or minimized component of the release plan for indie games. A Practical Guide to Indie Game Marketing provides you with the tools needed to build visibility and sell your indie games. With special focus on those developers with small budgets and limited staff and resources, this book is packed with tangible recommendations and techniques that you can put to use immediately. As a seasoned professional of the indie game arena, author Joel Dreskin gives you insight into practical, real-world experiences of marketing numerous successful games and also provides stories of the failures. View it here. An Architectural Approach to Level Design This is one of the first books to integrate architectural and spatial design theory with the field of level design. The book presents architectural techniques and theories for level designers to use in their own work. It connects architecture and level design in different ways that address the practical elements of how designers construct space and the experiential elements of how and why humans interact with this space. Throughout the text, readers learn skills for spatial layout, evoking emotion through gamespaces, and creating better levels through architectural theory. View it here. Learn more and download the ebook by clicking here. Did you know? GameDev.net and CRC Press also recently teamed up to bring GDNet+ Members up to a 20% discount on all CRC Press books. Learn more about this and other benefits here.


  • Content count

  • Joined

  • Last visited

Community Reputation

120 Neutral

About bobbias

  • Rank
  1. 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. 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. 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. 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. 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. 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. [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. 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. 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

    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.