How to Implement HDR Rendering using glsl]

Http://blog.csdn.net/a3070173/archive/2008/11/29/3408573.aspx

 

1. HDR, short for high dynamic rang, is a popular 3D special effect technology. Its basic principle is that although full floating-point tables can be used in computer graphics
2. Color Display, but previously due to hardware restrictions, most of the texture formats loaded from the outside can only be expressed in one byte for each color component, that is, 0-255,
3. When this low-range color value is converted to the floating point type, it will lead to a certain amount of color intervals, while the HDR technology uses the floating point type of external texture format to make up for the original
4. The color interval caused by the integer texture format enhances the Color Performance of computer graphics. Of course, this is only a general statement, and everyone has the same concept.
5. So I listed some useful references at the end of this Article. Here I will briefly describe my HDR-OpenGL implementation.
6. Now, the concept of HDR is easy to understand, but there are still many things to consider if coding is really necessary.
8. The following lists the main rendering processes:
9. Remarks (FBO stands for Frame Buffer object)
10. 1. rendering the entire scenario to fbo1
11. 2. subsample fbo1 to fbo2 of the original size of 1/4
12. 3. subsample fbo2 to the original fbo3 of 1/8 size
13. Downsample Cell Coloring tool:
14. Uniform sampler2d g_scenetexture;
16. Void main ()
17. {
18. Gl_fragcolor = texture2d (g_scenetexture, gl_texcoord [0]. St );
19. }
21. 4. Perform Gaussian filtering on the content that has been sampled and stored in fbo3 twice, and then process the processed image.
22. Saved in fbo4 (Note: Gaussian filter is divided into two channels: Horizontal Filter and vertical filter, so a fbo5 is required for transition)
23. Gaussian filter element coloring device:
24. Const int g_iweightnumber = 17;
26. Uniform sampler2d g_decaltexture;
27. Uniform bool g_bfiltermodel;
29. Uniform float g_aryweight [g_iweightnumber]; // blur weight array
30. Uniform vec2 g_aryverticaloffset [g_iweightnumber]; // array of horizontal blur Offsets
31. Uniform vec2 g_aryhorizontaloffset [g_iweightnumber]; // array of vertical blur Offsets
33. Void main ()
34. {
35. Vec4 vec4sum = vec4 (0.0 );
36. If (g_bfiltermodel)
37. {
38. // Horizontal Filtering
39. For (INT I = 0; I <g_iweightnumber; ++ I)
40. {
41. Vec4sum + = texture2d (g_decaltexture, gl_texcoord [0]. St + g_aryverticaloffset [I]) * g_aryweight [I];
42. }
43. }
44. Else
45. {
46. // Vertical Filtering
47. For (INT I = 0; I <g_iweightnumber; ++ I)
48. {
49. Vec4sum + = texture2d (g_decaltexture, gl_texcoord [0]. St + g_aryhorizontaloffset [I]) * g_aryweight [I];
50. }
51. }
53. Gl_fragcolor = vec4sum;
54. }
56. 5. The content in fbo4 performs special effects and tonemapping with the content in fbo1 to map the color values in the high dynamic range to the low dynamic range for display.
57. Tonemapping bitwise coloring tool:
58. Const float g_fgamma = 1.0/2.0;
60. Uniform float g_fbluramount; // fuzzy amount
61. Uniform float g_fradialeffectamount; // radiation effect volume
62. Uniform float g_fexposure; // amount of exposure
63. Uniform sampler2d g_scenetexture;
64. Uniform sampler2d g_blurtexture;
66. // Calculate the radial effect
67. Vec4 caculateradial (vec2 p_vec2texcoord, int p_isamplenumber,
68. Float p_fstartscale = 1.0, float p_fscalemul = 0.9)
69. {
70. // Temporary Variable
71. Vec4 vec4tempcolor = vec4 (0.0 );
72. Float fcurrentscale = p_fstartscale;
73. Vec2 vec2temptexcoord = vec2 (0.0 );
75. // Traverse sampling
76. For (INT I = 0; I <p_isamplenumber; ++ I)
77. {
78. Vec2temptexcoord = (p_vec2texcoord-0.5) * fcurrentscale + 0.5; // Sampling Method
79. Vec4tempcolor + = texture2d (g_blurtexture, vec2temptexcoord );
80. Fcurrentscale * = p_fscalemul;
81. }
82. Vec4tempcolor/= float (p_isamplenumber );
83. Return vec4tempcolor;
84. }
86. // Calculate the effect of small illustrations
87. Float caculatevignette (vec2 p_vec2position, float p_finner, float p_fouter)
88. {
89. Float L = length (p_vec2position );
90. Return (1.0-smoothstep (p_finner, p_fouter, L ));
91. }
93. Void main ()
94. {
95. Vec4 vec4scenecolor = texture2d (g_scenetexture, gl_texcoord [0]. St); // calculate the color of the original scene
96. Vec4 vec4blurcolor = texture2d (g_blurtexture, gl_texcoord [0]. St); // calculate the scene color after blur
97. Vec4 vec4radialeffectcolor = caculateradial (gl_texcoord [0]. St, 30, 1.0, 0.95); // calculate the color of the Radiation Effect
99. // Mixed scenario and blur
100. Vec4 vec4temp = lerp (vec4scenecolor, vec4blurcolor, g_fbluramount );
101. // Add the radioactive effect
102. Vec4temp + = vec4radialpolictcolor * g_fradial?tamount;
103. // Perform exposure
104. Vec4temp * = g_fexposure;
105. // Add a circular diffusion small illustration to make the middle part brighter and the four corners gradually become darker
106. Vec4temp * = caculatevignette (gl_texcoord [0]. St * 2.0-1.0, 0.7, 1.5 );
107. // Use the Gamma Correction specification for low-range illumination
108. Vec4temp. RGB = POW (vec4temp. RGB, vec3 (g_fgamma ));
109. // Final color
110. Gl_fragcolor = vec4temp;
111. }
113. Demo effect:
117. EXE file: http://www.fileupyours.com/view/219112/GLSL/HDR%20Rendering.rar
118. Vc9 Runtime Library: http://www.fileupyours.com/view/219112/GLSL/VC9RunningLib.rar
119. References: 1. DirectX SDK sample-hdrlighting (note: this can be obtained from DirectX SDK)
120. 2. nvidia sdk 10.5-HDR (note: the nvidia sdk can be downloaded free of charge on the NVIDIA website)