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

Shadow: Use Geometry Shader for better perfs.

Browse Source 
The 3 cascades are now rendered in a single pass, using 2D array texture and
a GS to do the dispatch ("layered rendering").
It's possible to use instancing instead but it requires the AMD_vertex_shader_layer
extension which is oddly part of opengl 4.2.
This commit is contained in:
Vincent Lejeune 2014-02-10 19:28:02 +01:00
parent b060b7651a
commit 934d1f10b8
16 changed files with 162 additions and 84 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
data/shaders/shadow.geom Normal file
View File

@ -0,0 +1,24 @@
#version 330 core
uniform mat4 ModelViewProjectionMatrix[3];
layout(triangles) in;
layout(triangle_strip, max_vertices=9) out;
in vec2 tc[3];
out vec2 uv;
void main(void)
{
for (int j = 0; j<3; j++)
{
gl_Layer = j;
for(int i=0; i<3; i++)
{
uv = tc[i];
gl_Position = ModelViewProjectionMatrix[j] * gl_in[i].gl_Position;
EmitVertex();
}
EndPrimitive();
}
}

14
data/shaders/shadow.vert Normal file
View File

@ -0,0 +1,14 @@
#version 330 core
in vec3 Position;
in vec2 Texcoord;
out vec2 tc;
void main(void)
{
tc = Texcoord;
gl_Position = vec4(Position, 1.);
}

20
data/shaders/sunlightshadow.frag
View File

@ -1,18 +1,14 @@
#version 130
uniform sampler2D ntex;
uniform sampler2D dtex;
uniform sampler2DShadow shadowtex0;
uniform sampler2DShadow shadowtex1;
uniform sampler2DShadow shadowtex2;
uniform sampler2DArrayShadow shadowtex;
//uniform sampler2D warpx;
///uniform sampler2D warpy;
uniform vec3 direction;
uniform vec3 col;
uniform mat4 invproj;
uniform mat4 shadowmat0;
uniform mat4 shadowmat1;
uniform mat4 shadowmat2;
uniform mat4 shadowmat[3];
//uniform int hasclouds;
//uniform vec2 wind;
//uniform float shadowoffset;
@ -32,7 +28,7 @@ float getShadowFactor(vec3 pos, float bias)
{
if (pos.z < 10.)
{
vec4 shadowcoord = (shadowmat0 * vec4(pos, 1.0));
vec4 shadowcoord = (shadowmat[0] * vec4(pos, 1.0));
shadowcoord /= shadowcoord.w;
vec2 shadowtexcoord = shadowcoord.xy * 0.5 + 0.5;
// shadowcoord = (shadowcoord * 0.5) + vec3(0.5);
@ -45,21 +41,21 @@ float getShadowFactor(vec3 pos, float bias)
//float shadowmapz = 2. * texture(shadowtex, vec3(shadowtexcoord, shadowcoord.z).x - 1.;
// bias += smoothstep(0.001, 0.1, moved) * 0.014; // According to the warping
return texture(shadowtex0, vec3(shadowtexcoord, 0.5 * (shadowcoord.z + bias * 0.001) + 0.5));
return texture(shadowtex, vec4(shadowtexcoord, 0., 0.5 * (shadowcoord.z + bias * 0.001) + 0.5));
}
else if (pos.z < 60)
{
vec4 shadowcoord = (shadowmat1 * vec4(pos, 1.0));
vec4 shadowcoord = (shadowmat[1] * vec4(pos, 1.0));
shadowcoord /= shadowcoord.w;
vec2 shadowtexcoord = shadowcoord.xy * 0.5 + 0.5;
return texture(shadowtex1, vec3(shadowtexcoord, 0.5 * (shadowcoord.z + bias * 0.001) + 0.5));
return texture(shadowtex, vec4(shadowtexcoord, 1., 0.5 * (shadowcoord.z + bias * 0.001) + 0.5));
}
else
{
vec4 shadowcoord = (shadowmat2 * vec4(pos, 1.0));
vec4 shadowcoord = (shadowmat[2] * vec4(pos, 1.0));
shadowcoord /= shadowcoord.w;
vec2 shadowtexcoord = shadowcoord.xy * 0.5 + 0.5;
return texture(shadowtex2, vec3(shadowtexcoord, 0.5 * (shadowcoord.z + bias) + 0.5));
return texture(shadowtex, vec4(shadowtexcoord, 2., 0.5 * (shadowcoord.z + bias) + 0.5));
}
}

2
data/shaders/white.frag
View File

@ -1,4 +1,4 @@
#version 130
#version 330
out vec4 FragColor;
void main()
{

29
src/graphics/glwrap.cpp
View File

@ -255,6 +255,35 @@ GLuint LoadProgram(const char * vertex_file_path, const char * fragment_file_pat
return ProgramID;
}
GLuint LoadProgram(const char * vertex_file_path, const char * geometry_file_path, const char * fragment_file_path) {
GLuint VertexShaderID = LoadShader(vertex_file_path, GL_VERTEX_SHADER);
GLuint FragmentShaderID = LoadShader(fragment_file_path, GL_FRAGMENT_SHADER);
GLuint GeometryShaderID = LoadShader(geometry_file_path, GL_GEOMETRY_SHADER);
GLuint ProgramID = glCreateProgram();
glAttachShader(ProgramID, VertexShaderID);
glAttachShader(ProgramID, GeometryShaderID);
glAttachShader(ProgramID, FragmentShaderID);
glLinkProgram(ProgramID);
GLint Result = GL_FALSE;
int InfoLogLength;
glGetProgramiv(ProgramID, GL_LINK_STATUS, &Result);
if (Result == GL_FALSE) {
glGetProgramiv(ProgramID, GL_INFO_LOG_LENGTH, &InfoLogLength);
char *ErrorMessage = new char[InfoLogLength];
glGetProgramInfoLog(ProgramID, InfoLogLength, NULL, ErrorMessage);
printf(ErrorMessage);
delete[] ErrorMessage;
}
glDeleteShader(VertexShaderID);
glDeleteShader(GeometryShaderID);
glDeleteShader(FragmentShaderID);
return ProgramID;
}
GLuint LoadTFBProgram(const char * vertex_file_path, const char **varyings, unsigned varyingscount) {
GLuint Shader = LoadShader(vertex_file_path, GL_VERTEX_SHADER);
GLuint Program = glCreateProgram();

1
src/graphics/glwrap.hpp
View File

@ -20,6 +20,7 @@
void initGL();
GLuint LoadProgram(const char * vertex_file_path, const char * fragment_file_path);
GLuint LoadProgram(const char * vertex_file_path, const char * geometry_file_path, const char * fragment_file_path);
GLuint LoadTFBProgram(const char * vertex_file_path, const char **varyings, unsigned varyingscount);
void bindUniformToTextureUnit(GLuint location, GLuint texid, unsigned textureUnit);
void setTexture(unsigned TextureUnit, GLuint TextureId, GLenum MagFilter, GLenum MinFilter, bool allowAF = false);

6
src/graphics/irr_driver.hpp
View File

@ -102,7 +102,7 @@ private:
RTT *m_rtts;
/** Shadow importance. */
ShadowImportance *m_shadow_importance;
core::matrix4 sun_ortho_matrix[3];
std::vector<core::matrix4> sun_ortho_matrix;
/** Additional details to be shown in case that a texture is not found.
* This is used to specify details like: "while loading kart '...'" */
@ -227,6 +227,10 @@ public:
void reset();
void setPhase(STKRenderingPass);
STKRenderingPass getPhase() const;
const std::vector<core::matrix4> &getShadowViewProj() const
{
return sun_ortho_matrix;
}
void IncreaseObjectCount();
core::array<video::IRenderTarget> &getMainSetup();
void updateConfigIfRelevant();

21
src/graphics/post_processing.cpp
View File

@ -346,7 +346,7 @@ void PostProcessing::renderSunlight()
glBindVertexArray(0);
}
void PostProcessing::renderShadowedSunlight(const core::matrix4 &sun_ortho_matrix0, const core::matrix4 &sun_ortho_matrix1, const core::matrix4 &sun_ortho_matrix2)
void PostProcessing::renderShadowedSunlight(const std::vector<core::matrix4> &sun_ortho_matrix, GLuint depthtex)
{
SunLightProvider * const cb = (SunLightProvider *)irr_driver->getCallback(ES_SUNLIGHT);
@ -359,16 +359,15 @@ void PostProcessing::renderShadowedSunlight(const core::matrix4 &sun_ortho_matri
glBindVertexArray(FullScreenShader::ShadowedSunLightShader::vao);
setTexture(0, static_cast<irr::video::COpenGLTexture*>(irr_driver->getRTT(RTT_NORMAL_AND_DEPTH))->getOpenGLTextureName(), GL_NEAREST, GL_NEAREST);
setTexture(1, static_cast<irr::video::COpenGLFBOTexture*>(irr_driver->getRTT(RTT_NORMAL_AND_DEPTH))->DepthBufferTexture, GL_NEAREST, GL_NEAREST);
setTexture(2, static_cast<irr::video::COpenGLFBOTexture*>(irr_driver->getRTT(RTT_SHADOW0))->DepthBufferTexture, GL_LINEAR, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL);
setTexture(3, static_cast<irr::video::COpenGLFBOTexture*>(irr_driver->getRTT(RTT_SHADOW1))->DepthBufferTexture, GL_LINEAR, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL);
setTexture(4, static_cast<irr::video::COpenGLFBOTexture*>(irr_driver->getRTT(RTT_SHADOW2))->DepthBufferTexture, GL_LINEAR, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL);
FullScreenShader::ShadowedSunLightShader::setUniforms(sun_ortho_matrix0, sun_ortho_matrix1, sun_ortho_matrix2, cb->getPosition(), irr_driver->getInvProjMatrix(), cb->getRed(), cb->getGreen(), cb->getBlue(), 0, 1, 2, 3, 4);
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D_ARRAY, depthtex);
glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameterf(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE);
glTexParameterf(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL);
FullScreenShader::ShadowedSunLightShader::setUniforms(sun_ortho_matrix, cb->getPosition(), irr_driver->getInvProjMatrix(), cb->getRed(), cb->getGreen(), cb->getBlue(), 0, 1, 2);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glBindVertexArray(0);
}

2
src/graphics/post_processing.hpp
View File

@ -75,7 +75,7 @@ public:
/** Generate diffuse and specular map */
void renderPointlight(const std::vector<float> &positions, const std::vector<float> &colors, const std::vector<float> &energy);
void renderSunlight();
void renderShadowedSunlight(const core::matrix4 &sun_ortho_matrix0, const core::matrix4 &sun_ortho_matrix1, const core::matrix4 &sun_ortho_matrix2);
void renderShadowedSunlight(const std::vector<core::matrix4> &sun_ortho_matrix, unsigned depthtex);
void renderFog(const core::matrix4 &ipvmat);
void renderSSAO(const core::matrix4 &invprojm, const core::matrix4 &projm);

40
src/graphics/render.cpp
View File

@ -480,12 +480,6 @@ void IrrDriver::renderShadows(//ShadowImportanceProvider * const sicb,
m_rtts->getRTT(RTT_SHADOW2)
};
unsigned rtt_size[] = {
2048,
1024,
512,
};
const float oldfar = camnode->getFarValue();
const float oldnear = camnode->getNearValue();
float FarValues[] =
@ -502,6 +496,7 @@ void IrrDriver::renderShadows(//ShadowImportanceProvider * const sicb,
};
const core::matrix4 &SunCamViewMatrix = m_suncam->getViewMatrix();
sun_ortho_matrix.clear();
// Build the 3 ortho projection (for the 3 shadow resolution levels)
for (unsigned i = 0; i < 3; i++)
@ -529,8 +524,8 @@ void IrrDriver::renderShadows(//ShadowImportanceProvider * const sicb,
float z = box.MaxEdge.Z;
// Snap to texels
const float units_per_w = w / rtt_size[i];
const float units_per_h = h / rtt_size[i];
const float units_per_w = w / 1024;
const float units_per_h = h / 1024;
float left = box.MinEdge.X;
float right = box.MaxEdge.X;
@ -557,18 +552,21 @@ void IrrDriver::renderShadows(//ShadowImportanceProvider * const sicb,
m_scene_manager->setActiveCamera(m_suncam);
m_suncam->render();
sun_ortho_matrix[i] = getVideoDriver()->getTransform(video::ETS_PROJECTION);
sun_ortho_matrix[i] *= getVideoDriver()->getTransform(video::ETS_VIEW);
sun_ortho_matrix[i] *= getInvViewMatrix();
irr_driver->setPhase(SHADOW_PASS);
glDisable(GL_BLEND);
glEnable(GL_CULL_FACE);
glCullFace(GL_FRONT);
m_video_driver->setRenderTarget(ShadowRTT[i], true, true);
glDrawBuffer(GL_NONE);
m_scene_manager->drawAll(scene::ESNRP_SOLID);
glCullFace(GL_BACK);
sun_ortho_matrix.push_back(getVideoDriver()->getTransform(video::ETS_PROJECTION) * getVideoDriver()->getTransform(video::ETS_VIEW));
}
assert(sun_ortho_matrix.size() == 3);
irr_driver->setPhase(SHADOW_PASS);
glDisable(GL_BLEND);
glEnable(GL_CULL_FACE);
glCullFace(GL_FRONT);
// m_video_driver->setRenderTarget(ShadowRTT[0], true, true);
glBindFramebuffer(GL_FRAMEBUFFER, m_rtts->getShadowFBO());
glViewport(0, 0, 1024, 1024);
glClear(GL_DEPTH_BUFFER_BIT);
glDrawBuffer(GL_NONE);
m_scene_manager->drawAll(scene::ESNRP_SOLID);
glCullFace(GL_BACK);
camnode->setNearValue(oldnear);
camnode->setFarValue(oldfar);
@ -770,6 +768,8 @@ void IrrDriver::renderLights(const core::aabbox3df& cambox,
video::SOverrideMaterial &overridemat,
int cam, float dt)
{
for (unsigned i = 0; i < sun_ortho_matrix.size(); i++)
sun_ortho_matrix[i] *= getInvViewMatrix();
core::array<video::IRenderTarget> rtts;
// Diffuse
rtts.push_back(m_rtts->getRTT(RTT_TMP1));
@ -792,7 +792,7 @@ void IrrDriver::renderLights(const core::aabbox3df& cambox,
{
m_lights[i]->render();
if (UserConfigParams::m_shadows)
m_post_processing->renderShadowedSunlight(sun_ortho_matrix[0], sun_ortho_matrix[1], sun_ortho_matrix[2]);
m_post_processing->renderShadowedSunlight(sun_ortho_matrix, m_rtts->getShadowDepthTex());
else
m_post_processing->renderSunlight();
continue;

2
src/graphics/rtts.cpp
View File

@ -37,7 +37,7 @@ RTT::RTT()
const dimension2du ssaosize = UserConfigParams::m_ssao == 2 ? res : quarter;
const u16 shadowside = 2048;
const u16 shadowside = 1024;
const dimension2du shadowsize0(shadowside, shadowside);
const dimension2du shadowsize1(shadowside / 2, shadowside / 2);
const dimension2du shadowsize2(shadowside / 4, shadowside / 4);

2
src/graphics/rtts.hpp
View File

@ -76,6 +76,8 @@ public:
~RTT();
ITexture *getRTT(TypeRTT which);
unsigned getShadowFBO() const { return shadowFBO; }
unsigned getShadowDepthTex() const { return shadowDepthTex; }
private:
ITexture *rtts[RTT_COUNT];

57
src/graphics/shaders.cpp
View File

@ -883,14 +883,20 @@ namespace MeshShader
void ShadowShader::init()
{
Program = LoadProgram(file_manager->getAsset("shaders/object_pass2.vert").c_str(), file_manager->getAsset("shaders/white.frag").c_str());
Program = LoadProgram(file_manager->getAsset("shaders/shadow.vert").c_str(), file_manager->getAsset("shaders/shadow.geom").c_str(), file_manager->getAsset("shaders/white.frag").c_str());
attrib_position = glGetAttribLocation(Program, "Position");
uniform_MVP = glGetUniformLocation(Program, "ModelViewProjectionMatrix");
}
void ShadowShader::setUniforms(const core::matrix4 &ModelViewProjectionMatrix)
void ShadowShader::setUniforms(const std::vector<core::matrix4> &ModelViewProjectionMatrix)
{
glUniformMatrix4fv(uniform_MVP, 1, GL_FALSE, ModelViewProjectionMatrix.pointer());
size_t size = ModelViewProjectionMatrix.size();
float *tmp = new float[16 * size];
for (unsigned i = 0; i < size; i++) {
memcpy(&tmp[16 * i], ModelViewProjectionMatrix[i].pointer(), 16 * sizeof(float));
}
glUniformMatrix4fv(uniform_MVP, size, GL_FALSE, tmp);
delete[] tmp;
}
GLuint RefShadowShader::Program;
@ -901,17 +907,23 @@ namespace MeshShader
void RefShadowShader::init()
{
Program = LoadProgram(file_manager->getAsset("shaders/object_pass2.vert").c_str(), file_manager->getAsset("shaders/object_unlit.frag").c_str());
Program = LoadProgram(file_manager->getAsset("shaders/shadow.vert").c_str(), file_manager->getAsset("shaders/shadow.geom").c_str(), file_manager->getAsset("shaders/object_unlit.frag").c_str());
attrib_position = glGetAttribLocation(Program, "Position");
attrib_texcoord = glGetAttribLocation(Program, "Texcoord");
uniform_MVP = glGetUniformLocation(Program, "ModelViewProjectionMatrix");
uniform_tex = glGetUniformLocation(Program, "tex");
}
void RefShadowShader::setUniforms(const core::matrix4 &ModelViewProjectionMatrix, unsigned TU_tex)
void RefShadowShader::setUniforms(const std::vector<core::matrix4> &ModelViewProjectionMatrix, unsigned TU_tex)
{
glUniformMatrix4fv(uniform_MVP, 1, GL_FALSE, ModelViewProjectionMatrix.pointer());
size_t size = ModelViewProjectionMatrix.size();
float *tmp = new float[16 * size];
for (unsigned i = 0; i < size; i++) {
memcpy(&tmp[16 * i], ModelViewProjectionMatrix[i].pointer(), 16 * sizeof(float));
}
glUniformMatrix4fv(uniform_MVP, size, GL_FALSE, tmp);
glUniform1i(uniform_tex, TU_tex);
delete[] tmp;
}
GLuint GrassShadowShader::Program;
@ -1289,12 +1301,8 @@ namespace FullScreenShader
GLuint ShadowedSunLightShader::Program;
GLuint ShadowedSunLightShader::uniform_ntex;
GLuint ShadowedSunLightShader::uniform_dtex;
GLuint ShadowedSunLightShader::uniform_shadowtex0;
GLuint ShadowedSunLightShader::uniform_shadowmat0;
GLuint ShadowedSunLightShader::uniform_shadowtex1;
GLuint ShadowedSunLightShader::uniform_shadowmat1;
GLuint ShadowedSunLightShader::uniform_shadowtex2;
GLuint ShadowedSunLightShader::uniform_shadowmat2;
GLuint ShadowedSunLightShader::uniform_shadowtex;
GLuint ShadowedSunLightShader::uniform_shadowmat;
GLuint ShadowedSunLightShader::uniform_direction;
GLuint ShadowedSunLightShader::uniform_col;
GLuint ShadowedSunLightShader::uniform_invproj;
@ -1305,31 +1313,30 @@ namespace FullScreenShader
Program = LoadProgram(file_manager->getAsset("shaders/screenquad.vert").c_str(), file_manager->getAsset("shaders/sunlightshadow.frag").c_str());
uniform_ntex = glGetUniformLocation(Program, "ntex");
uniform_dtex = glGetUniformLocation(Program, "dtex");
uniform_shadowtex0 = glGetUniformLocation(Program, "shadowtex0");
uniform_shadowmat0 = glGetUniformLocation(Program, "shadowmat0");
uniform_shadowtex1 = glGetUniformLocation(Program, "shadowtex1");
uniform_shadowmat1 = glGetUniformLocation(Program, "shadowmat1");
uniform_shadowtex2 = glGetUniformLocation(Program, "shadowtex2");
uniform_shadowmat2 = glGetUniformLocation(Program, "shadowmat2");
uniform_shadowtex = glGetUniformLocation(Program, "shadowtex");
uniform_shadowmat = glGetUniformLocation(Program, "shadowmat[0]");
uniform_direction = glGetUniformLocation(Program, "direction");
uniform_col = glGetUniformLocation(Program, "col");
uniform_invproj = glGetUniformLocation(Program, "invproj");
vao = createVAO(Program);
}
void ShadowedSunLightShader::setUniforms(const core::matrix4 &shadowmat0, const core::matrix4 &shadowmat1, const core::matrix4 &shadowmat2, const core::vector3df &direction, const core::matrix4 &InvProjMatrix, float r, float g, float b, unsigned TU_ntex, unsigned TU_dtex, unsigned TU_shadowtex0, unsigned TU_shadowtex1, unsigned TU_shadowtex2)
void ShadowedSunLightShader::setUniforms(const std::vector<core::matrix4> &shadowmat, const core::vector3df &direction, const core::matrix4 &InvProjMatrix, float r, float g, float b, unsigned TU_ntex, unsigned TU_dtex, unsigned TU_shadowtex)
{
glUniformMatrix4fv(uniform_shadowmat0, 1, GL_FALSE, shadowmat0.pointer());
glUniformMatrix4fv(uniform_shadowmat1, 1, GL_FALSE, shadowmat1.pointer());
glUniformMatrix4fv(uniform_shadowmat2, 1, GL_FALSE, shadowmat2.pointer());
size_t size = shadowmat.size();
float *tmp = new float[16 * size];
for (unsigned i = 0; i < size; i++) {
memcpy(&tmp[16 * i], shadowmat[i].pointer(), 16 * sizeof(float));
}
glUniformMatrix4fv(uniform_shadowmat, size, GL_FALSE, tmp);
glUniformMatrix4fv(uniform_invproj, 1, GL_FALSE, InvProjMatrix.pointer());
glUniform3f(uniform_direction, direction.X, direction.Y, direction.Z);
glUniform3f(uniform_col, r, g, b);
glUniform1i(uniform_ntex, TU_ntex);
glUniform1i(uniform_dtex, TU_dtex);
glUniform1i(uniform_shadowtex0, TU_shadowtex0);
glUniform1i(uniform_shadowtex1, TU_shadowtex1);
glUniform1i(uniform_shadowtex2, TU_shadowtex2);
glUniform1i(uniform_shadowtex, TU_shadowtex);
delete[] tmp;
}
GLuint Gaussian6HBlurShader::Program;

8
src/graphics/shaders.hpp
View File

@ -233,7 +233,7 @@ public:
static GLuint uniform_MVP;
static void init();
static void setUniforms(const core::matrix4 &ModelViewProjectionMatrix);
static void setUniforms(const std::vector<core::matrix4> &ModelViewProjectionMatrix);
};
class RefShadowShader
@ -244,7 +244,7 @@ public:
static GLuint uniform_MVP, uniform_tex;
static void init();
static void setUniforms(const core::matrix4 &ModelViewProjectionMatrix, unsigned TU_tex);
static void setUniforms(const std::vector<core::matrix4> &ModelViewProjectionMatrix, unsigned TU_tex);
};
class GrassShadowShader
@ -389,11 +389,11 @@ class ShadowedSunLightShader
{
public:
static GLuint Program;
static GLuint uniform_ntex, uniform_dtex, uniform_shadowtex0, uniform_shadowmat0, uniform_shadowtex1, uniform_shadowmat1, uniform_shadowtex2, uniform_shadowmat2, uniform_direction, uniform_col, uniform_invproj;
static GLuint uniform_ntex, uniform_dtex, uniform_shadowtex, uniform_shadowmat, uniform_direction, uniform_col, uniform_invproj;
static GLuint vao;
static void init();
static void setUniforms(const core::matrix4 &shadowmat0, const core::matrix4 &shadowmat1, const core::matrix4 &shadowmat2, const core::vector3df &direction, const core::matrix4 &InvProjMatrix, float r, float g, float b, unsigned TU_ntex, unsigned TU_dtex, unsigned TU_shadowtex0, unsigned TU_shadowtex1, unsigned TU_shadowtex2);
static void setUniforms(const std::vector<core::matrix4> &shadowmat, const core::vector3df &direction, const core::matrix4 &InvProjMatrix, float r, float g, float b, unsigned TU_ntex, unsigned TU_dtex, unsigned TU_shadowtex);
};
class Gaussian6HBlurShader

5
src/graphics/stkanimatedmesh.cpp
View File

@ -100,8 +100,9 @@ void STKAnimatedMesh::drawShadow(const GLMesh &mesh)
GLenum itype = mesh.IndexType;
size_t count = mesh.IndexCount;
assert(irr_driver->getPhase() == SHADOW_PASS);
core::matrix4 ShadowMVP;
computeMVP(ShadowMVP);
std::vector<core::matrix4> ShadowMVP(irr_driver->getShadowViewProj());
for (unsigned i = 0; i < ShadowMVP.size(); i++)
ShadowMVP[i] *= irr_driver->getVideoDriver()->getTransform(video::ETS_WORLD);
glUseProgram(MeshShader::ShadowShader::Program);
MeshShader::ShadowShader::setUniforms(ShadowMVP);
glBindVertexArray(mesh.vao_shadow_pass);

13
src/graphics/stkmesh.cpp
View File

@ -731,8 +731,9 @@ void STKMesh::drawShadow(const GLMesh &mesh, video::E_MATERIAL_TYPE type)
size_t count = mesh.IndexCount;
core::matrix4 ShadowMVP;
computeMVP(ShadowMVP);
std::vector<core::matrix4> ShadowMVP(irr_driver->getShadowViewProj());
for (unsigned i = 0; i < ShadowMVP.size(); i++)
ShadowMVP[i] *= irr_driver->getVideoDriver()->getTransform(video::ETS_WORLD);
if (type == irr_driver->getShader(ES_OBJECTPASS_REF))
{
@ -740,12 +741,12 @@ void STKMesh::drawShadow(const GLMesh &mesh, video::E_MATERIAL_TYPE type)
glUseProgram(MeshShader::RefShadowShader::Program);
MeshShader::RefShadowShader::setUniforms(ShadowMVP, 0);
}
else if (type == irr_driver->getShader(ES_GRASS) || type == irr_driver->getShader(ES_GRASS_REF))
/* else if (type == irr_driver->getShader(ES_GRASS) || type == irr_driver->getShader(ES_GRASS_REF))
{
setTexture(0, mesh.textures[0], GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true);
glUseProgram(MeshShader::GrassShadowShader::Program);
MeshShader::GrassShadowShader::setUniforms(ShadowMVP, windDir, 0);
}
}*/
else
{
glUseProgram(MeshShader::ShadowShader::Program);
@ -949,10 +950,10 @@ void initvaostate(GLMesh &mesh, video::E_MATERIAL_TYPE type)
{
mesh.vao_shadow_pass = createVAO(mesh.vertex_buffer, mesh.index_buffer, MeshShader::RefShadowShader::attrib_position, MeshShader::RefShadowShader::attrib_texcoord, -1, -1, -1, -1, -1, mesh.Stride);
}
else if (type == irr_driver->getShader(ES_GRASS) || type == irr_driver->getShader(ES_GRASS_REF))
/*else if (type == irr_driver->getShader(ES_GRASS) || type == irr_driver->getShader(ES_GRASS_REF))
{
mesh.vao_shadow_pass = createVAO(mesh.vertex_buffer, mesh.index_buffer, MeshShader::GrassShadowShader::attrib_position, MeshShader::GrassShadowShader::attrib_texcoord, -1, -1, -1, -1, MeshShader::GrassShadowShader::attrib_color, mesh.Stride);
}
}*/
else
{
mesh.vao_shadow_pass = createVAO(mesh.vertex_buffer, mesh.index_buffer, MeshShader::ShadowShader::attrib_position, -1, -1, -1, -1, -1, -1, mesh.Stride);