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.

OpenCV, Compute and immutability

I know some of my friends use rather regularly the very nice OpenCV contribution from Elliot Woods.

Most times people use the Camera/Projector calibration tool. This works pretty well (could do with some ui improvemements), but most times I wanted to look at it I always end up with the same problem, you need to download the whole Image pack.

This is a great pack of course, but in that scenario, downloading a 500 megs bulk of dlls (which can also depend of version) is let's call "not ideal". Ok in our times with super fast internet you would think it's ok, but well, my hard drive doesn't like it (so I don't either). All that to call a single opencv function!

So just wrote a small P/Invoke dll (and use static library linking instead of dynamic), one 20 lines of dynamic plugin to call the function and here we go, 1 megabyte dll which doesn't need any other external. I like minimalism ;)

I remember I wanted to do this for a while, and considering the amount of (no) time it took I fell very embarrassed )

Now after this there's a (few) things I wanted to add/change in that tool.

First the point selection is nice in some cases, but not so nice in others. Basically current technique renders object space coordinates in a texture, then you just sample that texture.

If you have a model crammed with small polygons it's fine enough, but what I would simply like to do in general is just get closest vertex from a triangle raycast. Since I don't want to blow up 100k rays in cpu, and 3d model is already in GPU (as obviously we want to render it), let's do a little bit of compute shader ;)

So first let's load the model into a big fat buffer (to avoid subsets annoyance, simple prefix sum on indices), then we have the following data structures:

Code Snippet

1. StructuredBuffer<float3> PositionBuffer : POSITIONBUFFER;
2. StructuredBuffer<uint3> IndexBuffer : INDEXBUFFER;
3.  
4. AppendStructuredBuffer<float3> AppendVertexHitBuffer : APPENDVERTEXHITBUFFER;
5.  
6. float3 raypos : RAYPOSITION;
7. float3 raydir : RAYDIRECTION;
8.  
9. int FaceCount : FACECOUNT;
10.  
11. float eps : EPSILON = 0.000001f;

Pretty simple, mouse position is converted back to ray, and we use append buffer to get potential candidates (since we might hit several triangles).

Now here is our ray shader (I omit the ray formula, which is the same as in http://www.geometrictools.com/ )

Code Snippet

31. [numthreads(64,1,1)]
32. void CS_RayTriangle(uint3 dtid : SV_DispatchThreadID)
33. {
34.     if (dtid.x >= FaceCount) { return; }
35.     
36.     uint3 face = IndexBuffer[dtid.x];
37.     
38.     float3 p1 = PositionBuffer[face.x];
39.     float3 p2 = PositionBuffer[face.y];
40.     float3 p3 = PositionBuffer[face.z];
41.     
42.     float3 diff = raypos - p1;
43.     float3 e1 = p2 - p1;
44.     float3 e2 = p3 - p1;
45.     float3 n = normalize(cross(e1,e2));
46.     
47.     float DdN = dot(raydir,n);
48.     float fsign;
49.     
50.     bool hit = true;
51.  
52.     //Do you rayhit
53.     
54.     if (hit)
55.     {
56.         AppendVertexHitBuffer.Append(p1);
57.         AppendVertexHitBuffer.Append(p2);
58.         AppendVertexHitBuffer.Append(p3);
59.     }
60. }

Now when we hit a triangle, we append 3 vertices as "candidates", we now need to find the one closest to us. We could readback filtered data (using CopyResourceRegion), and finish computation on CPU, but that's not fun, so let's continue ;)

First to think option is to sort the data, but that's expensive, we only want the closest element.

So first let's process all elements and write the closest distance into a single buffer:

Code Snippet

72. [numthreads(64,1,1)]
73. void CS_MinDistance(uint3 dtid : SV_DispatchThreadID)
74. {
75.     if (dtid.x >= VertexHitCountBuffer.Load(0)) { return; }
76.     
77.     float3 p = VertexHitBuffer[dtid.x];
78.     
79.     float d = distance(raypos,p);
80.     uint dummy;    
81.     InterlockedMin(RWMinDistanceBuffer[0],asuint(d),dummy);
82. }

Now we need to filter closest element:

Code Snippet

84. [numthreads(64,1,1)]
85. void CS_StoreIndex(uint3 dtid : SV_DispatchThreadID)
86. {
87.     if (dtid.x >= VertexHitCountBuffer.Load(0)) { return; }
88.     
89.     float3 p = VertexHitBuffer[dtid.x];
90.     float d = distance(raypos,p);
91.     uint ud = asuint(d);
92.     
93.     uint mind = MinDistanceBuffer[0];    
94.     InterlockedCompareStore(RWMinElementBuffer[0], mind,ud);
95. }

Please note that we don't store position directly since interlocked operations are only allowed on int/uint type. Also we don't handle case if we have more than one candidate, this is easy to replace Store by append (but anyway at some point we need to decide which point we select).

And just get position:

Code Snippet

97. [numthreads(1,1,1)]
98. void CS_ExtractPosition(uint3 dtid : SV_DispatchThreadID)
99. {
100.     uint idx = RWMinElementBuffer[0];
101.     RWPositionBuffer[0] = VertexHitBuffer[idx];
102. }

Copy those 12 bytes back in your CPU and you have your closest vertex.

One part of the morning well spent )

Now one feature which is always useful for a good editor (since at the end we edit points), if of course some form of undo/redo.

You have three main ways to implement undo:

• For each action, use one function to update your model and one function to revert it. THis can be really cumbersome and error prone.
• Serialize the state, and on undo create a new (or part modified) state from serialized data
• Use immutable state

I have much growing interest into using more immutable in general, this is safer and i like the concept around it (ok it doesn't map well everywhere and can consume memory), but in that case (something like 10 points and couple projectors data), this sounds like a good use case.

So here is a calibration point:

Code Snippet

10. public class CalibrationPoint
11. {
12.     private readonly Vector2 screenPosition;
13.     private readonly Vector3 objectPosition;
14.  
15.     public CalibrationPoint(Vector2 screenPosition, Vector3 objectPosition)
16.     {
17.         this.screenPosition = screenPosition;
18.         this.objectPosition = objectPosition;
19.     }
20.  
21.     public Vector2 ScreenPosition
22.     {
23.         get { return this.screenPosition; }
24.     }
25.  
26.     public Vector3 ObjectPosition
27.     {
28.         get { return this.objectPosition; }
29.     }
30. }

You can see that once we create our point, we can't change properties anymore.

No to update properties, instead of setting data directly, we return a new point. There's a little way to help memory, if property is the same we return the same instance:

Code Snippet

31. public CalibrationPoint SetScreenPosition(Vector2 screenPosition)
32. {
33.     return this.screenPosition == screenPosition ? this : new CalibrationPoint(screenPosition, this.objectPosition);
34. }
35.  
36. public CalibrationPoint SetObjectPosition(Vector3 objectPosition)
37. {
38.     return this.objectPosition == objectPosition ? this : new CalibrationPoint(this.screenPosition, objectPosition);
39. }
40.  
41. public CalibrationPoint Set(Vector2 screenPosition, Vector3 objectPosition)
42. {
43.     return this.objectPosition == objectPosition &&
44.         this.screenPosition == screenPosition ? this : new CalibrationPoint(screenPosition, objectPosition);
45. }

Now do the same for Projector and calibration data:

Code Snippet

10. public class Projector
11. {
12.     private readonly string name;
13.     private readonly IEnumerable<CalibrationPoint> points;
14.  
15.     public Projector(string name, IEnumerable<CalibrationPoint> points)
16.     {
17.         if (name == null)
18.         {
19.             throw new ArgumentNullException("name");
20.         }
21.         if (points == null)
22.         {
23.             throw new ArgumentNullException("points");
24.         }
25.         this.name = name;
26.         this.points = points;
27.     }
28.  
29.     public string Name
30.     {
31.         get { return this.name; }
32.     }
33.  
34.     public IEnumerable<CalibrationPoint> Points
35.     {
36.         get { return this.points; }
37.     }
38. }

Some of the functions to modify (create new) state:

Code Snippet

44. public Projector AddPoint(Vector2 screenPosition, Vector3 objectPosition)
45. {
46.     var point = new CalibrationPoint(screenPosition, objectPosition);
47.  
48.     return new Projector(this.name, this.points.Concat(new CalibrationPoint[] { point }));
49. }
50.  
51. public Projector RemovePoint(CalibrationPoint point)
52. {
53.     return new Projector(this.name, this.points.Where(p => p != point));
54. }

Calibration class:

Code Snippet

10. public class Calibration
11. {
12.     private readonly IEnumerable<Projector> projectors;
13.     private readonly CalibrationSettings settings;
14.  
15.     public Calibration(CalibrationSettings settings, IEnumerable<Projector> projectors)
16.     {
17.         if (settings == null)
18.         {
19.             throw new ArgumentNullException("settings");
20.         }
21.         if (projectors == null)
22.         {
23.             throw new ArgumentNullException("projectors");
24.         }
25.         this.settings = settings;
26.         this.projectors = projectors;
27.     }
28. }

And to update projector data:

Code Snippet

41. public Calibration UpdateProjector(Projector oldProjector, Projector newProjector)
42. {
43.     if (oldProjector == newProjector)
44.     {
45.         return this;
46.     }
47.     else
48.     {
49.         var projs = this.projectors.ToList();
50.         int idx = projs.IndexOf(oldProjector);
51.  
52.         if (idx >= 0)
53.         {
54.             projs[idx] = newProjector;
55.             return new Calibration(this.settings, projs);
56.         }
57.         else
58.         {
59.             throw new ArgumentException("oldProjector", "This projector is not part of this calibration data");
60.         }
61.     }
62. }

I could do argument check first of course, and you can use some "Builder classes" to maintain those updates, but you get the point.

Now someone would say, this is a lot of work for simple classes....

But now once you are done with this (not so bad) boilerplate, here is out undo stack:

Code Snippet

10. public class CalibrationUndoStack
11. {
12.     private readonly Stack<Calibration> undoStack;
13.  
14.     public CalibrationUndoStack(Calibration initial)
15.     {
16.         this.undoStack = new Stack<Calibration>();
17.         this.undoStack.Push(initial);
18.     }
19.  
20.     public void Apply(Func<Calibration, Calibration> commandFunc)
21.     {
22.         var newState = commandFunc(this.Current);
23.         if (newState != this.Current)
24.         {
25.             this.undoStack.Push(newState);
26.         }
27.     }
28.  
29.     public Calibration Current
30.     {
31.         get { return this.undoStack.Peek(); }
32.     }
33.  
34.     public Calibration Undo()
35.     {
36.         return this.CanUndo ? this.undoStack.Pop() : this.undoStack.Peek();
37.     }
38.  
39.     public bool CanUndo
40.     {
41.         get { return this.undoStack.Count > 1; }
42.     }
43. }

As you can see, since we always return a new state, we pass a lambda to the stack, and if object has been modified (eg: function returns a new state), then we push our new state. That's how easy that is.

To implement update commands becomes as trivial as :

Code Snippet

13. public static Calibration AddProjector(Calibration c, string name)
14. {
15.     return c.AddProjector(name);
16. }
17.  
18. public static Calibration RenameProjector(Calibration state, Projector projector, string newname)
19. {
20.     var p = projector.SetName(newname);
21.     return state.UpdateProjector(projector, p);
22. }
23.  
24. public static Calibration AddPoint(Calibration state, Projector projector, Vector2 screen, Vector3 obj)
25. {
26.     var p = projector.AddPoint(screen, obj);
27.     return state.UpdateProjector(projector, p);
28. }
29.  
30. public static Calibration SetScreenPoint(Calibration state, Projector projector, CalibrationPoint point, Vector2 screen)
31. {
32.     var newPoint = point.SetScreenPosition(screen);
33.     var newProjector = projector.UpdatePoint(point, newPoint);
34.     return state.UpdateProjector(projector, newProjector);
35.  
36. }

And as you notice, this looks pretty verbose, here is how to do the same in f# (I love type inference, amongst may other things)

Code Snippet

6. module CalibrationCommandsFS =
7.  
8.     let addprojector (c:Calibration,n) = c.AddProjector(n);
9.     
10.     let renameprojector(c:Calibration,p, n) = c.UpdateProjector(p,p.SetName(n))
11.  
12.     let addpoint(c:Calibration,p,s,o) = c.UpdateProjector(p,p.AddPoint(s,o))
13.  
14.     let setscreenpoint(c:Calibration,proj,pt,s) = c.UpdateProjector(proj,proj.UpdatePoint(pt,pt.SetScreenPosition(s)))

And to operate on calibration:

Code Snippet

17. let x = new CalibrationUndoStack()
18.  
19. let s = new CalibrationSettings(Matrix.Identity)
20. let empty  = []
21. let c = new Calibration(s, [])
22.  
23. x.Apply(fun c -> addprojector(c,"hello"))

That's it for now, but likely more f# soon ;)