Add mesh rendering

Author: Moneyl

Dependencies/Common

@@ -177,7 +177,7 @@ namespace Nanoforge.Render
             //Blending
             D3D11_BLEND_DESC blend = .();
             ZeroMemory(&blend);
-            blend.RenderTarget[0].BlendEnable = 1;
+            blend.RenderTarget[0].BlendEnable = 0;
             blend.RenderTarget[0].SrcBlend = .SRC_COLOR;
             blend.RenderTarget[0].DestBlend = .BLEND_FACTOR;
             blend.RenderTarget[0].BlendOp = .ADD;

Dependencies/RfgTools

@@ -0,0 +1,86 @@
+using Common;
+using System;
+using RfgTools.Formats.Meshes;
+using Direct3D;
+
+namespace Nanoforge.Render.Resources
+{
+	public class Mesh
+	{
+        public u32 NumLods { get; private set; } = 0;
+        public u32 LodLevel { get; set; } = 0;
+
+        //TODO: Change this to be shareable between mesh instances. Once chunk meshes are added having separate copies of this for each RenderObject will be a serious memory hog (was a problem in the C++ version)
+        private MeshDataBlock _config = null ~DeleteIfSet!(_);
+
+        private append Buffer _vertexBuffer;
+        private append Buffer _indexBuffer;
+        private u32 _numVertices = 0;
+        private u32 _numIndices = 0;
+        private u32 _vertexStride = 0;
+        private u32 _indexStride = 0;
+        private DXGI_FORMAT _indexBufferFormat = .UNKNOWN;
+        private D3D_PRIMITIVE_TOPOLOGY _topology = .D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP;
+
+        public Result<void> Init(ID3D11Device* device, MeshDataBlock config, Span<u8> indexBuffer, Span<u8> vertexBuffer, u32 numLods = 1)
+		{
+            _config = config.Clone(.. new .());
+
+            //Test the current assumption that each lod level has only 1 submesh when multiple lods exist
+            if (numLods != 1)
+                Runtime.Assert(numLods == config.Header.NumSubmeshes);
+
+            _vertexStride = config.Header.VertexStride0;
+            _indexStride = config.Header.IndexSize;
+            _numVertices = config.Header.NumVertices;
+            _numIndices = config.Header.NumIndices;
+            if (config.Header.IndexSize == 2)
+                _indexBufferFormat = .R16_UINT;
+            else if (config.Header.IndexSize == 4)
+                _indexBufferFormat = .R32_UINT;
+            else
+                return .Err; //Unsupported index format
+
+            _topology = .D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP; //Hardcoded since all RFG meshes have used this so far
+            NumLods = numLods;
+
+            if (_indexBuffer.Init(device, (u32)indexBuffer.Length, .INDEX_BUFFER, indexBuffer.Ptr) case .Err)
+                return .Err;
+            if (_vertexBuffer.Init(device, (u32)vertexBuffer.Length, .VERTEX_BUFFER, vertexBuffer.Ptr) case .Err)
+	            return .Err;
+
+            return .Ok;
+        }
+
+        public void Draw(ID3D11DeviceContext* context)
+        {
+            //Bind buffers
+            u32 vertexOffset = 0;
+            context.IASetIndexBuffer(_indexBuffer.Ptr, _indexBufferFormat, 0);
+            context.IASetVertexBuffers(0, 1, &_vertexBuffer.Ptr, &_vertexStride, &vertexOffset);
+
+            if (NumLods == 1) //In this case the mesh is split into several submeshes
+            {
+                for (var submesh in ref _config.Submeshes)
+                {
+                    u32 firstBlock = submesh.RenderBlocksOffset;
+                    for (u32 i in 0 ..< submesh.NumRenderBlocks)
+                    {
+                        var block = ref _config.RenderBlocks[firstBlock + i];
+                        context.DrawIndexed(block.NumIndices, block.StartIndex, 0);
+                    }    
+                }
+            }
+            else //In this case each submesh is a different lod level, so we only draw one submesh
+            {
+                var submesh = ref _config.Submeshes[LodLevel];
+                u32 firstBlock = submesh.RenderBlocksOffset;
+                for (u32 i in 0 ..< submesh.NumRenderBlocks)
+                {
+                    var block = ref _config.RenderBlocks[firstBlock + i];
+                    context.DrawIndexed(block.NumIndices, block.StartIndex, 0);
+                }
+            }
+        }
+	}
+}

src/Render/Renderer.bf

@@ -0,0 +1,59 @@
+using Common;
+using System;
+using Common.Math;
+using Direct3D;
+
+namespace Nanoforge.Render.Resources
+{
+    [Align(16), CRepr]
+    public struct PerObjectConstants
+    {
+        public Mat4 MVP;
+        public Mat4 Rotation;
+        public Vec4<f32> WorldPosition;
+    }
+
+	public class RenderObject
+	{
+        public Mesh ObjectMesh ~delete _;
+        Vec3<f32> Scale = .(1.0f, 1.0f, 1.0f);
+        Vec3<f32> Position = .Zero;
+        Mat3 Rotation = .Identity;
+        bool Visible = true;
+
+        public this(Mesh mesh, Vec3<f32> position, Mat3 rotation = .Identity)
+        {
+            ObjectMesh = mesh;
+            Position = position;
+            Rotation = rotation;
+        }
+
+        public void Draw(ID3D11DeviceContext* context, Buffer perObjectBuffer, Camera3D cam)
+        {
+            if (!Visible)
+                return;
+
+            PerObjectConstants constants = .();
+
+            //Calculate matrices
+            Mat4 rotation = .();
+            rotation.Vectors[0] = .(Rotation.Vectors[0].x, Rotation.Vectors[0].y, Rotation.Vectors[0].z, 0.0f);
+            rotation.Vectors[1] = .(Rotation.Vectors[1].x, Rotation.Vectors[1].y, Rotation.Vectors[1].z, 0.0f);
+            rotation.Vectors[2] = .(Rotation.Vectors[2].x, Rotation.Vectors[2].y, Rotation.Vectors[2].z, 0.0f);
+            rotation.Vectors[3] = .(0.0f, 0.0f, 0.0f, 1.0f);
+            Mat4 translation = Mat4.Translation(Position);
+            Mat4 scale = Mat4.Scale(Scale);
+            Mat4 model = rotation * translation * scale;
+
+            //Calculate final MVP matrix + set other constants
+            constants.MVP = Mat4.Transpose(model * cam.View * cam.Projection);
+            constants.Rotation = rotation;
+            constants.WorldPosition = .(Position.x, Position.y, Position.z, 1.0f);
+
+            //Set constants
+            perObjectBuffer.SetData(context, &constants);
+
+            ObjectMesh.Draw(context);
+        }
+	}
+}

src/Render/Resources/Mesh.bf

@@ -6,6 +6,8 @@ using Direct3D;
 using Common;
 using System;
 using Win32;
+using Common.Misc;
+using System.Threading;
 
 namespace Nanoforge.Render
 {
@@ -22,6 +24,10 @@ namespace Nanoforge.Render
         public ID3D11ShaderResourceView* View => _viewTexture.ShaderResourceView;
         public bool ErrorOccurred { get; private set; } = false;
 
+        public append List<RenderObject> RenderObjects ~ClearAndDeleteItems!(_);
+        public append Dictionary<Material, List<RenderObject>> ObjectsByMaterial ~ClearDictionaryAndDeleteValues!(_);
+        private append Monitor _renderObjectCreationLock;
+
         private ID3D11Device* _device = null;
         private ID3D11DeviceContext* _context = null;
         private ID3D11RasterizerState* _meshRasterizerState ~ReleaseCOM(&_);
@@ -50,6 +56,7 @@ namespace Nanoforge.Render
         private bool _primitiveBufferNeedsUpdate = true; //Set to true when the cpu side buffers have changed and need to be sent to the GPU
         public bool PrimitiveMaterialsSet => _lineListMaterial != null && _triangleListMaterial != null && _litTriangleListMaterial != null;
 
+        [CRepr, RequiredSize(16)]
         private struct ColoredVertex
         {
             public Vec3<f32> Position;
@@ -65,6 +72,7 @@ namespace Nanoforge.Render
             }
         }
 
+        [CRepr, RequiredSize(28)]
         private struct ColoredVertexLit
         {
             public Vec3<f32> Position;
@@ -85,17 +93,11 @@ namespace Nanoforge.Render
         [OnCompile(.TypeInit)]
         private static void ComptimeSizeChecks()
         {
-            //Make sure vertex structs are the expected size
-            Runtime.Assert(sizeof(ColoredVertex) == 16);
-            Runtime.Assert(sizeof(ColoredVertexLit) == 28);
-
             //D3D11 constant buffers must align to 16 bytes
             Runtime.Assert(strideof(PerFrameConstants) % 16 == 0);
             Runtime.Assert(strideof(PerObjectConstants) % 16 == 0);
         }
 
-        //TODO: Add drawing functions
-
         public this(ID3D11Device* device, ID3D11DeviceContext* context)
         {
             _device = device;
@@ -108,11 +110,6 @@ namespace Nanoforge.Render
             Camera.Init(.(312.615f, 56.846f, -471.078f), 80.0f, .(ViewWidth, ViewHeight), 1.0f, 10000.0f); 
         }
 
-        public ~this()
-        {
-
-        }
-
         public void Draw(f32 deltaTime)
         {
             if (ErrorOccurred || !PrimitiveMaterialsSet)
@@ -137,9 +134,18 @@ namespace Nanoforge.Render
 
             //Prepare state to render triangle strip meshes
             _context.VSSetConstantBuffers(0, 1, &_perObjectConstantsBuffer.Ptr);
-            //_context.RSSetState(_meshRasterizerState);
-            //_context.IASetPrimitiveTopology(.D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
-            //TODO: Add render objects tied to meshes and draw them here. Use to draw buildings, rocks, terrain, etc
+            _context.RSSetState(_meshRasterizerState);
+            _context.IASetPrimitiveTopology(.D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
+
+            //Render meshes
+            for (var kv in ObjectsByMaterial)
+            {
+                //Batch render objects by material
+                Material material = kv.key;
+                material.Use(_context);
+                for (RenderObject renderObject in kv.value)
+                    renderObject.Draw(_context, _perObjectConstantsBuffer, Camera);
+            }
 
             //Prepare state to render primitives
             _context.RSSetState(_primitiveRasterizerState);
@@ -192,6 +198,25 @@ namespace Nanoforge.Render
             ClearPrimitiveVertexBuffers();
         }
 
+        public Result<RenderObject> CreateRenderObject(StringView materialName, Mesh mesh, Vec3<f32> position, Mat3 rotation)
+        {
+            ScopedLock!(_renderObjectCreationLock);
+            if (RenderMaterials.GetMaterial(materialName) case .Ok(Material material))
+            {
+                RenderObject renderObject = new .(mesh, position, rotation);
+                RenderObjects.Add(renderObject);
+                if (!ObjectsByMaterial.ContainsKey(material))
+                    ObjectsByMaterial[material] = new List<RenderObject>();
+
+                ObjectsByMaterial[material].Add(renderObject);
+                return renderObject;
+            }
+            else
+            {
+                return .Err;
+            }
+        }
+
         private void UpdatePrimitiveBuffers()
         {
             //Update line list vertex buffer
@@ -511,12 +536,4 @@ namespace Nanoforge.Render
         public f32 Time = 0.0f;
         public Vec2<f32> ViewportDimensions = .Zero;
     }
-
-    [Align(16), CRepr]
-    public struct PerObjectConstants
-    {
-        public Mat4 MVP;
-        public Mat4 Rotation;
-        public Vec4<f32> WorldPosition;
-    }
 }