In this post, I’ll be presenting “SSSSH”, which will be the sound made by any real programmer who happens to accidentally read this…
This has been a side project of mine for the last month or so with a few goals:
- Play around more with Houdini (I keep paying for it, I should use it more because it’s great)
- Add more gbuffers to UE4, because that sounds like a useful thing to be able to do and understand.
- Play around with spherical harmonics (as a black box) to understand the range and limitations of the technique a bit better.
- Maybe accidentally make something that looks cool.
I won’t go too much into the details on spherical harmonics because:
a) There’s lots of good sites out there explaining them and
b) I haven’t taken the time to understand the math, so I really don’t know how it works, and I’m sort of ok with that for now 😛
But at my basic understanding level, spherical harmonics is a way of representing data using a set of functions that take spherical coordinates as an input, and return a value. Instead of directly storing the data (lighting, depth, whatever), you work out a best fit of these functions to your data, and store the coefficients of the functions.
Here is a very accurate diagram:
Feel free to reuse that amazing diagram.
SH is good for data that varies rather smoothly, so tends to be used for ambient/bounced lighting in a lot of engines.
The function series is infinite, so you can decide how many terms you want to use, which determines how many coefficients you store.
For this blog post, I decided to go with 4-band spherical harmonics, because I’m greedy and irresponsible.
That’s 16 float values.
Thanks to the great work of Matt Ebb, a great deal of work was already done for me:
I had to do a bit of fiddling to get things working in Houdini 15, but that was a good thing to do anyway, every bit of learning helps!
What I used from Matt were two nodes for reading and writing SH data given the Theta and Phi (polar and azimuthal) angles:
Not only that, but I was able to take the evaluate code and adapt it to shader code in UE4, which saved me a bunch of time there too.
It’s not designed to be used that way, so I’m sure that it isn’t amazingly efficient. If I decide to actually keep any of this work, I’ll drop down to 3 band SH and use the provided UE4 functions 🙂
Depth tracing in Houdini
I’m not going to go through every part of the Houdini networks, just the meat of it, but here’s what the main network looks like:
So all the stuff on the left is for rendering SH coefficients out to textures (more on that later), the middle section is where the work is done, the right hand side a handful of debug modes visualizers, including some from the previously mentioned Matt Ebb post.
Hits and misses
I’m doing this in SOPs (geometry operations), because it’s what I know best in Houdini at the moment, as a Houdini noob 🙂
I should try moving it to shops (materials/per pixel) at some point, if that is at all possible.
To cheat, if I need more per-pixel like data, I usually just subdivide my meshes like crazy, and then just do geometry processing anyway 😛
The basic functionality is:
- For each vertex in the source object:
- Fire a ray in every direction
- Collect every hit
- Store the distance to the furthest away primitive that is facing away from the vertex normal (so back face, essentially)
All the hits are stored in an array, along with the Phi and Theta angles I mentioned before, here’s what that intersection network looks like currently:
I’m also keeping track of the maximum hit length, which I will use later to normalize the depth data. The max length is tracked one level up from the getMaxIntersect network from the previous screenshot:
This method currently doesn’t work very well with objects with lots of gaps in them, because the gaps in the middle of an object will essentially absorb light when they shouldn’t.
It wouldn’t be hard to fix, I just haven’t taken the time yet.
Before storing to SH values, I wanted to move all the depth values into the 0-1 range, since there are various other places where having 0-1 values makes my life easier later.
One interesting thing that came up here: when tracing rays out from a point, there are always more rays that miss than hit.
That’s because surfaces are more likely to be convex than concave, so at least half of the rays are pointing out into space:
Realistically, I don’t really care about spherical data, I probably want to store hemispherical data around the inverse normal.
That might cause data problems in severely concave areas of the mesh, but I don’t think it would be too big a problem.
There are hemispherical basis functions that could be used for that, if I were a bit more math savvy:
Anyway, having lots of values shooting out to infinite (max hit length) was skewing all of the SH values, and I was losing a lot of accuracy, so I encoded misses as zero length data instead.
Debug fun times!
So now, in theory, I have a representation of object thickness for every vertex in my mesh!
One fun way to debug it (in Houdini) was to read the SH values using the camera forward vector, which basically should give me depth from the camera (like a z buffer):
And, in a different debug mode that Matt Ebb had in his work, each vertex gets a sphere copied onto it, and the sphere is displaced in every direction by the SH value on the corresponding vertex:
This gives a good visual indicator on how deep the object is in every direction, and was super useful once I got used to what I was looking at 🙂
And, just for fun, here is shot from a point where I was doing something really wrong:
Exporting the data
My plans for this were always to bake out the SH data into textures, partially just because I was curious what sort of variation I’d get out of it (I had planned to use displacement maps on the mesh in Houdini to vary the height).
One of my very clever workmates, James Sharpe, had the good suggestion of packing the coeffs into UV data as I was whining to him over lunch about the lack of multiple vertex color set support in UE4.
So I decided to run with UVs, and then move back to image based once I was sure everything was working 🙂
Which worked great, and as you can probably see from the shot above, per-vertex (UVs or otherwise) is perfectly adequate 🙂
Actually, I ended up putting coefficients 1-14 into uvs, and the last two into the red and green vertex color channels, so that I could keep a proper UV set in the first channel that I could use for textures.
And then, all the work…
Next blog post coming soon!
In it, I will discuss all the UE4 work, the things I should have done, or done better, might do in the future and a few more test shots and scene from in UE4!
To be continued!!