3D Game Engine Using DirectX11 (C++)


This piece of work is what I’m most proud of this semester; it is also one of the projects I had the most fun working on; and because of that, I am currently building upon it and plan to continue over the summer. This is the first time I have ever used a 3D engine, or attempted building my own framework.


Framework

The engine uses a scene graph to handle the objects in the scene; once the user creates one of the nodes and adds it to the graph, the Initialisation, Updating and Rendering is handled in the underlying framework. I tried to make it so that the user would be able to simply add something to the scene, whilst maintaining as much control as possible. The user is able to create and add a node using 2 lines of code; this then adds the object to the scene graph and everything is handled in the under lying code, the result of this code would load, update and render that object onto the window.

The Renderer is what I’ve used as the main DirectX interface; it handles all the shaders, rasteriser states and drawing itself. The other objects then build a vertex, index buffer and the other required information, which is then sent to the renderer and drawn on screen. Lighting and the view matrix is also handled here.

Models

 To load in a model, a secondary resource manager is used; this loads the textures and meshes into a container and given a Resource ID which is held by the object. This is to avoid loading in the same mesh or texture multiple times. In order to load in models, I have used ASSIMP library (http://assimp.sourceforge.net/ ) which loads the model files into the resource manager. Once the mesh is loaded in, the model objects then can be drawn to the screen.

A Skydome class (which can be essentially any model), inherits from model ,which moves with the camera.

Terrain

 Terrain is another main aspect of the engine; firstly a grid of quads are generated and an index and vertex buffer is created from that grid. Then, depending on the user specification, the terrain can be loaded in from a height map; or the terrain can be procedurally generated using a number seed. At the same time, a texture can be loaded in to encompass the entire mesh. The method I used for the terrain generation is Perlin Noise (more info can be found here http://freespace.virgin.net/hugo.elias/models/m_perlin.htm ).


Camera and Controls 

 I am using a first person camera which uses the method found here (http://www.braynzarsoft.net/index.php?p=D3D11FPC ). It handles the Yaw, Pitch and Roll axis and then builds a look at vector based on those values and the cameras position.

The camera in the demo uses both keyboard controls and a games for windows live controller; to use this I had to include the XINPUT Api.

Collision

The collision is handled fairly poorly admittedly and is definitely something I need to improve upon. Currently, only a model or something that inherits from model can be checked for collision. There are three levels of bounding; None, Sphere or Box (the box actually uses both a sphere and box, hence the reason I’m unhappy with it). I generate the bounding shapes using the “DirectXBoundingVolumes” class which is shipped with DirectX11.1; it seemed a waste to re-write a class I already had available.

The user can then use a “SetColliable” function which then stores a pointer to the model in a container. Then every update, we retrieve the spheres using the pointers, and test them against one another; then, if it is returned true, the boxes are checked, provided they have been built. An over writable method is then called for the user to implement.


If you would like any more information regarding the engine, please feel free to contact me!

Comments

Post a Comment

Popular posts from this blog

MIPS Graphics Library

Image
The reason for this task is twofold: first it helped show me show much work the processor had to do to display a simple shape on the screen; it also taught me memory management. The program was written in MARS virtual environment, and uses the Bitmap display to give a visual representation of the code. Each method uses 4 memory addresses to pass parameters, if any more are needed then they are sent to the stack.  The “SetPixel” method is the simplest, it takes the X, Y and colour of the pixel – calculates it position on the screen and then stores the colour into the memory address into the location where the screen gets its information.  The “DrawLine” method uses Bresenham’s Line algorithm. It takes a start point and end point of the line as parameters, as well as the colour. It then works out the gradient of the line, plots the first pixel, and then adds the gradient again to get to the next pixel. This repeats until it has reached the second point. The “Dr...
Read more

3D Renderer (C++)

Image
This is a 3D renderer that I wrote in C++ to load in and display “.md2” files, a fairly old format but a good basis into understanding graphics programming. An “.md2” file merely a list of vertices based around an origin, and a set of 3 integers which is loaded in as a polygon. A polygon contains 3 indexes, each point to a vertex in a list, contained within the model. This means that if a vertex is used more than once, it won’t be duplicated. The program started off with “Vertex” and “Matrix” classes which held the instructions to multiply them together; this is the basis of transforming and viewing the vertices on the screen. Once we had these, we could implement the full viewing pipeline, using perspective projection. And after this we could visually display these points on screen. To begin with I focused more on transformations and camera positioning whilst I had the points showing in world space. To visually show the model I made a “DrawWireFrame” method which drew lines...
Read more