||||A New Music

Stanford has a rendering competition in the Spring, as the final project of a rendering class (CS348b). I’m taking the class this quarter, so I’ll be part of the competition. Why not start preparing early?

I’ll be posting my progress in this blog. I don’t want to post everything here since this is really for my own personal endeavors that are unrelated to class, and I’d rather not flood this space with half-baked ideas and images.

At any rate, I certainly don’t anticipate winning (let’s face it, I’m a real-time graphics guy, not an offline rendering guy…), but there’s no harm in giving it a good go, right? At the end of it all, I’d just like to have a nice sci-fi image that I can be proud of.

Oh, and, of course, I want all of the scene content to be procedural…

(no surprises there, right?)

No, in fact, I haven’t fallen out of love with graphics and stopped working on all of my ideas. On the contrary, I’ve been spending the past month or so working hard on writing an OpenGL engine from the ground up. I have several reasons for doing so, among the them, a purely-curiosity-driven desire to learn the world of GL, as well as the fact that school uses GL in all coding assignments. It’s been a good experience and I’m progressing rapidly, but I must say, I’ve confirmed for myself once-and-for-all that DirectX is the better API, a least from an API standpoint (that is, considering only the interface, not necessarily the performance or functionality). Surely anyone out there who’s written a deferred pipeline in both APIs would have to agree…

At any rate, I’m revisiting SSAO, since my HLSL implementation was rather lacking (although good enough to produce some cool screenshots). I’ve come up with a fairly nice algorithm that uses only a linear depth buffer and screen-space (no unprojecting/reprojecting), but does a little bit of work to approximate the tangent plane at a given point, making it more accurate than a naive screen-space algorithm. I’m sure there are still lots of artifacts and places for improvement, but I’m please with the look of it so far.

Of course, the occlusion there is dramatically exaggerated; I wouldn’t dare turn it up that high in a serious game.

I’ve been playing around with post-processing functions (so to speak) on the terrain heightfields. When I designed the current terrain engine, I did so in such a way that terrain chunks have some amount of overlap, with the idea being that a “small amount” of post-processing can be done on the heightfield while avoiding seams. Of course, the only way to do this for anything that requires information about surrounding heights is to compute some redundant information (i.e., to overlap tiles a bit) and discard it.

Inspired by http://www.decarpentier.nl/scape-procedural-extensions, I started playing with using finite differences to modulate the heightfield according to its normal vector. The results are very compelling, although I’m not getting as nice of results as Giliam yet, presumably because he’s using an analytic derivative and distorting the input to the noise function, whereas I’m using a finite difference and just distorting texture coordinates.

Certainly looks promising.

A tribute to the greatest movie ever

The colors get quite interesting when you start adding more suns!

I played with more complicated atmospheres today. I refuse to implement overly-fancy techniques just to get something that boils down to a gradient with a few subtleties. Come on now. Here’s a shot from a sunset on a planet orbiting an O star:

I’m sure the math doesn’t work out…you can complain about not using real scattering equations all day, but man, it sure would be pretty to see this in-game. Don’t ever let the real math get in the way of beauty

Brought the terrain shaders over to the new deferred engine tonight. I didn’t touch the actual terrain code, so nothing’s new here…but it still looks good under the deferred pipeline, so that’s good news. And now we have distance blur as well!

Here we go again. Last time I tried nebulas, it was with fake, 2D noise functions. Now, I’m exploring the volumetric approach. So far, success has been fantastic. I’m running the whole nebula simulation on the GPU, so the generator is fast (< 1 second), even with a million+ particles. The nebula also renders at 60 FPS, which is nice, as I can actively explore it, unlike with previous attempts. Everything is shaping up really nicely, and the XDX Engine is getting plenty of new features along the way. Still need to play with colors, molecular clouds, and lighting in general.

Exciting!

By decent, I mean better than better, which, of course, is two levels above bad, so at least I’m making progress. This time the color looks correct and the reflection is more subtle, but it really brings the scene to life (I know, I said that about SSAO too..)

Just for comparison, here’s what the same scene looks like as it would look in my forward renderer (e.g., last week):

Yes indeed, I think XDX rendering has come quite far in a week.

Ah, that’s better. Not great, but way better! Playing with modulating normals and a new way of computing surface gloss.

This time, the DoF looks decent, but the reflections are pretty bad. I figure reflections are an essential part of any sci-fi-ish scene, so I’ve been working on them lately. This definitely isn’t right yet, but, like most of my recent posts, it’s a start.