ilikecats/stk-code_catmod
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Shaders: FullScreenShader are not loaded at startup.

Browse Source 
Besides being cleaner it also help finding error in shaders.
This commit is contained in:
Vincent Lejeune
2014-01-18 21:35:52 +01:00
parent 6a995ab178
commit 6df85e260c
3 changed files with 500 additions and 411 deletions
Download Patch File Download Diff File Expand all files Collapse all files

483
src/graphics/post_processing.cpp
View File

@@ -31,7 +31,6 @@
#include "race/race_manager.hpp"
#include "tracks/track.hpp"
#include "utils/log.hpp"
#include "graphics/glwrap.hpp"
#include <SViewFrustum.h>
@@ -199,328 +198,17 @@ void PostProcessing::update(float dt)
}
} // update
GLuint quad_vbo = 0;
static void initQuadVBO()
{
initGL();
const float quad_vertex[] = {
-1., -1., 0., 0., // UpperLeft
-1., 1., 0., 1., // LowerLeft
1., -1., 1., 0., // UpperRight
1., 1., 1., 1., // LowerRight
};
glGenBuffers(1, &quad_vbo);
glBindBuffer(GL_ARRAY_BUFFER, quad_vbo);
glBufferData(GL_ARRAY_BUFFER, 16 * sizeof(float), quad_vertex, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
}
static GLuint createVAO(GLuint Program)
{
if (!quad_vbo)
initQuadVBO();
GLuint vao;
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
GLuint attrib_position = glGetAttribLocation(Program, "Position");
GLuint attrib_texcoord = glGetAttribLocation(Program, "Texcoord");
glBindBuffer(GL_ARRAY_BUFFER, quad_vbo);
glEnableVertexAttribArray(attrib_position);
glEnableVertexAttribArray(attrib_texcoord);
glVertexAttribPointer(attrib_position, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), 0);
glVertexAttribPointer(attrib_texcoord, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), (GLvoid*)(2 * sizeof(float)));
glBindVertexArray(0);
return vao;
}
namespace BloomShader
{
GLuint Program = 0;
GLuint uniform_texture, uniform_low;
GLuint vao = 0;
void init()
{
initGL();
Program = LoadProgram(file_manager->getAsset("shaders/screenquad.vert").c_str(), file_manager->getAsset("shaders/bloom.frag").c_str());
uniform_texture = glGetUniformLocation(Program, "tex");
uniform_low = glGetUniformLocation(Program, "low");
vao = createVAO(Program);
}
}
namespace BloomBlendShader
{
GLuint Program = 0;
GLuint uniform_texture, uniform_low;
GLuint vao = 0;
void init()
{
initGL();
Program = LoadProgram(file_manager->getAsset("shaders/screenquad.vert").c_str(), file_manager->getAsset("shaders/bloomblend.frag").c_str());
uniform_texture = glGetUniformLocation(Program, "tex");
vao = createVAO(Program);
}
}
namespace PPDisplaceShader
{
GLuint Program = 0;
GLuint uniform_tex, uniform_dtex, uniform_viz;
GLuint vao = 0;
void init()
{
initGL();
Program = LoadProgram(file_manager->getAsset("shaders/screenquad.vert").c_str(), file_manager->getAsset("shaders/ppdisplace.frag").c_str());
uniform_tex = glGetUniformLocation(Program, "tex");
uniform_dtex = glGetUniformLocation(Program, "dtex");
uniform_viz = glGetUniformLocation(Program, "viz");
vao = createVAO(Program);
}
}
namespace ColorLevelShader
{
GLuint Program = 0;
GLuint uniform_tex, uniform_inlevel, uniform_outlevel;
GLuint vao = 0;
void init()
{
initGL();
Program = LoadProgram(file_manager->getAsset("shaders/screenquad.vert").c_str(), file_manager->getAsset("shaders/color_levels.frag").c_str());
uniform_tex = glGetUniformLocation(Program, "tex");
uniform_inlevel = glGetUniformLocation(Program, "inlevel");
uniform_outlevel = glGetUniformLocation(Program, "outlevel");
vao = createVAO(Program);
}
}
namespace PointLightShader
{
GLuint Program = 0;
GLuint uniform_ntex, uniform_center, uniform_col, uniform_energy, uniform_spec, uniform_invproj, uniform_viewm;
GLuint vao = 0;
void init()
{
initGL();
Program = LoadProgram(file_manager->getAsset("shaders/screenquad.vert").c_str(), file_manager->getAsset("shaders/pointlight.frag").c_str());
uniform_ntex = glGetUniformLocation(Program, "ntex");
uniform_center = glGetUniformLocation(Program, "center[0]");
uniform_col = glGetUniformLocation(Program, "col[0]");
uniform_energy = glGetUniformLocation(Program, "energy[0]");
uniform_spec = glGetUniformLocation(Program, "spec");
uniform_invproj = glGetUniformLocation(Program, "invproj");
uniform_viewm = glGetUniformLocation(Program, "viewm");
vao = createVAO(Program);
}
}
namespace LightBlendShader
{
GLuint Program = 0;
GLuint uniform_diffuse, uniform_specular, uniform_ambient_occlusion, uniform_specular_map, uniform_ambient;
GLuint vao = 0;
void init()
{
initGL();
Program = LoadProgram(file_manager->getAsset("shaders/screenquad.vert").c_str(), file_manager->getAsset("shaders/lightblend.frag").c_str());
uniform_diffuse = glGetUniformLocation(Program, "diffuse");
uniform_specular = glGetUniformLocation(Program, "specular");
uniform_ambient_occlusion = glGetUniformLocation(Program, "ambient_occlusion");
uniform_specular_map = glGetUniformLocation(Program, "specular_map");
uniform_ambient = glGetUniformLocation(Program, "ambient");
vao = createVAO(Program);
}
}
namespace Gaussian6HBlurShader
{
GLuint Program = 0;
GLuint uniform_tex, uniform_pixel;
GLuint vao = 0;
void init()
{
initGL();
Program = LoadProgram(file_manager->getAsset("shaders/screenquad.vert").c_str(), file_manager->getAsset("shaders/gaussian6h.frag").c_str());
uniform_tex = glGetUniformLocation(Program, "tex");
uniform_pixel = glGetUniformLocation(Program, "pixel");
vao = createVAO(Program);
}
}
namespace Gaussian3HBlurShader
{
GLuint Program = 0;
GLuint uniform_tex, uniform_pixel;
GLuint vao = 0;
void init()
{
initGL();
Program = LoadProgram(file_manager->getAsset("shaders/screenquad.vert").c_str(), file_manager->getAsset("shaders/gaussian3h.frag").c_str());
uniform_tex = glGetUniformLocation(Program, "tex");
uniform_pixel = glGetUniformLocation(Program, "pixel");
vao = createVAO(Program);
}
}
namespace Gaussian6VBlurShader
{
GLuint Program = 0;
GLuint uniform_tex, uniform_pixel;
GLuint vao = 0;
void init()
{
initGL();
Program = LoadProgram(file_manager->getAsset("shaders/screenquad.vert").c_str(), file_manager->getAsset("shaders/gaussian6v.frag").c_str());
uniform_tex = glGetUniformLocation(Program, "tex");
uniform_pixel = glGetUniformLocation(Program, "pixel");
vao = createVAO(Program);
}
}
namespace Gaussian3VBlurShader
{
GLuint Program = 0;
GLuint uniform_tex, uniform_pixel;
GLuint vao = 0;
void init()
{
initGL();
Program = LoadProgram(file_manager->getAsset("shaders/screenquad.vert").c_str(), file_manager->getAsset("shaders/gaussian3v.frag").c_str());
uniform_tex = glGetUniformLocation(Program, "tex");
uniform_pixel = glGetUniformLocation(Program, "pixel");
vao = createVAO(Program);
}
}
namespace PassThroughShader
{
GLuint Program = 0;
GLuint uniform_texture;
GLuint vao = 0;
void init()
{
initGL();
Program = LoadProgram(file_manager->getAsset("shaders/screenquad.vert").c_str(), file_manager->getAsset("shaders/texturedquad.frag").c_str());
uniform_texture = glGetUniformLocation(Program, "texture");
vao = createVAO(Program);
}
}
namespace GlowShader
{
GLuint Program = 0;
GLuint uniform_tex;
GLuint vao = 0;
void init()
{
initGL();
Program = LoadProgram(file_manager->getAsset("shaders/screenquad.vert").c_str(), file_manager->getAsset("shaders/glow.frag").c_str());
uniform_tex = glGetUniformLocation(Program, "tex");
vao = createVAO(Program);
}
}
namespace SSAOShader
{
GLuint Program = 0;
GLuint uniform_normals_and_depth, uniform_invprojm, uniform_projm, uniform_samplePoints;
float SSAOSamples[64];
GLuint vao = 0;
void init()
{
initGL();
Program = LoadProgram(file_manager->getAsset("shaders/screenquad.vert").c_str(), file_manager->getAsset("shaders/ssao.frag").c_str());
uniform_normals_and_depth = glGetUniformLocation(Program, "normals_and_depth");
uniform_invprojm = glGetUniformLocation(Program, "invprojm");
uniform_projm = glGetUniformLocation(Program, "projm");
uniform_samplePoints = glGetUniformLocation(Program, "samplePoints[0]");
vao = createVAO(Program);
for (unsigned i = 0; i < 16; i++) {
// Generate x/y component between -1 and 1
// Use double to avoid denorm and get a true uniform distribution
double x = rand();
x /= RAND_MAX;
x = 2 * x - 1;
double y = rand();
y /= RAND_MAX;
y = 2 * y - 1;
// compute z so that norm (x,y,z) is one
double z = sqrt(x * x + y * y);
// Norm factor
double w = rand();
w /= RAND_MAX;
SSAOSamples[4 * i] = (float)x;
SSAOSamples[4 * i + 1] = (float)y;
SSAOSamples[4 * i + 2] = (float)z;
SSAOSamples[4 * i + 3] = (float)w;
}
}
}
namespace FogShader
{
GLuint Program = 0;
GLuint uniform_tex, uniform_fogmax, uniform_startH, uniform_endH, uniform_start, uniform_end, uniform_col, uniform_campos, uniform_ipvmat;
GLuint vao = 0;
void init()
{
initGL();
Program = LoadProgram(file_manager->getAsset("shaders/screenquad.vert").c_str(), file_manager->getAsset("shaders/fog.frag").c_str());
uniform_tex = glGetUniformLocation(Program, "tex");
uniform_fogmax = glGetUniformLocation(Program, "fogmax");
uniform_startH = glGetUniformLocation(Program, "startH");
uniform_endH = glGetUniformLocation(Program, "endH");
uniform_start = glGetUniformLocation(Program, "start");
uniform_end = glGetUniformLocation(Program, "end");
uniform_col = glGetUniformLocation(Program, "col");
uniform_campos = glGetUniformLocation(Program, "campos");
uniform_ipvmat = glGetUniformLocation(Program, "ipvmat");
vao = createVAO(Program);
}
}
static
void renderBloom(ITexture *in)
{
if (!BloomShader::Program)
BloomShader::init();
const float threshold = World::getWorld()->getTrack()->getBloomThreshold();
glUseProgram(BloomShader::Program);
glBindVertexArray(BloomShader::vao);
glUniform1f(BloomShader::uniform_low, threshold);
glUseProgram(FullScreenShader::BloomShader::Program);
glBindVertexArray(FullScreenShader::BloomShader::vao);
glUniform1f(FullScreenShader::BloomShader::uniform_low, threshold);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, static_cast<irr::video::COpenGLTexture*>(in)->getOpenGLTextureName());
glUniform1i(BloomShader::uniform_texture, 0);
glUniform1i(FullScreenShader::BloomShader::uniform_texture, 0);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glBindVertexArray(0);
@@ -531,19 +219,17 @@ void renderBloom(ITexture *in)
static
void renderBloomBlend(ITexture *in)
{
if (!BloomBlendShader::Program)
BloomBlendShader::init();
glEnable(GL_BLEND);
glBlendEquation(GL_FUNC_ADD);
glBlendFunc(GL_ONE, GL_ONE);
glDisable(GL_DEPTH_TEST);
glUseProgram(BloomBlendShader::Program);
glBindVertexArray(BloomBlendShader::vao);
glUseProgram(FullScreenShader::BloomBlendShader::Program);
glBindVertexArray(FullScreenShader::BloomBlendShader::vao);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, static_cast<irr::video::COpenGLTexture*>(in)->getOpenGLTextureName());
glUniform1i(BloomBlendShader::uniform_texture, 0);
glUniform1i(FullScreenShader::BloomBlendShader::uniform_texture, 0);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glBindVertexArray(0);
@@ -556,24 +242,22 @@ void renderBloomBlend(ITexture *in)
static
void renderPPDisplace(ITexture *in)
{
if (!PPDisplaceShader::Program)
PPDisplaceShader::init();
glEnable(GL_BLEND);
glBlendEquation(GL_FUNC_ADD);
glBlendFunc(GL_ONE, GL_ONE);
glDisable(GL_DEPTH_TEST);
glUseProgram(PPDisplaceShader::Program);
glBindVertexArray(PPDisplaceShader::vao);
glUniform1i(PPDisplaceShader::uniform_viz, irr_driver->getDistortViz());
glUseProgram(FullScreenShader::PPDisplaceShader::Program);
glBindVertexArray(FullScreenShader::PPDisplaceShader::vao);
glUniform1i(FullScreenShader::PPDisplaceShader::uniform_viz, irr_driver->getDistortViz());
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, static_cast<irr::video::COpenGLTexture*>(in)->getOpenGLTextureName());
glUniform1i(PPDisplaceShader::uniform_tex, 0);
glUniform1i(FullScreenShader::PPDisplaceShader::uniform_tex, 0);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, static_cast<irr::video::COpenGLTexture*>(irr_driver->getRTT(RTT_DISPLACE))->getOpenGLTextureName());
glUniform1i(PPDisplaceShader::uniform_dtex, 1);
glUniform1i(FullScreenShader::PPDisplaceShader::uniform_dtex, 1);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
@@ -590,20 +274,17 @@ void renderColorLevel(ITexture *in)
core::vector3df m_inlevel = World::getWorld()->getTrack()->getColorLevelIn();
core::vector2df m_outlevel = World::getWorld()->getTrack()->getColorLevelOut();
if (!ColorLevelShader::Program)
ColorLevelShader::init();
glDisable(GL_BLEND);
glDisable(GL_DEPTH_TEST);
glUseProgram(ColorLevelShader::Program);
glBindVertexArray(ColorLevelShader::vao);
glUniform3f(ColorLevelShader::uniform_inlevel, m_inlevel.X, m_inlevel.Y, m_inlevel.Z);
glUniform2f(ColorLevelShader::uniform_outlevel, m_outlevel.X, m_outlevel.Y);
glUseProgram(FullScreenShader::ColorLevelShader::Program);
glBindVertexArray(FullScreenShader::ColorLevelShader::vao);
glUniform3f(FullScreenShader::ColorLevelShader::uniform_inlevel, m_inlevel.X, m_inlevel.Y, m_inlevel.Z);
glUniform2f(FullScreenShader::ColorLevelShader::uniform_outlevel, m_outlevel.X, m_outlevel.Y);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, static_cast<irr::video::COpenGLTexture*>(in)->getOpenGLTextureName());
glUniform1i(ColorLevelShader::uniform_tex, 0);
glUniform1i(FullScreenShader::ColorLevelShader::uniform_tex, 0);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glBindVertexArray(0);
@@ -614,26 +295,24 @@ void renderColorLevel(ITexture *in)
void PostProcessing::renderPointlight(ITexture *in, const std::vector<float> &positions, const std::vector<float> &colors, const std::vector<float> &energy)
{
if (!PointLightShader::Program)
PointLightShader::init();
glEnable(GL_BLEND);
glBlendEquation(GL_FUNC_ADD);
glBlendFunc(GL_ONE, GL_ONE);
glDisable(GL_DEPTH_TEST);
glUseProgram(PointLightShader::Program);
glBindVertexArray(PointLightShader::vao);
glUseProgram(FullScreenShader::PointLightShader::Program);
glBindVertexArray(FullScreenShader::PointLightShader::vao);
glUniform4fv(PointLightShader::uniform_center, 16, positions.data());
glUniform4fv(PointLightShader::uniform_col, 16, colors.data());
glUniform1fv(PointLightShader::uniform_energy, 16, energy.data());
glUniform1f(PointLightShader::uniform_spec, 200);
glUniformMatrix4fv(PointLightShader::uniform_invproj, 1, GL_FALSE, irr_driver->getInvProjMatrix().pointer());
glUniformMatrix4fv(PointLightShader::uniform_viewm, 1, GL_FALSE, irr_driver->getViewMatrix().pointer());
glUniform4fv(FullScreenShader::PointLightShader::uniform_center, 16, positions.data());
glUniform4fv(FullScreenShader::PointLightShader::uniform_col, 16, colors.data());
glUniform1fv(FullScreenShader::PointLightShader::uniform_energy, 16, energy.data());
glUniform1f(FullScreenShader::PointLightShader::uniform_spec, 200);
glUniformMatrix4fv(FullScreenShader::PointLightShader::uniform_invproj, 1, GL_FALSE, irr_driver->getInvProjMatrix().pointer());
glUniformMatrix4fv(FullScreenShader::PointLightShader::uniform_viewm, 1, GL_FALSE, irr_driver->getViewMatrix().pointer());
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, static_cast<irr::video::COpenGLTexture*>(in)->getOpenGLTextureName());
glUniform1i(PointLightShader::uniform_ntex, 0);
glUniform1i(FullScreenShader::PointLightShader::uniform_ntex, 0);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glBindVertexArray(0);
@@ -646,8 +325,6 @@ void PostProcessing::renderPointlight(ITexture *in, const std::vector<float> &po
void PostProcessing::renderLightbBlend(ITexture *diffuse, ITexture *specular, ITexture *ao, ITexture *specmap, bool debug)
{
const SColorf s = irr_driver->getSceneManager()->getAmbientLight();
if (!LightBlendShader::Program)
LightBlendShader::init();
glStencilFunc(GL_EQUAL, 1, ~0);
glEnable(GL_STENCIL_TEST);
glEnable(GL_BLEND);
@@ -658,23 +335,23 @@ void PostProcessing::renderLightbBlend(ITexture *diffuse, ITexture *specular, IT
glBlendFunc(GL_DST_COLOR, GL_ZERO);
glDisable(GL_DEPTH_TEST);
glUseProgram(LightBlendShader::Program);
glBindVertexArray(LightBlendShader::vao);
glUseProgram(FullScreenShader::LightBlendShader::Program);
glBindVertexArray(FullScreenShader::LightBlendShader::vao);
glUniform3f(LightBlendShader::uniform_ambient, s.r, s.g, s.b);
glUniform3f(FullScreenShader::LightBlendShader::uniform_ambient, s.r, s.g, s.b);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, static_cast<irr::video::COpenGLTexture*>(diffuse)->getOpenGLTextureName());
glUniform1i(LightBlendShader::uniform_diffuse, 0);
glUniform1i(FullScreenShader::LightBlendShader::uniform_diffuse, 0);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, static_cast<irr::video::COpenGLTexture*>(specular)->getOpenGLTextureName());
glUniform1i(LightBlendShader::uniform_specular, 1);
glUniform1i(FullScreenShader::LightBlendShader::uniform_specular, 1);
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D, static_cast<irr::video::COpenGLTexture*>(ao)->getOpenGLTextureName());
glUniform1i(LightBlendShader::uniform_ambient_occlusion, 2);
glUniform1i(FullScreenShader::LightBlendShader::uniform_ambient_occlusion, 2);
glActiveTexture(GL_TEXTURE3);
glBindTexture(GL_TEXTURE_2D, static_cast<irr::video::COpenGLTexture*>(specmap)->getOpenGLTextureName());
glUniform1i(LightBlendShader::uniform_specular_map, 3);
glUniform1i(FullScreenShader::LightBlendShader::uniform_specular_map, 3);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glBindVertexArray(0);
@@ -691,32 +368,28 @@ void PostProcessing::renderGaussian3Blur(video::ITexture *in, video::ITexture *t
glDisable(GL_BLEND);
glDisable(GL_DEPTH_TEST);
{
if (!Gaussian3VBlurShader::Program)
Gaussian3VBlurShader::init();
irr_driver->getVideoDriver()->setRenderTarget(temprtt, false, false);
glUseProgram(Gaussian3VBlurShader::Program);
glBindVertexArray(Gaussian3VBlurShader::vao);
glUseProgram(FullScreenShader::Gaussian3VBlurShader::Program);
glBindVertexArray(FullScreenShader::Gaussian3VBlurShader::vao);
glUniform2f(Gaussian3VBlurShader::uniform_pixel, inv_width, inv_height);
glUniform2f(FullScreenShader::Gaussian3VBlurShader::uniform_pixel, inv_width, inv_height);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, static_cast<irr::video::COpenGLTexture*>(in)->getOpenGLTextureName());
glUniform1i(Gaussian3VBlurShader::uniform_tex, 0);
glUniform1i(FullScreenShader::Gaussian3VBlurShader::uniform_tex, 0);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
}
{
if (!Gaussian3HBlurShader::Program)
Gaussian3HBlurShader::init();
irr_driver->getVideoDriver()->setRenderTarget(in, false, false);
glUseProgram(Gaussian3HBlurShader::Program);
glBindVertexArray(Gaussian3HBlurShader::vao);
glUseProgram(FullScreenShader::Gaussian3HBlurShader::Program);
glBindVertexArray(FullScreenShader::Gaussian3HBlurShader::vao);
glUniform2f(Gaussian3HBlurShader::uniform_pixel, inv_width, inv_height);
glUniform2f(FullScreenShader::Gaussian3HBlurShader::uniform_pixel, inv_width, inv_height);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, static_cast<irr::video::COpenGLTexture*>(temprtt)->getOpenGLTextureName());
glUniform1i(Gaussian3HBlurShader::uniform_tex, 0);
glUniform1i(FullScreenShader::Gaussian3HBlurShader::uniform_tex, 0);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
}
@@ -731,32 +404,28 @@ void PostProcessing::renderGaussian6Blur(video::ITexture *in, video::ITexture *t
glDisable(GL_BLEND);
glDisable(GL_DEPTH_TEST);
{
if (!Gaussian6VBlurShader::Program)
Gaussian6VBlurShader::init();
irr_driver->getVideoDriver()->setRenderTarget(temprtt, false, false);
glUseProgram(Gaussian6VBlurShader::Program);
glBindVertexArray(Gaussian6VBlurShader::vao);
glUseProgram(FullScreenShader::Gaussian6VBlurShader::Program);
glBindVertexArray(FullScreenShader::Gaussian6VBlurShader::vao);
glUniform2f(Gaussian6VBlurShader::uniform_pixel, inv_width, inv_height);
glUniform2f(FullScreenShader::Gaussian6VBlurShader::uniform_pixel, inv_width, inv_height);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, static_cast<irr::video::COpenGLTexture*>(in)->getOpenGLTextureName());
glUniform1i(Gaussian6VBlurShader::uniform_tex, 0);
glUniform1i(FullScreenShader::Gaussian6VBlurShader::uniform_tex, 0);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
}
{
if (!Gaussian6HBlurShader::Program)
Gaussian6HBlurShader::init();
irr_driver->getVideoDriver()->setRenderTarget(in, false, false);
glUseProgram(Gaussian6HBlurShader::Program);
glBindVertexArray(Gaussian6HBlurShader::vao);
glUseProgram(FullScreenShader::Gaussian6HBlurShader::Program);
glBindVertexArray(FullScreenShader::Gaussian6HBlurShader::vao);
glUniform2f(Gaussian6HBlurShader::uniform_pixel, inv_width, inv_height);
glUniform2f(FullScreenShader::Gaussian6HBlurShader::uniform_pixel, inv_width, inv_height);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, static_cast<irr::video::COpenGLTexture*>(temprtt)->getOpenGLTextureName());
glUniform1i(Gaussian6HBlurShader::uniform_tex, 0);
glUniform1i(FullScreenShader::Gaussian6HBlurShader::uniform_tex, 0);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
}
@@ -768,16 +437,14 @@ void PostProcessing::renderGaussian6Blur(video::ITexture *in, video::ITexture *t
void PostProcessing::renderPassThrough(ITexture *tex)
{
if (!PassThroughShader::Program)
PassThroughShader::init();
glDisable(GL_DEPTH_TEST);
glUseProgram(PassThroughShader::Program);
glBindVertexArray(PassThroughShader::vao);
glUseProgram(FullScreenShader::PassThroughShader::Program);
glBindVertexArray(FullScreenShader::PassThroughShader::vao);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, static_cast<irr::video::COpenGLTexture*>(tex)->getOpenGLTextureName());
glUniform1i(PassThroughShader::uniform_texture, 0);
glUniform1i(FullScreenShader::PassThroughShader::uniform_texture, 0);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glBindVertexArray(0);
@@ -789,16 +456,14 @@ void PostProcessing::renderPassThrough(ITexture *tex)
void PostProcessing::renderGlow(ITexture *tex)
{
if (!GlowShader::Program)
GlowShader::init();
glDisable(GL_DEPTH_TEST);
glUseProgram(GlowShader::Program);
glBindVertexArray(GlowShader::vao);
glUseProgram(FullScreenShader::GlowShader::Program);
glBindVertexArray(FullScreenShader::GlowShader::vao);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, static_cast<irr::video::COpenGLTexture*>(tex)->getOpenGLTextureName());
glUniform1i(GlowShader::uniform_tex, 0);
glUniform1i(FullScreenShader::GlowShader::uniform_tex, 0);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glBindVertexArray(0);
@@ -811,16 +476,14 @@ void PostProcessing::renderGlow(ITexture *tex)
void PostProcessing::renderSSAO(const core::matrix4 &invprojm, const core::matrix4 &projm)
{
if (!SSAOShader::Program)
SSAOShader::init();
glDisable(GL_DEPTH_TEST);
glDisable(GL_BLEND);
glUseProgram(SSAOShader::Program);
glBindVertexArray(SSAOShader::vao);
glUniformMatrix4fv(SSAOShader::uniform_invprojm, 1, GL_FALSE, invprojm.pointer());
glUniformMatrix4fv(SSAOShader::uniform_projm, 1, GL_FALSE, projm.pointer());
glUniform4fv(SSAOShader::uniform_samplePoints, 16, SSAOShader::SSAOSamples);
glUseProgram(FullScreenShader::SSAOShader::Program);
glBindVertexArray(FullScreenShader::SSAOShader::vao);
glUniformMatrix4fv(FullScreenShader::SSAOShader::uniform_invprojm, 1, GL_FALSE, invprojm.pointer());
glUniformMatrix4fv(FullScreenShader::SSAOShader::uniform_projm, 1, GL_FALSE, projm.pointer());
glUniform4fv(FullScreenShader::SSAOShader::uniform_samplePoints, 16, FullScreenShader::SSAOShader::SSAOSamples);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, static_cast<irr::video::COpenGLTexture*>(irr_driver->getRTT(RTT_NORMAL_AND_DEPTH))->getOpenGLTextureName());
@@ -828,7 +491,7 @@ void PostProcessing::renderSSAO(const core::matrix4 &invprojm, const core::matri
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glUniform1i(SSAOShader::uniform_normals_and_depth, 0);
glUniform1i(FullScreenShader::SSAOShader::uniform_normals_and_depth, 0);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glBindVertexArray(0);
@@ -854,27 +517,25 @@ void PostProcessing::renderFog(const core::vector3df &campos, const core::matrix
tmpcol.getGreen() / 255.0f,
tmpcol.getBlue() / 255.0f };
if (!FogShader::Program)
FogShader::init();
glDisable(GL_DEPTH_TEST);
glEnable(GL_BLEND);
glBlendEquation(GL_FUNC_ADD);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glUseProgram(FogShader::Program);
glBindVertexArray(FogShader::vao);
glUseProgram(FullScreenShader::FogShader::Program);
glBindVertexArray(FullScreenShader::FogShader::vao);
glUniform1f(FogShader::uniform_fogmax, fogmax);
glUniform1f(FogShader::uniform_startH, startH);
glUniform1f(FogShader::uniform_endH, endH);
glUniform1f(FogShader::uniform_start, start);
glUniform1f(FogShader::uniform_end, end);
glUniform3f(FogShader::uniform_col, col[0], col[1], col[2]);
glUniform3f(FogShader::uniform_campos, campos.X, campos.Y, campos.Z);
glUniformMatrix4fv(FogShader::uniform_ipvmat, 1, GL_FALSE, ipvmat.pointer());
glUniform1f(FullScreenShader::FogShader::uniform_fogmax, fogmax);
glUniform1f(FullScreenShader::FogShader::uniform_startH, startH);
glUniform1f(FullScreenShader::FogShader::uniform_endH, endH);
glUniform1f(FullScreenShader::FogShader::uniform_start, start);
glUniform1f(FullScreenShader::FogShader::uniform_end, end);
glUniform3f(FullScreenShader::FogShader::uniform_col, col[0], col[1], col[2]);
glUniform3f(FullScreenShader::FogShader::uniform_campos, campos.X, campos.Y, campos.Z);
glUniformMatrix4fv(FullScreenShader::FogShader::uniform_ipvmat, 1, GL_FALSE, ipvmat.pointer());
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, static_cast<irr::video::COpenGLTexture*>(irr_driver->getRTT(RTT_NORMAL_AND_DEPTH))->getOpenGLTextureName());
glUniform1i(FogShader::uniform_tex, 0);
glUniform1i(FullScreenShader::FogShader::uniform_tex, 0);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glBindVertexArray(0);

276
src/graphics/shaders.cpp
View File

@@ -65,6 +65,23 @@ Shaders::Shaders()
loadShaders();
}
GLuint quad_vbo = 0;
static void initQuadVBO()
{
initGL();
const float quad_vertex[] = {
-1., -1., 0., 0., // UpperLeft
-1., 1., 0., 1., // LowerLeft
1., -1., 1., 0., // UpperRight
1., 1., 1., 1., // LowerRight
};
glGenBuffers(1, &quad_vbo);
glBindBuffer(GL_ARRAY_BUFFER, quad_vbo);
glBufferData(GL_ARRAY_BUFFER, 16 * sizeof(float), quad_vertex, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
}
void Shaders::loadShaders()
{
const std::string &dir = file_manager->getAsset(FileManager::SHADER, "");
@@ -214,6 +231,23 @@ void Shaders::loadShaders()
if(m_shaders[i] == -1)
m_shaders[i] = saved_shaders[i];
}
initGL();
initQuadVBO();
FullScreenShader::BloomBlendShader::init();
FullScreenShader::BloomShader::init();
FullScreenShader::ColorLevelShader::init();
FullScreenShader::FogShader::init();
FullScreenShader::Gaussian3HBlurShader::init();
FullScreenShader::Gaussian3VBlurShader::init();
FullScreenShader::Gaussian6HBlurShader::init();
FullScreenShader::Gaussian6VBlurShader::init();
FullScreenShader::GlowShader::init();
FullScreenShader::LightBlendShader::init();
FullScreenShader::PassThroughShader::init();
FullScreenShader::PointLightShader::init();
FullScreenShader::PPDisplaceShader::init();
FullScreenShader::SSAOShader::init();
}
Shaders::~Shaders()
@@ -241,3 +275,245 @@ void Shaders::check(const int num) const
"persists, report a bug to us.", shader_names[num] + 3);
}
}
static GLuint createVAO(GLuint Program)
{
GLuint vao;
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
GLuint attrib_position = glGetAttribLocation(Program, "Position");
GLuint attrib_texcoord = glGetAttribLocation(Program, "Texcoord");
glBindBuffer(GL_ARRAY_BUFFER, quad_vbo);
glEnableVertexAttribArray(attrib_position);
glEnableVertexAttribArray(attrib_texcoord);
glVertexAttribPointer(attrib_position, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), 0);
glVertexAttribPointer(attrib_texcoord, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), (GLvoid*)(2 * sizeof(float)));
glBindVertexArray(0);
return vao;
}
namespace FullScreenShader
{
GLuint BloomShader::Program;
GLuint BloomShader::uniform_texture;
GLuint BloomShader::uniform_low;
GLuint BloomShader::vao;
void BloomShader::init()
{
Program = LoadProgram(file_manager->getAsset("shaders/screenquad.vert").c_str(), file_manager->getAsset("shaders/bloom.frag").c_str());
uniform_texture = glGetUniformLocation(Program, "tex");
uniform_low = glGetUniformLocation(Program, "low");
vao = createVAO(Program);
}
GLuint BloomBlendShader::Program;
GLuint BloomBlendShader::uniform_texture;
GLuint BloomBlendShader::uniform_low;
GLuint BloomBlendShader::vao;
void BloomBlendShader::init()
{
Program = LoadProgram(file_manager->getAsset("shaders/screenquad.vert").c_str(), file_manager->getAsset("shaders/bloomblend.frag").c_str());
uniform_texture = glGetUniformLocation(Program, "tex");
vao = createVAO(Program);
}
GLuint PPDisplaceShader::Program;
GLuint PPDisplaceShader::uniform_tex;
GLuint PPDisplaceShader::uniform_dtex;
GLuint PPDisplaceShader::uniform_viz;
GLuint PPDisplaceShader::vao;
void PPDisplaceShader::init()
{
Program = LoadProgram(file_manager->getAsset("shaders/screenquad.vert").c_str(), file_manager->getAsset("shaders/ppdisplace.frag").c_str());
uniform_tex = glGetUniformLocation(Program, "tex");
uniform_dtex = glGetUniformLocation(Program, "dtex");
uniform_viz = glGetUniformLocation(Program, "viz");
vao = createVAO(Program);
}
GLuint ColorLevelShader::Program;
GLuint ColorLevelShader::uniform_tex;
GLuint ColorLevelShader::uniform_inlevel;
GLuint ColorLevelShader::uniform_outlevel;
GLuint ColorLevelShader::vao;
void ColorLevelShader::init()
{
Program = LoadProgram(file_manager->getAsset("shaders/screenquad.vert").c_str(), file_manager->getAsset("shaders/color_levels.frag").c_str());
uniform_tex = glGetUniformLocation(Program, "tex");
uniform_inlevel = glGetUniformLocation(Program, "inlevel");
uniform_outlevel = glGetUniformLocation(Program, "outlevel");
vao = createVAO(Program);
}
GLuint PointLightShader::Program;
GLuint PointLightShader::uniform_ntex;
GLuint PointLightShader::uniform_center;
GLuint PointLightShader::uniform_col;
GLuint PointLightShader::uniform_energy;
GLuint PointLightShader::uniform_spec;
GLuint PointLightShader::uniform_invproj;
GLuint PointLightShader::uniform_viewm;
GLuint PointLightShader::vao;
void PointLightShader::init()
{
Program = LoadProgram(file_manager->getAsset("shaders/screenquad.vert").c_str(), file_manager->getAsset("shaders/pointlight.frag").c_str());
uniform_ntex = glGetUniformLocation(Program, "ntex");
uniform_center = glGetUniformLocation(Program, "center[0]");
uniform_col = glGetUniformLocation(Program, "col[0]");
uniform_energy = glGetUniformLocation(Program, "energy[0]");
uniform_spec = glGetUniformLocation(Program, "spec");
uniform_invproj = glGetUniformLocation(Program, "invproj");
uniform_viewm = glGetUniformLocation(Program, "viewm");
vao = createVAO(Program);
}
GLuint LightBlendShader::Program;
GLuint LightBlendShader::uniform_diffuse;
GLuint LightBlendShader::uniform_specular;
GLuint LightBlendShader::uniform_ambient_occlusion;
GLuint LightBlendShader::uniform_specular_map;
GLuint LightBlendShader::uniform_ambient;
GLuint LightBlendShader::vao;
void LightBlendShader::init()
{
Program = LoadProgram(file_manager->getAsset("shaders/screenquad.vert").c_str(), file_manager->getAsset("shaders/lightblend.frag").c_str());
uniform_diffuse = glGetUniformLocation(Program, "diffuse");
uniform_specular = glGetUniformLocation(Program, "specular");
uniform_ambient_occlusion = glGetUniformLocation(Program, "ambient_occlusion");
uniform_specular_map = glGetUniformLocation(Program, "specular_map");
uniform_ambient = glGetUniformLocation(Program, "ambient");
vao = createVAO(Program);
}
GLuint Gaussian6HBlurShader::Program;
GLuint Gaussian6HBlurShader::uniform_tex;
GLuint Gaussian6HBlurShader::uniform_pixel;
GLuint Gaussian6HBlurShader::vao;
void Gaussian6HBlurShader::init()
{
Program = LoadProgram(file_manager->getAsset("shaders/screenquad.vert").c_str(), file_manager->getAsset("shaders/gaussian6h.frag").c_str());
uniform_tex = glGetUniformLocation(Program, "tex");
uniform_pixel = glGetUniformLocation(Program, "pixel");
vao = createVAO(Program);
}
GLuint Gaussian3HBlurShader::Program;
GLuint Gaussian3HBlurShader::uniform_tex;
GLuint Gaussian3HBlurShader::uniform_pixel;
GLuint Gaussian3HBlurShader::vao;
void Gaussian3HBlurShader::init()
{
Program = LoadProgram(file_manager->getAsset("shaders/screenquad.vert").c_str(), file_manager->getAsset("shaders/gaussian3h.frag").c_str());
uniform_tex = glGetUniformLocation(Program, "tex");
uniform_pixel = glGetUniformLocation(Program, "pixel");
vao = createVAO(Program);
}
GLuint Gaussian6VBlurShader::Program;
GLuint Gaussian6VBlurShader::uniform_tex;
GLuint Gaussian6VBlurShader::uniform_pixel;
GLuint Gaussian6VBlurShader::vao;
void Gaussian6VBlurShader::init()
{
Program = LoadProgram(file_manager->getAsset("shaders/screenquad.vert").c_str(), file_manager->getAsset("shaders/gaussian6v.frag").c_str());
uniform_tex = glGetUniformLocation(Program, "tex");
uniform_pixel = glGetUniformLocation(Program, "pixel");
vao = createVAO(Program);
}
GLuint Gaussian3VBlurShader::Program;
GLuint Gaussian3VBlurShader::uniform_tex;
GLuint Gaussian3VBlurShader::uniform_pixel;
GLuint Gaussian3VBlurShader::vao;
void Gaussian3VBlurShader::init()
{
Program = LoadProgram(file_manager->getAsset("shaders/screenquad.vert").c_str(), file_manager->getAsset("shaders/gaussian3v.frag").c_str());
uniform_tex = glGetUniformLocation(Program, "tex");
uniform_pixel = glGetUniformLocation(Program, "pixel");
vao = createVAO(Program);
}
GLuint PassThroughShader::Program;
GLuint PassThroughShader::uniform_texture;
GLuint PassThroughShader::vao;
void PassThroughShader::init()
{
Program = LoadProgram(file_manager->getAsset("shaders/screenquad.vert").c_str(), file_manager->getAsset("shaders/texturedquad.frag").c_str());
uniform_texture = glGetUniformLocation(Program, "texture");
vao = createVAO(Program);
}
GLuint GlowShader::Program;
GLuint GlowShader::uniform_tex;
GLuint GlowShader::vao;
void GlowShader::init()
{
Program = LoadProgram(file_manager->getAsset("shaders/screenquad.vert").c_str(), file_manager->getAsset("shaders/glow.frag").c_str());
uniform_tex = glGetUniformLocation(Program, "tex");
vao = createVAO(Program);
}
GLuint SSAOShader::Program;
GLuint SSAOShader::uniform_normals_and_depth;
GLuint SSAOShader::uniform_invprojm;
GLuint SSAOShader::uniform_projm;
GLuint SSAOShader::uniform_samplePoints;
GLuint SSAOShader::vao;
float SSAOShader::SSAOSamples[64];
void SSAOShader::init()
{
Program = LoadProgram(file_manager->getAsset("shaders/screenquad.vert").c_str(), file_manager->getAsset("shaders/ssao.frag").c_str());
uniform_normals_and_depth = glGetUniformLocation(Program, "normals_and_depth");
uniform_invprojm = glGetUniformLocation(Program, "invprojm");
uniform_projm = glGetUniformLocation(Program, "projm");
uniform_samplePoints = glGetUniformLocation(Program, "samplePoints[0]");
vao = createVAO(Program);
for (unsigned i = 0; i < 16; i++) {
// Generate x/y component between -1 and 1
// Use double to avoid denorm and get a true uniform distribution
double x = rand();
x /= RAND_MAX;
x = 2 * x - 1;
double y = rand();
y /= RAND_MAX;
y = 2 * y - 1;
// compute z so that norm (x,y,z) is one
double z = sqrt(x * x + y * y);
// Norm factor
double w = rand();
w /= RAND_MAX;
SSAOSamples[4 * i] = (float)x;
SSAOSamples[4 * i + 1] = (float)y;
SSAOSamples[4 * i + 2] = (float)z;
SSAOSamples[4 * i + 3] = (float)w;
}
}
GLuint FogShader::Program;
GLuint FogShader::uniform_tex;
GLuint FogShader::uniform_fogmax;
GLuint FogShader::uniform_startH;
GLuint FogShader::uniform_endH;
GLuint FogShader::uniform_start;
GLuint FogShader::uniform_end;
GLuint FogShader::uniform_col;
GLuint FogShader::uniform_campos;
GLuint FogShader::uniform_ipvmat;
GLuint FogShader::vao;
void FogShader::init()
{
Program = LoadProgram(file_manager->getAsset("shaders/screenquad.vert").c_str(), file_manager->getAsset("shaders/fog.frag").c_str());
uniform_tex = glGetUniformLocation(Program, "tex");
uniform_fogmax = glGetUniformLocation(Program, "fogmax");
uniform_startH = glGetUniformLocation(Program, "startH");
uniform_endH = glGetUniformLocation(Program, "endH");
uniform_start = glGetUniformLocation(Program, "start");
uniform_end = glGetUniformLocation(Program, "end");
uniform_col = glGetUniformLocation(Program, "col");
uniform_campos = glGetUniformLocation(Program, "campos");
uniform_ipvmat = glGetUniformLocation(Program, "ipvmat");
vao = createVAO(Program);
}
}

152
src/graphics/shaders.hpp
View File

@@ -20,8 +20,160 @@
#include <IShaderConstantSetCallBack.h>
#include <IMeshSceneNode.h>
#include <vector>
#include "graphics/glwrap.hpp"
using namespace irr;
namespace MeshShader
{
}
namespace FullScreenShader
{
class BloomShader
{
public:
static GLuint Program;
static GLuint uniform_texture, uniform_low;
static GLuint vao;
static void init();
};
class BloomBlendShader
{
public:
static GLuint Program;
static GLuint uniform_texture, uniform_low;
static GLuint vao;
static void init();
};
class PPDisplaceShader
{
public:
static GLuint Program;
static GLuint uniform_tex, uniform_dtex, uniform_viz;
static GLuint vao;
static void init();
};
class ColorLevelShader
{
public:
static GLuint Program;
static GLuint uniform_tex, uniform_inlevel, uniform_outlevel;
static GLuint vao;
static void init();
};
class PointLightShader
{
public:
static GLuint Program;
static GLuint uniform_ntex, uniform_center, uniform_col, uniform_energy, uniform_spec, uniform_invproj, uniform_viewm;
static GLuint vao;
static void init();
};
class LightBlendShader
{
public:
static GLuint Program;
static GLuint uniform_diffuse, uniform_specular, uniform_ambient_occlusion, uniform_specular_map, uniform_ambient;
static GLuint vao;
static void init();
};
class Gaussian6HBlurShader
{
public:
static GLuint Program;
static GLuint uniform_tex, uniform_pixel;
static GLuint vao;
static void init();
};
class Gaussian3HBlurShader
{
public:
static GLuint Program;
static GLuint uniform_tex, uniform_pixel;
static GLuint vao;
static void init();
};
class Gaussian6VBlurShader
{
public:
static GLuint Program;
static GLuint uniform_tex, uniform_pixel;
static GLuint vao;
static void init();
};
class Gaussian3VBlurShader
{
public:
static GLuint Program;
static GLuint uniform_tex, uniform_pixel;
static GLuint vao;
static void init();
};
class PassThroughShader
{
public:
static GLuint Program;
static GLuint uniform_texture;
static GLuint vao;
static void init();
};
class GlowShader
{
public:
static GLuint Program;
static GLuint uniform_tex;
static GLuint vao;
static void init();
};
class SSAOShader
{
public:
static GLuint Program;
static GLuint uniform_normals_and_depth, uniform_invprojm, uniform_projm, uniform_samplePoints;
static GLuint vao;
static float SSAOSamples[64];
static void init();
};
class FogShader
{
public:
static GLuint Program;
static GLuint uniform_tex, uniform_fogmax, uniform_startH, uniform_endH, uniform_start, uniform_end, uniform_col, uniform_campos, uniform_ipvmat;
static GLuint vao;
static void init();
};
}
#define FOREACH_SHADER(ACT) \
ACT(ES_NORMAL_MAP) \
ACT(ES_NORMAL_MAP_LIGHTMAP) \