Particle revamp (Part 1)

I did not post for a little while, been attending several events in the mean time:

• Kinecthack London: Worked on network Kinect stream and real time point cloud alignment
• Revision : Did my first production in a demoparty (ranked 8th in demo category)
• Node15: Workshops and some quick sneaky DX12 presentation (Note: I'm not part of Early Access Program, I just figured the API myself and managed to get some render system up and running fighting with drivers, so I'm not on NDA ;)

Ok all those events were great fun, I should explain some technical parts about it, will do at some point, but for now let's go into some other technical parts.


I wanted to revamp my particle system for a while, at some point I was thinking maybe a scratch rewrite would be fine since it's not an insane code base, but as usual my sensible way of doing comes back and I decided to just improve and refactor, which is always a better decision ;)


So I got a lot of nice features already, tons of emitters (Position, Distance Field, Texture, Mesh, Kinect2, Point clouds...), some nice interaction parts, including advanced effectors like Sph,(accelerated with spatial grids), plenty of various force fields, and collider system (mostly distance field based, after all, a plane collider is just a distance field check with a specific function).


Many effectors can also be controlled via "micro curves" (which is basically a 1d texture rendered from a track in my timeline, and driven by particle age.


All the simulation part is entirely manager in my GPU (compute shader), and is pretty fast so I did not feel that part needed a major rewrite (but will have improvements, that's for next post).


Particle counter is basically a ring buffer, and is currently managed in CPU, which is not a big deal for effectors, but a real problem for emitters, and since now most of my machines are fully dx11.1 enabled (eg: I got access to UAV at every stage feature), this becomes quite a blocker (as it opens a lot of possibilities that I'll explain later).


So I decided to revamp (here understand : improve, not rewrite) this part, but first let's explain the problem.


So we have a small structure that maintains the emission counters, like:

Code Snippet

15. [StructLayout(LayoutKind.Sequential)]
16. public struct EmitData
17. {
18.     public uint EmitCount;
19.     public uint MaxParticles;
20.     public uint EmitOffset;
21.     public uint ThisFrameCount;
22.     public uint ThisFrameStartOffset;
23.     private Vector3 dummy;
24. }

As you see it's just an evil mutable struct (it's only used to copy to constant buffer, don't worry ;)

Now emitter just implements a simple interface:

Code Snippet

56. public interface IParticleEmitterObject : IParticleEffectObject
57. {
58.     int Emit(RenderContext context, ParticleSystem particles);
59. }

As you see, emitters returns how many particles they did emit, then the particle system, after each emitter has been processed, updates the counters structures no next emitter starts in the right location.

This works really well for simple emitters (32 particles randomly placed), but now I also have emitters that take data from GPU.

So let's take another example, emit from texture.
This is done in the following steps:

• Create a buffer (pos+color), with an Append flag
• Dispatch a compute shader that will go read each pixel
• If pixel satisfies a condition (luminance for example, but can be anything else), append the pixel position + color in the Append buffer. 
• Copy buffer counter.
• Dispatch N particles (where N is in CPU), get a random pixel that did satisfy the condition and push it to the particles buffers.

Now as you can clearly see that creates a problem, the amount of particles to emit is set in CPU, but we have no idea how many pixels did satisfy the condition. So we can have 3 edgy (and one can be nasty) cases (consider our emit count is 32)

• We can have 20000 pixels that pass the test in frame 1, and emit 32 particles from that, int the next frame, I can emit 32 particles from a 200 pixel buffer. This means we have poor coverage control, I'd like to emit more particles if more pixels pass the test.
• Less than 32 pixels passed the test (like 10), so some element get emitted several times.
• Worst case of all, no pixels at all pass the test, so result can be... unpredictable.

So to handle those cases, we have several options:

• In the compute shader emitter, if thread ID is > amount of elements that pass the test, push a "degenerate particle" (like position = float.maxvalue). This is of course ugly, needs to be repeated in every shader that take a gpu counter, but at least it works (even tho it could provide problems at simulation level).
• Get the counter back in CPU: This is simple (just copy the counter back in a small staging buffer and read it back into cpu, then choose what you do), but it creates a stall as we need to flush and process the command buffer, and wait for it to be fully executed before to get back our 4 precious bytes. So again, not ideal.
• Do it properly :) Move the counter data in GPU, and code to maintain that data to compute shader, and profit :)

So first thing, since counter data is in a constant buffer, let's not change all the shaders and the logic, so we use a small structured buffer which contains an exact copy of the data (so we process in structured buffer, and then use CopyResource to copy from StructuredBuffer to Constant Buffer

Code Snippet

6. //Matches the cbuffer layout, so we can use copyresource
7. struct sParticleEmitInfo
8. {
9.     uint emitCount;
10.     uint maxParticles;
11.     uint emitOffset;
12.     uint thisFrameCount;
13.     uint thisFrameStartOffset;
14.     float3 dummy; //to match cbuffer padding
15. };
16.  
17. StructuredBuffer<sParticleEmitInfo> ParticleEmitBuffer : PARTICLEEMITBUFFER;
18. RWStructuredBuffer<sParticleEmitInfo> RWParticleEmitBuffer : RWPARTICLEEMITBUFFER;

Now we need to modify our emitter, so amount of particles emitted can be either provided as int (like before), or using a location in our graphics card.

So for this we model a union type, I would gladly prefer that in f# but for now don't want to move all my codebase to it :)

Code Snippet

11. public class ParticleEmitterResult
12. {
13.     private StaticResult staticResult;
14.     private DidNotRunResult didNotRunResult;
15.     private UnorderedAccessViewResult uavResult;
16.     private BufferResult bufferResult;
17.     private ResultType resultType;
18.  
19.     private ParticleEmitterResult()
20.     {
21.  
22.     }
23.  
24.     public static ParticleEmitterResult DidNotRun()
25.     {
26.         ParticleEmitterResult result = new ParticleEmitterResult();
27.         result.didNotRunResult = new DidNotRunResult();
28.         result.resultType = ResultType.DidNotRun;
29.         return result;
30.     }
31.  
32.     public static ParticleEmitterResult Static(uint elementCount)
33.     {
34.         ParticleEmitterResult result = new ParticleEmitterResult();
35.         result.staticResult = new StaticResult(elementCount);
36.         result.resultType = ResultType.Static;
37.         return result;
38.     }
39.  
40.     public static ParticleEmitterResult UnorderedView(UnorderedAccessView view)
41.     {
42.         if (view == null)
43.             throw new ArgumentNullException("view");
44.  
45.         ParticleEmitterResult result = new ParticleEmitterResult();
46.         result.uavResult = new UnorderedAccessViewResult(view);
47.         result.resultType = ResultType.Uav;
48.         return result;
49.     }
50.  
51.     public static ParticleEmitterResult Buffer(SharpDX.Direct3D11.Buffer buffer, int offset)
52.     {
53.         if (buffer == null)
54.             throw new ArgumentNullException("buffer");
55.         if (offset < 0)
56.             throw new ArgumentOutOfRangeException("offset", "offset must be greater than 0");
57.  
58.         ParticleEmitterResult result = new ParticleEmitterResult();
59.         result.bufferResult = new BufferResult(buffer, offset);
60.         result.resultType = ResultType.Buffer;
61.         return result;
62.     }
63.  
64.     internal void Handle(RenderContext context, IParticleEmitterResultHandler handler)
65.     {
66.         switch(this.resultType)
67.         {
68.             case ResultType.DidNotRun:
69.                 handler.HandleDidNotRun(context);
70.                 break;
71.             case ResultType.Static:
72.                 handler.HandleStaticResult(context, this.staticResult.ElementCount);
73.                 break;
74.             case ResultType.Uav:
75.                 handler.HandleUavResult(context, this.uavResult.UnorderedView);
76.                 break;
77.             case ResultType.Buffer:
78.                 handler.HandleBuffer(context, this.bufferResult.Buffer, this.bufferResult.Offset);
79.                 break;
80.         }
81.     }
82.  
83.     public enum ResultType { DidNotRun, Static, Uav, Buffer }
84.  
85.     public sealed class DidNotRunResult
86.     {
87.  
88.     }
89.  
90.     public sealed class StaticResult
91.     {
92.         private readonly uint elementCount;
93.  
94.         public uint ElementCount
95.         {
96.             get { return this.elementCount; }
97.         }
98.  
99.         public StaticResult(uint elementCount)
100.         {
101.             this.elementCount = elementCount;
102.         }
103.     }
104.  
105.     public sealed class UnorderedAccessViewResult
106.     {
107.         private readonly UnorderedAccessView view;
108.         
109.         public UnorderedAccessView UnorderedView
110.         {
111.             get { return this.view; }
112.         }
113.  
114.         public UnorderedAccessViewResult(UnorderedAccessView view)
115.         {
116.             this.view = view;
117.         }
118.     }
119.  
120.     public sealed class BufferResult
121.     {
122.         private readonly SharpDX.Direct3D11.Buffer buffer;
123.         private readonly int offset;
124.  
125.         public SharpDX.Direct3D11.Buffer Buffer
126.         {
127.             get { return this.buffer; }
128.         }
129.  
130.         public int Offset
131.         {
132.             get { return this.offset; }
133.         }
134.  
135.         public BufferResult(SharpDX.Direct3D11.Buffer buffer, int offset)
136.         {
137.             this.buffer = buffer;
138.             this.offset = offset;
139.         }
140.     }
141. }

This is a bit cumbersome, but well it's pretty safe to use.
As a side note in f# this would look like this:

Code Snippet

3. open SharpDX.Direct3D11
4. open System
5.  
6. type ParticleSystemArgs(maxElements:int) =
7.     member x.maxElements = maxElements
8.  
9. type StaticEmitResult(elementCount:int) =
10.     member x.elementCount = if elementCount < 0 then raise(ArgumentOutOfRangeException("elementCount","Muse be greater or equalthan 0")) else elementCount
11.  
12. type EmitUnorderedViewResult(view:UnorderedAccessView) =
13.     member x.view = if view = null then raise(ArgumentNullException("view")) else view
14.  
15. type EmitBufferResult(buffer:Buffer,offset:int) =
16.     member x.buffer = if buffer = null then raise(ArgumentNullException("buffer")) else buffer
17.     member x.offset = if offset < 0 then raise(ArgumentOutOfRangeException("offset","Offset should be greater or equal than 0")) else offset
18.  
19. type ParticleEmitResult =
20.     | DidNotEmit of unit
21.     | StaticResult of StaticEmitResult
22.     | UavResult of EmitUnorderedViewResult
23.     | BufferResult of EmitBufferResult
24.  
25. type IParticleEmitter =
26.    // abstract method
27.    abstract member Emit: ParticleSystemArgs -> ParticleEmitResult
28.  
29. type IParticleEmitHandler =  
30.     abstract member HandleNoEmit : unit -> unit
31.     abstract member HandleStatic : int -> unit
32.     abstract member HandleUav : UnorderedAccessView -> unit
33.     abstract member HandleBuffer : EmitBufferResult -> unit
34.  
35.  
36. module ParticleFunctions =
37.  
38.     let ApplyHandler (x:ParticleEmitResult, handler: IParticleEmitHandler)=
39.         match x with
40.             | DidNotEmit d -> handler.HandleNoEmit()
41.             | StaticResult sr -> handler.HandleStatic(sr.elementCount)
42.             | UavResult ur -> handler.HandleUav(ur.view)
43.             | BufferResult br -> handler.HandleBuffer(br)
44.  
45.     let DoEmit(emitter:IParticleEmitter,args:ParticleSystemArgs, handler : IParticleEmitHandler) =
46.         ApplyHandler(emitter.Emit(args), handler)

Much more concise and the pattern matching is much safer in there, but whatever :)

Code Snippet

56. public interface IParticleEmitterObject : IParticleEffectObject
57. {
58.     ParticleEmitterResult Emit(RenderContext context, ParticleSystem particles);
59. }

Pretty simple, now we can return different data types that can contain data.

And now we have another interface to handle result, as :

Code Snippet

11. public interface IParticleEmitterResultHandler
12. {
13.     void HandleDidNotRun(RenderContext context);
14.     void HandleStaticResult(RenderContext context, uint elementCount);
15.     void HandleUavResult(RenderContext context, UnorderedAccessView uav);
16.     void HandleBuffer(RenderContext context, SharpDX.Direct3D11.Buffer buffer, int offset);
17. }

As you can see, there's 4 cases, let's first explain those:

• Did not run: Emitter did not run at all, I decided to have it as a case instead of returning 0 (so you can also explain why it did not run.
• Static : This is the same case as our previous cases
• UnorderedView : Counter is located in UAV, which is the case we we use Emit/Counter buffers to push particles. So for example if we want to emit every pixel that did pass the test in our previous case, we do an indirect dispatch and return the view (which contains the counter)
• Buffer : This is in a GPU buffer (we also need to provide location in that case). This is very useful for coverage based emitters (for example, we could say, emit 50% of the elements that passed the test every frame, in that case we need to process the counter in a small compute shader to generate a custom dispatch call).

So from there, we can easily update our structured buffer above (using compute shader, but actually kept the readback version for debug purposes)

Now the only small difference is when processing effectors, we don't know the particle count anymore, so instead of using Dispatch we use DispatchIndirect (which is trivial to implement), and use Indirect buffers for drawing as well so, DrawIndirect to draw as sprite, and DrawIndexedInstancedIndirect to render particles as geometry.

So here we go, from there we have a fully fledged counter system in our graphics card, which also mean, for any type of emitters where we want to push every element that pass the test, we can now do it in a single pass (no more need for intermediate buffer, use a CounterBuffer or use InterlockedAdd).

And now since got access to UAV at every stage, it's possible to load balance using tessellation/domain shader

Here is an example of an hybrid particle emitter (which doesn't draw anything on screen but just push adaptive amount of particles depending on triangle size)

Declaration:

Code Snippet

20. cbuffer cbemitParams : register(b0)
21. {
22.     float MinSize = 0.1f;
23.     float MaxSize = 20.0f;
24.     float MinimumTessel = 1.0f;
25.     float MaximumTessel = 12.0f;
26.     float VelocityScale = 1.0f;
27. };
28.  
29. struct vsInput
30. {
31.     float3 p : POSITION;
32.     float3 n : NORMAL;
33. };
34.  
35. struct hsConstOutput
36. {
37.     float edges[3]        : SV_TessFactor;
38.     float inside[1]       : SV_InsideTessFactor;
39. };

Our hardcore vertex and hull shaders:

Code Snippet

41. vsInput VS(vsInput input)
42. {
43.     return input;
44. }
45.  
46. [domain("tri")]
47. [partitioning("fractional_even")]
48. [outputtopology("triangle_cw")]
49. [outputcontrolpoints(3)]
50. [patchconstantfunc("HSConst")]
51. vsInput HS(InputPatch<vsInput, 3> input, uint id : SV_OutputControlPointID)
52. {
53.     return input[id];
54. }

Now the hull constant function, which defines tesselation factor based on triangle size:

Code Snippet

56. hsConstOutput HSConst(InputPatch<vsInput, 3> patch)
57. {
58.     hsConstOutput output;
59.     
60.     float3 p1 = patch[0].p;
61.     float3 p2 = patch[1].p;
62.     float3 p3 = patch[2].p;
63.     
64.     float v = length(cross(p2-p1,p3-p1));
65.     
66.     float r = MaxSize - MinSize;
67.     float n = (v - MinSize) / r;
68.     float f = MinimumTessel + n * (MaximumTessel - MinimumTessel);
69.     f = clamp(f,MinimumTessel,MaximumTessel);
70.     
71.     output.edges[0] = f;
72.     output.edges[1] = f;
73.     output.edges[2] = f;
74.     output.inside[0] =f;
75.     
76.     return output;
77. }

And the domain shader, which performs the emission:

Code Snippet

60. [domain("tri")]
61. void DS(hsConstOutput input, OutputPatch<vsInput, 3> op, float3 dl : SV_DomainLocation)
62. {
63.     uint vid = RWPositionBuffer.IncrementCounter();
64.  
65.     float3 p = uv.x * op[0].p
66.         + uv.y * op[1].p
67.         + uv.z * op[2].p;
68.  
69.     float3 n = uv.x * op[0].n
70.         + uv.y * op[1].n
71.         + uv.z * op[2].n;
72.  
73.     n = normalize(n) * VelocityScale;
74.  
75.     uint particleid = (vid + EmitOffset) % MaxParticles;
76.  
77.     RWPositionBuffer[particleid] = p;
78.     RWInitialPositionBuffer[particleid] = p;
79.     RWVelocityBuffer[particleid] = n;
80. }

As you see we perform increment counter on Particle position buffer (flag is set to 0 before to run the shader).

Then we just return the position buffer UAV as a result, which contains the total amount of particles that got emitted.

Make sure to disable pixelshader and geometry shader, set a dummy viewport (otherwise it will not run), and disable depth state, and profit :)

Next part, demoing various emitters, and explain some other new features that this did open.