mrleo1nid/mrgameeng
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Parallel rendering pipeline, ring vertex buffer, phase timings

Browse Source 
Five optimizations measured on the 100k-entity stress scene (Release,
vsync off): 103 FPS baseline -> 297 FPS.

- Sprite submission and vertex building run on all cores above
  Renderer2DOptions.ParallelThreshold (default 8192). Work is sliced
  into 4096-entity segments: a Friflo chunk holds a whole archetype,
  so per-chunk parallelism degenerates to one thread. Segments merge
  in deterministic order, preserving radix sort stability.
- Vertex buffer is ring-written with SetDataOptions.NoOverwrite
  (GPU buffer 2x frame size); Discard only on wrap-around.
- Texture2DRegion precomputes UVs - four float divisions per sprite
  per frame removed.
- Renderer2D exposes per-phase timings (submit/sort/build/upload/draw),
  shown in the sample HUD - all further optimization is data-driven.
- Sample BounceSystem parallelized the same segmented way.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
This commit is contained in:
Leonid Pershin
2026-06-11 05:06:55 +03:00
co-authored by Claude Fable 5
parent af319d1276
commit e06f24a319
10 changed files with 589 additions and 132 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/MrGameEng.Graphics/Renderer2D.cs
+239 -102
View File
@@ -1,3 +1,4 @@
using System.Diagnostics;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
@@ -6,12 +7,17 @@ namespace MrGameEng.Graphics;
/// <summary>
/// The engine's 2D renderer: a sprite batcher over dynamic vertex buffers.
/// Per frame: <see cref="BeginFrame"/> (camera) → <see cref="Submit"/> per sprite (with culling)
/// → <see cref="EndFrame"/> (sort layer → depth → texture, build vertices, issue draw calls).
/// → <see cref="EndFrame"/> (stable sort layer → depth → texture, build vertices, issue draw calls).
/// Above <see cref="Renderer2DOptions.ParallelThreshold"/> sprites, submission and vertex
/// building run on all cores; the vertex buffer is ring-written (NoOverwrite) to avoid GPU stalls.
/// Registered as a service; scenes attach it via <c>scene.UseRenderer2D()</c>.
/// </summary>
public sealed class Renderer2D : IDisposable
{
private const int MaxQuadsPerDraw = 8192;
private const int ParallelBlock = 4096;
private static readonly int VertexStride = VertexPositionColorTexture.VertexDeclaration.VertexStride;
/// <summary>Render layer registry. Register layers before the first frame.</summary>
public LayerRegistry Layers { get; } = new();
@@ -28,6 +34,21 @@ public sealed class Renderer2D : IDisposable
/// <summary>Sprites rejected by culling this frame.</summary>
public int CulledSprites { get; private set; }
/// <summary>Milliseconds spent submitting sprites (BeginFrame → EndFrame) last frame.</summary>
public float SubmitMs { get; private set; }
/// <summary>Milliseconds spent sorting last frame.</summary>
public float SortMs { get; private set; }
/// <summary>Milliseconds spent building vertices last frame.</summary>
public float BuildMs { get; private set; }
/// <summary>Milliseconds spent uploading vertices to the GPU last frame.</summary>
public float UploadMs { get; private set; }
/// <summary>Milliseconds spent issuing draw calls last frame.</summary>
public float DrawMs { get; private set; }
private readonly GraphicsDevice _device;
private readonly Renderer2DOptions _options;
private readonly SpriteBatcher _batcher;
@@ -37,6 +58,9 @@ public sealed class Renderer2D : IDisposable
private VertexPositionColorTexture[] _vertices;
private CameraState _screenCamera;
private bool _begun;
private long _submitStartTimestamp;
private int _ringCursor;
private int _ringBaseVertex;
/// <summary>Creates the renderer. One instance per game is enough.</summary>
public Renderer2D(GraphicsDevice device, Renderer2DOptions? options = null)
@@ -46,7 +70,7 @@ public sealed class Renderer2D : IDisposable
_batcher = new SpriteBatcher(_options.InitialCapacity);
_vertices = new VertexPositionColorTexture[_options.InitialCapacity * 4];
_vertexBuffer = new DynamicVertexBuffer(
device, VertexPositionColorTexture.VertexDeclaration, _vertices.Length, BufferUsage.WriteOnly);
device, VertexPositionColorTexture.VertexDeclaration, _vertices.Length * 2, BufferUsage.WriteOnly);
_effect = new BasicEffect(device)
{
@@ -58,6 +82,8 @@ public sealed class Renderer2D : IDisposable
_indexBuffer = CreateQuadIndexBuffer(device);
}
internal int ParallelThreshold => _options.ParallelThreshold;
/// <summary>Begins a frame with the given camera. Called by <see cref="CameraSystem"/>.</summary>
public void BeginFrame(in Camera camera)
{
@@ -70,6 +96,7 @@ public sealed class Renderer2D : IDisposable
SubmittedSprites = 0;
CulledSprites = 0;
_begun = true;
_submitStartTimestamp = Stopwatch.GetTimestamp();
}
/// <summary>
@@ -86,63 +113,86 @@ public sealed class Renderer2D : IDisposable
/// <summary>Submits one sprite. Invisible sprites (outside the camera) are culled here.</summary>
public void Submit(in Transform2D transform, in Sprite sprite)
{
if (!_begun)
EnsureBegun();
switch (TryBuildInstance(in transform, in sprite, out var instance, out var key))
{
throw new InvalidOperationException("Submit called outside BeginFrame/EndFrame (is CameraSystem registered first?).");
case SubmitResult.Visible:
_batcher.Submit(in instance, key);
SubmittedSprites++;
break;
case SubmitResult.Culled:
CulledSprites++;
break;
}
if (sprite.Region is not { } region)
{
return;
}
var layer = Layers[sprite.Layer];
var (center, radius) = CullingMath.SpriteBoundingCircle(in transform, region, sprite.Origin);
if (layer.Space == LayerSpace.World &&
!CullingMath.CircleIntersectsRect(center, radius, Camera.CullRect))
{
CulledSprites++;
return;
}
var depth = layer.SortMode == LayerSortMode.YSort ? center.Y : sprite.Depth;
_batcher.Submit(
new SpriteInstance
{
Region = region,
Center = center,
HalfSize = new Vector2(region.Width * transform.Scale.X, region.Height * transform.Scale.Y) / 2f,
Rotation = transform.Rotation,
Color = sprite.Color,
Flip = sprite.Flip,
Layer = sprite.Layer.Value,
},
SpriteSortKey.Make(sprite.Layer.Value, depth, region.TextureSortKey));
SubmittedSprites++;
}
/// <summary>Sorts, builds vertices and issues draw calls. Called by <see cref="RenderFlushSystem"/>.</summary>
public void EndFrame()
{
if (!_begun)
{
throw new InvalidOperationException("EndFrame called without BeginFrame.");
}
EnsureBegun();
_begun = false;
DrawCalls = 0;
var order = _batcher.Sort();
if (order.Length == 0)
var submitEnd = Stopwatch.GetTimestamp();
SubmitMs = ToMs(submitEnd - _submitStartTimestamp);
SortMs = 0f;
BuildMs = 0f;
UploadMs = 0f;
DrawMs = 0f;
_batcher.Sort();
var count = _batcher.Count;
var sortEnd = Stopwatch.GetTimestamp();
SortMs = ToMs(sortEnd - submitEnd);
if (count == 0)
{
return;
}
EnsureVertexCapacity(order.Length * 4);
BuildVertices(order);
_vertexBuffer.SetData(_vertices, 0, order.Length * 4, SetDataOptions.Discard);
var order = _batcher.SortedOrder;
EnsureVertexCapacity(count * 4);
if (count >= _options.ParallelThreshold)
{
var blocks = (count + ParallelBlock - 1) / ParallelBlock;
Parallel.For(0, blocks, block =>
{
var end = Math.Min((block + 1) * ParallelBlock, count);
for (var i = block * ParallelBlock; i < end; i++)
{
BuildVertex(order, i);
}
});
}
else
{
for (var i = 0; i < count; i++)
{
BuildVertex(order, i);
}
}
var buildEnd = Stopwatch.GetTimestamp();
BuildMs = ToMs(buildEnd - sortEnd);
// Кольцевая запись: NoOverwrite не заставляет GPU ждать предыдущий кадр;
// Discard только на перемотке кольца.
var vertexCount = count * 4;
SetDataOptions hint;
if (_ringCursor + vertexCount <= _vertexBuffer.VertexCount)
{
_ringBaseVertex = _ringCursor;
hint = SetDataOptions.NoOverwrite;
}
else
{
_ringBaseVertex = 0;
hint = SetDataOptions.Discard;
}
_vertexBuffer.SetData(_ringBaseVertex * VertexStride, _vertices, 0, vertexCount, VertexStride, hint);
_ringCursor = _ringBaseVertex + vertexCount;
var uploadEnd = Stopwatch.GetTimestamp();
UploadMs = ToMs(uploadEnd - buildEnd);
_device.BlendState = BlendState.AlphaBlend;
_device.SamplerStates[0] = _options.Sampler;
@@ -151,7 +201,8 @@ public sealed class Renderer2D : IDisposable
_device.SetVertexBuffer(_vertexBuffer);
_device.Indices = _indexBuffer;
DrawBatches(order);
DrawBatches(order, count);
DrawMs = ToMs(Stopwatch.GetTimestamp() - uploadEnd);
}
/// <summary>Converts a physical screen point to world coordinates using the current camera.</summary>
@@ -168,6 +219,88 @@ public sealed class Renderer2D : IDisposable
_indexBuffer.Dispose();
}
// --- Параллельная по-чанковая подача (используется SpriteRenderSystem выше порога) ----
internal void BeginChunkedSubmit(ReadOnlySpan<int> chunkLengths)
{
EnsureBegun();
_batcher.BeginChunks(chunkLengths);
}
internal SpriteChunkWriter GetChunkWriter(int chunkIndex) => _batcher.GetChunkWriter(chunkIndex);
internal void SubmitInto(ref SpriteChunkWriter writer, in Transform2D transform, in Sprite sprite)
{
switch (TryBuildInstance(in transform, in sprite, out var instance, out var key))
{
case SubmitResult.Visible:
writer.Add(in instance, key);
break;
case SubmitResult.Culled:
writer.AddCulled();
break;
}
}
internal void EndChunk(int chunkIndex, in SpriteChunkWriter writer) => _batcher.EndChunk(chunkIndex, in writer);
internal void CommitChunkedSubmit()
{
SubmittedSprites += _batcher.CommitChunks();
CulledSprites += _batcher.LastChunkCulled;
}
private enum SubmitResult
{
Skipped,
Culled,
Visible,
}
private SubmitResult TryBuildInstance(
in Transform2D transform, in Sprite sprite, out SpriteInstance instance, out ulong key)
{
instance = default;
key = 0;
if (sprite.Region is not { } region)
{
return SubmitResult.Skipped;
}
var layer = Layers[sprite.Layer];
var (center, radius) = CullingMath.SpriteBoundingCircle(in transform, region, sprite.Origin);
if (layer.Space == LayerSpace.World &&
!CullingMath.CircleIntersectsRect(center, radius, Camera.CullRect))
{
return SubmitResult.Culled;
}
var depth = layer.SortMode == LayerSortMode.YSort ? center.Y : sprite.Depth;
instance = new SpriteInstance
{
Region = region,
Center = center,
HalfSize = new Vector2(region.Width * transform.Scale.X, region.Height * transform.Scale.Y) / 2f,
Rotation = transform.Rotation,
Color = sprite.Color,
Flip = sprite.Flip,
Layer = sprite.Layer.Value,
};
key = SpriteSortKey.Make(sprite.Layer.Value, depth, region.TextureSortKey);
return SubmitResult.Visible;
}
private void EnsureBegun()
{
if (!_begun)
{
throw new InvalidOperationException(
"Renderer used outside BeginFrame/EndFrame (is CameraSystem registered first?).");
}
}
private (int Width, int Height, ViewportMapping Mapping) ResolveVirtualResolution()
{
var viewport = _device.Viewport;
@@ -180,53 +313,48 @@ public sealed class Renderer2D : IDisposable
CameraMath.ComputeMapping(viewport.Width, viewport.Height, virtualSize.X, virtualSize.Y));
}
private void BuildVertices(ReadOnlySpan<int> order)
private void BuildVertex(int[] order, int i)
{
for (var i = 0; i < order.Length; i++)
ref readonly var instance = ref _batcher[order[i]];
var region = instance.Region;
var u0 = region.U0;
var v0 = region.V0;
var u1 = region.U1;
var v1 = region.V1;
if ((instance.Flip & SpriteFlip.X) != 0)
{
ref readonly var instance = ref _batcher[order[i]];
var bounds = instance.Region.Bounds;
var texture = instance.Region.Texture;
var u0 = bounds.X / (float)texture.Width;
var v0 = bounds.Y / (float)texture.Height;
var u1 = (bounds.X + bounds.Width) / (float)texture.Width;
var v1 = (bounds.Y + bounds.Height) / (float)texture.Height;
if ((instance.Flip & SpriteFlip.X) != 0)
{
(u0, u1) = (u1, u0);
}
if ((instance.Flip & SpriteFlip.Y) != 0)
{
(v0, v1) = (v1, v0);
}
Vector2 rx, ry;
if (instance.Rotation == 0f)
{
rx = new Vector2(instance.HalfSize.X, 0f);
ry = new Vector2(0f, instance.HalfSize.Y);
}
else
{
var (sin, cos) = MathF.SinCos(instance.Rotation);
rx = new Vector2(instance.HalfSize.X * cos, instance.HalfSize.X * sin);
ry = new Vector2(-instance.HalfSize.Y * sin, instance.HalfSize.Y * cos);
}
var center = instance.Center;
var vertex = i * 4;
_vertices[vertex + 0] = Vertex(center - rx - ry, instance.Color, u0, v0);
_vertices[vertex + 1] = Vertex(center + rx - ry, instance.Color, u1, v0);
_vertices[vertex + 2] = Vertex(center - rx + ry, instance.Color, u0, v1);
_vertices[vertex + 3] = Vertex(center + rx + ry, instance.Color, u1, v1);
(u0, u1) = (u1, u0);
}
if ((instance.Flip & SpriteFlip.Y) != 0)
{
(v0, v1) = (v1, v0);
}
Vector2 rx, ry;
if (instance.Rotation == 0f)
{
rx = new Vector2(instance.HalfSize.X, 0f);
ry = new Vector2(0f, instance.HalfSize.Y);
}
else
{
var (sin, cos) = MathF.SinCos(instance.Rotation);
rx = new Vector2(instance.HalfSize.X * cos, instance.HalfSize.X * sin);
ry = new Vector2(-instance.HalfSize.Y * sin, instance.HalfSize.Y * cos);
}
var center = instance.Center;
var vertex = i * 4;
_vertices[vertex + 0] = Vertex(center - rx - ry, instance.Color, u0, v0);
_vertices[vertex + 1] = Vertex(center + rx - ry, instance.Color, u1, v0);
_vertices[vertex + 2] = Vertex(center - rx + ry, instance.Color, u0, v1);
_vertices[vertex + 3] = Vertex(center + rx + ry, instance.Color, u1, v1);
}
private void DrawBatches(ReadOnlySpan<int> order)
private void DrawBatches(int[] order, int count)
{
var batchStart = 0;
ref readonly var first = ref _batcher[order[0]];
@@ -234,11 +362,11 @@ public sealed class Renderer2D : IDisposable
var currentLayer = first.Layer;
ApplyLayerMatrices(currentLayer);
for (var i = 1; i <= order.Length; i++)
for (var i = 1; i <= count; i++)
{
Texture2D? texture = null;
byte layer = 0;
if (i < order.Length)
if (i < count)
{
ref readonly var instance = ref _batcher[order[i]];
texture = instance.Region.Texture;
@@ -252,7 +380,7 @@ public sealed class Renderer2D : IDisposable
DrawRange(currentTexture, batchStart, i - batchStart);
batchStart = i;
if (i < order.Length)
if (i < count)
{
currentTexture = texture!;
if (layer != currentLayer)
@@ -281,7 +409,8 @@ public sealed class Renderer2D : IDisposable
foreach (var pass in _effect.CurrentTechnique.Passes)
{
pass.Apply();
_device.DrawIndexedPrimitives(PrimitiveType.TriangleList, firstQuad * 4, 0, quads * 2);
_device.DrawIndexedPrimitives(
PrimitiveType.TriangleList, _ringBaseVertex + firstQuad * 4, 0, quads * 2);
DrawCalls++;
}
@@ -292,23 +421,31 @@ public sealed class Renderer2D : IDisposable
private void EnsureVertexCapacity(int vertexCount)
{
if (_vertices.Length >= vertexCount)
if (_vertices.Length < vertexCount)
{
return;
var capacity = _vertices.Length;
while (capacity < vertexCount)
{
capacity *= 2;
}
_vertices = new VertexPositionColorTexture[capacity];
}
var capacity = _vertices.Length;
while (capacity < vertexCount)
// GPU-буфер держим вдвое больше CPU-массива — кольцу нужен запас,
// чтобы NoOverwrite срабатывал чаще, чем Discard.
var wantedBuffer = _vertices.Length * 2;
if (_vertexBuffer.VertexCount < wantedBuffer)
{
capacity *= 2;
_vertexBuffer.Dispose();
_vertexBuffer = new DynamicVertexBuffer(
_device, VertexPositionColorTexture.VertexDeclaration, wantedBuffer, BufferUsage.WriteOnly);
_ringCursor = 0;
}
_vertices = new VertexPositionColorTexture[capacity];
_vertexBuffer.Dispose();
_vertexBuffer = new DynamicVertexBuffer(
_device, VertexPositionColorTexture.VertexDeclaration, capacity, BufferUsage.WriteOnly);
}
private static float ToMs(long timestampDelta) => (float)timestampDelta * 1000f / Stopwatch.Frequency;
private static VertexPositionColorTexture Vertex(Vector2 position, Color color, float u, float v) =>
new(new Vector3(position, 0f), color, new Vector2(u, v));