721 lines
30 KiB
C#
721 lines
30 KiB
C#
using System;
|
||
using System.Collections.Generic;
|
||
using System.Collections.Immutable;
|
||
using System.Numerics;
|
||
using System.Runtime.InteropServices;
|
||
using AcDream.App.Rendering.Gpu;
|
||
using AcDream.App.Rendering.Wb;
|
||
using AcDream.Core.Meshing;
|
||
using AcDream.Content;
|
||
using AcDream.Core.Vfx;
|
||
using DatReaderWriter.Enums;
|
||
|
||
namespace AcDream.App.Rendering;
|
||
|
||
/// <summary>
|
||
/// Campaign V slice V6l: the particle renderer's RHI submission arm — V4e's
|
||
/// content, landed as a SECOND arm for the reason §5.5.6 gave.
|
||
///
|
||
/// <para><b>The contract amendment this arm exists to use.</b> Both particle
|
||
/// pipelines draw with PER-INSTANCE vertex attributes: <c>particle</c> at
|
||
/// locations 2–6 (centre, two sheet axes, colour, texture slot) and
|
||
/// <c>particle_mesh</c> at 3–7 (a <c>mat4</c> model and a colour). The V0
|
||
/// contract could express instanced DRAWING but not instanced vertex INPUT,
|
||
/// which is what stopped V4e at §5.5.16. <see cref="GpuVertexLayout"/> now
|
||
/// carries a per-binding stride and input rate — a second binding at
|
||
/// <see cref="GpuVertexInputRate.Instance"/> — which both backends implement
|
||
/// natively and at no cost.</para>
|
||
///
|
||
/// <para><b>What differs from the GL arm, and why.</b> The imperative
|
||
/// <c>glBlendFunc</c> switch becomes five PIPELINES (two billboard blends, three
|
||
/// mesh blends) because core Vulkan 1.3 does not make blend dynamic; the
|
||
/// per-flight VAO/VBO pool disappears because every ring allocation inside a
|
||
/// frame is already distinct memory that lives until the frame retires; the
|
||
/// binding-9 texture table is not bound at all, because the device owns the
|
||
/// table and the encoder binds set 2; and the pass is BORROWED from
|
||
/// <see cref="IWorldPassScope"/>, because the frame's one backbuffer pass
|
||
/// resolves and a second pass could not load what it left.</para>
|
||
///
|
||
/// <para>Everything above the submission seam — emitter iteration, retail
|
||
/// distance ordering, the deferred-alpha handoff to <see cref="RetailAlphaQueue"/>,
|
||
/// billboard axis construction, blend resolution — is the same CPU code on both
|
||
/// arms. Only where the bytes land differs.</para>
|
||
/// </summary>
|
||
public sealed unsafe partial class ParticleRenderer
|
||
{
|
||
private readonly IGpuDevice? _device;
|
||
private readonly ICurrentGpuFrameSource? _frames;
|
||
private readonly IWorldPassScope? _scope;
|
||
|
||
private IGpuPipeline? _billboardAlphaPipeline;
|
||
private IGpuPipeline? _billboardAdditivePipeline;
|
||
private IGpuPipeline? _meshAlphaPipeline;
|
||
private IGpuPipeline? _meshAdditivePipeline;
|
||
private IGpuPipeline? _meshInversePipeline;
|
||
private IGpuBuffer? _quadVertexBuffer;
|
||
private IGpuBuffer? _quadIndexBuffer;
|
||
|
||
/// <summary>
|
||
/// The unit quad both arms draw billboards from: XY in [-0.5, +0.5] with a
|
||
/// matching UV, four vertices of two floats each twice over.
|
||
/// </summary>
|
||
private static readonly float[] QuadVertices =
|
||
[
|
||
-0.5f, -0.5f, 0f, 0f,
|
||
0.5f, -0.5f, 1f, 0f,
|
||
0.5f, 0.5f, 1f, 1f,
|
||
-0.5f, 0.5f, 0f, 1f,
|
||
];
|
||
|
||
private static readonly uint[] QuadIndices = [0, 1, 2, 0, 2, 3];
|
||
|
||
private const uint QuadStrideBytes = 4 * sizeof(float);
|
||
|
||
private static readonly uint MeshInstanceStrideBytes =
|
||
(uint)sizeof(MeshParticleGpuInstance);
|
||
|
||
/// <summary>
|
||
/// The billboard layout: the shared unit quad at vertex rate, and one
|
||
/// <see cref="BillboardGpuInstance"/> per particle at instance rate.
|
||
///
|
||
/// <para>The instance stride is <c>sizeof(BillboardGpuInstance)</c> rather
|
||
/// than a restated number, for the reason §5.5.16 drew from the sky's
|
||
/// 32-versus-36 defect: a layout that restates a CPU record's footprint from
|
||
/// memory is one field away from scattering the draw into noise while leaving
|
||
/// nothing else in the frame visibly wrong.</para>
|
||
/// </summary>
|
||
internal static GpuVertexLayout BillboardVertexLayout { get; } = new(
|
||
ImmutableArray.Create(
|
||
new GpuVertexBinding(0, QuadStrideBytes, GpuVertexInputRate.Vertex),
|
||
new GpuVertexBinding(
|
||
1,
|
||
(uint)sizeof(BillboardGpuInstance),
|
||
GpuVertexInputRate.Instance)),
|
||
ImmutableArray.Create(
|
||
new GpuVertexAttribute(0, GpuVertexFormat.Float2, 0, Binding: 0),
|
||
new GpuVertexAttribute(1, GpuVertexFormat.Float2, 8, Binding: 0),
|
||
new GpuVertexAttribute(2, GpuVertexFormat.Float4, 0, Binding: 1),
|
||
new GpuVertexAttribute(3, GpuVertexFormat.Float4, 16, Binding: 1),
|
||
new GpuVertexAttribute(4, GpuVertexFormat.Float4, 32, Binding: 1),
|
||
new GpuVertexAttribute(5, GpuVertexFormat.Float4, 48, Binding: 1),
|
||
// Location 6 is `in uint aTextureIndex` — an INTEGER shader input,
|
||
// so R8G8B8A8's normalized cousin would be wrong in kind. It is one
|
||
// 32-bit unsigned value; Float1 would reinterpret its bits.
|
||
new GpuVertexAttribute(6, GpuVertexFormat.UInt1, 64, Binding: 1),
|
||
new GpuVertexAttribute(7, GpuVertexFormat.UInt1, 68, Binding: 1)));
|
||
|
||
/// <summary>
|
||
/// The mesh-particle layout: the shared world-mesh vertex at vertex rate,
|
||
/// and a <c>mat4</c> model plus a colour at instance rate. A <c>mat4</c>
|
||
/// vertex input occupies four consecutive locations, one per column, which is
|
||
/// exactly what the GL arm's four <c>glVertexAttribPointer</c> calls set up.
|
||
/// </summary>
|
||
internal static GpuVertexLayout MeshVertexLayout { get; } = new(
|
||
ImmutableArray.Create(
|
||
new GpuVertexBinding(
|
||
0,
|
||
GpuVertexLayout.WorldMesh.StrideBytes,
|
||
GpuVertexInputRate.Vertex),
|
||
new GpuVertexBinding(1, MeshInstanceStrideBytes, GpuVertexInputRate.Instance)),
|
||
ImmutableArray.Create(
|
||
new GpuVertexAttribute(0, GpuVertexFormat.Float3, 0, Binding: 0),
|
||
new GpuVertexAttribute(1, GpuVertexFormat.Float3, 12, Binding: 0),
|
||
new GpuVertexAttribute(2, GpuVertexFormat.Float2, 24, Binding: 0),
|
||
new GpuVertexAttribute(3, GpuVertexFormat.Float4, 0, Binding: 1),
|
||
new GpuVertexAttribute(4, GpuVertexFormat.Float4, 16, Binding: 1),
|
||
new GpuVertexAttribute(5, GpuVertexFormat.Float4, 32, Binding: 1),
|
||
new GpuVertexAttribute(6, GpuVertexFormat.Float4, 48, Binding: 1),
|
||
new GpuVertexAttribute(7, GpuVertexFormat.Float4, 64, Binding: 1),
|
||
new GpuVertexAttribute(8, GpuVertexFormat.UInt1, 80, Binding: 1)));
|
||
|
||
/// <summary>
|
||
/// The RHI arm's constructor. No GL context, no <c>Shader</c>, no
|
||
/// <c>BindlessSupport</c>: the five pipelines compile <c>particle</c> and
|
||
/// <c>particle_mesh</c> from the committed SPIR-V, and both texture sources
|
||
/// already hand out the device's own <c>GpuTextureSlot</c> (V4t).
|
||
/// </summary>
|
||
internal ParticleRenderer(
|
||
IGpuDevice device,
|
||
ICurrentGpuFrameSource frames,
|
||
IWorldPassScope scope,
|
||
ParticleSystem particles,
|
||
TextureCache? textures = null,
|
||
IDatReaderWriter? dats = null,
|
||
WbMeshAdapter? meshAdapter = null,
|
||
RetailAlphaQueue? alphaQueue = null,
|
||
long? alphaScratchBudgetBytes = null)
|
||
{
|
||
_device = device ?? throw new ArgumentNullException(nameof(device));
|
||
_frames = frames ?? throw new ArgumentNullException(nameof(frames));
|
||
_scope = scope ?? throw new ArgumentNullException(nameof(scope));
|
||
_textures = textures;
|
||
_dats = dats;
|
||
_meshAdapter = meshAdapter;
|
||
_particles = particles ?? throw new ArgumentNullException(nameof(particles));
|
||
_alphaQueue = alphaQueue;
|
||
_alphaSource = new AlphaDrawSource(this);
|
||
long scratchBudget = alphaScratchBudgetBytes
|
||
?? AcDream.App.Rendering.Residency.AlphaScratchBudgetProfile.Create(
|
||
AcDream.App.Rendering.Residency.ResidencyBudgetOptions.Default.AlphaScratchBytes)
|
||
.ParticleBytes;
|
||
_alphaScratchPolicy =
|
||
new AcDream.App.Rendering.Residency.RetainedScratchCapacityPolicy(scratchBudget);
|
||
if (_meshAdapter is not null)
|
||
{
|
||
_meshReferences = new ParticleMeshReferenceTracker(
|
||
gfxObjId => _meshAdapter.IncrementRefCount(gfxObjId),
|
||
gfxObjId => _meshAdapter.DecrementRefCount(gfxObjId));
|
||
}
|
||
_emitterRetirements = new ParticleEmitterRetirementTracker(
|
||
handle => _meshReferences?.Release(handle),
|
||
handle => _particleGfxInfoByEmitter.Remove(handle),
|
||
handle => _textures?.ReleaseParticleTextureOwner(handle),
|
||
error => Console.Error.WriteLine($"[particles] {error}"));
|
||
|
||
try
|
||
{
|
||
CreateRhiResources(device, scope.SampleCount);
|
||
_particles.EmitterDied += OnEmitterDied;
|
||
}
|
||
catch
|
||
{
|
||
DisposeRhiResources();
|
||
throw;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// True when mesh particles can be submitted at all. The GL arm's second
|
||
/// <c>Shader</c> answer was deleted at Campaign V slice V11; only the RHI
|
||
/// pipelines remain, built exactly when a shared mesh arena exists.
|
||
/// </summary>
|
||
private bool MeshParticlesAvailable => _meshAlphaPipeline is not null;
|
||
|
||
private void CreateRhiResources(IGpuDevice device, int sampleCount)
|
||
{
|
||
_billboardAlphaPipeline = CreateBillboardPipeline(
|
||
device, "particle-billboard-alpha", GpuBlendMode.StraightAlpha, sampleCount);
|
||
_billboardAdditivePipeline = CreateBillboardPipeline(
|
||
device, "particle-billboard-additive", GpuBlendMode.Additive, sampleCount);
|
||
|
||
ReadOnlySpan<byte> quadVertexBytes = MemoryMarshal.AsBytes<float>(QuadVertices);
|
||
_quadVertexBuffer = device.CreateBuffer(new GpuBufferDescription(
|
||
"particle-quad-vertices",
|
||
quadVertexBytes.Length,
|
||
GpuBufferUsage.Vertex | GpuBufferUsage.TransferDestination,
|
||
GpuMemoryResidency.DeviceLocal));
|
||
_quadVertexBuffer.Upload(0, quadVertexBytes);
|
||
|
||
ReadOnlySpan<byte> quadIndexBytes = MemoryMarshal.AsBytes<uint>(QuadIndices);
|
||
_quadIndexBuffer = device.CreateBuffer(new GpuBufferDescription(
|
||
"particle-quad-indices",
|
||
quadIndexBytes.Length,
|
||
GpuBufferUsage.Index | GpuBufferUsage.TransferDestination,
|
||
GpuMemoryResidency.DeviceLocal));
|
||
_quadIndexBuffer.Upload(0, quadIndexBytes);
|
||
|
||
// The mesh pipelines exist exactly when the GL arm's second shader would:
|
||
// when a shared mesh arena is published to draw instanced GfxObjs from.
|
||
if (_meshAdapter?.MeshManager?.GlobalBuffer is null)
|
||
return;
|
||
|
||
_meshAlphaPipeline = CreateMeshParticlePipeline(
|
||
device, "particle-mesh-alpha", GpuBlendMode.StraightAlpha, sampleCount);
|
||
_meshAdditivePipeline = CreateMeshParticlePipeline(
|
||
device, "particle-mesh-additive", GpuBlendMode.Additive, sampleCount);
|
||
_meshInversePipeline = CreateMeshParticlePipeline(
|
||
device, "particle-mesh-inverse", GpuBlendMode.InverseAlpha, sampleCount);
|
||
}
|
||
|
||
/// <summary>
|
||
/// One billboard pipeline. Depth TESTS but does not WRITE and culling is off,
|
||
/// which is the GL arm's bracket verbatim
|
||
/// (<c>Enable(DepthTest)</c>/<c>DepthMask(false)</c>/<c>Disable(CullFace)</c>).
|
||
///
|
||
/// <para>Depth compare is <c>Less</c>, not the contract's <c>LessOrEqual</c>
|
||
/// default: the world frame runs under <c>GL_LESS</c> and this renderer never
|
||
/// called <c>glDepthFunc</c>, so it inherited it. Alpha-to-coverage is off
|
||
/// for the same kind of reason and the opposite way round — the frame-global
|
||
/// state controller disables it and only <c>WbDrawDispatcher</c>'s opaque
|
||
/// bracket turns it on, so particles have never drawn with it.</para>
|
||
/// </summary>
|
||
private static IGpuPipeline CreateBillboardPipeline(
|
||
IGpuDevice device,
|
||
string name,
|
||
GpuBlendMode blend,
|
||
int sampleCount) =>
|
||
device.CreatePipeline(new GpuPipelineDescription
|
||
{
|
||
Name = name,
|
||
Shaders = new GpuShaderSet("particle"),
|
||
VertexLayout = BillboardVertexLayout,
|
||
Topology = GpuPrimitiveTopology.TriangleList,
|
||
Blend = blend,
|
||
Depth = new GpuDepthState(Test: true, Write: false, GpuCompareOp.Less),
|
||
Cull = GpuCullMode.None,
|
||
FrontFace = GpuFrontFace.CounterClockwise,
|
||
AlphaToCoverage = false,
|
||
ColorWrite = true,
|
||
SampleCount = sampleCount,
|
||
});
|
||
|
||
/// <summary>
|
||
/// One mesh-particle pipeline. Same depth bracket as the billboards; the
|
||
/// winding is CW because <c>PrepareMeshPipeline</c> sets
|
||
/// <c>glFrontFace(GL_CW)</c>, and the cull mode stays DYNAMIC because it is
|
||
/// resolved per sub-batch from the DAT's own <c>CullMode</c>.
|
||
/// </summary>
|
||
private static IGpuPipeline CreateMeshParticlePipeline(
|
||
IGpuDevice device,
|
||
string name,
|
||
GpuBlendMode blend,
|
||
int sampleCount) =>
|
||
device.CreatePipeline(new GpuPipelineDescription
|
||
{
|
||
Name = name,
|
||
Shaders = new GpuShaderSet("particle_mesh"),
|
||
VertexLayout = MeshVertexLayout,
|
||
Topology = GpuPrimitiveTopology.TriangleList,
|
||
Blend = blend,
|
||
Depth = new GpuDepthState(Test: true, Write: false, GpuCompareOp.Less),
|
||
Cull = GpuCullMode.None,
|
||
FrontFace = GpuFrontFace.Clockwise,
|
||
AlphaToCoverage = false,
|
||
ColorWrite = true,
|
||
SampleCount = sampleCount,
|
||
});
|
||
|
||
/// <summary>
|
||
/// The immediate ordered path on the RHI arm: the same runs, in the same
|
||
/// retail distance order, recorded into the borrowed world pass.
|
||
/// </summary>
|
||
private void DrawOrderedRhi(ICamera camera)
|
||
{
|
||
ParticleSubmissionOrdering.Sort(_submissionScratch);
|
||
GlobalMeshBuffer? global = _meshAdapter?.MeshManager?.GlobalBuffer;
|
||
Matrix4x4 viewProjection = camera.View * camera.Projection;
|
||
IGpuPassEncoder encoder = _scope!.RequireEncoder();
|
||
IGpuFrame frame = RequireRhiFrame();
|
||
|
||
for (int i = 0; i < _submissionScratch.Count;)
|
||
{
|
||
ParticleSubmission submission = _submissionScratch[i];
|
||
if (submission.Kind == ParticleSubmissionKind.Billboard)
|
||
{
|
||
BatchKey key = _drawListScratch[submission.DrawIndex].Key;
|
||
_runScratch.Clear();
|
||
do
|
||
{
|
||
_runScratch.Add(_drawListScratch[submission.DrawIndex].Instance);
|
||
i++;
|
||
if (i >= _submissionScratch.Count)
|
||
break;
|
||
submission = _submissionScratch[i];
|
||
}
|
||
while (submission.Kind == ParticleSubmissionKind.Billboard
|
||
&& _drawListScratch[submission.DrawIndex].Key == key);
|
||
|
||
DrawInstancesRhi(encoder, frame, _runScratch, viewProjection, key.Additive);
|
||
continue;
|
||
}
|
||
|
||
if (!MeshParticlesAvailable || global is null)
|
||
{
|
||
i++;
|
||
continue;
|
||
}
|
||
|
||
MeshParticleDraw meshDraw = _meshDrawListScratch[submission.DrawIndex];
|
||
MeshBatchKey meshKey = meshDraw.Key;
|
||
ObjectRenderBatch batch = meshDraw.Batch;
|
||
_meshRunScratch.Clear();
|
||
do
|
||
{
|
||
_meshRunScratch.Add(_meshDrawListScratch[submission.DrawIndex].Instance);
|
||
i++;
|
||
if (i >= _submissionScratch.Count)
|
||
break;
|
||
submission = _submissionScratch[i];
|
||
}
|
||
while (submission.Kind == ParticleSubmissionKind.Mesh
|
||
&& _meshDrawListScratch[submission.DrawIndex].Key == meshKey);
|
||
|
||
int neededInstances = _meshRunScratch.Count;
|
||
if (_meshInstanceScratch.Length < neededInstances)
|
||
_meshInstanceScratch = new MeshParticleGpuInstance[neededInstances + 256];
|
||
for (int instance = 0; instance < _meshRunScratch.Count; instance++)
|
||
{
|
||
WriteMeshGpuInstance(
|
||
ref _meshInstanceScratch[instance],
|
||
_meshRunScratch[instance]);
|
||
}
|
||
|
||
GpuRingAllocation instances = WriteVertexRing<MeshParticleGpuInstance>(
|
||
frame,
|
||
_meshInstanceScratch.AsSpan(0, neededInstances));
|
||
DrawMeshBatchRhi(
|
||
encoder,
|
||
frame,
|
||
global,
|
||
batch,
|
||
viewProjection,
|
||
instances.Buffer,
|
||
instances.OffsetBytes,
|
||
(uint)_meshRunScratch.Count,
|
||
firstInstance: 0);
|
||
}
|
||
}
|
||
|
||
private void DrawInstancesRhi(
|
||
IGpuPassEncoder encoder,
|
||
IGpuFrame frame,
|
||
List<ParticleInstance> instances,
|
||
Matrix4x4 viewProjection,
|
||
bool additive)
|
||
{
|
||
if (instances.Count == 0)
|
||
return;
|
||
|
||
if (_instanceScratch.Length < instances.Count)
|
||
_instanceScratch = new BillboardGpuInstance[instances.Count + 256];
|
||
for (int i = 0; i < instances.Count; i++)
|
||
WriteBillboardGpuInstance(ref _instanceScratch[i], instances[i]);
|
||
|
||
GpuRingAllocation ring = WriteVertexRing<BillboardGpuInstance>(
|
||
frame,
|
||
_instanceScratch.AsSpan(0, instances.Count));
|
||
BindBillboardPipeline(
|
||
encoder,
|
||
frame,
|
||
viewProjection,
|
||
additive,
|
||
ring.Buffer,
|
||
ring.OffsetBytes);
|
||
encoder.DrawIndexed(
|
||
(uint)QuadIndices.Length,
|
||
(uint)instances.Count,
|
||
0,
|
||
0,
|
||
0);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Binds a billboard pipeline and immediately re-establishes both vertex
|
||
/// sources and the index source. Every pipeline owns its own vertex array on
|
||
/// GL, and attribute pointers plus the index binding are vertex-array state,
|
||
/// so a pipeline switch silently drops them while storage bindings survive.
|
||
/// </summary>
|
||
private void BindBillboardPipeline(
|
||
IGpuPassEncoder encoder,
|
||
IGpuFrame frame,
|
||
Matrix4x4 viewProjection,
|
||
bool additive,
|
||
IGpuBuffer instanceBuffer,
|
||
uint instanceOffsetBytes)
|
||
{
|
||
encoder.BindPipeline(additive
|
||
? _billboardAdditivePipeline!
|
||
: _billboardAlphaPipeline!);
|
||
encoder.SetPushConstants(new GpuPushConstants
|
||
{
|
||
ViewProjection = viewProjection,
|
||
DrawIdOffset = 0,
|
||
LightingMode = 0,
|
||
RenderPass = 0,
|
||
LightDebug = 0,
|
||
// Billboards carry their texture slot per instance at location 6;
|
||
// the block's texture members are unread by particle.frag.
|
||
TextureIndexA = 0,
|
||
TextureIndexB = 0,
|
||
ParamA = 0f,
|
||
ParamB = 0f,
|
||
});
|
||
encoder.BindVertexBuffer(0, _quadVertexBuffer!, 0);
|
||
encoder.BindVertexBuffer(1, instanceBuffer, instanceOffsetBytes);
|
||
encoder.BindIndexBuffer(_quadIndexBuffer!, 0, GpuIndexType.UInt32);
|
||
WorldFrameSectionBinding.BindClipRegions(
|
||
encoder,
|
||
_scope!.Sections,
|
||
frame);
|
||
}
|
||
|
||
private void DrawMeshBatchRhi(
|
||
IGpuPassEncoder encoder,
|
||
IGpuFrame frame,
|
||
GlobalMeshBuffer global,
|
||
ObjectRenderBatch batch,
|
||
Matrix4x4 viewProjection,
|
||
IGpuBuffer instanceBuffer,
|
||
uint instanceOffsetBytes,
|
||
uint instanceCount,
|
||
uint firstInstance)
|
||
{
|
||
if (instanceCount == 0)
|
||
return;
|
||
|
||
encoder.BindPipeline(PipelineForMeshBlend(ResolveMeshBlend(batch)));
|
||
encoder.SetPushConstants(new GpuPushConstants
|
||
{
|
||
ViewProjection = viewProjection,
|
||
DrawIdOffset = 0,
|
||
LightingMode = 0,
|
||
RenderPass = 0,
|
||
LightDebug = 0,
|
||
TextureIndexA = batch.TextureSlot.Index,
|
||
TextureIndexB = 0,
|
||
// uParamA is a float, so the array layer is widened here rather than
|
||
// in the shader. Layers are small integers; the sampled value is
|
||
// bit-identical to the GL arm's.
|
||
ParamA = batch.TextureIndex,
|
||
ParamB = 0f,
|
||
});
|
||
// BindPipeline restores the pipeline's own default cull mode, so the
|
||
// per-sub-batch override has to follow it, exactly as the world
|
||
// dispatcher's does.
|
||
ApplyMeshCullModeRhi(encoder, batch.CullMode);
|
||
encoder.BindVertexBuffer(
|
||
0,
|
||
global.VertexStore ?? throw new InvalidOperationException(
|
||
"The shared mesh arena has no vertex store."),
|
||
0);
|
||
encoder.BindVertexBuffer(1, instanceBuffer, instanceOffsetBytes);
|
||
encoder.BindIndexBuffer(
|
||
global.IndexStore ?? throw new InvalidOperationException(
|
||
"The shared mesh arena has no index store."),
|
||
0,
|
||
GpuIndexType.UInt16);
|
||
WorldFrameSectionBinding.BindClipRegions(
|
||
encoder,
|
||
_scope!.Sections,
|
||
frame);
|
||
encoder.DrawIndexed(
|
||
(uint)batch.IndexCount,
|
||
instanceCount,
|
||
(uint)batch.FirstIndex,
|
||
(int)batch.BaseVertex,
|
||
firstInstance);
|
||
}
|
||
|
||
private IGpuPipeline PipelineForMeshBlend(TranslucencyKind blend) => blend switch
|
||
{
|
||
TranslucencyKind.Additive => _meshAdditivePipeline!,
|
||
TranslucencyKind.InvAlpha => _meshInversePipeline!,
|
||
_ => _meshAlphaPipeline!,
|
||
};
|
||
|
||
/// <summary>
|
||
/// The RHI form of <see cref="ApplyMeshCullMode"/>. <c>FrontFace</c> is
|
||
/// re-issued with it because <c>BindPipeline</c> restores the pipeline's own
|
||
/// default and the two always travel together on the GL arm.
|
||
/// </summary>
|
||
private static void ApplyMeshCullModeRhi(IGpuPassEncoder encoder, CullMode mode)
|
||
{
|
||
encoder.SetFrontFace(GpuFrontFace.Clockwise);
|
||
encoder.SetCullMode(mode switch
|
||
{
|
||
CullMode.None => GpuCullMode.None,
|
||
CullMode.Clockwise => GpuCullMode.Front,
|
||
_ => GpuCullMode.Back,
|
||
});
|
||
}
|
||
|
||
/// <summary>
|
||
/// Writes the whole deferred-alpha payload into the frame ring once. The two
|
||
/// sections survive as ordinary values so every later
|
||
/// <see cref="DrawPreparedAlphaBatchRhi"/> binds the same bytes with a
|
||
/// <c>firstInstance</c> offset instead of recopying — which is exactly what
|
||
/// the GL arm's <c>baseInstance</c> does.
|
||
/// </summary>
|
||
private void PrepareDeferredAlphaDrawsRhi(ReadOnlySpan<int> tokens)
|
||
{
|
||
IGpuFrame frame = RequireRhiFrame();
|
||
int count = tokens.Length;
|
||
if (_preparedAlpha.Length < count)
|
||
Array.Resize(ref _preparedAlpha, count + 256);
|
||
if (_preparedInstanceOffsets.Length < count)
|
||
Array.Resize(ref _preparedInstanceOffsets, count + 256);
|
||
if (_instanceScratch.Length < count)
|
||
Array.Resize(ref _instanceScratch, count + 256);
|
||
if (_meshInstanceScratch.Length < count)
|
||
_meshInstanceScratch = new MeshParticleGpuInstance[count + 256];
|
||
|
||
int billboardCount = 0;
|
||
int meshCount = 0;
|
||
for (int i = 0; i < count; i++)
|
||
{
|
||
DeferredParticleDraw deferred = _deferredAlpha[tokens[i]];
|
||
_preparedAlpha[i] = deferred;
|
||
if (deferred.Kind == ParticleSubmissionKind.Billboard)
|
||
{
|
||
_preparedInstanceOffsets[i] = (uint)billboardCount;
|
||
WriteBillboardGpuInstance(
|
||
ref _instanceScratch[billboardCount++],
|
||
deferred.Billboard.Instance);
|
||
}
|
||
else
|
||
{
|
||
_preparedInstanceOffsets[i] = (uint)meshCount;
|
||
WriteMeshGpuInstance(
|
||
ref _meshInstanceScratch[meshCount++],
|
||
deferred.Mesh.Instance);
|
||
}
|
||
}
|
||
|
||
_preparedBillboardInstances = billboardCount > 0
|
||
? SectionOf(WriteVertexRing<BillboardGpuInstance>(
|
||
frame,
|
||
_instanceScratch.AsSpan(0, billboardCount)))
|
||
: default;
|
||
_preparedMeshInstances = meshCount > 0
|
||
? SectionOf(WriteVertexRing<MeshParticleGpuInstance>(
|
||
frame,
|
||
_meshInstanceScratch.AsSpan(0, meshCount)))
|
||
: default;
|
||
_preparedAlphaCount = count;
|
||
}
|
||
|
||
private void DrawPreparedAlphaBatchRhi(int firstPreparedDraw, int drawCount)
|
||
{
|
||
GlobalMeshBuffer? global = _meshAdapter?.MeshManager?.GlobalBuffer;
|
||
IGpuPassEncoder encoder = _scope!.RequireEncoder();
|
||
|
||
int i = firstPreparedDraw;
|
||
int preparedEnd = firstPreparedDraw + drawCount;
|
||
while (i < preparedEnd)
|
||
{
|
||
DeferredParticleDraw deferred = _preparedAlpha[i];
|
||
if (deferred.Kind == ParticleSubmissionKind.Billboard)
|
||
{
|
||
BatchKey key = deferred.Billboard.Key;
|
||
Matrix4x4 viewProjection = deferred.ViewProjection;
|
||
uint baseInstance = _preparedInstanceOffsets[i];
|
||
int runStart = i;
|
||
do
|
||
{
|
||
i++;
|
||
if (i >= preparedEnd)
|
||
break;
|
||
deferred = _preparedAlpha[i];
|
||
}
|
||
while (deferred.Kind == ParticleSubmissionKind.Billboard
|
||
&& deferred.Billboard.Key == key
|
||
&& deferred.ViewProjection == viewProjection);
|
||
|
||
if (_preparedBillboardInstances.Buffer is { } billboards)
|
||
{
|
||
BindBillboardPipeline(
|
||
encoder,
|
||
RequireRhiFrame(),
|
||
viewProjection,
|
||
key.Additive,
|
||
billboards,
|
||
_preparedBillboardInstances.OffsetBytes);
|
||
encoder.DrawIndexed(
|
||
(uint)QuadIndices.Length,
|
||
(uint)(i - runStart),
|
||
0,
|
||
0,
|
||
baseInstance);
|
||
}
|
||
|
||
continue;
|
||
}
|
||
|
||
if (!MeshParticlesAvailable || global is null)
|
||
{
|
||
i++;
|
||
continue;
|
||
}
|
||
|
||
MeshBatchKey meshKey = deferred.Mesh.Key;
|
||
ObjectRenderBatch batch = deferred.Mesh.Batch;
|
||
Matrix4x4 meshViewProjection = deferred.ViewProjection;
|
||
uint meshBaseInstance = _preparedInstanceOffsets[i];
|
||
int meshRunStart = i;
|
||
do
|
||
{
|
||
i++;
|
||
if (i >= preparedEnd)
|
||
break;
|
||
deferred = _preparedAlpha[i];
|
||
}
|
||
while (deferred.Kind == ParticleSubmissionKind.Mesh
|
||
&& deferred.Mesh.Key == meshKey
|
||
&& deferred.ViewProjection == meshViewProjection);
|
||
|
||
if (_preparedMeshInstances.Buffer is { } meshInstances)
|
||
{
|
||
DrawMeshBatchRhi(
|
||
encoder,
|
||
RequireRhiFrame(),
|
||
global,
|
||
batch,
|
||
meshViewProjection,
|
||
meshInstances,
|
||
_preparedMeshInstances.OffsetBytes,
|
||
(uint)(i - meshRunStart),
|
||
meshBaseInstance);
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>A ring slice reduced to the two values a later vertex bind needs.</summary>
|
||
private readonly record struct RhiVertexSection(IGpuBuffer? Buffer, uint OffsetBytes);
|
||
|
||
private RhiVertexSection _preparedBillboardInstances;
|
||
private RhiVertexSection _preparedMeshInstances;
|
||
|
||
private static RhiVertexSection SectionOf(GpuRingAllocation allocation) =>
|
||
new(allocation.Buffer, allocation.OffsetBytes);
|
||
|
||
private static GpuRingAllocation WriteVertexRing<T>(IGpuFrame frame, ReadOnlySpan<T> data)
|
||
where T : unmanaged
|
||
{
|
||
int elementBytes = sizeof(T);
|
||
int byteCount = Math.Max(data.Length * elementBytes, elementBytes);
|
||
GpuRingAllocation allocation = frame.AllocateRing(byteCount, GpuRingUsage.Vertex);
|
||
if (!data.IsEmpty)
|
||
data.CopyTo(allocation.AsSpan<T>());
|
||
return allocation;
|
||
}
|
||
|
||
private IGpuFrame RequireRhiFrame()
|
||
{
|
||
if (!_dynamicFrameStarted)
|
||
throw new InvalidOperationException("BeginFrame must be called before drawing particles.");
|
||
|
||
return _frames!.CurrentFrame
|
||
?? throw new InvalidOperationException(
|
||
"ParticleRenderer requires an open IGpuFrame (see GpuDeviceFrameLifetime).");
|
||
}
|
||
|
||
private void DisposeRhiResources()
|
||
{
|
||
List<Exception>? failures = null;
|
||
void Attempt(Action action)
|
||
{
|
||
try { action(); }
|
||
catch (Exception error) { (failures ??= []).Add(error); }
|
||
}
|
||
|
||
Attempt(() => _billboardAlphaPipeline?.Dispose());
|
||
_billboardAlphaPipeline = null;
|
||
Attempt(() => _billboardAdditivePipeline?.Dispose());
|
||
_billboardAdditivePipeline = null;
|
||
Attempt(() => _meshAlphaPipeline?.Dispose());
|
||
_meshAlphaPipeline = null;
|
||
Attempt(() => _meshAdditivePipeline?.Dispose());
|
||
_meshAdditivePipeline = null;
|
||
Attempt(() => _meshInversePipeline?.Dispose());
|
||
_meshInversePipeline = null;
|
||
Attempt(() => _quadVertexBuffer?.Dispose());
|
||
_quadVertexBuffer = null;
|
||
Attempt(() => _quadIndexBuffer?.Dispose());
|
||
_quadIndexBuffer = null;
|
||
_preparedBillboardInstances = default;
|
||
_preparedMeshInstances = default;
|
||
|
||
if (failures is not null)
|
||
throw new AggregateException("The particle renderer's RHI resources did not fully release.", failures);
|
||
}
|
||
}
|