Which part are you finding hard to understand, the theory or the implementation?

If it's the former then I can move this to 'Graphics Programming & Theory' where you may get a more detailed answer and reading recommendations.

Otherwise, what is it about the implementation you don't get? Any specific code fragments you've seen that you don't get or are trying to write but don't know how?


As for the SDK samples, have you looked at my HDRPipeline sample?



It started out as my own educational toy to try and understand the 'behind the scenes' steps involved with HDRI.

hth
Jack

The individual steps involved in HDRI are pretty simple and its the complexity of many simple steps that make the whole thing seem rather daunting.

I would recommend you step back and get familiar with post-processing algorithms. As an implementation detail this is absolutely key to HDRI. Being familiar with how to "ping pong" between render targets and how to compose your scene off-screen using 'render-to-texture' then apply pixel shaders to them when sending them to the actual visible backbuffer...

Once you've cracked that you can build up the HDRI stuff without too much difficulty. You can drop in the various bits and pieces as you go - it might look rubbish, but you can get away without luminance measuring temporarily if you just set a constant for example.

hth
Jack

As was the case when I was learning most of this stuff, you're probably making it out to be more complex than it really is ;)

If you need a few pointers, here's a short summary of what's involved:
-Make a high-precision render target. For this you're gonna want to have some familiarity with how DirectX handles texture formats. You probably want the A16R16G16B16F one for now, but once you get a handle on this you can experiment with HDR encoding just like Epic and Valve. (Google it!)
-Assign this to the back buffer using some of DX's helper funcs.
-Draw everything as normal.
-Do your postprocessing and write to a regular 24-bit color texture. Remember to run a tone-mapping pass! (Google some algorithms for this until you find one you like as there are lots)

That's really all there is to it! You might want to have a look at Humus' work, as he has some very nice, clean implementations of a lot of interesting effects, including an HDR pipeline. Some of it uses DX10, but there's a lot of easy-to-understand HLSL and GLSL code that shouldn't be too hard to adapt to your own nefarious ends :) As with jollyjeffers, I'd be more than willing to contribute what I can, although I think the Microsoft MVP and tute author might be the better option among us.

EDIT: Hurrr. I totally forgot about measuring luminance, which is probably the part that has you all confused. Thanks jeffers! Yeah. That's mostly just using sequentially smaller render targets until you can get it down to a nice 1x1 final value. Assuming you have the DX SDK, I *highly* recommend reading that little 'documentation' thing for the HDRLighting sample, as it provides a pretty easy-to-understand explanation of the whole process along with snippets of the actual code showing implementation.

I've got a quick question, to make sure I understand HDR as it's used for video games...

You basically render as if you could render a larger range of luminance, then just scale it down to the actual range?

Quote:Original post by dbzprogrammer
You basically render as if you could render a larger range of luminance, then just scale it down to the actual range?

Yes, that's basically how it works. It's also common to use hacks like Bloom to fake the appearance of certain areas being much brighter than their surroundings (like they were in the original HDR image).