My First Homemade 3D Engine

Way back in late 2017, I wanted to start working on 3d games. I downloaded unity and couldn’t navigate the UI, so my very next idea was to simply build a game engine from scratch. And why not, right?

I was familiar with c++ since that’s the language that came default with Visual Studio and I had been using SFML for 2D for ~2 years at that point, so I decided how hard would it be to add one measly little dimension - well, read more to find out!

First, a history of my fascination with the third dimension

After taking a java class in school around the same time I had been playing wolfenstein 3d, I figured I knew enough to try out a similar game, so I started googling. At this point, I hadn’t learned vectors yet (or any really fancy math), so I had to stick to algebra and geometry to get me through. My approach was to draw a grid in mspaint (where each color corresponded to a different type of wall or empty space), then I would read in the bitmap and use that as - well - a map.

Shooting out 320 high resolution light rays from the camera, I get the distance to the wall (which tells us its height), and using a crude texture sampler, draw in a wall slice. [I would show the notebook diagrams, but those are long gone]

Eventually, I added object sprites. These would always point at the camera (not just a nod to the classic fps - a limit of my technical skill :P )

Not satisfied with having to manually draw every little thing, I began my long relationship with random generation. Believe me, I use random levels whenever possible.

BEHOLD MY FIRST RANDOM LEVEL GENERATOR

(Yellow is the vision cone - kinda like a flashlight!)

It’s not much, but at the time I was super happy with it. You just hit run, a tiny automaton runs around randomly clearing walls and out pops a level. My friend told me about some neighbor count pruning to clean up noise and there it is. [unfortunately these are the only screen shots I have, since I lost access to my school computer and didn’t make backups]

[I’ll come back and fill this in with more example/explanation if I ever stumble across some more]

So by this time, I had a functional 2.5D tech demo and wanted to do more. (At this point, I was gonna make a 2.5D nuclear throne because that was my favorite game - you can probably notice the influence in a lot of my stuff if you look)

Back to the main feature - real red-blooded 3D!

So around late 2017/early 2018 I wanted to try my hand at 3D. I was playing quake and felt confident I could hack something similar together (first wolf3d, now quake, in… 15 years catch me remaking a doom 3 clone)

I was kinda (not very) familiar with graphics from using SFML, so googling about opengl brought up myriad tutorials and stackoverflow posts. I started following the tutorials, whack-a-mole-ing bugs as they came up. It was super basic (and looking back it was based on old legacy opengl anyway), but I got it to work!!!

This was one of the earliest 3D scenes I ever made. Just a simple castle on a hill - but it was so awesome to see it. If you notice the shading looks off, that’s because I didn’t have a light source; I used the angle to the player to shade the entire face. So the face has a normal, and based on that normal it would shade the face. (If I remember correctly I was doing all of this on the CPU and sending shaded triangles to the GPU to draw)

Some more screenshots of the early early 3D stuff. The left shows a debug mode where it draws wire-frame with normals

This was my first ever game in 3D. It was a random maze (See I told you it would be back). I got a mini-map (actually using SFML for that part), and a sci-fi blaster (that’s what that’s supposed to be) As you can see, it’s very bare bones with not too pleasant lighting. So further reading and further coding I improved a little.

I made a more advanced level generator for this one. It would make many rooms using the random-walk algorithm from the java days, but then connect them together with hallways. I was attempting to give more structure so that I could better put enemy and object placement (remember I was still trying to make a nuclear throne clone)

I added texture and uv support (although I was just starting out with texturing) [Also, that design is pretty similar to my current sci-fi jumpsuit chacater]

The above two images show one of my earliest bugs in 3D programming (the first of many… many)

I spent like two days trying to debug the thing, until I gave up and started from the top of the algorithm and walked through. It was within 5 minutes of reading the algorithm that I found I had a buffer offset issue. My frustration with myself - unimaginable.

Here is a collection of other screenshots from the early period

Some other interesting tid-bits about this engine - I swicthed from using textures to using color because it’s hard to uv unwrap and paint textures. So that’s why some of the models are just solid color instead of textured. [in fact, it wasn’t until very, very recently that I started texturing - I’ve been running with the colored models for a while]

Another thing I tried was to have console commands to build a scene. I wrote a basic scripting language, a parser, and a way to add/manipulate primitives. The tree and red/green temple thing were both made using console commands. This proved tedious so I abandoned it, but it was still pretty fun.

Some techy stuff

At this point in the project, the player was a floating camera that could simply go through walls - not very realistic.

So like any good programmer who’s looking to reinvent the wheel, I started researching how doom and quake handled collisions. This led me down the rabbit hole of binary space partitioning (BSP). BSP is basically, you take a face and then loop over all the other faces in a scene and put them behind or in front of the splitting face to create a tree.

These are diagrams I wrote back in early 2018 to understand the process of binary space partitioning. This is 2D analogs, but the process is more or less the same for 3D

This took me a long time to debug and get working right, but once I got it, I was so happy!

This is just a cool screenshot I took while debugging the BSPs. I wanted to see what the actual triangle planes looked like so I could see how they were getting sliced.

The part where it gets cool

This bunker was entirely procedurally made - my goal was to make a 3D doom like game with self-building levels.

My algorithm for this was to build a bunch of room, then manually label where all the doors where. Then the algorithm would pick a random room, then try to add more rooms onto all the available doors. It would then push all the newly added doors to a queue. I had to do bounding box overlap tests to make sure no rooms intersected.

An example room - this is the big round one

This was really cool, but I wanted to add keys like in doom 2

So I wrote a program to automatically place doors, then place a key, all while making sure it was actually solvable

This is one of the larger maps it generated. Each circle is a doorway and the lines connect them together. Every doorway has a color code that shows which key/door color it is locked behind. The colors also stack. So for instance, the light blue is stacked on top of white - you need the white key and then the blue key

This was a pretty complex algorithm (especially since I hacked it together and didn’t know any best practices) [note: still don’t know the best practices]

All the code should be in my github under the project “3d_2”

A more complex scene I made in blender imported directly into the game engine

That’s about the end of the line for my first 3D game engine. I did try to add portals, but I can’t find the video of it (not the last time I’ll try to make portals)

I really had fun with this project - I was extremely in the deep end (having to learn opengl, research binary space partitions, mess around with matrix math until it worked, etc.) But I really got a good grasp of the principles.

I’ve remade a c++/opengl engine several times by now, but they’re all iterations on this first one. Even now when I’m working on unity, I understand the behind-the-scenes stuff so I can better utilize the systems.

My First Homemade 3D Engine

Learning to Art