For reference: Procedural Ships I (three years ago).
There will always be more to do. Even as far as I've come, you could easily single out a thousand things to improve. The texturing is awful. And is that a complete lack of bumpmap? Yikes. Spec map is boring. Every plate is pretty much the same -- no color, no different texturing, no nothing. Boring. The geometric structure? It's a 60-line algorithm, terribly simple and still terribly illogical.
And yet, somehow, I find myself falling in love with these ships. They are something more than the sum of their parts. Somehow, in the childish simplicity of it all, there is beauty.
Three years ago I was on the tip of the iceberg. Now, I feel, nothing has changed in that regard. The ships are a thousand times better, and yet, every moment that I explore proceduralism is another moment in which I realize that the iceberg is bigger than I ever did -- perhaps ever will -- comprehend. I now find it quite likely that I'll live out my entire life on the tip of this iceberg. It isn't a bad thing 🙂
Color grading was fun. It was cool. But it was hand-written.
In the true style of Limit Theory, let us give the computer the freedom. Allow it to generate procedural color transformations. An interpolated, n-point bezier grade applied (independently) to color channels. Control points generated using fractal noise. And now, you no longer have something that is cool, but rather, something truly magical. To watch the computer apply new artistic interpretations to the same image. This is Limit Theory 🙂
It's cheating, sure, but can give a lovely, artistic look. The eye really does love those gradients...
Suppose you want a nice rounded box mesh. You know how to create a mesh for a tesselated box. You know how to get a nice sphere mesh from a tesselated box mesh - you just project the box's points to a sphere:
p' = normalize(p)
What about a rounded box? How can we take a tessellated box mesh and project it nicely to a rounded box? For a box spanning [-1, 1], with a rounding radius of r, you simply:
p_box = clamp(p, -vec3(1 - r), vec3(1 - r))
p' = p_box + r * normalize(p - p_box)
Clamp the point to a smaller box, project the remainder to a sphere, reconstruct. Note that, while I say 'vec3' here, it's good for 2D as well (or however many Ds you need).
I write this down both for myself, and since I didn't find anything by searching (yes, I'm a bit embarrassed that I tried searching this first...)
Been fine-tuning the math this month. After more than three years, I really did finally get them 🙂 For a while there I wasn't sure I ever would. Now on to ships...
Superior to a linear interface in literally every way. This is the beginning of the end for you, scrollbars, listboxes, treeviews, and all you other ridiculous little controls 🙂
I guess I'm prepared to admit that, after finally getting everything tweaked properly...linear lighting does look darn good.
Kind of amazing how what amounts to little more than a sqrt in the lighting falloff is...so influential to the eye's perception of correctness..!
NOTE: Aberration is too aggressive.
A much more intuitive way to visualize the data. And appropriate, considering the game's context 🙂
Area of "star" is proportional to memory footprint. The connectivity is reflective of the structure of the data. Cool stuff...someday I'll do the same with the code rather than just the data. That'll be fantastic.
In-Engine Data Map
In-Engine Data Map (Closeup)
Edit: and a few more just for show 🙂 This is a pretty deep visualization of a ship, going all the way down to the attached hardpoints (thrusters, weapons, power generator) and most of the data therein. Amazing how beautiful and structured the data is.
Hard not to be proud of a c++ engine that lets you look inside of it with no boilerplate code 🙂
Runtime Reflection in the LT Engine (on the right)
Really a shame that I didn't post about any of the recent graphical improvements 🙁 Gotta hop back on the bandwagon at some point though!