Getting lines rendering correctly

Author: larsbrubaker

RenderGl/WorldViewExtensions.cs

@@ -177,7 +177,24 @@ public static void Render3DLineNoPrep(this WorldView world,
 					}
 				}
 
-				// render the line mesh directly
+				// When the D3D scene pipeline is active, create a fresh mesh with baked
+				// world-space vertices and route it through the same pipeline as other
+				// control geometry (opaque or overlay depending on current depth test state).
+				if (GL.Instance is INativeSceneRenderer nativeSceneRenderer
+					&& nativeSceneRenderer.IsSceneRenderingActive)
+				{
+					var lineMesh = CreateTransformedLineMesh(lineTransform);
+
+					if (startArrow || endArrow)
+					{
+						AppendArrowHeads(lineMesh, start, end, startScale, normal, arrowWidth, arrowLength, startArrow, endArrow);
+					}
+
+					RenderHelper.Render(lineMesh, color, Matrix4X4.Identity, RenderTypes.Shaded, forceCullBackFaces: false);
+					return;
+				}
+
+				// GL compat fallback: render the line mesh directly
 				GL.Color4(color.Red0To255, color.Green0To255, color.Blue0To255, color.Alpha0To255);
 				GL.Enable(EnableCap.Blend);
 
@@ -214,6 +231,78 @@ public static void Render3DLineNoPrep(this WorldView world,
 			}
 		}
 
+		/// <summary>
+		/// Creates a fresh mesh from scaledLineMesh with vertices pre-transformed by lineTransform.
+		/// Each line needs its own mesh because scaledLineMesh is shared and modified per-call.
+		/// </summary>
+		private static Mesh CreateTransformedLineMesh(Matrix4X4 lineTransform)
+		{
+			var mesh = new Mesh();
+			for (int i = 0; i < scaledLineMesh.Vertices.Count; i++)
+			{
+				var pos = Vector3Ex.Transform(new Vector3(scaledLineMesh.Vertices[i]), lineTransform);
+				mesh.Vertices.Add(new Vector3Float(pos));
+			}
+
+			for (int faceIndex = 0; faceIndex < scaledLineMesh.Faces.Count; faceIndex++)
+			{
+				mesh.Faces.Add(scaledLineMesh.Faces[faceIndex]);
+			}
+
+			mesh.CalculateNormals();
+			return mesh;
+		}
+
+		/// <summary>
+		/// Appends arrow head cone geometry to an existing mesh.
+		/// </summary>
+		private static void AppendArrowHeads(Mesh mesh, Vector3 start, Vector3 end, double startScale, Vector3 normal, double arrowWidth, double arrowLength, bool startArrow, bool endArrow)
+		{
+			if (startArrow)
+			{
+				AppendCone(mesh, start, startScale, -normal, arrowWidth, arrowLength);
+			}
+
+			if (endArrow)
+			{
+				AppendCone(mesh, end, startScale, normal, arrowWidth, arrowLength);
+			}
+		}
+
+		private static void AppendCone(Mesh mesh, Vector3 basePos, double scale, Vector3 normal, double arrowWidth, double arrowLength)
+		{
+			var sides = 12;
+			var perpendicular = normal.GetPerpendicular().GetNormal();
+			var rotation = Matrix4X4.CreateRotation(normal, MathHelper.Tau / sides);
+			var offset = perpendicular * arrowWidth * scale;
+			var tipPos = basePos + (normal * arrowLength * scale);
+
+			int baseVertexIndex = mesh.Vertices.Count;
+			// Add tip vertex
+			mesh.Vertices.Add(new Vector3Float(tipPos));
+			// Add base center vertex
+			mesh.Vertices.Add(new Vector3Float(basePos));
+
+			// Add ring vertices
+			for (int side = 0; side <= sides; side++)
+			{
+				mesh.Vertices.Add(new Vector3Float(basePos + offset));
+				offset = offset.Transform(rotation);
+			}
+
+			int tipIndex = baseVertexIndex;
+			int baseCenterIndex = baseVertexIndex + 1;
+			int ringStart = baseVertexIndex + 2;
+
+			for (int side = 0; side < sides; side++)
+			{
+				// Side triangle (tip to ring edge)
+				mesh.Faces.Add(ringStart + side, tipIndex, ringStart + side + 1, mesh.Vertices);
+				// Base triangle (center to ring edge)
+				mesh.Faces.Add(baseCenterIndex, ringStart + side, ringStart + side + 1, mesh.Vertices);
+			}
+		}
+
 		private static void RenderHead(Vector3 basePos, double startScale, Vector3 normal, double arrowWidth, double arrowLength, bool invert)
 		{
 			if (invert)

VorticeD3D/NativeSceneEffects.cs

@@ -55,6 +55,7 @@ public partial class VorticeD3DGl
 		public int DepthPeelingLayers { get; set; } = 6;
 
 		private readonly List<MeshRenderCommand> queuedSceneCommands = new();
+		private readonly List<MeshRenderCommand> queuedOverlayCommands = new();
 		private BedRenderCommand queuedBedCommand;
 		private readonly List<SelectionOutlineCommand> queuedSelectionOutlines = new();
 		private readonly NativeSceneRenderPlanner renderPlanner = new();
@@ -403,6 +404,7 @@ private void RenderQueuedSceneEffects()
 			}
 
 			if (queuedSceneCommands.Count == 0
+				&& queuedOverlayCommands.Count == 0
 				&& queuedSelectionOutlines.Count == 0
 				&& queuedBedCommand == null)
 			{
@@ -428,7 +430,7 @@ private void RenderQueuedSceneEffects()
 			RenderOpaqueCommands(renderPlan.OpaqueCommands);
 			RenderSceneDepth(renderPlan, queuedBedCommand);
 			RenderTransparentLayers(renderPlan.TransparentCommands, queuedBedCommand);
-			RenderTransparentOverlays(renderPlan.TransparentCommands);
+			RenderTransparentOverlays();
 			CompositeSceneTargets();
 			BlitResolvedSceneToScreen();
 			RenderSelectionOutlines();
@@ -964,10 +966,46 @@ private void BlitResolvedSceneToScreen()
 			UnbindSceneTextures();
 		}
 
-		private void RenderTransparentOverlays(IReadOnlyList<MeshRenderCommand> transparentCommands)
+		private void RenderTransparentOverlays()
 		{
 			BindColorTarget(transparentOverlayTarget);
 			ClearColorTarget(transparentOverlayTarget, new Color4(0, 0, 0, 0));
+
+			if (queuedOverlayCommands.Count == 0)
+			{
+				return;
+			}
+
+			// Render overlay commands with no depth test and alpha blending.
+			// These are 3D controls drawn as semi-transparent ghosts, always visible on top.
+			var noDepthState = GetOrCreateDepthStencilState(false, ComparisonFunction.Always, false);
+			var alphaBlend = GetOrCreateBlendState(
+				true,
+				(int)BlendingFactorSrc.SrcAlpha,
+				(int)BlendingFactorDest.OneMinusSrcAlpha,
+				ColorWriteEnable.All);
+
+			foreach (var command in queuedOverlayCommands)
+			{
+				if (!SceneRenderModeUtilities.RequiresSceneMeshPass(command.RenderType))
+				{
+					continue;
+				}
+
+				RenderMeshCommand(
+					command,
+					null,
+					enableWireframe: false,
+					wireframeOnly: false,
+					offsetFill: false,
+					enableDepthPeeling: false,
+					firstPeelPass: false,
+					opaqueDepthView: null,
+					nearDepthView: null,
+					colorWritesEnabled: true,
+					blendStateOverride: alphaBlend,
+					depthStencilStateOverride: noDepthState);
+			}
 		}
 
 		private void InitializeDualDepthPeel(IReadOnlyList<MeshRenderCommand> transparentCommands, BedRenderCommand bedCommand, ID3D11DepthStencilState depthState)
@@ -1547,6 +1585,7 @@ private void UnbindSceneTextures()
 		private void ClearQueuedSceneEffects()
 		{
 			queuedSceneCommands.Clear();
+			queuedOverlayCommands.Clear();
 			queuedBedCommand = null;
 			queuedSelectionOutlines.Clear();
 		}

VorticeD3D/NativeSceneRenderer.cs

@@ -75,7 +75,18 @@ public bool TryRender(MeshRenderCommand command)
 				return false;
 			}
 
-			QueueSceneCommand(command);
+			// When depth test is disabled, the caller wants this rendered as an
+			// always-visible overlay (e.g., 3D control ghost pass with alpha < 255).
+			bool depthTestEnabled = enableCapState.TryGetValue((int)EnableCap.DepthTest, out var d) && d;
+			if (depthTestEnabled)
+			{
+				QueueSceneCommand(command);
+			}
+			else
+			{
+				queuedOverlayCommands.Add(command);
+			}
+
 			return true;
 		}