| 3D C/C++ tutorials - OpenGL 2.1 - High dynamic range, bloom |
| Home Resources OpenGL Software rendering Ray tracing Downloads |
|
3D C/C++ tutorials -> OpenGL 2.1 -> High dynamic range, bloom
Use for personal or educational purposes only. Commercial and other profit uses strictly prohibited. Exploitation of content on a website or in a publication prohibited.
To compile and run these tutorials some or all of these libraries are required: FreeImage 3.16.0, GLEW 1.11.0, GLUT 3.7.6 / GLUT for Dev-C++, GLM 0.9.5.4
opengl_tutorials_win32_framework.h
...
class COpenGLRenderer
{
protected:
int Width, Height;
mat4x4 Model, View, Projection;
CTexture Kocka, Podlaha;
GLuint HDRColorBuffer, DepthBuffer, LuminanceBuffer, MinificationBuffer[8], LDRColorBuffer, BrightPixelsBuffer, BloomBuffer[12];
GLuint FBO;
CShaderProgram PerPixelLighting, Luminance, Minification, ToneMapping, BrightPixels, BlurH, BlurV;
float *data;
public:
CString Text;
float Intensity;
public:
COpenGLRenderer();
~COpenGLRenderer();
bool Init();
void Render(float FrameTime);
void Resize(int Width, int Height);
void Destroy();
};
...
opengl_tutorials_win32_framework.cpp
...
COpenGLRenderer::COpenGLRenderer()
{
Camera.SetViewMatrixPointer(&View);
}
COpenGLRenderer::~COpenGLRenderer()
{
}
bool COpenGLRenderer::Init()
{
if(gl_version < 21)
{
ErrorLog.Set("OpenGL 2.1 not supported!");
return false;
}
bool Error = false;
if(!GLEW_ARB_texture_non_power_of_two)
{
ErrorLog.Append("GL_ARB_texture_non_power_of_two not supported!\r\n");
Error = true;
}
if(!GLEW_ARB_depth_texture)
{
ErrorLog.Append("GL_ARB_depth_texture not supported!\r\n");
Error = true;
}
if(!GLEW_ARB_texture_float)
{
ErrorLog.Append("GL_ARB_texture_float not supported!\r\n");
Error = true;
}
if(!GLEW_ARB_framebuffer_object)
{
ErrorLog.Append("GL_ARB_framebuffer_object not supported!\r\n");
Error = true;
}
Error |= !Kocka.LoadTexture2D("kocka.jpg");
Error |= !Podlaha.LoadTexture2D("podlaha.jpg");
Error |= !PerPixelLighting.Load("per_pixel_lighting.vs", "per_pixel_lighting.fs");
Error |= !Luminance.Load("luminance.vs", "luminance.fs");
Error |= !Minification.Load("minification.vs", "minification.fs");
Error |= !ToneMapping.Load("tone_mapping.vs", "tone_mapping.fs");
Error |= !BrightPixels.Load("bright_pixels.vs", "bright_pixels.fs");
Error |= !BlurH.Load("blur.vs", "blurh.fs");
Error |= !BlurV.Load("blur.vs", "blurv.fs");
if(Error)
{
return false;
}
PerPixelLighting.UniformLocations = new GLuint[1];
PerPixelLighting.UniformLocations[0] = glGetUniformLocation(PerPixelLighting, "CameraPosition");
Luminance.UniformLocations = new GLuint[2];
Luminance.UniformLocations[0] = glGetUniformLocation(Luminance, "odx");
Luminance.UniformLocations[1] = glGetUniformLocation(Luminance, "ody");
ToneMapping.UniformLocations = new GLuint[1];
ToneMapping.UniformLocations[0] = glGetUniformLocation(ToneMapping, "MaxRGBValue");
BlurH.UniformLocations = new GLuint[2];
BlurH.UniformLocations[0] = glGetUniformLocation(BlurH, "Width");
BlurH.UniformLocations[1] = glGetUniformLocation(BlurH, "odw");
BlurV.UniformLocations = new GLuint[2];
BlurV.UniformLocations[0] = glGetUniformLocation(BlurV, "Width");
BlurV.UniformLocations[1] = glGetUniformLocation(BlurV, "odh");
glUseProgram(BlurH);
glUniform1i(BlurH.UniformLocations[0], 5);
glUseProgram(BlurV);
glUniform1i(BlurV.UniformLocations[0], 5);
glUseProgram(0);
glGenTextures(1, &HDRColorBuffer);
glGenTextures(1, &DepthBuffer);
glGenTextures(1, &LuminanceBuffer);
glGenTextures(8, MinificationBuffer);
glGenTextures(1, &LDRColorBuffer);
glGenTextures(1, &BrightPixelsBuffer);
glGenTextures(12, BloomBuffer);
glGenFramebuffers(1, &FBO);
data = new float[4096];
Intensity = 2.0f;
glLightfv(GL_LIGHT0, GL_AMBIENT, &vec4(vec3(0.25f), 1.0f));
glLightfv(GL_LIGHT0, GL_POSITION, &vec4(-2.0f, 2.0f, -2.0f, 1.0f));
return true;
}
void COpenGLRenderer::Render(float FrameTime)
{
// set viewport, perspective projection and modelview matrix --------------------------------------------------------------
glViewport(0, 0, Width, Height);
glMatrixMode(GL_PROJECTION);
glLoadMatrixf(&Projection);
glMatrixMode(GL_MODELVIEW);
glLoadMatrixf(&View);
// set light diffuse color ------------------------------------------------------------------------------------------------
glLightfv(GL_LIGHT0, GL_DIFFUSE, &vec4(vec3(Intensity), 1.0f));
// render scene to HDRColorBuffer texture ---------------------------------------------------------------------------------
glBindFramebuffer(GL_FRAMEBUFFER, FBO);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, HDRColorBuffer, 0);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, DepthBuffer, 0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
glUseProgram(PerPixelLighting);
glUniform3fv(PerPixelLighting.UniformLocations[0], 1, &Camera.Position);
glBindTexture(GL_TEXTURE_2D, Kocka);
glBegin(GL_QUADS);
glNormal3f( 0.0f, 0.0f, 1.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f(-0.5f, -0.5f, 0.5f);
glTexCoord2f(1.0f, 0.0f); glVertex3f( 0.5f, -0.5f, 0.5f);
glTexCoord2f(1.0f, 1.0f); glVertex3f( 0.5f, 0.5f, 0.5f);
glTexCoord2f(0.0f, 1.0f); glVertex3f(-0.5f, 0.5f, 0.5f);
glNormal3f( 0.0f, 0.0f, -1.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f( 0.5f, -0.5f, -0.5f);
glTexCoord2f(1.0f, 0.0f); glVertex3f(-0.5f, -0.5f, -0.5f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(-0.5f, 0.5f, -0.5f);
glTexCoord2f(0.0f, 1.0f); glVertex3f( 0.5f, 0.5f, -0.5f);
glNormal3f( 1.0f, 0.0f, 0.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f( 0.5f, -0.5f, 0.5f);
glTexCoord2f(1.0f, 0.0f); glVertex3f( 0.5f, -0.5f, -0.5f);
glTexCoord2f(1.0f, 1.0f); glVertex3f( 0.5f, 0.5f, -0.5f);
glTexCoord2f(0.0f, 1.0f); glVertex3f( 0.5f, 0.5f, 0.5f);
glNormal3f(-1.0f, 0.0f, 0.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f(-0.5f, -0.5f, -0.5f);
glTexCoord2f(1.0f, 0.0f); glVertex3f(-0.5f, -0.5f, 0.5f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(-0.5f, 0.5f, 0.5f);
glTexCoord2f(0.0f, 1.0f); glVertex3f(-0.5f, 0.5f, -0.5f);
glNormal3f( 0.0f, 1.0f, 0.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f(-0.5f, 0.5f, 0.5f);
glTexCoord2f(1.0f, 0.0f); glVertex3f( 0.5f, 0.5f, 0.5f);
glTexCoord2f(1.0f, 1.0f); glVertex3f( 0.5f, 0.5f, -0.5f);
glTexCoord2f(0.0f, 1.0f); glVertex3f(-0.5f, 0.5f, -0.5f);
glNormal3f( 0.0f, -1.0f, 0.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f(-0.5f, -0.5f, -0.5f);
glTexCoord2f(1.0f, 0.0f); glVertex3f( 0.5f, -0.5f, -0.5f);
glTexCoord2f(1.0f, 1.0f); glVertex3f( 0.5f, -0.5f, 0.5f);
glTexCoord2f(0.0f, 1.0f); glVertex3f(-0.5f, -0.5f, 0.5f);
glEnd();
glBindTexture(GL_TEXTURE_2D, Podlaha);
glBegin(GL_QUADS);
glNormal3f(0.0f, 1.0f, 0.0f);
glTexCoord2f( 0.0f, 0.0f); glVertex3f(-5.0f, -0.5f, 5.0f);
glTexCoord2f(10.0f, 0.0f); glVertex3f( 5.0f, -0.5f, 5.0f);
glTexCoord2f(10.0f, 10.0f); glVertex3f( 5.0f, -0.5f, -5.0f);
glTexCoord2f( 0.0f, 10.0f); glVertex3f(-5.0f, -0.5f, -5.0f);
glEnd();
glUseProgram(0);
glDisable(GL_CULL_FACE);
glDisable(GL_DEPTH_TEST);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
// set orthogonal projection and reset modelview matrix -------------------------------------------------------------------
glMatrixMode(GL_PROJECTION);
glLoadMatrixf(&OrthogonalProjectionMatrix(0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f));
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
// get the maximal value of the RGB components of the HDR image -----------------------------------------------------------
static float MaxRGBValue = 1.0f, maxrgbvalue = 1.0f, mrgbvi, oldmaxrgbvalue = maxrgbvalue;
static DWORD LastTime = 0;
DWORD Time = GetTickCount();
if(Time - LastTime > 250) // 4 times per second only ----------------------------------------------------------------------
{
LastTime = Time;
// render LiminanceBuffer texture -------------------------------------------------------------------------------------
glBindFramebuffer(GL_FRAMEBUFFER, FBO);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, LuminanceBuffer, 0);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, 0, 0);
glBindTexture(GL_TEXTURE_2D, HDRColorBuffer);
glUseProgram(Luminance);
glBegin(GL_QUADS);
glVertex2f(0.0f, 0.0f);
glVertex2f(1.0f, 0.0f);
glVertex2f(1.0f, 1.0f);
glVertex2f(0.0f, 1.0f);
glEnd();
glUseProgram(0);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
int i = 0, x = Width, y = Height;
float odx = 1.0f / (float)x, ody = 1.0f / (float)y;
// downscale LuminanceBuffer texture to less than 32x32 pixels --------------------------------------------------------
do
{
x /= 2;
y /= 2;
glViewport(0, 0, x, y);
glBindFramebuffer(GL_FRAMEBUFFER, FBO);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, MinificationBuffer[i], 0);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, 0, 0);
glBindTexture(GL_TEXTURE_2D, i == 0 ? LuminanceBuffer : MinificationBuffer[i - 1]);
glUseProgram(Minification);
glUniform1f(Luminance.UniformLocations[0], odx);
glUniform1f(Luminance.UniformLocations[1], ody);
glBegin(GL_QUADS);
glTexCoord2f(0.0f, 0.0f); glVertex2f(0.0f, 0.0f);
glTexCoord2f(1.0f - odx, 0.0f); glVertex2f(1.0f, 0.0f);
glTexCoord2f(1.0f - odx, 1.0f - ody); glVertex2f(1.0f, 1.0f);
glTexCoord2f(0.0f, 1.0f - ody); glVertex2f(0.0f, 1.0f);
glEnd();
glUseProgram(0);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
odx = 1.0f / (float)x;
ody = 1.0f / (float)y;
i++;
}
while(x > 32 || y > 32);
glViewport(0, 0, Width, Height);
// read downscaled LuminanceBuffer texture data -----------------------------------------------------------------------
glBindTexture(GL_TEXTURE_2D, MinificationBuffer[i - 1]);
glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_FLOAT, data);
glBindTexture(GL_TEXTURE_2D, 0);
// get the maximal luminance value ------------------------------------------------------------------------------------
maxrgbvalue = 0.0f;
for(int p = 0; p < x * y * 4; p += 4)
{
maxrgbvalue = max(maxrgbvalue, data[p]);
}
if(maxrgbvalue < 1.0) maxrgbvalue = 1.0;
if(maxrgbvalue != oldmaxrgbvalue) mrgbvi = abs(maxrgbvalue - MaxRGBValue);
oldmaxrgbvalue = maxrgbvalue;
}
if(MaxRGBValue < maxrgbvalue) { MaxRGBValue += mrgbvi * FrameTime; if(MaxRGBValue > maxrgbvalue) MaxRGBValue = maxrgbvalue; }
if(MaxRGBValue > maxrgbvalue) { MaxRGBValue -= mrgbvi * FrameTime; if(MaxRGBValue < maxrgbvalue) MaxRGBValue = maxrgbvalue; }
// render HDRColorBuffer texture to LDRColorBuffer texture with tone mapping shader applied -------------------------------
glBindFramebuffer(GL_FRAMEBUFFER, FBO);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, LDRColorBuffer, 0);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, 0, 0);
glBindTexture(GL_TEXTURE_2D, HDRColorBuffer);
glUseProgram(ToneMapping);
glUniform1f(ToneMapping.UniformLocations[0], MaxRGBValue);
glBegin(GL_QUADS);
glVertex2f(0.0f, 0.0f);
glVertex2f(1.0f, 0.0f);
glVertex2f(1.0f, 1.0f);
glVertex2f(0.0f, 1.0f);
glEnd();
glUseProgram(0);
glBindTexture(GL_TEXTURE_2D, 0);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
// render BrightPixelsBuffer texture --------------------------------------------------------------------------------------
glBindFramebuffer(GL_FRAMEBUFFER, FBO);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, BrightPixelsBuffer, 0);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, 0, 0);
glBindTexture(GL_TEXTURE_2D, LDRColorBuffer);
glUseProgram(BrightPixels);
glBegin(GL_QUADS);
glVertex2f(0.0f, 0.0f);
glVertex2f(1.0f, 0.0f);
glVertex2f(1.0f, 1.0f);
glVertex2f(0.0f, 1.0f);
glEnd();
glUseProgram(0);
glBindTexture(GL_TEXTURE_2D, 0);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
// downscale and blur BrightPixelsBuffer texture 4x -----------------------------------------------------------------------
for(int i = 0; i < 4; i++)
{
int ds = 2 * (i + 1);
// set viewport to 1/ds of the screen ----------------------------------------------------------------------------------
glViewport(0, 0, Width / ds, Height / ds);
// downscale ----------------------------------------------------------------------------------------------------------
glBindFramebuffer(GL_FRAMEBUFFER, FBO);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, BloomBuffer[i*3+0], 0);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, 0, 0);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, BrightPixelsBuffer);
glColor3f(1.0f, 1.0f, 1.0f);
glBegin(GL_QUADS);
glTexCoord2f(0.0f, 0.0f); glVertex2f(0.0f, 0.0f);
glTexCoord2f(1.0f, 0.0f); glVertex2f(1.0f, 0.0f);
glTexCoord2f(1.0f, 1.0f); glVertex2f(1.0f, 1.0f);
glTexCoord2f(0.0f, 1.0f); glVertex2f(0.0f, 1.0f);
glEnd();
glBindTexture(GL_TEXTURE_2D, 0);
glDisable(GL_TEXTURE_2D);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
// horizontal blur ----------------------------------------------------------------------------------------------------
glBindFramebuffer(GL_FRAMEBUFFER, FBO);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, BloomBuffer[i*3+1], 0);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, 0, 0);
glBindTexture(GL_TEXTURE_2D, BloomBuffer[i*3+0]);
glUseProgram(BlurH);
glUniform1f(BlurH.UniformLocations[1], 1.0f / (float)(Width / ds));
glBegin(GL_QUADS);
glVertex2f(0.0f, 0.0f);
glVertex2f(1.0f, 0.0f);
glVertex2f(1.0f, 1.0f);
glVertex2f(0.0f, 1.0f);
glEnd();
glUseProgram(0);
glBindTexture(GL_TEXTURE_2D, 0);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
// vertical blur ------------------------------------------------------------------------------------------------------
glBindFramebuffer(GL_FRAMEBUFFER, FBO);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, BloomBuffer[i*3+2], 0);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, 0, 0);
glBindTexture(GL_TEXTURE_2D, BloomBuffer[i*3+1]);
glUseProgram(BlurV);
glUniform1f(BlurH.UniformLocations[1], 1.0f / (float)(Height / ds));
glBegin(GL_QUADS);
glVertex2f(0.0f, 0.0f);
glVertex2f(1.0f, 0.0f);
glVertex2f(1.0f, 1.0f);
glVertex2f(0.0f, 1.0f);
glEnd();
glUseProgram(0);
glBindTexture(GL_TEXTURE_2D, 0);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
}
// display LDRColorBuffer texture ----------------------------------------------------------------------------------------
glViewport(0, 0, Width, Height);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, LDRColorBuffer);
glColor3f(1.0f, 1.0f, 1.0f);
glBegin(GL_QUADS);
glTexCoord2f(0.0f, 0.0f); glVertex2f(0.0f, 0.0f);
glTexCoord2f(1.0f, 0.0f); glVertex2f(1.0f, 0.0f);
glTexCoord2f(1.0f, 1.0f); glVertex2f(1.0f, 1.0f);
glTexCoord2f(0.0f, 1.0f); glVertex2f(0.0f, 1.0f);
glEnd();
glBindTexture(GL_TEXTURE_2D, 0);
glDisable(GL_TEXTURE_2D);
// blend 4 downscaled and blurred BrightPixelsBuffer textures over the screen ---------------------------------------------
for(int i = 0; i < 4; i++)
{
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, BloomBuffer[(3-i)*3+2]);
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_COLOR);
glEnable(GL_BLEND);
glColor3f(1.0f, 1.0f, 1.0f);
glBegin(GL_QUADS);
glTexCoord2f(0.0f, 0.0f); glVertex2f(0.0f, 0.0f);
glTexCoord2f(1.0f, 0.0f); glVertex2f(1.0f, 0.0f);
glTexCoord2f(1.0f, 1.0f); glVertex2f(1.0f, 1.0f);
glTexCoord2f(0.0f, 1.0f); glVertex2f(0.0f, 1.0f);
glEnd();
glDisable(GL_BLEND);
glBindTexture(GL_TEXTURE_2D, 0);
glDisable(GL_TEXTURE_2D);
}
// end --------------------------------------------------------------------------------------------------------------------
Text.Set("I: %.02f, MRGBV: %.03f", Intensity, MaxRGBValue);
}
void COpenGLRenderer::Resize(int Width, int Height)
{
this->Width = Width;
this->Height = Height;
Projection = PerspectiveProjectionMatrix(45.0f, (float)Width, (float)Height, 0.125f, 512.0f);
glBindTexture(GL_TEXTURE_2D, HDRColorBuffer);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F, Width, Height, 0, GL_RGBA, GL_FLOAT, NULL);
glBindTexture(GL_TEXTURE_2D, DepthBuffer);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT32, Width, Height, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL);
glBindTexture(GL_TEXTURE_2D, LuminanceBuffer);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F, Width, Height, 0, GL_RGBA, GL_FLOAT, NULL);
int i = 0, x = Width, y = Height;
do
{
x /= 2;
y /= 2;
glBindTexture(GL_TEXTURE_2D, MinificationBuffer[i]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F, x, y, 0, GL_RGBA, GL_FLOAT, NULL);
i++;
}
while(x > 32 || y > 32);
glBindTexture(GL_TEXTURE_2D, LDRColorBuffer);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, Width, Height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glBindTexture(GL_TEXTURE_2D, BrightPixelsBuffer);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, Width, Height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
for(int i = 0; i < 4; i++)
{
int ds = 2 * (i + 1);
for(int ii = 0; ii < 3; ii++)
{
glBindTexture(GL_TEXTURE_2D, BloomBuffer[3*i+ii]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, Width / ds, Height / ds, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
}
}
}
void COpenGLRenderer::Destroy()
{
delete [] data;
Kocka.Delete();
Podlaha.Delete();
glDeleteTextures(1, &HDRColorBuffer);
glDeleteTextures(1, &DepthBuffer);
glDeleteTextures(1, &LuminanceBuffer);
glDeleteTextures(8, MinificationBuffer);
glDeleteTextures(1, &LDRColorBuffer);
glDeleteTextures(1, &BrightPixelsBuffer);
glDeleteTextures(12, BloomBuffer);
if(gl_version >= 21)
{
PerPixelLighting.Delete();
Luminance.Delete();
Minification.Delete();
ToneMapping.Delete();
BrightPixels.Delete();
BlurH.Delete();
BlurV.Delete();
}
if(GLEW_ARB_framebuffer_object)
{
glDeleteFramebuffers(1, &FBO);
}
}
...
per_pixel_lighting.vs
#version 120
uniform vec3 CameraPosition;
varying vec3 LD, Normal, LDR, EV;
void main()
{
LD = gl_LightSource[0].position.xyz - gl_Vertex.xyz;
Normal = gl_Normal;
LDR = reflect(-LD, Normal);
EV = CameraPosition - gl_Vertex.xyz;
gl_TexCoord[0] = gl_MultiTexCoord0;
gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
}
per_pixel_lighting.fs
#version 120
uniform sampler2D Texture;
varying vec3 LD, Normal, EV, LDR;
void main()
{
vec3 LDN = normalize(LD);
vec3 NormalN = normalize(Normal);
vec3 LDRN = normalize(LDR);
vec3 EVN = normalize(EV);
float NdotLD = max(dot(NormalN, LDN), 0.0);
float EVdotLDR = pow(max(dot(EVN, LDRN), 0.0), 32.0);
vec3 Color = texture2D(Texture, gl_TexCoord[0].st).rgb * (gl_LightSource[0].ambient.rgb + gl_LightSource[0].diffuse.rgb * (NdotLD + EVdotLDR));
gl_FragColor = vec4(Color, 1.0);
}
luminance.vs
#version 120
void main()
{
gl_TexCoord[0] = gl_Vertex;
gl_Position = gl_Vertex * 2.0 - 1.0;
}
luminance.fs
#version 120
uniform sampler2D HDRColorBuffer;
void main()
{
vec3 Color = texture2D(HDRColorBuffer, gl_TexCoord[0].st).rgb;
float MaxRGBValue = max(Color.r, max(Color.g, Color.b));
gl_FragColor = vec4(MaxRGBValue, 0.0, 0.0, 0.0);
}
minification.vs
#version 120
void main()
{
gl_TexCoord[0] = gl_MultiTexCoord0;
gl_Position = gl_Vertex * 2.0 - 1.0;
}
minification.fs
#version 120
uniform sampler2D LuminanceBuffer;
uniform float odx, ody;
void main()
{
float a = texture2D(LuminanceBuffer, gl_TexCoord[0].st + vec2(0.0, 0.0)).r;
float b = texture2D(LuminanceBuffer, gl_TexCoord[0].st + vec2(odx, 0.0)).r;
float c = texture2D(LuminanceBuffer, gl_TexCoord[0].st + vec2(odx, ody)).r;
float d = texture2D(LuminanceBuffer, gl_TexCoord[0].st + vec2(0.0, ody)).r;
float maxlum = max(max(a, b), max(c, d));
gl_FragColor = vec4(maxlum, 0.0, 0.0, 0.0);
}
tone_mapping.vs
#version 120
void main()
{
gl_TexCoord[0] = gl_Vertex;
gl_Position = gl_Vertex * 2.0 - 1.0;
}
tone_mapping.fs
#version 120
uniform sampler2D HDRColorBuffer;
uniform float MaxRGBValue;
void main()
{
vec3 Color = texture2D(HDRColorBuffer, gl_TexCoord[0].st).rgb;
gl_FragColor = vec4(Color / MaxRGBValue, 1.0);
}
bright_pixels.vs
#version 120
void main()
{
gl_TexCoord[0] = gl_Vertex;
gl_Position = gl_Vertex * 2.0 - 1.0;
}
bright_pixels.fs
#version 120
uniform sampler2D LDRColorBuffer;
void main()
{
vec3 Color = texture2D(LDRColorBuffer, gl_TexCoord[0].st).rgb;
float MaxRGBValue = max(Color.r, max(Color.g, Color.b));
if(MaxRGBValue > 0.90)
{
gl_FragColor = vec4(Color, 1.0);
}
}
blur.vs
#version 120
void main()
{
gl_TexCoord[0] = gl_Vertex;
gl_Position = gl_Vertex * 2.0 - 1.0;
}
blurh.fs
#version 120
uniform sampler2D Texture;
uniform int Width;
uniform float odw;
void main()
{
vec3 Color = vec3(0.0);
int wp1 = Width + 1;
float Sum = 0.0;
for(int x = -Width; x <= Width; x++)
{
float width = (wp1 - abs(float(x)));
Color += texture2D(Texture, gl_TexCoord[0].st + vec2(odw * x, 0.0)).rgb * width;
Sum += width;
}
gl_FragColor = vec4(Color / Sum, 1.0);
}
blurv.fs
#version 120
uniform sampler2D Texture;
uniform int Width;
uniform float odh;
void main()
{
vec3 Color = vec3(0.0);
int wp1 = Width + 1;
float Sum = 0.0;
for(int y = -Width; y <= Width; y++)
{
float width = (wp1 - abs(float(y)));
Color += texture2D(Texture, gl_TexCoord[0].st + vec2(0.0, odh * y)).rgb * width;
Sum += width;
}
gl_FragColor = vec4(Color / Sum, 1.0);
}
Download
high_dynamic_range_bloom.zip (Visual Studio 2005 Professional)
|
|
© 2010 - 2016 Bc. Michal Belanec, michalbelanec (at) centrum (dot) sk
Last update June 25, 2016 OpenGL® is a registered trademark of Silicon Graphics Inc. |