Expanding our BasicModel Class

Refresher on GeometryGenerator

If you are new to this series of posts, or simply have forgotten, way back in July, when we had yet to even cover lighting, we created a utility class to generate mesh geometry for some common 3D solids.  This class had functions to create a 3D boxes, spheres, cylinders and cones, and 2D grids.  The definition, stripped of all the implementation, looked like this:

public class GeometryGenerator {
    public static MeshData CreateBox(float width, float height, float depth)
    public static MeshData CreateSphere(float radius, int sliceCount, int stackCount)
    public static MeshData CreateCylinder(float bottomRadius, float topRadius, float height, int sliceCount, int stackCount)
    public static MeshData CreateGrid(float width, float depth, int m, int n)
}

The MeshData class here is simply a container for a list of vertices and a list of indices. The functions used the mathematical formulas for the solids to generate position, normal, texture and tangent coordinates, along with the indices to triangulate the meshes.  Until now, we have been using this class to generate our geometry, and then we have had to handle creating vertex and index buffers for the geometry, so that we can submit them for rendering.  Generally, this means that we also have to keep track of the number of indices, number of vertices, materials, textures, and world matrices for each mesh that we create in this way.  Additionally, we have usually slammed all of our different mesh data into a single vertex and index buffer pair, so that we also have to keep track of the starting offsets for each object as well.  Thus we end up with a bunch of member variables in our example programs to represent each object, like so:

// All for our central box mesh
private Buffer _shapesVB;
private Buffer _shapesIB;
private ShaderResourceView _stoneTexSRV;
private readonly Material _boxMat;
private readonly Matrix _boxWorld;
private int _boxVertexOffset;
private int _boxIndexOffset;
private int _boxIndexCount;

That’s not great, and I’m sick of copying all this junk, along with the code to create the buffers, and to set all the shader variables and render these objects.  Our BasicModel class handles all of this stuff, so we might as well take advantage of it.

BuildFromMeshData()

All of the GeometryGenerator methods return us a MeshData object.  The process that we will use to transform this MeshData into a BasicModel is the same, regardless of whether the mesh is a sphere, box or cone, so we will factor it out into a helper function, BuildFromMeshData(). 

private static BasicModel BuildFromMeshData(Device device, GeometryGenerator.MeshData mesh) {
    var ret = new BasicModel();

    var subset = new MeshGeometry.Subset {
        FaceCount = mesh.Indices.Count / 3,
        FaceStart = 0,
        VertexCount = mesh.Vertices.Count,
        VertexStart = 0
    };
    ret._subsets.Add(subset);
            
    var max = new Vector3(float.MinValue);
    var min = new Vector3(float.MaxValue);
    foreach (var vertex in mesh.Vertices) {
        max = Vector3.Maximize(max, vertex.Position);
        min = Vector3.Minimize(min, vertex.Position);
    }

    ret.BoundingBox = new BoundingBox(min, max);
            
    ret._vertices.AddRange(mesh.Vertices.Select(v => new PosNormalTexTan(v.Position, v.Normal, v.TexC, v.TangentU)).ToList());
    ret._indices.AddRange(mesh.Indices.Select(i => (short)i));

    ret.Materials.Add(new Material { Ambient = Color.Gray, Diffuse = Color.White, Specular = new Color4(16, 1, 1, 1) });
    ret.DiffuseMapSRV.Add(null);
    ret.NormalMapSRV.Add(null);

    ret._modelMesh.SetSubsetTable(ret._subsets);
    ret._modelMesh.SetVertices(device, ret._vertices);
    ret._modelMesh.SetIndices(device, ret._indices);

    return ret;
}

Our first step is to create a Subset for the entire mesh, and add it to the newly created Model. Next, we calculate the extents of the mesh geometry and construct a BoundingBox enclosing the mesh. After that, we transform the MeshData vertex and indices into the format used by the BasicModel, and set the respective collections of the Model.

Next, we add a default, white material, and null diffuse and normal maps. Remember, these properties are public, so we can assign different materials and textures later if we need to (and, in fact, if you are using our NormalMap effect, you must replace this null normal map, or else you get odd results…).  Lastly, we initialize the Model’s MeshGeometry object, creating the subset table, vertex buffer and index buffer, and return the constructed BasicModel.

Factory Methods – CreateBox, CreateSphere, CreateCylinder, CreateGrid

With the BuildFromMeshData function factored out, our factory methods become very simple.  All we need to do is call the appropriate GeometryGenerator function to create the mesh data, and then return the Model created by the helper function.

public static BasicModel CreateBox(Device device, float width, float height, float depth) {
    var box = GeometryGenerator.CreateBox(width, height, depth);
    return BuildFromMeshData(device, box);
}
public static BasicModel CreateSphere(Device device, float radius, int slices, int stacks) {
    var sphere = GeometryGenerator.CreateSphere(radius, slices, stacks);
    return BuildFromMeshData(device, sphere);
}
public static BasicModel CreateCylinder(Device device, float bottomRadius, float topRadius, float height, int sliceCount, int stackCount) {
    var cylinder = GeometryGenerator.CreateCylinder(bottomRadius, topRadius, height, sliceCount, stackCount);
    return BuildFromMeshData(device, cylinder);
}
public static BasicModel CreateGrid(Device device, float width, float depth, int xVerts, int zVerts) {
    var grid = GeometryGenerator.CreateGrid(width, depth, xVerts, zVerts);
    return BuildFromMeshData(device, grid);
}

ShapesModelDemo

The advantage of using our new BasicModel factory methods is primarily in how much shorter and clearer our code becomes.  Our initialization and drawing code is markedly shorter, and our demo class has much less state that it needs to handle directly.

Our Init() method for this demo is much more straightforward, even with the addition of non-default materials and textures:

public override bool Init() {
    if (!base.Init()) return false;
    Effects.InitAll(Device);
    InputLayouts.InitAll(Device);
    RenderStates.InitAll(Device);

    _texMgr = new TextureManager();
    _texMgr.Init(Device);


    _gridModel = BasicModel.CreateGrid(Device, 20, 20, 40, 40);
    _gridModel.Materials[0] = new Material() { Diffuse = Color.SaddleBrown, Specular = new Color4(16, .9f, .9f, .9f)};
    _gridModel.DiffuseMapSRV[0] = _texMgr.CreateTexture("Textures/floor.dds");
    _gridModel.NormalMapSRV[0] = _texMgr.CreateTexture("textures/floor_nmap.dds");
            
    _boxModel = BasicModel.CreateBox(Device, 1, 1, 1);
    _boxModel.Materials[0] = new Material() { Ambient = Color.Red, Diffuse = Color.Red, Specular = new Color4(64.0f, 1.0f, 1.0f, 1.0f)};
    _boxModel.NormalMapSRV[0] = _texMgr.CreateTexture("Textures/bricks_nmap.dds");

    _sphereModel = BasicModel.CreateSphere(Device, 1, 20, 20);
    _sphereModel.Materials[0] = new Material() { Ambient = Color.Blue, Diffuse = Color.Blue, Specular = new Color4(64.0f, 1.0f, 1.0f, 1.0f)};
    _sphereModel.NormalMapSRV[0] = _texMgr.CreateTexture("Textures/stones_nmap.dds");

    _cylinderModel = BasicModel.CreateCylinder(Device, 1, 1, 3, 20, 20);
    _cylinderModel.Materials[0] = new Material() { Ambient = Color.Green, Diffuse = Color.Green, Specular = new Color4(64.0f, 1.0f, 1.0f, 1.0f)};
    _cylinderModel.NormalMapSRV[0] = _texMgr.CreateTexture("Textures/stones_nmap.dds");

    _grid = new BasicModelInstance() {
        Model = _gridModel, TexTransform = Matrix.Scaling(10, 10, 1),
        World = Matrix.Identity
    };

    _box = new BasicModelInstance() {
        Model = _boxModel,
        World = Matrix.Translation(-3, 1, 0)
    };

    _sphere = new BasicModelInstance() {
        Model = _sphereModel,
        World = Matrix.Translation(0, 1, 0)
    };

    _cylinder = new BasicModelInstance() {
        Model = _cylinderModel,
        World = Matrix.Translation(3, 1.5f, 0)
    };
            
    return true;
}

Likewise, our DrawScene() method nearly becomes trivial, when we are able to leverage the BasicModelInstance Draw() function.

public override void DrawScene() {
    ImmediateContext.ClearRenderTargetView(RenderTargetView, Color.Silver);
    ImmediateContext.ClearDepthStencilView(DepthStencilView, DepthStencilClearFlags.Depth | DepthStencilClearFlags.Stencil, 1.0f, 0);

    var viewProj = _camera.ViewProj;

    Effects.NormalMapFX.SetDirLights(_dirLights);
    Effects.NormalMapFX.SetEyePosW(_camera.Position);

    var floorTech = Effects.NormalMapFX.Light3TexTech;
    var activeTech = Effects.NormalMapFX.Light3Tech;

    ImmediateContext.InputAssembler.InputLayout = InputLayouts.PosNormalTexTan;
    ImmediateContext.InputAssembler.PrimitiveTopology = PrimitiveTopology.TriangleList;

    if (Util.IsKeyDown(Keys.W)) {
        ImmediateContext.Rasterizer.State = RenderStates.WireframeRS;
    }

    for (int p = 0; p < activeTech.Description.PassCount; p++) {
        var pass = activeTech.GetPassByIndex(p);
        _box.Draw(ImmediateContext, pass, viewProj);
        _sphere.Draw(ImmediateContext, pass, viewProj);
        _cylinder.Draw(ImmediateContext, pass, viewProj);
    }
    for (int p = 0; p < floorTech.Description.PassCount; p++) {
        var pass = activeTech.GetPassByIndex(p);
        _grid.Draw(ImmediateContext, pass, viewProj);
    }
    SwapChain.Present(0, PresentFlags.None);
    ImmediateContext.Rasterizer.State = null;
}

Next Time…

We really will move on to shadow mapping…