sync renderengine

Author: LoneWandererProductions

RenderEngine/GpuMesh.cs

@@ -29,6 +29,11 @@ public sealed class GpuMesh : IDisposable
         /// </summary>
         private bool _isSolidLayoutConfigured;
 
+        /// <summary>
+        /// The is translucent layout configured
+        /// </summary>
+        private bool _isTranslucentLayoutConfigured;
+
         /// <summary>
         /// Gets the textured VAO handle.
         /// </summary>
@@ -54,6 +59,21 @@ public sealed class GpuMesh : IDisposable
         /// </summary>
         public int SolidVertexCount { get; private set; }
 
+        /// <summary>
+        /// Gets the VAO handle of the translucent solid geometry (glass, water): drawn in a separate blended pass.
+        /// </summary>
+        public int TranslucentVao { get; private set; }
+
+        /// <summary>
+        /// Gets the VBO handle of the translucent solid geometry.
+        /// </summary>
+        public int TranslucentVbo { get; private set; }
+
+        /// <summary>
+        /// Gets the translucent vertex count.
+        /// </summary>
+        public int TranslucentVertexCount { get; private set; }
+
         /// <summary>
         /// Gets the sub-mesh ranges for multi-textured rendering.
         /// </summary>
@@ -163,11 +183,47 @@ public void UploadSolid(IntPtr dataPointer, int floatCount, bool isDynamic = fal
             GL.BindVertexArray(0);
         }
 
+        /// <summary>
+        /// Uploads translucent untextured geometry (7 floats/vertex: X,Y,Z,R,G,B,A). It is kept apart from the opaque
+        /// solid part so the renderer can draw it after everything opaque, with blending on and depth writes off.
+        /// </summary>
+        /// <param name="dataPointer">The data pointer.</param>
+        /// <param name="floatCount">The float count.</param>
+        /// <param name="isDynamic">if set to <c>true</c> [is dynamic].</param>
+        public void UploadTranslucent(IntPtr dataPointer, int floatCount, bool isDynamic = false)
+        {
+            TranslucentVertexCount = floatCount / 7;
+            if (floatCount == 0) return;
+
+            if (TranslucentVao == 0) TranslucentVao = GL.GenVertexArray();
+            if (TranslucentVbo == 0) TranslucentVbo = GL.GenBuffer();
+
+            GL.BindVertexArray(TranslucentVao);
+            GL.BindBuffer(BufferTarget.ArrayBuffer, TranslucentVbo);
+
+            var usage = isDynamic ? BufferUsageHint.DynamicDraw : BufferUsageHint.StaticDraw;
+            GL.BufferData(BufferTarget.ArrayBuffer, floatCount * sizeof(float), dataPointer, usage);
+
+            if (!_isTranslucentLayoutConfigured)
+            {
+                GL.VertexAttribPointer(0, 3, VertexAttribPointerType.Float, false, 7 * sizeof(float), 0);
+                GL.EnableVertexAttribArray(0);
+                GL.VertexAttribPointer(1, 4, VertexAttribPointerType.Float, false, 7 * sizeof(float),
+                    3 * sizeof(float));
+                GL.EnableVertexAttribArray(1);
+
+                _isTranslucentLayoutConfigured = true;
+            }
+
+            GL.BindVertexArray(0);
+        }
+
         /// <summary>
         /// Resets this instance.
         /// </summary>
         public void Reset()
         {
+            TranslucentVertexCount = 0;
             SolidVertexCount = 0;
             Ranges.Clear();
         }
@@ -199,8 +255,21 @@ public void Dispose()
                 SolidVao = 0;
             }
 
+            if (TranslucentVbo != 0)
+            {
+                GL.DeleteBuffer(TranslucentVbo);
+                TranslucentVbo = 0;
+            }
+
+            if (TranslucentVao != 0)
+            {
+                GL.DeleteVertexArray(TranslucentVao);
+                TranslucentVao = 0;
+            }
+
             _isTexturedLayoutConfigured = false;
             _isSolidLayoutConfigured = false;
+            _isTranslucentLayoutConfigured = false;
             Ranges.Clear();
         }
     }

RenderEngine/ProceduralEntry.cs

@@ -18,6 +18,6 @@ namespace RenderEngine
     internal readonly record struct ProceduralEntry(
         string Name,
         string Description,
-        Func<int, int, object, RawTextureBuffer?> Generator
+        Func<int, int, object?, RawTextureBuffer?> Generator
     );
 }

RenderEngine/RenderBatch.cs

@@ -42,6 +42,12 @@ public sealed class RenderBatch
         /// </summary>
         public readonly UnmanagedList<float> Solid3DVertices = new(16384);
 
+        /// <summary>
+        /// The translucent solid 3D vertices (any vertex alpha below 255: glass, water). Same layout as
+        /// <see cref="Solid3DVertices"/>, but drawn in a later blended pass instead of with the opaque geometry.
+        /// </summary>
+        public readonly UnmanagedList<float> Translucent3DVertices = new(2048);
+
         /// <summary>
         /// The textured 3D batches
         /// Layout: X, Y, Z, U, V, R, G, B, A (9 floats) - Grouped by TextureId
@@ -158,9 +164,10 @@ public void AddTexturedTriangle((int x, int y) p1, (int x, int y) p2, (int x, in
         /// <param name="color">The color.</param>
         public void AddSolid3DTriangle(Vector3 v1, Vector3 v2, Vector3 v3, (int r, int g, int b, int a) color)
         {
-            AddColoredVertex3D(v1, color, Solid3DVertices);
-            AddColoredVertex3D(v2, color, Solid3DVertices);
-            AddColoredVertex3D(v3, color, Solid3DVertices);
+            var target = color.a < 255 ? Translucent3DVertices : Solid3DVertices;
+            AddColoredVertex3D(v1, color, target);
+            AddColoredVertex3D(v2, color, target);
+            AddColoredVertex3D(v3, color, target);
         }
 
         /// <summary>
@@ -170,9 +177,10 @@ public void AddSolid3DTriangle(
             Vector3 v1, Vector3 v2, Vector3 v3,
             (int r, int g, int b, int a) c1, (int r, int g, int b, int a) c2, (int r, int g, int b, int a) c3)
         {
-            AddColoredVertex3D(v1, c1, Solid3DVertices);
-            AddColoredVertex3D(v2, c2, Solid3DVertices);
-            AddColoredVertex3D(v3, c3, Solid3DVertices);
+            var target = c1.a < 255 || c2.a < 255 || c3.a < 255 ? Translucent3DVertices : Solid3DVertices;
+            AddColoredVertex3D(v1, c1, target);
+            AddColoredVertex3D(v2, c2, target);
+            AddColoredVertex3D(v3, c3, target);
         }
 
         /// <summary>
@@ -324,6 +332,7 @@ public void Clear()
             SolidLineVertices.Clear();
             SolidTriangleVertices.Clear();
             Solid3DVertices.Clear();
+            Translucent3DVertices.Clear();
 
             foreach (var list in TexturedBatches.Values)
             {

RenderEngine/Simple2DRenderer.cs

@@ -49,7 +49,7 @@ public sealed class Simple2DRenderer : IDisposable
         /// <summary>
         /// The resources
         /// </summary>
-        private readonly GlResourceManager _resources;
+        private readonly GlResourceManager? _resources;
 
         // --- Solid VAO/VBO ---
 
@@ -152,7 +152,7 @@ public void Resize(int width, int height)
         /// <param name="width">Width of the render viewport in pixels.</param>
         /// <param name="height">Height of the render viewport in pixels.</param>
         /// <param name="resources">The GL resource manager instance.</param>
-        public Simple2DRenderer(int width, int height, GlResourceManager resources)
+        public Simple2DRenderer(int width, int height, GlResourceManager? resources)
         {
             Width = width;
             Height = height;
@@ -1073,4 +1073,4 @@ public void Dispose()
             }
         }
     }
-}
+}

RenderEngine/Simple3DRenderer.cs

@@ -50,7 +50,7 @@ public sealed class Simple3DRenderer : IDisposable
         /// <summary>
         /// Reference tracker managing engine-level compiled shader assets and texture definitions.
         /// </summary>
-        private readonly GlResourceManager _resources;
+        private readonly GlResourceManager? _resources;
 
         /// <summary>
         /// Hardware layout buffer markers tracking active states
@@ -87,6 +87,12 @@ public sealed class Simple3DRenderer : IDisposable
         /// <summary>
         /// The active program
         /// </summary>
+        /// <summary>
+        /// Baked meshes that carry translucent geometry (glass, water) drawn this frame. They are drawn once the opaque
+        /// world is complete, in <see cref="DrawTranslucentMeshes"/>, so they blend with what lies behind them.
+        /// </summary>
+        private readonly List<GpuMesh> _translucentMeshes = new();
+
         private int _activeProgram = -1;
 
         /// <summary>
@@ -220,7 +226,7 @@ public sealed class Simple3DRenderer : IDisposable
         /// <param name="width">The target canvas width.</param>
         /// <param name="height">The target canvas height.</param>
         /// <param name="resources">The shared unmanaged resource coordinator.</param>
-        public Simple3DRenderer(int width, int height, GlResourceManager resources)
+        public Simple3DRenderer(int width, int height, GlResourceManager? resources)
         {
             _resources = resources;
             UpdateProjection(width, height);
@@ -539,6 +545,7 @@ public void BeginFrame()
             _activeProgram = -1;
             _activeVao = -1;
             _activeTexture = -1;
+            _translucentMeshes.Clear();
 
             ApplyFrameState();
 
@@ -590,6 +597,9 @@ public void BeginFrame()
         /// </summary>
         public void EndFrame()
         {
+            // Everything opaque is in the depth buffer by now: blend the glass and the water over it.
+            DrawTranslucentMeshes();
+
             if (!_framePostProcessed || !_fboInitialized) return;
 
             // 1. Restore GLWpfControl's target FBO and Viewport
@@ -808,6 +818,22 @@ public unsafe void Flush(RenderBatch batch)
                 GL.DrawArrays(PrimitiveType.Triangles, 0, batch.Solid3DVertices.Length / 7);
             }
 
+            if (batch.Translucent3DVertices.Length > 0)
+            {
+                BindProgram(_shaderSolid);
+                BindVao(_vaoSolid);
+                EnsureSolidMatrices();
+
+                EnsureBufferCapacity(_vboSolid, ref _vboSolidCapacity, batch.Translucent3DVertices.Length);
+                GL.BindBuffer(BufferTarget.ArrayBuffer, _vboSolid);
+                GL.BufferSubData(BufferTarget.ArrayBuffer, IntPtr.Zero,
+                    batch.Translucent3DVertices.Length * sizeof(float), (IntPtr)batch.Translucent3DVertices.Pointer);
+
+                BeginBlendedPass();
+                GL.DrawArrays(PrimitiveType.Triangles, 0, batch.Translucent3DVertices.Length / 7);
+                EndBlendedPass();
+            }
+
             if (batch.Textured3DBatches.Count > 0)
             {
                 BindProgram(_shaderTex);
@@ -844,6 +870,53 @@ public unsafe void Flush(RenderBatch batch)
             BindVao(0);
         }
 
+        /// <summary>
+        /// Switches to alpha blending without depth writes: translucent surfaces still hide behind opaque ones (depth
+        /// test on) but do not hide each other or what is drawn after them.
+        /// </summary>
+        private static void BeginBlendedPass()
+        {
+            GL.Enable(EnableCap.Blend);
+            GL.BlendFunc(BlendingFactor.SrcAlpha, BlendingFactor.OneMinusSrcAlpha);
+            GL.DepthMask(false);
+        }
+
+        /// <summary>
+        /// Back to the opaque state set by <see cref="ApplyFrameState"/>.
+        /// </summary>
+        private static void EndBlendedPass()
+        {
+            GL.DepthMask(true);
+            GL.Disable(EnableCap.Blend);
+        }
+
+        /// <summary>
+        /// Draws the translucent part (glass, water) of every mesh drawn this frame, after all opaque geometry.
+        /// </summary>
+        private void DrawTranslucentMeshes()
+        {
+            if (_translucentMeshes.Count == 0) return;
+
+            EnsureInitialized();
+
+            BindProgram(_shaderSolid);
+            EnsureSolidMatrices();
+            BeginBlendedPass();
+
+            for (var i = 0; i < _translucentMeshes.Count; i++)
+            {
+                var mesh = _translucentMeshes[i];
+                if (mesh.TranslucentVao == 0 || mesh.TranslucentVertexCount <= 0) continue;
+
+                BindVao(mesh.TranslucentVao);
+                GL.DrawArrays(PrimitiveType.Triangles, 0, mesh.TranslucentVertexCount);
+            }
+
+            EndBlendedPass();
+            BindVao(0);
+            _translucentMeshes.Clear();
+        }
+
         /// <summary>
         /// Renders a persistent mesh directly from GPU VRAM with zero PCIe memory transfers.
         /// </summary>
@@ -861,6 +934,8 @@ public void DrawStaticMesh(GpuMesh mesh)
                 GL.DrawArrays(PrimitiveType.Triangles, 0, mesh.SolidVertexCount);
             }
 
+            if (mesh.TranslucentVertexCount > 0) _translucentMeshes.Add(mesh);
+
             if (mesh.Ranges.Count == 0) return;
 
             BindProgram(_shaderTex);