profile cpu to gpu sync

Author: 4sval

Editor/EditorWindow.cs

@@ -137,13 +137,27 @@ private void DoRender(FrameEventArgs args)
         try
         {
             Manager.Render();
+            WaitForGpu();
+            SwapBuffers();
         }
         finally
         {
             Profiler.EndFrame();
         }
+    }
+
+    private const int MaxFramesInFlight = 2;
+    private readonly Queue<IntPtr> _frameFences = new();
+    private void WaitForGpu()
+    {
+        using var _ = Profiler.Cpu("Wait for GPU");
 
-        SwapBuffers();
+        _frameFences.Enqueue(GL.FenceSync(SyncCondition.SyncGpuCommandsComplete, WaitSyncFlags.None));
+        if (_frameFences.Count <= MaxFramesInFlight) return;
+
+        var fence = _frameFences.Dequeue();
+        GL.ClientWaitSync(fence, ClientWaitSyncFlags.SyncFlushCommandsBit, long.MaxValue);
+        GL.DeleteSync(fence);
     }
 
     private void DoTextInput(TextInputEventArgs e)
@@ -167,6 +181,11 @@ protected override void Dispose(bool disposing)
         {
             CursorState = CursorState.Normal;
             Manager.Dispose();
+
+            while (_frameFences.TryDequeue(out var fence))
+            {
+                GL.DeleteSync(fence);
+            }
         }
 
         base.Dispose(disposing);

Snooper/Core/Containers/Resources/CullView.cs

@@ -3,9 +3,26 @@
 
 namespace Snooper.Core.Containers.Resources;
 
-public readonly struct CullView(IViewProjectionProvider view, CameraComponent lodReference)
+public readonly struct CullView
 {
-    public readonly Matrix4x4 ViewProjection = view.ViewMatrix * view.ProjectionMatrix;
-    public readonly Vector3 LodReferencePosition = lodReference.InverseViewMatrix.Translation;
-    public readonly float LodProjectionScale = lodReference.ProjectionMatrix.M22;
+    public readonly Matrix4x4 ViewProjection;
+    public readonly Vector3 LodReferencePosition;
+    public readonly float LodProjectionScale;
+    public readonly float LodOrthoExtent;
+
+    public CullView(IViewProjectionProvider view, CameraComponent lodReference)
+    {
+        ViewProjection = view.ViewMatrix * view.ProjectionMatrix;
+        LodReferencePosition = lodReference.InverseViewMatrix.Translation;
+        LodProjectionScale = lodReference.ProjectionMatrix.M22;
+        LodOrthoExtent = 0.0f;
+    }
+
+    public CullView(ShadowMapView view, CameraComponent distanceReference)
+    {
+        ViewProjection = view.ViewProjection;
+        LodReferencePosition = distanceReference.InverseViewMatrix.Translation;
+        LodProjectionScale = 0.0f;
+        LodOrthoExtent = view.OrthoExtent;
+    }
 }

Snooper/Core/Containers/Resources/CullingResources.cs

@@ -80,6 +80,7 @@ public void UpdateOverrideLod(BufferAllocation allocation, int overrideLod)
 
     private readonly Plane[] _planes = new Plane[Settings.MaxCullingViews * 6];
     private readonly Vector4[] _lodReferences = new Vector4[Settings.MaxCullingViews];
+    private readonly float[] _lodOrthoExtents = new float[Settings.MaxCullingViews];
 
     public void Cull<TInstanceData>(ReadOnlySpan<CullView> views, ShaderStorageBuffer<TInstanceData> instances, IndirectDrawBuffer commands) where TInstanceData : unmanaged, IPerInstanceData
     {
@@ -98,11 +99,13 @@ public void Cull<TInstanceData>(ReadOnlySpan<CullView> views, ShaderStorageBuffe
             _planes[b + 5] = new Plane(matrix.M14 - matrix.M13, matrix.M24 - matrix.M23, matrix.M34 - matrix.M33, matrix.M44 - matrix.M43); // Top
 
             _lodReferences[i] = new Vector4(views[i].LodReferencePosition, views[i].LodProjectionScale);
+            _lodOrthoExtents[i] = views[i].LodOrthoExtent;
         }
 
         _compute.Use();
         _compute.SetUniform("uFrustumPlanes", _planes);
         _compute.SetUniform("uLodReference", _lodReferences);
+        _compute.SetUniform("uLodOrthoExtent", _lodOrthoExtents);
         _compute.SetUniform("uViewCount", (uint) viewCount);
         _compute.SetUniform("uViewCapacity", (uint) commands.Capacity);
 

Snooper/Rendering/Components/Camera/ShadowMapView.cs

@@ -11,13 +11,14 @@ namespace Snooper.Rendering.Components.Camera;
     public Matrix4x4 ViewProjection { get; }
 
     public int Slot { get; }
+    public float OrthoExtent { get; }
     public float TexelWorldSize { get; }
     public float DepthScale { get; }
     public float SplitFar { get; }
 
     public int ViewIndex => Slot + 1;
 
-    public ShadowMapView(Matrix4x4 viewMatrix, Matrix4x4 projectionMatrix, int slot, float texelWorldSize, float depthScale, float splitFar)
+    public ShadowMapView(Matrix4x4 viewMatrix, Matrix4x4 projectionMatrix, int slot, float orthoExtent, float texelWorldSize, float depthScale, float splitFar)
     {
         ViewMatrix = viewMatrix;
         ProjectionMatrix = projectionMatrix;
@@ -26,6 +27,7 @@ public ShadowMapView(Matrix4x4 viewMatrix, Matrix4x4 projectionMatrix, int slot,
         ViewProjection = viewMatrix * projectionMatrix;
 
         Slot = slot;
+        OrthoExtent = orthoExtent;
         TexelWorldSize = texelWorldSize;
         DepthScale = depthScale;
         SplitFar = splitFar;

Snooper/Rendering/Containers/Framebuffers/SunCascades.cs

@@ -98,7 +98,7 @@ public ShadowMapView[] Update(CameraComponent camera, DirectionalLightComponent
             // default [-1, 1] clip range, so window depth only ever spans [0.5, 1.0]
             var depthScale = 0.5f / depthRange;
 
-            Views[i] = new ShadowMapView(viewMatrix, projectionMatrix, FirstSlot + i, texelWorldSize, depthScale, far);
+            Views[i] = new ShadowMapView(viewMatrix, projectionMatrix, FirstSlot + i, radius, texelWorldSize, depthScale, far);
         }
 
         return Views;

Snooper/Shaders/culling.comp

@@ -39,6 +39,7 @@ layout(std430, binding = BINDING_CULL_SECTIONS) buffer SectionDescriptorsBuffer
 
 uniform vec4 uFrustumPlanes[MAX_CULLING_VIEWS * 6];
 uniform vec4 uLodReference[MAX_CULLING_VIEWS];
+uniform float uLodOrthoExtent[MAX_CULLING_VIEWS]; // > 0 marks the view orthographic, and is its half-width in world units
 
 uniform uint uViewCount;
 uniform uint uViewCapacity;
@@ -106,6 +107,7 @@ void main()
 
     vec3 lodRefPos = uLodReference[view].xyz;
     float lodScale = uLodReference[view].w;
+    float lodOrthoExtent = uLodOrthoExtent[view];
 
     uint localMin = 0xFFFFFFFFu;
     uint localMax = 0;
@@ -181,7 +183,9 @@ void main()
             else
             {
                 // Automatic LOD selection based on screen size
-                float screenRadius = mesh.SphereRadius * lodScale / sClosestDist[0];
+                float screenRadius = lodOrthoExtent > 0.0
+                    ? mesh.SphereRadius / lodOrthoExtent
+                    : mesh.SphereRadius * lodScale / sClosestDist[0];
                 float screenSize = screenRadius * 2.0;
 
                 for (uint i = 1u; i <= mesh.MaxLOD; ++i)