Intersections Part2 : Id Maps

In the previous post, I spoke about the ability to perform hit detection using analytical functions.

This works extremely well when we can restrict our use case to it, but now we have some other cases where this is not as ideal:

• Perform detection on arbitrary shape/3d model.
• User input is not a pointer anymore, but can also be arbitrary (threshold camera texture, Kinect Body Index)
• Both previous cases combined together

While we can often perform detection for 3d model by using triangle raycast (I'll keep that one for next post), it can be pretty expensive (specially if we perform a 10 touch hit detection, we need to raycast 10 times).

So instead, one easy technique is to use ID map.

Concept is extremely simple, instead of performing hit with a function, we will render our scene into a UInt texture, where each pixel will be object ID.

Of course it means you have to render your scene another time, but in that case you can also easily use the following:

• Render to a downsized texture (512*512 is often sufficient)
• Render either bounding volumes, or simplified versions of our 3d models.

Great thing with this technique, our depth buffer already makes sure that we have closest object ID stored (so we get that for "free").

So now we have our ID map, picking objectID from pointer is trivial:

Code Snippet

7. Texture2D<uint> ObjectIDTexture;
8.  
9. RWStructuredBuffer<uint> RWObjectBuffer : BACKBUFFER;
10.  
11. float2 MousePosition;
12. int width = 512;
13. int height = 424;
14. [numthreads(1,1,1)]
15. void CS(uint3 tid : SV_DispatchThreadID)
16. {
17.     uint w,h;
18.     ObjectIDTexture.GetDimensions(w,h);
19.     
20.     float2 p = MousePosition;
21.     p = p * 0.5f  + 0.5f;
22.     p.y = 1.0f-p.y;
23.     p.x *= (float)w;
24.     p.y *= (float)h;
25.     
26.     uint obj = ObjectIDTexture.Load(int3(p,0));
27.     RWObjectBuffer[0] = obj;
28.  
29. }

Not much more is involved, we grab the pixel id, store in a buffer that we can retrieve in staging.

In case we need multiple pointer, we only need to grab N pixels instead, so process stays pretty simple (and we don't need to render scene for each pointer).


Now as mentioned before, we might need to perform detection against arbitrary texture.

As a starter, for simplicity, I will restrict the use case to single user texture.

So first we render user into a R8_Uint texture , where 0 means no active user and anything else = active.

We render our object map next in the same resolution.

We create a buffer (same size as object count, uint), that will store how many user pixel hit an object pixel.

Dispatch to perform this count.

Use another Append buffer, that select elements over a minimum account of pixel (this is generally important to avoid noise with camera/kinect textures).

Accumulating pixel hit count is done this way:

Code Snippet

8. Texture2D<uint> ObjectIDTexture;
9. Texture2D<float> InputTexture;
10.  
11. RWStructuredBuffer<uint> RWObjectBuffer : BACKBUFFER;
12.  
13. float Minvalue;
14. int maxObjectID;
15.  
16. [numthreads(8,8,1)]
17. void CS(uint3 tid : SV_DispatchThreadID)
18. {
19.     uint obj = ObjectIDTexture[tid.xy];
20.     float value = InputTexture[tid.xy];
21.     
22.     if (value > Minvalue && obj < maxObjectID)
23.     {
24.         uint oldValue;
25.         InterlockedAdd(RWObjectBuffer[obj],1,oldValue);
26.     }
27. }

Make sure you use InterlockedAdd, as you need atomic operation in that case.


Next we can filter elements:

Code Snippet

6. StructuredBuffer<uint> HitCountBuffer;
7. AppendStructuredBuffer<uint> AppendObjectIDBuffer : BACKBUFFER;
8.  
9. int minHitCount;
10.  
11. [numthreads(64,1,1)]
12. void CS(uint3 tid : SV_DispatchThreadID)
13. {
14.     uint c,stride;
15.     HitCountBuffer.GetDimensions(c,stride);
16.     if (tid.x >= c)
17.         return;
18.     
19.     int hitcount = HitCountBuffer[tid.x];
20.     if (hitcount >= minHitCount)
21.     {
22.         AppendObjectIDBuffer.Append(tid.x);
23.     }
24. }

This is that easy, of course instead of only rendering ObjectID in the map, we can easily add some extra metadata (triangle ID, closest vertexID) for easier lookup.


Now in order to perform multi user detection (for example, using Kinect2 body Index texture), process is not much different.

Instead of having a buffer of ObjectCount, we create it of ObjectCount*UserCount

Accumulator becomes:

Code Snippet

8. Texture2D<uint> ObjectIDTexture;
9. Texture2D<uint> UserIDTexture;
10.  
11. RWStructuredBuffer<uint> RWObjectBuffer : BACKBUFFER;
12.  
13. float Minvalue;
14. int maxObjectID;
15. int objectCount;
16.  
17. [numthreads(8,8,1)]
18. void CS(uint3 tid : SV_DispatchThreadID)
19. {
20.     uint obj = ObjectIDTexture[tid.xy];
21.     uint pid = UserIDTexture[tid.xy];
22.  
23.     if (pid != 255 < maxObjectID)
24.     {
25.         uint oldValue;
26.         InterlockedAdd(RWObjectBuffer[pid*objectCount+obj],1,oldValue);
27.     }
28. }

And filtering becomes:

Code Snippet

6. StructuredBuffer<uint> HitCountBuffer;
7. AppendStructuredBuffer<uint2> AppendObjectIDBuffer : BACKBUFFER;
8.  
9. int minHitCount;
10. int objectCount;
11. [numthreads(64,1,1)]
12. void CS(uint3 tid : SV_DispatchThreadID)
13. {
14.     uint c,stride;
15.     HitCountBuffer.GetDimensions(c,stride);
16.     if (tid.x >= c)
17.         return;
18.     
19.     int hitcount = HitCountBuffer[tid.x];
20.     if (hitcount >= minHitCount)
21.     {
22.         uint2 result;
23.         result.x = tid.x % objectCount; //objectid;
24.         result.y = tid.x / objectCount;
25.         AppendObjectIDBuffer.Append(result);
26.     }
27. }

We now have a tuple userid/object id instead, as shown in the following screenshot:

Please also note this technique can also easily be optimized with stencil, setting a bit per user. You get then limited to 8 users tho (7 users in case you also want to reserve one bit for object itself).

You will need one pass per user also (so 6 pass with proper depth stencil state/reference value).

If you lucky enough and can run on Windows10/DirectX11.3, and have a card that allows you, you can also simply do :

Code Snippet

1. Texture2D<uint> BodyIndexTexture : register(t0);
2.  
3. uint PS(float4 p : SV_Position) : SV_StencilRef
4. {
5.     uint id = BodyIndexTexture.Load(int3(p.xy, 0));
6.     if (id = 255) //No user magic value provided by Kinect2
7.         discard;
8.     return id;
9. }

Here is a simple stencil test rig, to show all of the intermediates:

That's it for part 2 (that was simple no?)

For the next (and last) part, I'll explain a few more advanced cases (triangle raycast, scene precull....)

Intersections Part1

So last month been working on latest commercial project (nothing involving any extreme creative skills), so back into research mode.

I got plenty of new ideas for rendering, and quite some parts of my engine are undergoing some reasonable cleanup (mostly new binding model to ease dx12 transition later on).

There's different areas in my tool that I'm keen on improving, many new parts will be for other blog posts, but one has lately drawn my attention and I really wanted to get this one sorted.

As many of you know (or don't), I've been working on many interactive installations around, from small to (very) large.

One common requirement for those are some form of Hit Detection, you have some input device (Kinect, Camera, Mouse, Touch, Leap....), and you need to know if you hit some object in your scene in order to have those elements to react.

After many years in the industry, I've been developing a lot of routines in that aspect, so I thought it would be nice to have all of that as a decent library (to just pick when needed).

After a bit of conversation with my top coder Eric, we wanted to do a bit of feature list, what do we expect of an intersection engine, then the following came up:

• We have various scenarios, some routines are better fit to some use cases, so we don't want a "one mode to rule them all". For example, if our objects are near spherical, we don't want to ray cast mesh triangles, ray cast on bounding sphere is appropriate (and of course much faster).
• We want our routines sandboxed, so 4v/flaretic subpatch, it should be one node with inputs/outputs, cooking done properly inside and optimized. That saves us load time, reduce compilation times for shaders (or allow precompiled), and easier to control workflow (if our routine is not needed it costs 0).
• We want our library minimal, so actually hit routines should not even create data themselves, they are a better fit as pure behaviours (It also helps to have those routines working in different environments).
• We don't want to be gpu only, if a case fits better as CPU, then we should use CPU (if preparing buffers costs more time than performing the test directly, then let's just do it directly in cpu).

Next we wanted to decide which type of outputs we needed, this came out:

• bool/int flag, which indicates if object is hit or not
• filtered version for hit objects
• filtered version for non hit objects

Then here are the most important hit detection features we require (they cover a large part of our use cases in general)

• Mouse/Pointer(s) to 2d shape (in most cases we want rectangle, circle).
• Pointer(s) to 3d object (with selectable precision, either raycast bounding volume eg sphere/box, or go at triangle level).
• Area(s) to shapes (rectangle selection)
• Arbitrary texture to shape (most common scenario for this is infrared camera, or kinect body index texture). In that case we also want the ability to differenciate between user id as well as object id.
• In any 3d scenario, we also eventually want either closest object or all objects that get from the test.
• We also have 3 general cases in 3d : Intersect (ray), Containment (is our object inside another test primitive), Proximity (is our object "close enough" to some place).

So once those requirements are set, to perform hit detection we generally have the 2 main following scenarios, you use analytical function or you use a map.

So let's show some examples, if that first post about it, I'll only speak about analytical functions.

In this case, we generally follow the usual pattern, convert our input into the desired structure (point to ray for example), and every mode follow the current pseudo code (c# version)

Code Snippet

64. bool[] hitResults = new bool[objectCount];
65. List<int> hitObjectList = new List<int>();
66.  
67. for (int i = 0; i < objectCount; i++)
68. {
69.     var obj = testObjects[i];
70.  
71.     bool hr = Performtest(userObject, obj);
72.     hitResults[i] = hr;
73.  
74.     if (hr)
75.     {
76.         hitObjectList.Add(i);
77.     }
78. }

Pretty much all test modes will follow this pattern, only difference after is the test function.

Obviously when we start to reach a certain number of elements, this can become slow. And many times, our objects might be on our GPU, so we are not gonna load them back into CPU.

Translating this into hlsl is extremely straightforward, here is some pesudo code for it.

Code Snippet

1. bool PerformTest(SomeUserObject userInput, SomeStruct object)
2. {
3.     return //Perform your intersection/containment/proximity routine here
4. }
5.  
6. StructuredBuffer<SomeStruct> ObjectBuffers  : register(t0);
7.  
8. RWStructuredBuffer<uint> RWObjectHitResultBuffer : register(u0);
9.  
10. AppendStructuredBuffer<uint> AppendObjectHitBuffer : register(u1);
11. RWStructuredBuffer<uint> RWObjectHitBuffer : register(u1); //In this case, UAV should have a counter flag
12.  
13. cbuffer cbUserInput : register(b0)
14. {
15.     SomeStruct userInput;
16. };
17.  
18. cbuffer cbObjectData : register(b1)
19. {
20.     uint objectCount;
21. };
22.  
23. [numthreads(128, 1, 1)]
24. void CS(uint3 i : SV_DispatchThreadID)
25. {
26.     if (i.x >= objectCount)
27.         return;
28.  
29.     uint oid = i.x;
30.  
31.     SomeUserObject object = ObjectBuffers[oid];
32.  
33.     bool hitResult = PerformTest(userInput, object);
34.     RWObjectHitResultBuffer[oid] = hitResult;
35.     if (hitResult)
36.     {
37.         //If we use append buffer
38.         AppendObjectHitBuffer.Append(oid);
39.  
40.         //If we use counter buffer
41.         uint idx = RWObjectHitBuffer.IncrementCounter();
42.         RWObjectHitBuffer[idx] = oid;
43.     }
44. }

As you can see there's no huge difference into that.

It's pretty straightforward to perform ray to sphere/triangle/box as a starter.

Rectangle selection is also extremely simple:

• Construct a 2d transformation for the screen area to check
• Multiply inverse by camera projection
• Build a frustrum from this
• Perform a object/frustrum test insqtead of ray test.

here is a small range test example

Simple no? ;)

Now I can foresee 2 important question that our acute reader is probably already thinking of:

• How do we get closest object?
• What if we perfom several user inputs?

Of course, there are solutions for that.

Closest object.

First we will consider that our test function is also capable of returning distance.

So we modify our code by:

Code Snippet

1. struct HitResult
2. {
3.     uint objectID;
4.     float distanceToObject;
5. };
6.  
7. bool PerformTest(SomeUserObject userInput, SomeStruct object, out float distanceToObject)
8. {
9.     return //Perform your intersection/containment/proximity routine here
10. }
11.  
12. StructuredBuffer<SomeStruct> ObjectBuffers  : register(t0);
13.  
14. RWStructuredBuffer<uint> RWObjectHitResultBuffer : register(u0);
15.  
16. AppendStructuredBuffer<HitResult> AppendObjectHitBuffer : register(u1);
17.  
18. cbuffer cbUserInput : register(b0)
19. {
20.     SomeStruct userInput;
21. };
22.  
23. cbuffer cbObjectData : register(b1)
24. {
25.     uint objectCount;
26. };
27.  
28. [numthreads(128, 1, 1)]
29. void CS(uint3 i : SV_DispatchThreadID)
30. {
31.     if (i.x >= objectCount)
32.         return;
33.  
34.     uint oid = i.x;
35.  
36.     SomeUserObject object = ObjectBuffers[oid];
37.  
38.     float d;
39.     bool hitResult = PerformTest(userInput, object,  d);
40.     RWObjectHitResultBuffer[oid] = hitResult;
41.     if (hitResult)
42.     {
43.         HitResult hr;
44.         hr.objectID = oid;
45.         hr.distanceToObject = d;
46.         //If we use append buffer
47.         AppendObjectHitBuffer.Append(hr);
48.     }
49. }

Now our buffer also contains our distance to object, the only leftover is to grab the closest element.

We have 2 ways to work that out:

• Use Compute shader (Use InterlockedMin to filter closest element, since distance is generally positive there's no float to uint tricks to apply), then perform another pass to check if element distance is equal to minimum.
• Use Pipeline ; DepthBuffer is pretty good to keep closest element, so we might as well let him do it for us ;)

Using pipeline is extremely easy as well, process is as follow:

• Create a 1x1 render target (uint), Associated with a 1x1 depth buffer

Prepare an indirect draw buffer (from the UAV counter), and draw as point list, write to pixel 0 in vertex, and pass distance so it's written to depth buffer, since code speaks more, here it is:

Code Snippet

1. struct HitResult
2. {
3.     uint objectID;
4.     float distanceToObject;
5. };
6.  
7. StructuredBuffer<HitResult> ObjectHitBuffer : register(u0);
8.  
9. cbuffer cbObjectData : register(b1)
10. {
11.     float invFarPlane;
12. };
13.  
14. void VS(uint iv: SV_vertexID, out float4 p : SV_Position,
15.     out float objDist : OBJECTDISTANCE,
16.     out uint objID : OBJECTID)
17. {    
18.     p = float4(0, 0, 0, 1); //We render to a 1x1 texture, position is always 0
19.     HitResult hr = ObjectHitBuffer[iv];
20.     
21.     objID = hr.objectID;
22.     //Make sure we go in 0-1 range
23.     objDist = hr.distanceToObject * invFarPlane;
24. }
25.  
26. void PS(float4 p : SV_Position, float objDist : OBJECTDISTANCE, uint objID : OBJECTID,
27.     out uint closestObjID : SV_Target0, out float d : SV_Depth)
28. {
29.     //Just push object id
30.     closestObjID = objID;
31.     d = objDist; //Depth will preserve closest distance
32. }

Now our pixel contains our closest object (clear to 0xFFFFFFFF so this value will mean "no hit")

To finish for this first part, let's now add the fact that we have multiple "user Inputs".

We want to know the closest object per user.

This is not much more complicated (but of course will cost a test for each user/object).

Code Snippet

1. struct HitResult
2. {
3.     uint objectID;
4.     float distanceToObject;
5. };
6.  
7. bool PerformTest(UserInput userInput, SomeStruct object, out float distanceToObject)
8. {
9.     return //Perform your intersection/containment/proximity routine here
10. }
11.  
12. StructuredBuffer<SomeStruct> ObjectBuffers  : register(t0);
13. StructuredBuffer<UserInput> UserInputBuffer : register(t1);
14.  
15. RWStructuredBuffer<uint> RWObjectHitResultBuffer : register(u0);
16.  
17. RWStructuredBuffer<HitResult> RWObjectHitBuffer : register(u1); //Counter flag
18. RWStructuredBuffer<uint> RWObjectHitUserIDBuffer : register(u2);
19.  
20. cbuffer cbObjectData : register(b0)
21. {
22.     uint objectCount;
23.     uint userCount;
24. };
25.  
26. [numthreads(128, 1, 1)]
27. void CS(uint3 tid : SV_DispatchThreadID)
28. {
29.     if (tid.x >= objectCount)
30.         return;
31.  
32.     uint oid = tid.x;
33.  
34.     SomeUserObject object = ObjectBuffers[oid];
35.     uint hitCount = 0;
36.     for (uint i = 0; i < userCount; i++)
37.     {
38.         float d;
39.         bool hitResult = PerformTest(userInput, object, d);
40.  
41.         if (hitResult)
42.         {
43.             hitCount++;
44.             HitResult hr;
45.             hr.objectID = oid;
46.             hr.distanceToObject = d;
47.  
48.             uint idx = RWObjectHitBuffer.IncrementCounter();
49.             RWObjectHitBuffer[idx] = hr;
50.             RWObjectHitUserIDBuffer[idx] = i;
51.         }
52.     }
53.     RWObjectHitResultBuffer[oid] = hitCount;
54. }

Now we have a buffer with every hit from every user (here is a small example screenshot):

So instead of using a 1x1 texture, we use a Nx1 texture (where N is user Input count).

Process to get closest element is (almost) the same as per the single input.

Only difference, in Vertex Shader, route the objectID/Distance to the relevant user pixel, and you're set!


That's it for first part, next round, I'll explain how the "map technique works", stay tuned.

Resource Handling with Tiled Resources in DirectX11.2

After upgrading my particle system, the next part that needs my attention is my deferred renderer.

It has all type of lights (using compute shader when possible, pixel shaders if light also has shadows), and all the standard usual suspects (HBAO, Dof, Bokeh, Tonemap...)

Now I started to upgrade my shaders for the next level:

• Msaa support with subpixel (sample shading)
• Allow better AO usage (AO Factor can be set as low quality or each light can have an AO factor)
• Better organization of some calculations (to avoid them to be done twice).
• Some other cool things ;)

Before I start to revamp the glue code to handle all this, as soon as you start to use Msaa targets  (this is no news of course), your memory footprint grows quite drastically.

In my use case, since I'm not dealing with the usual "single level game scenario", I can also have several full HD (or more, or less) which all need to be rendered every frame and composited. 

I looked a bit at my memory usage, and while it's not too bad (reasonably efficient usage of pools and temporary resources), I thought I could start to have a proper think about it before to start coding ;)

So generally when we render scenes, we have several type of resources lifetimes:

• "Scene lifetime" : Those are resources which live with your scene, so until you decide to unload your whole scene, those resources must live. A good example is some particle buffers, as they are read write, they need to be persisted across frames.
• "Frame lifetime" : Those are the ones that we use for a single frame, often some intermediate results, that needs to be persisted across a sufficiently long part in the frame duration. For example, Linear Depth is quite often required for a long part in your post processing pipeline, since it's used by a decent amount of post processors.
• "Scoped lifetime" : Those have a very short lifetime (generally within a unit of work/function call)

When I did a first memory profile test, I could see that actually a lot of my memory footprint is caused by those Scoped resources, so I decided to first focus on those.

So as a starter, here are my local resources for some of my post processors

• Depth of field: 1 target for CoC (R16f), 1 target for temp blur (4 channels, format is renderer dependent)
• Hbao : 4 targets for AO + blur (2 are R16f, other 2 are R16G16f)
• Bokeh : 1 buffer for sprite filtering, 1 target for overdraw (renderer dependent).

Now for those short lived resources, you can handle them in the following way.

• Create/Dispose : you create resources every time they are needed and release become to leave the function, in c# code, this would look like the traditional use pattern as:

Code Snippet

246. using (var buffer = DX11StructuredBuffer.CreateAppend<float>(device, 1024))
247. {
248.     //Do some work
249.  
250. } //Buffer is now disposed

While this is a natural pattern in c#, it is not designed to work well with real time graphics (resource creation is expensive, and creating / releasing gpu resources all the time is not such a good idea, memory fragmentation looming).

• Resource Pool : instead of creating resources all the time, to create a small wrapper around it to keep a isLocked flag. This looks this way in c#:

Code Snippet

252. var buffer = Device.ResourcePool.LockStructuredBuffer<float>(1024);
253.  
254. //do something with buffer : buffer.Element.ShaderView;
255.  
256. buffer.UnLock(); // Markas free to reuse

When we request a resource, the pool will check if a buffer with the required flags/stride is available, if this is the case, mark it as "In Use" and return it. If no buffer matching specifications is found, create and return a new one.

This scheme is quite popular (I've seen this in Unity and many other code bases), has an advantage of being simple, but also has some issues.

First, you need to keep a pool per resource type, eg: one for textures (of each type), one for buffers.

Second, the biggest disadvantage (specially for Render Targets), we need an exact size and format.
We can certainly optimize format support using Typeless resources (but you still need to create views in that case), but for size that's a no go (or at least a non practical thing), since we would often need to implement our own sampler (which is not a big deal, except for Anisotropic, but that would badly pollute our shader code base). Also we would need a bit of viewport/scissor gymnastic. Again, not that hard but really not convenient.

So if you render 3 scenes, each with different resolutions, your pool starts to collect a lot of resources of different sizes, your resource lists become bigger....

Of course you can clear any unused resources from time to time (eg: Dispose anything that has not been used), add a number of frames since not used and threshold that (yay, let's write a garbage collector for GPU resources, hpmf....).

Nevertheless, I find that for "Frame lifetime" (and eventually a small subset of "Scene lifetime") resources, this model fits reasonably well, so I'll definitely keep it for a while (I guess DX12 Heaps will change that part, but let's keep DirectX12 for later posts ;)

So now we have clearly seen the problem, for my scoped resources, if I go back to the ao->dof->bokeh case, I have to create 6 targets + one buffer (one of them can be reused, but lot of intermediates are in different formats depending on which port processing I'm currently applying)

Adding a second scene with a different resolution, that's of course 12 targets.

One main thing is, all this post processing is not applied at the same time (since your GPU serializes commands anyway). So all that memory could be happily shared. But we haven't got enough fine tuned access to gpu memory for this (again, resources pointing to the same locations are now trivial in dx12, but here still in dx11). So it looks like a dead end.

In the mean time in the Windows 8.1 world, some great Samaritan (s) have introduced a few new features, one of them called Tiled Resources.

Basically a resource created as Tiled has no initial memory, you have to map Tiles (which are 64k chunks of memory) to them. Memory tiles are provided by a buffer created with a tile pool attribute.

Code Snippet

31. BufferDescription bdPool = new BufferDescription()
32. {
33.     BindFlags = BindFlags.None,
34.     CpuAccessFlags = CpuAccessFlags.None,
35.     OptionFlags = ResourceOptionFlags.TilePool,
36.     SizeInBytes = memSize,
37.     Usage = ResourceUsage.Default
38. };

So you can create a huge resource with no memory, and assign tiles to some parts of it depending on your scene.

This of course has a wide use for games (terrain/landscapes streaming, large shadow map rendering), and most examples follow that direction (check for sparse textures if you want documentation about those).

Then I noticed in one slide (forgot if it was from NVidia or Microsoft), "Tiled resources can eventually be used for more aggressive memory packing of short lived data".

There was no further explanation, but that sounds like my use case, so obviously, let's remove the "eventually" word and try it (here understand : have it working).

So in that case we think about it in reverse. Instead of having a large resources backed by a pool and which is partly updated/cleared, We provide a back end, and allocate the same tiles to different resources (of course they need to belong to different unit of work, the ones that need to be used at the same time must not overlap).

So let's do a first try, and create two Tiled buffers, which point to the same memory location.

Code Snippet

35. SharpDX.Direct3D11.BufferDescription bd = new BufferDescription()
36. {
37.     BindFlags = BindFlags.ShaderResource | BindFlags.UnorderedAccess,
38.     CpuAccessFlags = CpuAccessFlags.None,
39.     OptionFlags = ResourceOptionFlags.BufferAllowRawViews | ResourceOptionFlags.Tiled,
40.     SizeInBytes = memSize,
41.     Usage = ResourceUsage.Default,
42.     StructureByteStride = 4
43. };
44.  
45. SharpDX.Direct3D11.BufferDescription bd2 = new BufferDescription()
46. {
47.     BindFlags = BindFlags.ShaderResource | BindFlags.UnorderedAccess,
48.     CpuAccessFlags = CpuAccessFlags.None,
49.     OptionFlags = ResourceOptionFlags.Tiled,
50.     SizeInBytes = memSize,
51.     Usage = ResourceUsage.Default,
52.     StructureByteStride = 4
53. };
54.  
55. var Buffer1 = DX11StructuredBuffer.CreateTiled<int>(device, elemCount);
56. var Buffer2 = DX11StructuredBuffer.CreateTiled<int>(device, elemCount);

Here I show the arguments of CreateTiled static constructor, for readability.

And we need to provide a backend for it:

Code Snippet

58. SharpDX.Direct3D11.BufferDescription bdPool = new BufferDescription()
59. {
60.     BindFlags = BindFlags.None,
61.     CpuAccessFlags = CpuAccessFlags.None,
62.     OptionFlags = ResourceOptionFlags.TilePool,
63.     SizeInBytes = 65536,
64.     Usage = ResourceUsage.Default
65. };
66.  
67. var bufferPool = new SharpDX.Direct3D11.Buffer(device, bdPool);

Now we assign the same tile(s) to each buffer like this:

Code Snippet

91. var rangeFlags = new TileRangeFlags[] { TileRangeFlags.None };
92. context.Context.UpdateTileMappings(resource, 1, new TiledResourceCoordinate[] { }, new TileRegionSize[] { }, this.tilePoolBuffer, 1, rangeFlags, new int[] { 0 }, new int[] { }, TileMappingFlags.None);

We do this for each buffer


Next a simple test for it, create an Immutable resource, with some random data, same size as our tiled buffer (not pool)

Use copy resource on either Buffer1 or Buffer2 (not both).

Create two staging resources s1 and s2

Readback data from buffer1 into s1 and Buffer2 into s2.

Surprise, we then have data uploaded and copied from our immutable buffer in both s1 and s2.

So now we have the proof of concept working, we create a small tile pool (with an inital memory allocation).

Now for each post processor, we register our resources (and update tile offset accordingly to avoid overlap, we also need to eventually pad buffers/textures since our start location needs to be aligned to a full tile).

Before that, we need to check if our pool is big enough, and resize if required, the beauty of it, this is not destructive (increasing pool size will allocate new Tiles but will preserve mappings of existing ones), so this is done as:

Code Snippet

121.  
122. context.Context.ResizeTilePool(this.tilePoolBuffer, newPageCount * PageSize);

And that's more or less it, now our pool size is equal to the largest unit of work instead of adding between them.

It simply means, in the case above, that our pool size is the sum of the size of the largest effector (which is hbao in the example).

Adding another post processing chain somewhere else will reuse that same memory for all the short lived objects, so if I start to have 5 scenes rendering that's a quite significant gain.

As a side note registration looks (for now) this way:

Code Snippet

235. this.Device.SharedTiledPool.BeginCollect();
236.  
237. lindepth = this.Device.SharedTiledPool.PlaceRenderTarget(context, DepthTexture.Width, DepthTexture.Height, Format.R32_Float);
238. rthbaox = this.Device.SharedTiledPool.PlaceRenderTarget(context,DepthTexture.Width, DepthTexture.Height, Format.R16_Float);
239. rthbaoy = this.Device.SharedTiledPool.PlaceRenderTarget(context,DepthTexture.Width, DepthTexture.Height, Format.R16G16_Float);
240. rtblurx = this.Device.SharedTiledPool.PlaceRenderTarget(context, DepthTexture.Width, DepthTexture.Height, Format.R16G16_Float);
241. rtblury = this.Device.SharedTiledPool.PlaceRenderTarget(context, DepthTexture.Width, DepthTexture.Height, Format.R16_Float);
242.  
243. this.Device.SharedTiledPool.EndCollect();

Now of course I had a performance check Pool vs Pool, which ended up on a draw (so I keep the same performances, no penalty, always a good thing), and here is a small memory profiling.

I render one scene in full hd + hdr, and a second scene in half hd + hdr


Case 1 (old pool only):

• Global pool : 241 459 200
• Tiled Pool: 0

Case 2 (starting to use shared pool):

• Global pool: 109 670 400
• Tiled pool : 58 064 896
• Total memory: 167 735 296

So ok, 70 megs gain in a day where some people will say that you have 12 gigs of ram in a Titan card is meaningless, but well :

• Most people don't have a Titan card. (I normally plan on 4gb cards when doing projects).
• Adding a new scene will not change the tiled pool size, and increase the global pool in a much smaller fashion.
• If you start to add Msaa or render 3x full HD, you can expect a larger gain
• When you start to have a few assets in the Mix (like a 2+ gigs car model, never happened to me did it? ;) a hundred meg can make a huge difference.
• For cards that don't support tiled resources, the technique is really easily swappable, so it's not a big deal to fallback to global pool if feature is not supported (or leave the user decide).
• I applied it quickly as a proof of concept and only on 3 effectors, now this work I can also more aggressively optimize the post processing pipeline chain in the same way (and actually also anything that needs temporary resources in my general rendering, and there's a lot).

That's it for now, as a side note, I have some other pretty cool use cases for this, they will likely end up here when I'll have implemented them.

Particles revamp Part 3 : Selectors

In the last 2 posts, I explained how I moved my particle system to have GPU managed counter and to allow regions to have better emission/behaviour control.

This already offers a pretty great deal of flexibility, but then there are 2 parts that are missing:

• Now with regions, my valid particles can be scattered within my main buffer, that means emit count is not for the full particle system anymore, but per region.
• Many times I want to be able to only apply behaviours to particles that satisfy a particular condition (within an area, only particles that collided at leqst once, any particle within mouse raycast....)

In a funny way both problems can be solved using a similar technique... Selectors

So the idea is really simple, you have a predicate function (eg: anything from a particle that returns true or false), if a particle satisfies this predicate, then apply effectors, else do nothing.

As the amount of buffers to copy would be huge, we will do it in the most simple way eg: If a particle satisfies condition then add the particle index into a selection buffer, then create another dispatcher and only process the particles that satisfied the condition.

The only difference now is that behaviours must be aware that they operate either on plain buffer, or on a selection.

So first we need the following data:

Code Snippet

58. ByteAddressBuffer SelectionCountBuffer : SELECTIONCOUNTBUFFER;
59. StructuredBuffer<uint> SelectionIDBuffer : SELECTIONIDBUFFER;
60. RWStructuredBuffer<uint> RWSelectionIDBuffer : RWSELECTIONIDBUFFER; //Use for deterministic selection count
61. AppendStructuredBuffer<uint> AppendSelectionIDBuffer : APPENDSELECTIONIDBUFFER; //Use for unordered selection

Now we use some helper function:

Code Snippet

151. void AppendToSelection(uint id, bool predicate)
152. {
153.     if (predicate)
154.     {
155.         AppendSelectionIDBuffer.Append(id);
156.     }
157. }

Next we do a little cooking with our append buffer to generate new dispatch calls.

Now one difference is that our behaviours also need to fetch data either in a linear fashion (no selector), or using that lookup table, so a couple helper functions and a few defines do a great job for this purpose:

Code Snippet

170. #if PARTICLE_USE_SELECTION == 1
171. uint GetParticleIndex(uint tid)
172. {
173.     return SelectionIDBuffer[tid];
174. }
175.  
176. bool IsOverBounds(uint tid)
177. {
178.     uint selectionCount = SelectionCountBuffer.Load(0);
179.     return tid >= selectionCount;
180. }
181. #else
182. uint GetParticleIndex(uint tid)
183. {
184.     return tid;
185. }
186.  
187. bool IsOverBounds(uint tid)
188. {
189.     return tid >= EmitCount;
190. }
191. #endif

So for each behaviour, we now have 2 shaders, one to process linearly, one to process using lookup table.

So now here is an example of a "Within Sphere" selector

Code Snippet

3. float4 sphere : SPHERE;
4.  
5. [numthreads(64, 1, 1)]
6. void CS( uint3 i : SV_DispatchThreadID )
7. {
8.     if (IsOverBounds(i.x))
9.         return;
10.     int idx = GetParticleIndex(i.x);
11.     float3 p = PositionBuffer[idx];
12.     float d = length(sphere.xyz - p) - sphere.w;
13.     AppendToSelection(idx, d < 0.0f);
14. }

As any acute reader will notice, I'm also using the helper functions in the case of a selector, which means a selector can operate on a selection!

This part means you can stack selectors (in which case you have a "AND" operator. i did not implement that yet, since it might make things overcomplex, but there is also another rationale over it.

You remember that I said that now with regions my emitted particles are scattered inside the buffer, so that means any selector/global behaviour needs to operate only on emitted particles.

For global elements, you can call them once per region, but if you have 20 that multiplies your Dispatches a lot.

So instead, let's think simpler, we can easily for each region create a global lookup table that only contains emitted particles.

Code Snippet

6. cbuffer cbRegionInfo : register(b11)
7. {
8.     uint StartRegionOffset;
9.     uint RegionElementCount;
10. }
11.  
12. //This is called once per region
13. [numthreads(64,1,1)]
14. void CS_CopyRegionIndices(uint3 tid : SV_DispatchThreadID)
15. {
16.     if (tid.x >= EmitCount)
17.         return;
18.     //Get location in global buffer
19.     uint id = tid.x + StartRegionOffset;
20.     //Push particle ID
21.     AppendSelectionIDBuffer.Append(id);
22. }

Yes, it is that simple, we call this shader once per region (we clear Append buffer counter on first call, but preserve it on next iterations), and we have our global emission count.

So now we can select from within this buffer (which contains global indices, not local ones), and perform our behaviours/display only on emitted elements.


So now selectors can be owned by 2 "containers"

• Within the particle system: We can select particles and apply effectors
• Outside of the particle system : So we can select particles to route them to a custom render shader.

Since my selectors don't own any buffers, but are provided contexts, this is really easy.

So of course in case of selectors, you can also have them within a region, or globals, as the screenshot here shows:

You can see the Filter nodes grabs a particle selector for custom display, the Selector node can allow to select elements within the particle system, they both use the same "WithinSphere" node.


So this provides a huge amount of flexibility, and still keeps pretty high performances (as stream compaction makes sure that we only operate on needed elements).

But now we can also see that we operate in "Immediate mode", eg:If the particle satisfies the condition, apply, else , don't. This is done every frame.

In some cases this is not ideal, we want to say: If the particle has satisfied the condition once (for example , mouse raycast), then apply the effector until we release the button.

So in that case the switch is simple, as you seen previously, I the particle satisfies a condition, it is pushed into an append buffer.
So now let's change the code by:

Code Snippet

150. #if PARTICLE_SELECTION_RETAINED == 0
151. void AppendToSelection(uint id, bool predicate)
152. {
153.     if (predicate)
154.     {
155.         AppendSelectionIDBuffer.Append(id);
156.     }
157. }
158. #else
159. void AppendToSelection(uint id, bool predicate)
160. {
161.     if (predicate)
162.     {
163.         RWSelectionIDBuffer[id] = 1;
164.     }
165. }
166. #endif

We just write in a flag in order to tell that we satisfied the condition once.

Then our selector becomes:

Code Snippet

7. [numthreads(64, 1, 1)]
8. void CS_Reset(uint3 tid : SV_DispatchThreadID)
9. {
10.     if (IsOverBounds(i.x))
11.         return;
12.     int idx = GetParticleIndex(i.x);
13.  
14.     RWSelectionIDBuffer[idx] = 0;
15. }
16.  
17. [numthreads(64, 1, 1)]
18. void CS_Append(uint3 tid : SV_DispatchThreadID)
19. {
20.     if (IsOverBounds(i.x))
21.         return;
22.     int idx = GetParticleIndex(i.x);
23.  
24.     uint isFlagged = SelectionIDBuffer[idx];
25.  
26.     if (isFlagged)
27.     {
28.         AppendSelectionIDBuffer.Append(idx);
29.     }
30. }

So we add a second pass, which grabs every particle that has been flagged at least once (until we reset), and we now have our retained collector.

Here we go, revamping this particle system was actually really fun, allowed to have a reasonable code clean up alongside improvements, and now I got a lot of new funky effectors/emitters and selectors to write ;)

For the next posts, I'm not too sure yet, maybe some pipeline tricks, but there is something else coming that is much more interesting (hint for readers: read a bit of F# code, that will help you) :)