Santiago Pacheco's Portfolio

As AHR is now "mature", I decided to go and try to implement it inside Unreal Engine 4. Still at early stages, but getting there.

Well, this blog needed some fresh air, so here it is.
I have been working in my GI technique, and one aspect I wanted to fix was the voxel clear code.
As is the trend today, AHR relies on a voxelized scene representation to compute the GI, and given that the scene can change each frame, the grid needs to be cleared each frame also.
That is a problem, as calling ClearUnorderedAccessViewUint() on a 512x512x512 grid takes about 25 ms on my system ( GTX 750 Ti + FX-6300 ). It's quite a bad result, taking into account that, using a high quality preset, rendering the GI itself takes 25 ms.
So, how did I manage to bring that 25 ms down to 0.7 ms ( a ~3500 % improvement ) you may ask? Well, here is how.

I'm using 32 bits per voxel because DirectX forces me to do it if I want to use atomics, but the data I store doesn't need that much precision. So I took 8 bits out of the voxel, and use them to store a frame counter. When raytracing, I compare the ID from the voxel to the current frame ID to see if it's valid.
So now I have 256 frames to clear the grids, wich I do with a simple compute shader. I could use ClearView(), and that would be awesome, but it just for DX 11.1, and only ( to the extend of my knowledge) AMD supports creating a 11.1 device, so that's a no-go.

Overall, the results are really good. With that change, the total frame time got a 50% reduction, without any noticeable impact on visual quality.
Still have some things to fix, but the idea is there

Screenshot!

Well, this blog has been dead for a while. I was working hard on getting AHR ready for the GDC, as I was rejected at SIGGRAPH (but not by far actually).
So, here's a new video:
Again, I can't provide a lot of details. Just hope that I get into the GDC, will explain everything there ;)

Global Illumination is the thing of the moment. Rendering it at real time is a really complex problem, so a lot of techniques have surfaced lately, mainly influenced by the amount of raw power and programability of current gen GPUs, and the new generation of consoles.

With Visual Studio 2012 Microsoft dumped the DirectX SDK, and the effects library with it( along other things), which I needed for my engine.

So I finally got to work again in the particles simulation, and I made some advances. Mainly, fixing the displacement of the particles and adding a "pseudo z culling" step. Actually, what I'm doing is compare the distance of the sample to the camera with the distance of the scene to the camera, and only add the sample to the final color if the distance is smaller.
Oh, I forgot. I also optimized part of the voxel update code, so I'm now using 80.000 particles at 90 - 110 fps. Quite nice!
There are things to do though. First of all, add some shading, maybe even shadows. I have other thing in mind, that I mentioned earlier, regarding compression of the voxels ( particles are sparse after all right? ) but it still needs some more work.
For now, here are some screens:

Working on a parser the other day, I decided to use the new <regex> library in C++ 11.
It's awesome, once you get to know the regex sintax. To make development faster, I coded a couple functions. They are nothing fancy, but they speed up my workflow.