Geometry and Functions

After finishing my projects, I finally have time to work on some way long overdue features.

I'm doing a lot of work on my user interface revamp, and also doing a lot of code cleanup since now Windows Phone gives us access (also long overdue) to all nice features like P/Invoke, Direct2d....

This means after a bit of tweaking on SharpDX code base, windows phone is now AnyCpu, which is really great, having x86, x64, ARM and lot of targets to maintain is not pleasing at all.

Also I decided to move on and remove the old DirectX11/DirectX11.1 targets on my toolbox. No more Windows 7 support, I prefer to focus on having a better build for Desktop / RT / Phone instead.

Now after all this I thought it was time to work on another (well overdue as well) feature.

I've always been interested into processing geometry in compute shaders instead of using StreamOut.

This gives some pretty useful advantages:

• Write in place : RWStructuredBuffer rocks, no need for ping/pong
• Writing Indexed geometry using Geometry Shader is doable, but rather painful.
• Much easier to do more advanced post processing
• Access to indirect Draw, which means it's much easier to instance generated geometry, StreamOut does not give us access to internal counter, except using a query, eg: not ideal.

Here are my structures:

Code Snippet

16. private DX11StructuredBuffer positionbuffer;
17. private DX11StructuredBuffer normalsbuffer;
18. private DX11StructuredBuffer uvbuffer;
19.  
20. private DX11StructuredBuffer appendindexbuffer;
21.  
22. private DX11InstancedIndexedDrawer drawer;
23. private DispatchIndirectBuffer vertexIndirectDispatch;
24. private DispatchIndirectBuffer indexIndirectDispacth;

Pretty simple, with two things to note:

• Position buffer is created with the counter flag
• Index Buffer is created with the append flag

Now there are a few bits to consider:

• Structured Buffer is not bindable as Vertex Buffer: This is more or less a non issue in my case, since most of my shaders already fetch data from StructuredBuffers using SV_VertexID
• StructuredBuffer is not bindable as Index Buffer. This is more annoying, since you need to bind it to the pipeline, no way to fetch. This is quite easy to sort still, as you can just create a standard index buffer (which allow raw view and give it UAV access), then just use a compute shader to copy indices.

So with this setup we are more or less set, you can process per vertex using VertexIndirectDispatcher, process per face using IndexIndirectDispatcher, and since you have access to counter/append, you can also easily emit/remove Geometry.

Now one main issue with this setup, you need to feed your buffers with some initial geometry. 

You have a very simple way to do this in DirectX11.1 , but the feature is only supported on ATI.

So instead, let's replace my old monolithic geometry builders by something more flexible

For now my geometry builders look like this:

Code Snippet

17. public DX11IndexedGeometry QuadNormals(Quad settings)
18. {
19.     DX11IndexedGeometry geom = new DX11IndexedGeometry(device);
20.     geom.Tag = settings;
21.     geom.PrimitiveType = settings.PrimitiveType;
22.  
23.     List<Pos4Norm3Tex2Vertex> vertices = new List<Pos4Norm3Tex2Vertex>();
24.     List<int> indices = new List<int>();
25.  
26.     //Build your array
27.  
28.     geom.VertexBuffer = DX11VertexBuffer.CreateImmutable(device, vertices.ToArray());
29.     geom.IndexBuffer = DX11IndexBuffer.CreateImmutable(device, indices.ToArray());
30.     geom.InputLayout = Pos4Norm3Tex2Vertex.Layout;
31.     geom.VertexBuffer.InputLayout = geom.InputLayout;
32.     geom.Topology = PrimitiveTopology.TriangleList;
33.     geom.HasBoundingBox = true;
34.     return geom;
35. }

This has a bit too many things to do:

• Read settings
• Build Vertices/Indices list
• Create Geometry resource

The big problem is that all is in one function, so let's improve and decouple this a little bit

First geometry builders do some pretty simple things, append vertices and append faces, so let's change the construction code like this.

Code Snippet

10. public class SegmentBuilder : IGeometryBuilder<Segment>
11. {
12.     public PrimitiveInfo GetPrimitiveInfo(Segment settings)
13.     {
14.         float phase = settings.Phase;
15.         float cycles = settings.Cycles;
16.         float inner = settings.InnerRadius;
17.         int res = settings.Resolution;
18.         bool flat = settings.Flat;
19.  
20.         int vcount = res * 2;
21.         int icount = (res - 1) * 6;
22.  
23.         return new PrimitiveInfo(vcount, icount);
24.     }
25.  
26.     public void Construct(Segment settings, Action<Vector3, Vector3, Vector2> appendVertex, Action<Int3> appendIndex)
27.     {
28.  
29.     }
30. }

Now we have one builder class responsible to build geometry, but it has no idea of which data structure we use anymore, which is great, since now it's very easy to:

• Use different data back end (DataStream, List...)
• Pack data the way we want
• Completely bypass something (if resolution parameter does not change for example, we can set appendIndex function to null, so we completely ignore building faces).

Here is a simple example to append data into lists:

Code Snippet

10. public class ListGeometryAppender
11. {
12.     private List<Pos4Norm3Tex2Vertex> vertices = new List<Pos4Norm3Tex2Vertex>();
13.     private List<int> indices = new List<int>();
14.  
15.     public List<Pos4Norm3Tex2Vertex> Vertices { get { return this.vertices; } }
16.     public List<int> Indices { get { return this.indices; } }
17.  
18.     public void AppendVertex(Vector3 position, Vector3 normal, Vector2 uv)
19.     {
20.         Pos4Norm3Tex2Vertex v = new Pos4Norm3Tex2Vertex()
21.         {
22.             Position = new Vector4(position.X, position.Y, position.Z, 1.0f),
23.             Normals = normal,
24.             TexCoords = uv
25.         };
26.         this.vertices.Add(v);
27.     }
28.  
29.     public void AppendIndex(Int3 index)
30.     {
31.         this.indices.Add(index.X);
32.         this.indices.Add(index.Y);
33.         this.indices.Add(index.Z);
34.     }
35.  
36.     public void TransformVertices(Func<Pos4Norm3Tex2Vertex,Pos4Norm3Tex2Vertex> transformFunction)
37.     {
38.         for (int i = 0; i < this.vertices.Count; i++)
39.         {
40.             Pos4Norm3Tex2Vertex v = vertices[i];
41.             vertices[i] = transformFunction(v);
42.         }
43.     }
44. }

Now to construct our geometry, we can simply do:

Code Snippet

14. public partial class PrimitivesManager
15. {
16.     public DX11IndexedGeometry Cylinder(Cylinder settings)
17.     {
18.         CylinderBuilder builder = new CylinderBuilder();
19.         ListGeometryAppender appender = new ListGeometryAppender();
20.         PrimitiveInfo info = builder.GetPrimitiveInfo(settings);
21.         builder.Construct(settings, appender.AppendVertex, appender.AppendIndex);
22.         return FromAppender(settings, appender, info);
23.     }
24.  
25.     private DX11IndexedGeometry FromAppender(AbstractPrimitiveDescriptor descriptor, ListGeometryAppender appender, PrimitiveInfo info)
26.     {
27.         DX11IndexedGeometry geom = new DX11IndexedGeometry(device);
28.         geom.Tag = descriptor;
29.         geom.PrimitiveType = descriptor.PrimitiveType;
30.         geom.VertexBuffer = DX11VertexBuffer.CreateImmutable(device, appender.Vertices.ToArray());
31.         geom.IndexBuffer = DX11IndexBuffer.CreateImmutable(device, appender.Indices.ToArray());
32.         geom.InputLayout = Pos4Norm3Tex2Vertex.Layout;
33.         geom.Topology = PrimitiveTopology.TriangleList;
34.         geom.HasBoundingBox = info.IsBoundingBoxKnown;
35.         geom.BoundingBox = info.BoundingBox;
36.         return geom;
37.     }
38. }

What is great by passing functions instead of interfaces, it's much easier to composite actions, for example, we can easily compute bounding box while we create our List.

Code Snippet

18. SegmentBuilder builder = new SegmentBuilder();
19. ListGeometryAppender appender = new ListGeometryAppender();
20. PrimitiveInfo info = builder.GetPrimitiveInfo(settings);
21.  
22. Vector3 max = new Vector3(float.MinValue, float.MinValue, float.MinValue);
23. Vector3 min = new Vector3(float.MaxValue, float.MaxValue, float.MaxValue);
24.  
25. builder.Construct(settings, (v, n, u) =>
26.     { appender.AppendVertex(v, n, u); min = Vector3.Min(min, v); max = Vector3.Max(max, v); }, appender.AppendIndex);

We can also attach several Appenders, like:

Code Snippet

42. SegmentBuilder builder = new SegmentBuilder();
43.  
44. ListGeometryAppender appender = new ListGeometryAppender();
45. MultiListGeometryAppender multilist = new MultiListGeometryAppender();
47. builder.Construct(settings, (v, n, u) =>
48.     {
49.         appender.AppendVertex(v, n, u);
50.         multilist.AppendVertex(v, n, u);
51.     }
52.     ,appender.AppendIndex);

And you noticed we can optimize by only filling one index buffer ;)

To build StructuredBuffers instead of geometry, here we are:

Code Snippet

39. SegmentBuilder builder = new SegmentBuilder();
40. MultiListGeometryAppender appender = new MultiListGeometryAppender();
41.  
42. builder.Construct(settings, appender.AppendVertex, appender.AppendIndex);
43.  
44. DX11StructuredBuffer intialposition = DX11StructuredBuffer.CreateImmutable<Vector3>(device, appender.Positions.ToArray());
45. DX11StructuredBuffer initialindices = DX11StructuredBuffer.CreateImmutable<Int3>(device, appender.Indices.ToArray());

Also, we can write to a dynamic buffer directly:

Code Snippet

39. SegmentBuilder builder = new SegmentBuilder();
40. PrimitiveInfo info = builder.GetPrimitiveInfo(settings);
41. DX11StructuredBuffer dynamicposition = DX11StructuredBuffer.CreateDynamic<Vector3>(device, info.VerticesCount);
42. DataStream ds = dynamicposition.MapForWrite(context);
43. builder.Construct(settings, (p,n,u) => ds.Write(p) , null);
44. dynamicposition.Unmap(context);

Here we are, next post I'll show a few examples of what we can now do with compute geometry (and some new idea for particle system ;)