Matt Sutherlin

Around this time, summer school was wrapping up and I got pretty busy prepping for all of my finals and projects due at the end of the semester.  Unfortunately, that also meant that there wasn’t a lot of graphics work getting done at the time.  The big update here is that these pyramids are a mesh that I built in Max and exported through the FBX conversion pipeline that I wrote for our engine.  Each pyramid is 8k polys, and there are a lot of them in the scene.

This image was taken on 8/14/12.

GoodGraphics06.png, terribly high polycount models exported from Max.

This is a big jump from the previous image.  Here, we built a plane of cubes and then applied sin waves to it to create ripples.  Additionally, the whole thing used a very primitive spatial partitioning so that we could group uniform sections of the plane into cells and perform operations on all objects in the cell together.  The simple test was to have an inner and outer culling radius; when a cell hit the inner culling radius all objects in it turned wireframe and then were culled completely upon reaching the outer culling radius.

Some notable updates on the purely graphics side of it was that models were finally being loaded in from files (albeit files that I had to construct by hand), and the camera was improved enough to give rotational control as well as the already existing translational control.  Also, it was the very primitive start of a DirectX state management system that gave the ability to switch individual models to wireframe and back.  Most importantly, depth buffering finally worked.

This image was taken on 7/24/12.

GoodGraphics05.png, fun with math and spatial partitioning.

With the success of getting a textured 3D model into the engine, I thought I’d have some fun with it at this point.  Fun is apparently building a huge cube of cubes.  This is a 20x20x20 stack of cubes, built to test that I could actually handle more than a single object in the engine and to start doing a little stress testing.  You’ll notice that I hadn’t gotten the depth buffer fully functioning yet, producing a really weird screen capture.  All mesh data was still hardcoded, but the camera was improved enough to be able to back out enough to capture the whole scene.  But not improved enough to be able to pan around it.  Go figure.

This image was taken on 7/14/12.

GoodGraphics04.png, a lot of textured cubes with no depth buffering.

The next step was to add texturing to my 3D cube.  I took a texture we had used in my 2D game the previous year (if you ever played Coalescence, you’ll recognize it as the solid element) and put that on every face.  Literally the simplest UV unwrapping I could do.  Also, all of the mesh data was still hardcoded.  And the camera was still terrible.

This image was taken on 7/11/12.

GoodGraphics03.png, a simple textured cube.

The second step in building my DX11 graphics engine was to move from drawing an untextured quad to drawing an untextured model.  Pretty exciting stuff!  The camera at this point was so primitive that this was the best capture I could take that actually showed the 3D nature of the cube. Also, I’m pretty sure that all of the mesh data was hardcoded at this point.

This image was taken on 7/10/12.

GoodGraphics02.png, a simple untextured cube.