• Advertisement
Sign in to follow this  
  • entries
  • comments
  • views

New Journal, Old Project, Present State.

Sign in to follow this  


Hello Everyone!

I started over my journal entries based on many things, but mainly this: I have recently altered my view on what I enjoy doing. I thought I wanted to make full-fledged game (and I do!) but the inner workings of things behind the scenes and closer to the metal has drawn me in more than anything else. I enjoy taking things apart, figuring out how they work, and putting it all back together in my own way.

My journey through programming games and computer graphics in general has been an interesting one; I've seemingly worked my way form the bottom up rather than the top down. My first program was a 2.5D game, much like DOOM (Yay raycasting!). From there, I focused on 3D programming techniques and created some 3D software renderers. I even created some terrain editors using those renderer's, and learned a lot about what goes on in the GPU.

After that, I moved on to using OpenGL and began looking into making a voxel game. This has been me for the past year and a half or so, and it's been amazing! I've learned a lot on pushing a ton of data to the GPU, dealing with simplified physics and collision detection, and work with existing engines (JMonkeyEngine and Unity) in order to see how it all comes together.

Lately, I've been delving deep into the issues I've had with these engine's I've used. As nice as they've been to get off my a** and get some decent work going, they also set some limitations to the work that I've been trying to do. As I've worked deeper into why that is and what needs to be done to fix the problem for myself, I learned more and more that I don't truly understand what goes on under the hood, and I wanted to understand it all. As a lesson to myself, I thought it would be good to try to do it myself -- learn about it all, put it all together, and more importantly, rely on others only for code that I already truly understand and write everything I don't understand. Therefore I set off on my quest to start a game engine. This wasn't without doubts, however. I've focused on my other work and started this project on the side; and only now am I sure that this is something that can be completed, something I can follow through on.

Now let's get to the meat:

Third Party Libraries:

  • libPNG and other simple I/O libraries

  • GLFW for window, context, and input management

  • OpenGL for rendering with the GPU

  • GLEW for handling OpenGL version issues

  • GLM for vectors, matrices and math

    With that, I started designing the layout of the engine, based off of the current and past engine's I've used, and the plethora of reading I've done over the past four years. I decided to do a component-based design, all connected through a multi-threaded event system. I broke down the structure into the following parts:

    Game Engine Structure:

    • Core - The core functionality of the engine. Math, System, Logging, Input, etc.

    • Rendering - Window and OpenGL management, as well as culling, shaders, effects, and anything else connected to rendering.

    • Physics - Adding functionality to a game to make it more realistic. This can include collision, gravity, force and moment generation, etc.

    • Game - This isn't a game engine component, but an actual game! This is helpful for testing and prototyping engine parts before adding it to the engine.

      Something not included here is external modules I'll make as I'm working on stuff; for example, I've created a Voxel external module for the voxel work I'm doing, and this allows others to reuse that module if they also want to make a voxel game -- like an engine, but not core to ALL games. These external modules fit better with certain genres.

      And with this general structure, I began work! I'm now about 6 months into this engine build, and I've got many of the core systems fleshed out. I created the bare bones for the Rendering Engine and the Core Engine, and the voxel/game portion is already rendering a world onto the screen that the player can explore. Currently, I just implemented the EventManager class and with the lambda function capabilities and templated member functions for classes, I've laid the groundwork for an event system capable of handling events and listeners of ANY class -- something I'm very, very happy with. It looks like this for implementation:

      #include #include "EventManager.h"typedef struct Event { int a;} Event;class Listener {public: void operator()(const Event& e) { std::cout << "Event Recieved! A = " << e.a << std::endl; }};void main() { Listener listener; EventManager::register(listener); Event event; event.a = 10; EventManager::fire(event);}// OUTPUT://// >>// >> Event Recieved! A = 10// >>

      In future posts I'll cover more details about the engine; for now, this is a good introduction. I look forward to see where this goes, and I'll be back soon with some posts about the current implementation I've got with the engine!

Sign in to follow this  


Recommended Comments

There are no comments to display.

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now

  • Advertisement