Raytracing on the GPU

Unity Engine
1

Hello, I’m currently researching and investigating how to do raytracing on the GPU or in shaders. The goal of this is to learn and create raytraced shadows in unity that are faster than unity’s current shadow mapping algorithm. (Little to ambitious there, but fast enough for realtime use) Inspired from UE4’s results -

After following a simple raytracing tutorial in unity, I managed to create some simple raytraced shadows on the CPU. (Very simple)

1205×889 4.83 KB

However, it uses Physics.Raycast and it requires mesh colliers or some kind of collision to detect the objects. Not good or feasible for real time use, but the result is right there!!!

So my next step is to start doing this on the GPU. Only 2 questions that are not really answered for me. is this.

  1. How to cast the ray
    A. On the CPU, for each pixel, trace the incoming rays from the directional light.
  2. How to tell if it intersected and object.
    A. On the CPU, if the object has a collider and the ray hits it, return white. If it doesn’t return black.

So Im hitting quite a few walls for when Im doing this in the shader. One of the things I found out is to find out on the shader if a ray has intersected or hit and object. The object needs to have a defined Intersection function or distance function. Which is pretty easy to do for a simple scene, but if I wanted this dynamic then it would be very very very very time consuming to create an intersection or distance function for every single complex object in a scene like shown above. Now I could create a little program that creates and objects distance functions automatically and send them to the shader. Only problem is the shader cant really take that many distance functions (Im probably wrong) and I have no idea how to create this program as its beyond my current programming abilities.

EDIT - Currently looking at command buffers documentation.

So if any could provide me with some pointers, or perhaps some helpful code or suggestions. Id appreciate it.

2 Likes
2

Did you read what signed distance field is or did you just watch the video? Because that’s kind of the answer to your question.
You see, in order to ray-trace/ray-march something you need a scene representation first. You use mesh colliders in your cpu implementation. You could do the same thing on the gpu. Collect all the colliders in the scene, send them to a gpu buffer and ray trace through them in pixel or compute shader - i.e., get world space position for every pixel and compute intersection of the incoming light ray with every collider.
That is basically what Unreal is doing only the scene representation is very different. Unreal is using signed distance field. That means they precompute distance to the nearest surface at every point. And if you know distance to nearest surface at every point then you can easily compute intersection with any ray and a surface. The tricky part it to make the SDF small and efficient.

1 Like