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

Merge branch 'master' of github.com:supertuxkart/stk-code

Browse Source 
Conflicts:
	src/graphics/render.cpp
	src/graphics/shaders.cpp
	src/graphics/stkmesh.cpp
This commit is contained in:
hiker 2014-04-11 08:08:13 +10:00
commit 54c7d67b90
25 changed files with 1508 additions and 1257 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
.travis.yml
View File

@ -11,12 +11,17 @@ compiler:
# only: # only:
# - master # - master
before_install: before_install:
# UPDATE REPOS # Update repos
- sudo apt-get update -qq - sudo apt-get update -qq
# INSTALL DEPENDENCIES # Install dependencies
- sudo apt-get install build-essential cmake libogg-dev libvorbis-dev libopenal-dev libxxf86vm-dev libgl1-mesa-dev libglu1-mesa-dev libcurl4-openssl-dev libfribidi-dev libbluetooth-dev - sudo apt-get install build-essential cmake libogg-dev libvorbis-dev libopenal-dev libxxf86vm-dev libcurl4-openssl-dev libfribidi-dev libbluetooth-dev
# Install mesa from an other repo (a newer version is required)
- sudo apt-add-repository "deb http://archive.ubuntu.com/ubuntu quantal main restricted"
- sudo apt-key adv --recv-keys --keyserver keyserver.ubuntu.com 3B4FE6ACC0B21F32
- sudo apt-get update -qq
- sudo apt-get install libgl1-mesa-dev libglu1-mesa-dev
script: script:
# BUILD COMMANDS # Build commands
- mkdir build - mkdir build
- cd build - cd build
- cmake .. -DCMAKE_BUILD_TYPE=Debug - cmake .. -DCMAKE_BUILD_TYPE=Debug

14
data/shaders/instanced_grass.vert
View File

@ -1,6 +1,14 @@
layout (std140) uniform MatrixesData
{
mat4 ViewMatrix;
mat4 ProjectionMatrix;
mat4 InverseViewMatrix;
mat4 InverseProjectionMatrix;
mat4 ShadowViewProjMatrixes[4];
};
uniform vec3 windDir; uniform vec3 windDir;
uniform mat4 ViewProjectionMatrix;
uniform mat4 InverseViewMatrix;
in vec3 Origin; in vec3 Origin;
in vec3 Orientation; in vec3 Orientation;
@ -21,7 +29,7 @@ void main()
{ {
mat4 ModelMatrix = getWorldMatrix(Origin + windDir * Color.r, Orientation, Scale); mat4 ModelMatrix = getWorldMatrix(Origin + windDir * Color.r, Orientation, Scale);
mat4 TransposeInverseModelView = transpose(getInverseWorldMatrix(Origin + windDir * Color.r, Orientation, Scale) * InverseViewMatrix); mat4 TransposeInverseModelView = transpose(getInverseWorldMatrix(Origin + windDir * Color.r, Orientation, Scale) * InverseViewMatrix);
gl_Position = ViewProjectionMatrix * ModelMatrix * vec4(Position, 1.); gl_Position = ProjectionMatrix * ViewMatrix * ModelMatrix * vec4(Position, 1.);
nor = (TransposeInverseModelView * vec4(Normal, 0.)).xyz; nor = (TransposeInverseModelView * vec4(Normal, 0.)).xyz;
uv = Texcoord; uv = Texcoord;
} }

12
data/shaders/instanced_object_pass.vert
View File

@ -1,5 +1,11 @@
uniform mat4 ViewProjectionMatrix; layout (std140) uniform MatrixesData
uniform mat4 InverseViewMatrix; {
mat4 ViewMatrix;
mat4 ProjectionMatrix;
mat4 InverseViewMatrix;
mat4 InverseProjectionMatrix;
mat4 ShadowViewProjMatrixes[4];
};
in vec3 Origin; in vec3 Origin;
in vec3 Orientation; in vec3 Orientation;
@ -19,7 +25,7 @@ void main(void)
{ {
mat4 ModelMatrix = getWorldMatrix(Origin, Orientation, Scale); mat4 ModelMatrix = getWorldMatrix(Origin, Orientation, Scale);
mat4 TransposeInverseModelView = transpose(getInverseWorldMatrix(Origin, Orientation, Scale) * InverseViewMatrix); mat4 TransposeInverseModelView = transpose(getInverseWorldMatrix(Origin, Orientation, Scale) * InverseViewMatrix);
gl_Position = ViewProjectionMatrix * ModelMatrix * vec4(Position, 1.); gl_Position = ProjectionMatrix * ViewMatrix * ModelMatrix * vec4(Position, 1.);
nor = (TransposeInverseModelView * vec4(Normal, 0.)).xyz; nor = (TransposeInverseModelView * vec4(Normal, 0.)).xyz;
uv = Texcoord; uv = Texcoord;
} }

14
data/shaders/normalmap.vert
View File

@ -1,6 +1,14 @@
uniform mat4 ModelViewProjectionMatrix; layout (std140) uniform MatrixesData
uniform mat4 TransposeInverseModelView; {
mat4 ViewMatrix;
mat4 ProjectionMatrix;
mat4 InverseViewMatrix;
mat4 InverseProjectionMatrix;
mat4 ShadowViewProjMatrixes[4];
};
uniform mat4 ModelMatrix;
uniform mat4 InverseModelMatrix;
#if __VERSION__ >= 130 #if __VERSION__ >= 130
in vec3 Position; in vec3 Position;
@ -23,6 +31,8 @@ varying vec2 uv;
void main() void main()
{ {
mat4 ModelViewProjectionMatrix = ProjectionMatrix * ViewMatrix * ModelMatrix;
mat4 TransposeInverseModelView = transpose(InverseModelMatrix * InverseViewMatrix);
uv = Texcoord; uv = Texcoord;
tangent = (TransposeInverseModelView * vec4(Tangent, 1.)).xyz; tangent = (TransposeInverseModelView * vec4(Tangent, 1.)).xyz;
bitangent = (TransposeInverseModelView * vec4(Bitangent, 1.)).xyz; bitangent = (TransposeInverseModelView * vec4(Bitangent, 1.)).xyz;

19
data/shaders/object_pass.vert
View File

@ -1,5 +1,15 @@
uniform mat4 ModelViewProjectionMatrix; layout (std140) uniform MatrixesData
uniform mat4 TransposeInverseModelView; {
mat4 ViewMatrix;
mat4 ProjectionMatrix;
mat4 InverseViewMatrix;
mat4 InverseProjectionMatrix;
mat4 ShadowViewProjMatrixes[4];
};
uniform mat4 ModelMatrix;
uniform mat4 InverseModelMatrix;
uniform mat4 TextureMatrix = uniform mat4 TextureMatrix =
mat4(1., 0., 0., 0., mat4(1., 0., 0., 0.,
0., 1., 0., 0., 0., 1., 0., 0.,
@ -11,9 +21,11 @@ in vec3 Position;
in vec2 Texcoord; in vec2 Texcoord;
in vec2 SecondTexcoord; in vec2 SecondTexcoord;
in vec3 Normal; in vec3 Normal;
in vec4 Color;
out vec3 nor; out vec3 nor;
out vec2 uv; out vec2 uv;
out vec2 uv_bis; out vec2 uv_bis;
out vec4 color;
#else #else
attribute vec3 Position; attribute vec3 Position;
attribute vec3 Normal; attribute vec3 Normal;
@ -27,6 +39,9 @@ varying vec2 uv_bis;
void main(void) void main(void)
{ {
color = Color.zyxw;
mat4 ModelViewProjectionMatrix = ProjectionMatrix * ViewMatrix * ModelMatrix;
mat4 TransposeInverseModelView = transpose(InverseModelMatrix * InverseViewMatrix);
gl_Position = ModelViewProjectionMatrix * vec4(Position, 1.); gl_Position = ModelViewProjectionMatrix * vec4(Position, 1.);
nor = (TransposeInverseModelView * vec4(Normal, 0.)).xyz; nor = (TransposeInverseModelView * vec4(Normal, 0.)).xyz;
uv = (TextureMatrix * vec4(Texcoord, 1., 1.)).xy; uv = (TextureMatrix * vec4(Texcoord, 1., 1.)).xy;

6
data/shaders/objectpass_rimlit.frag
View File

@ -6,17 +6,17 @@ uniform vec2 screen;
uniform vec3 ambient; uniform vec3 ambient;
#if __VERSION__ >= 130 #if __VERSION__ >= 130
in vec3 normal; in vec3 nor;
in vec2 uv; in vec2 uv;
out vec4 FragColor; out vec4 FragColor;
#else #else
varying vec3 normal; varying vec3 nor;
varying vec2 uv; varying vec2 uv;
#define FragColor gl_FragColor #define FragColor gl_FragColor
#endif #endif
void main() { void main() {
float rim = 1.0 - dot(normal, vec3(0., 0., -1)); float rim = 1.0 - dot(nor, vec3(0., 0., -1));
rim = smoothstep(0.5, 1.5, rim) * 0.35; rim = smoothstep(0.5, 1.5, rim) * 0.35;
vec4 color = texture(Albedo, uv); vec4 color = texture(Albedo, uv);

25
data/shaders/objectpass_rimlit.vert
View File

@ -1,25 +0,0 @@
uniform mat4 ModelViewProjectionMatrix;
uniform mat4 TransposeInverseModelView;
uniform mat4 TextureMatrix;
#if __VERSION__ >= 130
in vec3 Position;
in vec3 Normal;
in vec2 Texcoord;
in vec4 Color;
out vec2 uv;
out vec3 normal;
#else
attribute vec3 Position;
attribute vec3 Normal;
attribute vec2 Texcoord;
attribute vec4 Color;
varying vec2 uv;
varying vec3 normal;
#endif
void main() {
normal = (TransposeInverseModelView * vec4(Normal, 0)).xyz;
uv = (TextureMatrix * vec4(Texcoord, 1., 1.)).xy;
gl_Position = ModelViewProjectionMatrix * vec4(Position, 1.);
}

15
data/shaders/objectpass_spheremap.frag
View File

@ -1,7 +1,14 @@
layout (std140) uniform MatrixesData
{
mat4 ViewMatrix;
mat4 ProjectionMatrix;
mat4 InverseViewMatrix;
mat4 InverseProjectionMatrix;
mat4 ShadowViewProjMatrixes[4];
};
uniform samplerCube tex; uniform samplerCube tex;
uniform mat4 invproj;
uniform vec2 screen; uniform vec2 screen;
uniform mat4 TransposeViewMatrix;
#if __VERSION__ >= 130 #if __VERSION__ >= 130
in vec3 nor; in vec3 nor;
@ -15,12 +22,12 @@ varying vec3 nor;
void main() { void main() {
vec3 fpos = gl_FragCoord.xyz / vec3(screen, 1.); vec3 fpos = gl_FragCoord.xyz / vec3(screen, 1.);
vec4 xpos = 2.0 * vec4(fpos, 1.0) - 1.0; vec4 xpos = 2.0 * vec4(fpos, 1.0) - 1.0;
xpos = invproj * xpos; xpos = InverseProjectionMatrix * xpos;
xpos.xyz /= xpos.w; xpos.xyz /= xpos.w;
vec3 viewSampleDir = reflect(xpos.xyz, nor); vec3 viewSampleDir = reflect(xpos.xyz, nor);
// Convert sampleDir in world space (where tex was generated) // Convert sampleDir in world space (where tex was generated)
vec4 sampleDir = TransposeViewMatrix * vec4(viewSampleDir, 0.); vec4 sampleDir = transpose(InverseViewMatrix) * vec4(viewSampleDir, 0.);
vec4 detail0 = texture(tex, sampleDir.xyz); vec4 detail0 = texture(tex, sampleDir.xyz);
FragColor = vec4(detail0.xyz, 1.); FragColor = vec4(detail0.xyz, 1.);

8
data/shaders/shadow.geom
View File

@ -1,6 +1,10 @@
layout (std140) uniform MatrixesData layout (std140) uniform MatrixesData
{ {
mat4 ViewProjectionMatrix[4]; mat4 ViewMatrix;
mat4 ProjectionMatrix;
mat4 InverseViewMatrix;
mat4 InverseProjectionMatrix;
mat4 ShadowViewProjMatrixes[4];
}; };
#if __VERSION__ >= 400 #if __VERSION__ >= 400
@ -20,7 +24,7 @@ void emitToLayer(int layerId)
for(int i=0; i<3; i++) for(int i=0; i<3; i++)
{ {
uv = tc[i]; uv = tc[i];
gl_Position = ViewProjectionMatrix[layerId] * gl_in[i].gl_Position; gl_Position = ShadowViewProjMatrixes[layerId] * gl_in[i].gl_Position;
EmitVertex(); EmitVertex();
} }
EndPrimitive(); EndPrimitive();

12
data/shaders/sky.frag
View File

@ -1,5 +1,13 @@
layout (std140) uniform MatrixesData
{
mat4 ViewMatrix;
mat4 ProjectionMatrix;
mat4 InverseViewMatrix;
mat4 InverseProjectionMatrix;
mat4 ShadowViewProjMatrixes[4];
};
uniform samplerCube tex; uniform samplerCube tex;
uniform mat4 InvProjView;
uniform vec2 screen; uniform vec2 screen;
@ -14,7 +22,7 @@ void main(void)
{ {
vec3 eyedir = gl_FragCoord.xyz / vec3(screen, 1.); vec3 eyedir = gl_FragCoord.xyz / vec3(screen, 1.);
eyedir = 2.0 * eyedir - 1.0; eyedir = 2.0 * eyedir - 1.0;
vec4 tmp = (InvProjView * vec4(eyedir, 1.)); vec4 tmp = (InverseViewMatrix * InverseProjectionMatrix * vec4(eyedir, 1.));
eyedir = tmp.xyz / tmp.w; eyedir = tmp.xyz / tmp.w;
vec4 color = texture(tex, eyedir); vec4 color = texture(tex, eyedir);
FragColor = vec4(color.xyz, 1.); FragColor = vec4(color.xyz, 1.);

41
data/shaders/splatting.vert
View File

@ -1,41 +0,0 @@
// SuperTuxKart - a fun racing game with go-kart
// Copyright (C) 2013 the SuperTuxKart team
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 3
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
uniform mat4 ModelViewProjectionMatrix;
uniform mat4 TransposeInverseModelView;
#if __VERSION__ >= 130
in vec3 Position;
in vec2 Texcoord;
in vec2 SecondTexcoord;
out vec2 uv;
out vec2 uv_bis;
#else
attribute vec3 Position;
attribute vec2 Texcoord;
attribute vec2 SecondTexcoord;
varying vec2 uv;
varying vec2 uv_bis;
#endif
void main()
{
uv = Texcoord;
uv_bis = SecondTexcoord;
gl_Position = ModelViewProjectionMatrix * vec4(Position, 1.);
}

13
data/shaders/untextured_object.vert
View File

@ -1,4 +1,13 @@
uniform mat4 ModelViewProjectionMatrix; layout (std140) uniform MatrixesData
{
mat4 ViewMatrix;
mat4 ProjectionMatrix;
mat4 InverseViewMatrix;
mat4 InverseProjectionMatrix;
mat4 ShadowViewProjMatrixes[4];
};
uniform mat4 ModelMatrix;
#if __VERSION__ >= 130 #if __VERSION__ >= 130
in vec3 Position; in vec3 Position;
@ -14,5 +23,5 @@ varying vec4 color;
void main(void) void main(void)
{ {
color = Color.zyxw; color = Color.zyxw;
gl_Position = ModelViewProjectionMatrix * vec4(Position, 1.); gl_Position = ProjectionMatrix * ViewMatrix * ModelMatrix * vec4(Position, 1.);
} }

1
src/graphics/glwrap.cpp
View File

@ -229,6 +229,7 @@ GLuint LoadShader(const char * file, unsigned type)
sprintf(versionString, "#version %d\n", irr_driver->getGLSLVersion()); sprintf(versionString, "#version %d\n", irr_driver->getGLSLVersion());
std::string Code = versionString; std::string Code = versionString;
std::ifstream Stream(file, std::ios::in); std::ifstream Stream(file, std::ios::in);
Code += "//" + std::string(file) + "\n";
if (Stream.is_open()) if (Stream.is_open())
{ {
std::string Line = ""; std::string Line = "";

2
src/graphics/irr_driver.hpp
View File

@ -226,6 +226,8 @@ private:
void renderSolidSecondPass(); void renderSolidSecondPass();
void renderTransparent(); void renderTransparent();
void renderParticles(); void renderParticles();
void computeCameraMatrix(scene::ICameraSceneNode * const camnode,
Camera * const camera);
void renderShadows(//ShadowImportanceProvider * const sicb, void renderShadows(//ShadowImportanceProvider * const sicb,
scene::ICameraSceneNode * const camnode, scene::ICameraSceneNode * const camnode,
//video::SOverrideMaterial &overridemat, //video::SOverrideMaterial &overridemat,

126
src/graphics/render.cpp
View File

@ -164,11 +164,9 @@ void IrrDriver::renderGLSL(float dt)
}*/ }*/
// Get Projection and view matrix // Get Projection and view matrix
irr_driver->setPhase(SOLID_NORMAL_AND_DEPTH_PASS); computeCameraMatrix(camnode, camera);
m_scene_manager->drawAll(scene::ESNRP_CAMERA); glBindBufferBase(GL_UNIFORM_BUFFER, 0, SharedObject::ViewProjectionMatrixesUBO);
irr_driver->setProjMatrix(irr_driver->getVideoDriver()->getTransform(video::ETS_PROJECTION));
irr_driver->setViewMatrix(irr_driver->getVideoDriver()->getTransform(video::ETS_VIEW));
irr_driver->genProjViewMatrix();
// Fire up the MRT // Fire up the MRT
PROFILER_PUSH_CPU_MARKER("- Solid Pass 1", 0xFF, 0x00, 0x00); PROFILER_PUSH_CPU_MARKER("- Solid Pass 1", 0xFF, 0x00, 0x00);
@ -424,8 +422,27 @@ void IrrDriver::renderSolidFirstPass()
glDisable(GL_BLEND); glDisable(GL_BLEND);
glEnable(GL_CULL_FACE); glEnable(GL_CULL_FACE);
irr_driver->setPhase(SOLID_NORMAL_AND_DEPTH_PASS); irr_driver->setPhase(SOLID_NORMAL_AND_DEPTH_PASS);
GroupedFPSM<FPSM_DEFAULT>::reset();
GroupedFPSM<FPSM_ALPHA_REF_TEXTURE>::reset();
GroupedFPSM<FPSM_NORMAL_MAP>::reset();
m_scene_manager->drawAll(scene::ESNRP_SOLID); m_scene_manager->drawAll(scene::ESNRP_SOLID);
glUseProgram(MeshShader::ObjectPass1Shader::Program);
for (unsigned i = 0; i < GroupedFPSM<FPSM_DEFAULT>::MeshSet.size(); ++i)
{
drawObjectPass1(*GroupedFPSM<FPSM_DEFAULT>::MeshSet[i], GroupedFPSM<FPSM_DEFAULT>::MVPSet[i], GroupedFPSM<FPSM_DEFAULT>::TIMVSet[i]);
}
glUseProgram(MeshShader::ObjectRefPass1Shader::Program);
for (unsigned i = 0; i < GroupedFPSM<FPSM_ALPHA_REF_TEXTURE>::MeshSet.size(); ++i)
{
drawObjectRefPass1(*GroupedFPSM<FPSM_ALPHA_REF_TEXTURE>::MeshSet[i], GroupedFPSM<FPSM_ALPHA_REF_TEXTURE>::MVPSet[i], GroupedFPSM<FPSM_ALPHA_REF_TEXTURE>::TIMVSet[i], GroupedFPSM<FPSM_ALPHA_REF_TEXTURE>::MeshSet[i]->TextureMatrix);
}
glUseProgram(MeshShader::NormalMapShader::Program);
for (unsigned i = 0; i < GroupedFPSM<FPSM_NORMAL_MAP>::MeshSet.size(); ++i)
{
drawNormalPass(*GroupedFPSM<FPSM_NORMAL_MAP>::MeshSet[i], GroupedFPSM<FPSM_NORMAL_MAP>::MVPSet[i], GroupedFPSM<FPSM_NORMAL_MAP>::TIMVSet[i]);
}
} }
void IrrDriver::renderSolidSecondPass() void IrrDriver::renderSolidSecondPass()
@ -441,10 +458,51 @@ void IrrDriver::renderSolidSecondPass()
glEnable(GL_DEPTH_TEST); glEnable(GL_DEPTH_TEST);
glDisable(GL_ALPHA_TEST); glDisable(GL_ALPHA_TEST);
glDisable(GL_BLEND); glDisable(GL_BLEND);
GroupedSM<SM_DEFAULT>::reset();
GroupedSM<SM_ALPHA_REF_TEXTURE>::reset();
GroupedSM<SM_RIMLIT>::reset();
GroupedSM<SM_SPHEREMAP>::reset();
GroupedSM<SM_SPLATTING>::reset();
GroupedSM<SM_UNLIT>::reset();
GroupedSM<SM_DETAILS>::reset();
GroupedSM<SM_UNTEXTURED>::reset();
setTexture(0, m_rtts->getRenderTarget(RTT_TMP1), GL_NEAREST, GL_NEAREST); setTexture(0, m_rtts->getRenderTarget(RTT_TMP1), GL_NEAREST, GL_NEAREST);
setTexture(1, m_rtts->getRenderTarget(RTT_TMP2), GL_NEAREST, GL_NEAREST); setTexture(1, m_rtts->getRenderTarget(RTT_TMP2), GL_NEAREST, GL_NEAREST);
setTexture(2, m_rtts->getRenderTarget(RTT_SSAO), GL_NEAREST, GL_NEAREST); setTexture(2, m_rtts->getRenderTarget(RTT_SSAO), GL_NEAREST, GL_NEAREST);
m_scene_manager->drawAll(scene::ESNRP_SOLID); m_scene_manager->drawAll(scene::ESNRP_SOLID);
glUseProgram(MeshShader::ObjectPass2Shader::Program);
for (unsigned i = 0; i < GroupedSM<SM_DEFAULT>::MeshSet.size(); i++)
drawObjectPass2(*GroupedSM<SM_DEFAULT>::MeshSet[i], GroupedSM<SM_DEFAULT>::MVPSet[i], GroupedSM<SM_DEFAULT>::MeshSet[i]->TextureMatrix);
glUseProgram(MeshShader::ObjectRefPass2Shader::Program);
for (unsigned i = 0; i < GroupedSM<SM_ALPHA_REF_TEXTURE>::MeshSet.size(); i++)
drawObjectRefPass2(*GroupedSM<SM_ALPHA_REF_TEXTURE>::MeshSet[i], GroupedSM<SM_ALPHA_REF_TEXTURE>::MVPSet[i], GroupedSM<SM_ALPHA_REF_TEXTURE>::MeshSet[i]->TextureMatrix);
glUseProgram(MeshShader::ObjectRimLimitShader::Program);
for (unsigned i = 0; i < GroupedSM<SM_RIMLIT>::MeshSet.size(); i++)
drawObjectRimLimit(*GroupedSM<SM_RIMLIT>::MeshSet[i], GroupedSM<SM_RIMLIT>::MVPSet[i], GroupedSM<SM_RIMLIT>::TIMVSet[i], GroupedSM<SM_RIMLIT>::MeshSet[i]->TextureMatrix);
glUseProgram(MeshShader::SphereMapShader::Program);
for (unsigned i = 0; i < GroupedSM<SM_SPHEREMAP>::MeshSet.size(); i++)
drawSphereMap(*GroupedSM<SM_SPHEREMAP>::MeshSet[i], GroupedSM<SM_SPHEREMAP>::MVPSet[i], GroupedSM<SM_SPHEREMAP>::TIMVSet[i]);
glUseProgram(MeshShader::SplattingShader::Program);
for (unsigned i = 0; i < GroupedSM<SM_SPLATTING>::MeshSet.size(); i++)
drawSplatting(*GroupedSM<SM_SPLATTING>::MeshSet[i], GroupedSM<SM_SPLATTING>::MVPSet[i]);
glUseProgram(MeshShader::ObjectUnlitShader::Program);
for (unsigned i = 0; i < GroupedSM<SM_UNLIT>::MeshSet.size(); i++)
drawObjectUnlit(*GroupedSM<SM_UNLIT>::MeshSet[i], GroupedSM<SM_UNLIT>::MVPSet[i]);
glUseProgram(MeshShader::DetailledObjectPass2Shader::Program);
for (unsigned i = 0; i < GroupedSM<SM_DETAILS>::MeshSet.size(); i++)
drawDetailledObjectPass2(*GroupedSM<SM_DETAILS>::MeshSet[i], GroupedSM<SM_DETAILS>::MVPSet[i]);
glUseProgram(MeshShader::UntexturedObjectShader::Program);
for (unsigned i = 0; i < GroupedSM<SM_UNTEXTURED>::MeshSet.size(); i++)
drawUntexturedObject(*GroupedSM<SM_UNTEXTURED>::MeshSet[i], GroupedSM<SM_UNTEXTURED>::MVPSet[i]);
} }
void IrrDriver::renderTransparent() void IrrDriver::renderTransparent()
@ -470,9 +528,7 @@ void IrrDriver::renderParticles()
m_scene_manager->drawAll(scene::ESNRP_TRANSPARENT_EFFECT); m_scene_manager->drawAll(scene::ESNRP_TRANSPARENT_EFFECT);
} }
void IrrDriver::renderShadows(//ShadowImportanceProvider * const sicb, void IrrDriver::computeCameraMatrix(scene::ICameraSceneNode * const camnode,
scene::ICameraSceneNode * const camnode,
//video::SOverrideMaterial &overridemat,
Camera * const camera) Camera * const camera)
{ {
m_scene_manager->setCurrentRendertime(scene::ESNRP_SOLID); m_scene_manager->setCurrentRendertime(scene::ESNRP_SOLID);
@ -557,6 +613,35 @@ void IrrDriver::renderShadows(//ShadowImportanceProvider * const sicb,
sun_ortho_matrix.push_back(getVideoDriver()->getTransform(video::ETS_PROJECTION) * getVideoDriver()->getTransform(video::ETS_VIEW)); sun_ortho_matrix.push_back(getVideoDriver()->getTransform(video::ETS_PROJECTION) * getVideoDriver()->getTransform(video::ETS_VIEW));
} }
assert(sun_ortho_matrix.size() == 4); assert(sun_ortho_matrix.size() == 4);
camnode->setNearValue(oldnear);
camnode->setFarValue(oldfar);
camnode->render();
camera->activate();
m_scene_manager->drawAll(scene::ESNRP_CAMERA);
irr_driver->setProjMatrix(irr_driver->getVideoDriver()->getTransform(video::ETS_PROJECTION));
irr_driver->setViewMatrix(irr_driver->getVideoDriver()->getTransform(video::ETS_VIEW));
irr_driver->genProjViewMatrix();
float *tmp = new float[16 * 8];
memcpy(tmp, irr_driver->getViewMatrix().pointer(), 16 * sizeof(float));
memcpy(&tmp[16], irr_driver->getProjMatrix().pointer(), 16 * sizeof(float));
memcpy(&tmp[32], irr_driver->getInvViewMatrix().pointer(), 16 * sizeof(float));
memcpy(&tmp[48], irr_driver->getInvProjMatrix().pointer(), 16 * sizeof(float));
size_t size = irr_driver->getShadowViewProj().size();
for (unsigned i = 0; i < size; i++)
memcpy(&tmp[16 * i + 64], irr_driver->getShadowViewProj()[i].pointer(), 16 * sizeof(float));
glBindBuffer(GL_UNIFORM_BUFFER, SharedObject::ViewProjectionMatrixesUBO);
glBufferSubData(GL_UNIFORM_BUFFER, 0, 16 * 8 * sizeof(float), tmp);
delete tmp;
}
void IrrDriver::renderShadows(//ShadowImportanceProvider * const sicb,
scene::ICameraSceneNode * const camnode,
//video::SOverrideMaterial &overridemat,
Camera * const camera)
{
irr_driver->setPhase(SHADOW_PASS); irr_driver->setPhase(SHADOW_PASS);
glDisable(GL_BLEND); glDisable(GL_BLEND);
@ -567,25 +652,11 @@ void IrrDriver::renderShadows(//ShadowImportanceProvider * const sicb,
glClear(GL_DEPTH_BUFFER_BIT); glClear(GL_DEPTH_BUFFER_BIT);
glDrawBuffer(GL_NONE); glDrawBuffer(GL_NONE);
size_t size = irr_driver->getShadowViewProj().size();
float *tmp = new float[16 * size];
for (unsigned i = 0; i < size; i++) {
memcpy(&tmp[16 * i], irr_driver->getShadowViewProj()[i].pointer(), 16 * sizeof(float));
}
glBindBuffer(GL_UNIFORM_BUFFER, SharedObject::ViewProjectionMatrixesUBO);
glBufferSubData(GL_UNIFORM_BUFFER, 0, 16 * 4 * sizeof(float), tmp);
glBindBufferBase(GL_UNIFORM_BUFFER, 0, SharedObject::ViewProjectionMatrixesUBO); glBindBufferBase(GL_UNIFORM_BUFFER, 0, SharedObject::ViewProjectionMatrixesUBO);
delete tmp;
m_scene_manager->drawAll(scene::ESNRP_SOLID); m_scene_manager->drawAll(scene::ESNRP_SOLID);
glBindBuffer(GL_UNIFORM_BUFFER, 0);
glCullFace(GL_BACK); glCullFace(GL_BACK);
camnode->setNearValue(oldnear);
camnode->setFarValue(oldfar);
camnode->render();
camera->activate();
m_scene_manager->drawAll(scene::ESNRP_CAMERA);
glViewport(0, 0, UserConfigParams::m_width, UserConfigParams::m_height); glViewport(0, 0, UserConfigParams::m_width, UserConfigParams::m_height);
@ -1268,7 +1339,7 @@ void IrrDriver::renderSkybox()
glBindVertexArray(MeshShader::SkyboxShader::cubevao); glBindVertexArray(MeshShader::SkyboxShader::cubevao);
glDisable(GL_CULL_FACE); glDisable(GL_CULL_FACE);
assert(SkyboxTextures.size() == 6); assert(SkyboxTextures.size() == 6);
core::matrix4 transform = irr_driver->getProjViewMatrix();
core::matrix4 translate; core::matrix4 translate;
translate.setTranslation(camera->getAbsolutePosition()); translate.setTranslation(camera->getAbsolutePosition());
@ -1276,7 +1347,7 @@ void IrrDriver::renderSkybox()
const f32 viewDistance = (camera->getNearValue() + camera->getFarValue()) * 0.5f; const f32 viewDistance = (camera->getNearValue() + camera->getFarValue()) * 0.5f;
core::matrix4 scale; core::matrix4 scale;
scale.setScale(core::vector3df(viewDistance, viewDistance, viewDistance)); scale.setScale(core::vector3df(viewDistance, viewDistance, viewDistance));
transform *= translate * scale; core::matrix4 transform = translate * scale;
core::matrix4 invtransform; core::matrix4 invtransform;
transform.getInverse(invtransform); transform.getInverse(invtransform);
@ -1285,9 +1356,10 @@ void IrrDriver::renderSkybox()
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glUseProgram(MeshShader::SkyboxShader::Program); glUseProgram(MeshShader::SkyboxShader::Program);
MeshShader::SkyboxShader::setUniforms(transform, invtransform, MeshShader::SkyboxShader::setUniforms(transform,
core::vector2df(float(UserConfigParams::m_width), core::vector2df(float(UserConfigParams::m_width),
float(UserConfigParams::m_height)), 0); float(UserConfigParams::m_height)),
0);
glDrawElements(GL_TRIANGLES, 6 * 6, GL_UNSIGNED_INT, 0); glDrawElements(GL_TRIANGLES, 6 * 6, GL_UNSIGNED_INT, 0);
glBindVertexArray(0); glBindVertexArray(0);
} }

312
src/graphics/shaders.cpp
View File

@ -49,7 +49,7 @@ Shaders::Shaders()
m_callbacks[ES_SHADOWGEN] = new ShadowGenProvider(); m_callbacks[ES_SHADOWGEN] = new ShadowGenProvider();
m_callbacks[ES_DISPLACE] = new DisplaceProvider(); m_callbacks[ES_DISPLACE] = new DisplaceProvider();
for(s32 i=0 ; i < ES_COUNT ; i++) for (s32 i = 0; i < ES_COUNT; i++)
m_shaders[i] = -1; m_shaders[i] = -1;
loadShaders(); loadShaders();
@ -170,7 +170,7 @@ static void initShadowVPMUBO()
{ {
glGenBuffers(1, &SharedObject::ViewProjectionMatrixesUBO); glGenBuffers(1, &SharedObject::ViewProjectionMatrixesUBO);
glBindBuffer(GL_UNIFORM_BUFFER, SharedObject::ViewProjectionMatrixesUBO); glBindBuffer(GL_UNIFORM_BUFFER, SharedObject::ViewProjectionMatrixesUBO);
glBufferData(GL_UNIFORM_BUFFER, 16 * 4 * sizeof(float), 0, GL_STATIC_DRAW); glBufferData(GL_UNIFORM_BUFFER, 16 * 8 * sizeof(float), 0, GL_STATIC_DRAW);
glBindBuffer(GL_UNIFORM_BUFFER, 0); glBindBuffer(GL_UNIFORM_BUFFER, 0);
} }
@ -180,9 +180,9 @@ void Shaders::loadShaders()
IGPUProgrammingServices * const gpu = irr_driver->getVideoDriver()->getGPUProgrammingServices(); IGPUProgrammingServices * const gpu = irr_driver->getVideoDriver()->getGPUProgrammingServices();
#define glsl(a, b, c) gpu->addHighLevelShaderMaterialFromFiles((a).c_str(), (b).c_str(), (IShaderConstantSetCallBack*) c) #define glsl(a, b, c) gpu->addHighLevelShaderMaterialFromFiles((a).c_str(), (b).c_str(), (IShaderConstantSetCallBack*) c)
#define glslmat(a, b, c, d) gpu->addHighLevelShaderMaterialFromFiles((a).c_str(), (b).c_str(), (IShaderConstantSetCallBack*) c, d) #define glslmat(a, b, c, d) gpu->addHighLevelShaderMaterialFromFiles((a).c_str(), (b).c_str(), (IShaderConstantSetCallBack*) c, d)
#define glsl_noinput(a, b) gpu->addHighLevelShaderMaterialFromFiles((a).c_str(), (b).c_str(), (IShaderConstantSetCallBack*) 0) #define glsl_noinput(a, b) gpu->addHighLevelShaderMaterialFromFiles((a).c_str(), (b).c_str(), (IShaderConstantSetCallBack*) 0)
// Save previous shaders (used in case some shaders don't compile) // Save previous shaders (used in case some shaders don't compile)
int saved_shaders[ES_COUNT]; int saved_shaders[ES_COUNT];
@ -279,14 +279,14 @@ void Shaders::loadShaders()
check(i); check(i);
} }
#undef glsl #undef glsl
#undef glslmat #undef glslmat
#undef glsl_noinput #undef glsl_noinput
// In case we're reloading and a shader didn't compile: keep the previous, working one // In case we're reloading and a shader didn't compile: keep the previous, working one
for(s32 i=0 ; i < ES_COUNT ; i++) for (s32 i = 0; i < ES_COUNT; i++)
{ {
if(m_shaders[i] == -1) if (m_shaders[i] == -1)
m_shaders[i] = saved_shaders[i]; m_shaders[i] = saved_shaders[i];
} }
@ -377,7 +377,7 @@ E_MATERIAL_TYPE Shaders::getShader(const ShaderType num) const
{ {
assert(num < ES_COUNT); assert(num < ES_COUNT);
return (E_MATERIAL_TYPE) m_shaders[num]; return (E_MATERIAL_TYPE)m_shaders[num];
} }
void Shaders::check(const int num) const void Shaders::check(const int num) const
@ -397,8 +397,8 @@ namespace MeshShader
GLuint ObjectPass1Shader::attrib_position; GLuint ObjectPass1Shader::attrib_position;
GLuint ObjectPass1Shader::attrib_normal; GLuint ObjectPass1Shader::attrib_normal;
GLuint ObjectPass1Shader::attrib_texcoord; GLuint ObjectPass1Shader::attrib_texcoord;
GLuint ObjectPass1Shader::uniform_MVP; GLuint ObjectPass1Shader::uniform_MM;
GLuint ObjectPass1Shader::uniform_TIMV; GLuint ObjectPass1Shader::uniform_IMM;
GLuint ObjectPass1Shader::uniform_tex; GLuint ObjectPass1Shader::uniform_tex;
void ObjectPass1Shader::init() void ObjectPass1Shader::init()
@ -410,15 +410,17 @@ namespace MeshShader
attrib_position = glGetAttribLocation(Program, "Position"); attrib_position = glGetAttribLocation(Program, "Position");
attrib_normal = glGetAttribLocation(Program, "Normal"); attrib_normal = glGetAttribLocation(Program, "Normal");
attrib_texcoord = glGetAttribLocation(Program, "Texcoord"); attrib_texcoord = glGetAttribLocation(Program, "Texcoord");
uniform_MVP = glGetUniformLocation(Program, "ModelViewProjectionMatrix"); uniform_MM = glGetUniformLocation(Program, "ModelMatrix");
uniform_TIMV = glGetUniformLocation(Program, "TransposeInverseModelView"); uniform_IMM = glGetUniformLocation(Program, "InverseModelMatrix");
uniform_tex = glGetUniformLocation(Program, "tex"); uniform_tex = glGetUniformLocation(Program, "tex");
GLuint uniform_ViewProjectionMatrixesUBO = glGetUniformBlockIndex(Program, "MatrixesData");
glUniformBlockBinding(Program, uniform_ViewProjectionMatrixesUBO, 0);
} }
void ObjectPass1Shader::setUniforms(const core::matrix4 &ModelViewProjectionMatrix, const core::matrix4 &TransposeInverseModelView, unsigned TU_tex) void ObjectPass1Shader::setUniforms(const core::matrix4 &ModelMatrix, const core::matrix4 &InverseModelMatrix, unsigned TU_tex)
{ {
glUniformMatrix4fv(uniform_MVP, 1, GL_FALSE, ModelViewProjectionMatrix.pointer()); glUniformMatrix4fv(uniform_MM, 1, GL_FALSE, ModelMatrix.pointer());
glUniformMatrix4fv(uniform_TIMV, 1, GL_FALSE, TransposeInverseModelView.pointer()); glUniformMatrix4fv(uniform_IMM, 1, GL_FALSE, InverseModelMatrix.pointer());
glUniform1i(uniform_tex, TU_tex); glUniform1i(uniform_tex, TU_tex);
} }
@ -426,8 +428,8 @@ namespace MeshShader
GLuint ObjectRefPass1Shader::attrib_position; GLuint ObjectRefPass1Shader::attrib_position;
GLuint ObjectRefPass1Shader::attrib_normal; GLuint ObjectRefPass1Shader::attrib_normal;
GLuint ObjectRefPass1Shader::attrib_texcoord; GLuint ObjectRefPass1Shader::attrib_texcoord;
GLuint ObjectRefPass1Shader::uniform_MVP; GLuint ObjectRefPass1Shader::uniform_MM;
GLuint ObjectRefPass1Shader::uniform_TIMV; GLuint ObjectRefPass1Shader::uniform_IMM;
GLuint ObjectRefPass1Shader::uniform_TM; GLuint ObjectRefPass1Shader::uniform_TM;
GLuint ObjectRefPass1Shader::uniform_tex; GLuint ObjectRefPass1Shader::uniform_tex;
@ -440,17 +442,19 @@ namespace MeshShader
attrib_position = glGetAttribLocation(Program, "Position"); attrib_position = glGetAttribLocation(Program, "Position");
attrib_normal = glGetAttribLocation(Program, "Normal"); attrib_normal = glGetAttribLocation(Program, "Normal");
attrib_texcoord = glGetAttribLocation(Program, "Texcoord"); attrib_texcoord = glGetAttribLocation(Program, "Texcoord");
uniform_MVP = glGetUniformLocation(Program, "ModelViewProjectionMatrix"); uniform_MM = glGetUniformLocation(Program, "ModelMatrix");
uniform_TIMV = glGetUniformLocation(Program, "TransposeInverseModelView"); uniform_IMM = glGetUniformLocation(Program, "InverseModelMatrix");
uniform_TM = glGetUniformLocation(Program, "TextureMatrix"); uniform_TM = glGetUniformLocation(Program, "TextureMatrix");
uniform_tex = glGetUniformLocation(Program, "tex"); uniform_tex = glGetUniformLocation(Program, "tex");
GLuint uniform_ViewProjectionMatrixesUBO = glGetUniformBlockIndex(Program, "MatrixesData");
glUniformBlockBinding(Program, uniform_ViewProjectionMatrixesUBO, 0);
} }
void ObjectRefPass1Shader::setUniforms(const core::matrix4 &ModelViewProjectionMatrix, const core::matrix4 &TransposeInverseModelView, const core::matrix4 &TextureMatrix, unsigned TU_tex) void ObjectRefPass1Shader::setUniforms(const core::matrix4 &ModelMatrix, const core::matrix4 &InverseModelMatrix, const core::matrix4 &TextureMatrix, unsigned TU_tex)
{ {
glUniformMatrix4fv(uniform_MVP, 1, GL_FALSE, ModelViewProjectionMatrix.pointer()); glUniformMatrix4fv(uniform_MM, 1, GL_FALSE, ModelMatrix.pointer());
glUniformMatrix4fv(uniform_TM, 1, GL_FALSE, TextureMatrix.pointer()); glUniformMatrix4fv(uniform_TM, 1, GL_FALSE, TextureMatrix.pointer());
glUniformMatrix4fv(uniform_TIMV, 1, GL_FALSE, TransposeInverseModelView.pointer()); glUniformMatrix4fv(uniform_IMM, 1, GL_FALSE, InverseModelMatrix.pointer());
glUniform1i(uniform_tex, TU_tex); glUniform1i(uniform_tex, TU_tex);
} }
@ -493,8 +497,8 @@ namespace MeshShader
GLuint NormalMapShader::attrib_texcoord; GLuint NormalMapShader::attrib_texcoord;
GLuint NormalMapShader::attrib_tangent; GLuint NormalMapShader::attrib_tangent;
GLuint NormalMapShader::attrib_bitangent; GLuint NormalMapShader::attrib_bitangent;
GLuint NormalMapShader::uniform_MVP; GLuint NormalMapShader::uniform_MM;
GLuint NormalMapShader::uniform_TIMV; GLuint NormalMapShader::uniform_IMM;
GLuint NormalMapShader::uniform_normalMap; GLuint NormalMapShader::uniform_normalMap;
void NormalMapShader::init() void NormalMapShader::init()
@ -507,15 +511,17 @@ namespace MeshShader
attrib_texcoord = glGetAttribLocation(Program, "Texcoord"); attrib_texcoord = glGetAttribLocation(Program, "Texcoord");
attrib_tangent = glGetAttribLocation(Program, "Tangent"); attrib_tangent = glGetAttribLocation(Program, "Tangent");
attrib_bitangent = glGetAttribLocation(Program, "Bitangent"); attrib_bitangent = glGetAttribLocation(Program, "Bitangent");
uniform_MVP = glGetUniformLocation(Program, "ModelViewProjectionMatrix"); uniform_MM = glGetUniformLocation(Program, "ModelMatrix");
uniform_TIMV = glGetUniformLocation(Program, "TransposeInverseModelView"); uniform_IMM = glGetUniformLocation(Program, "InverseModelMatrix");
uniform_normalMap = glGetUniformLocation(Program, "normalMap"); uniform_normalMap = glGetUniformLocation(Program, "normalMap");
GLuint uniform_ViewProjectionMatrixesUBO = glGetUniformBlockIndex(Program, "MatrixesData");
glUniformBlockBinding(Program, uniform_ViewProjectionMatrixesUBO, 0);
} }
void NormalMapShader::setUniforms(const core::matrix4 &ModelViewProjectionMatrix, const core::matrix4 &TransposeInverseModelView, unsigned TU_normalMap) void NormalMapShader::setUniforms(const core::matrix4 &ModelMatrix, const core::matrix4 &InverseModelMatrix, unsigned TU_normalMap)
{ {
glUniformMatrix4fv(uniform_MVP, 1, GL_FALSE, ModelViewProjectionMatrix.pointer()); glUniformMatrix4fv(uniform_MM, 1, GL_FALSE, ModelMatrix.pointer());
glUniformMatrix4fv(uniform_TIMV, 1, GL_FALSE, TransposeInverseModelView.pointer()); glUniformMatrix4fv(uniform_IMM, 1, GL_FALSE, InverseModelMatrix.pointer());
glUniform1i(uniform_normalMap, TU_normalMap); glUniform1i(uniform_normalMap, TU_normalMap);
} }
@ -525,8 +531,6 @@ namespace MeshShader
GLuint InstancedObjectPass1Shader::attrib_orientation; GLuint InstancedObjectPass1Shader::attrib_orientation;
GLuint InstancedObjectPass1Shader::attrib_origin; GLuint InstancedObjectPass1Shader::attrib_origin;
GLuint InstancedObjectPass1Shader::attrib_scale; GLuint InstancedObjectPass1Shader::attrib_scale;
GLuint InstancedObjectPass1Shader::uniform_MP;
GLuint InstancedObjectPass1Shader::uniform_VM;
GLuint InstancedObjectPass1Shader::uniform_tex; GLuint InstancedObjectPass1Shader::uniform_tex;
void InstancedObjectPass1Shader::init() void InstancedObjectPass1Shader::init()
@ -541,15 +545,13 @@ namespace MeshShader
attrib_position = glGetAttribLocation(Program, "Position"); attrib_position = glGetAttribLocation(Program, "Position");
attrib_scale = glGetAttribLocation(Program, "Scale"); attrib_scale = glGetAttribLocation(Program, "Scale");
attrib_normal = glGetAttribLocation(Program, "Normal"); attrib_normal = glGetAttribLocation(Program, "Normal");
uniform_MP = glGetUniformLocation(Program, "ViewProjectionMatrix");
uniform_VM = glGetUniformLocation(Program, "InverseViewMatrix");
uniform_tex = glGetUniformLocation(Program, "tex"); uniform_tex = glGetUniformLocation(Program, "tex");
GLuint uniform_ViewProjectionMatrixesUBO = glGetUniformBlockIndex(Program, "MatrixesData");
glUniformBlockBinding(Program, uniform_ViewProjectionMatrixesUBO, 0);
} }
void InstancedObjectPass1Shader::setUniforms(const core::matrix4 &ModelViewProjectionMatrix, const core::matrix4 &ViewMatrix, unsigned TU_tex) void InstancedObjectPass1Shader::setUniforms(unsigned TU_tex)
{ {
glUniformMatrix4fv(uniform_MP, 1, GL_FALSE, ModelViewProjectionMatrix.pointer());
glUniformMatrix4fv(uniform_VM, 1, GL_FALSE, ViewMatrix.pointer());
glUniform1i(uniform_tex, TU_tex); glUniform1i(uniform_tex, TU_tex);
} }
@ -560,8 +562,6 @@ namespace MeshShader
GLuint InstancedObjectRefPass1Shader::attrib_orientation; GLuint InstancedObjectRefPass1Shader::attrib_orientation;
GLuint InstancedObjectRefPass1Shader::attrib_origin; GLuint InstancedObjectRefPass1Shader::attrib_origin;
GLuint InstancedObjectRefPass1Shader::attrib_scale; GLuint InstancedObjectRefPass1Shader::attrib_scale;
GLuint InstancedObjectRefPass1Shader::uniform_MP;
GLuint InstancedObjectRefPass1Shader::uniform_VM;
GLuint InstancedObjectRefPass1Shader::uniform_tex; GLuint InstancedObjectRefPass1Shader::uniform_tex;
void InstancedObjectRefPass1Shader::init() void InstancedObjectRefPass1Shader::init()
@ -577,15 +577,13 @@ namespace MeshShader
attrib_scale = glGetAttribLocation(Program, "Scale"); attrib_scale = glGetAttribLocation(Program, "Scale");
attrib_normal = glGetAttribLocation(Program, "Normal"); attrib_normal = glGetAttribLocation(Program, "Normal");
attrib_texcoord = glGetAttribLocation(Program, "Texcoord"); attrib_texcoord = glGetAttribLocation(Program, "Texcoord");
uniform_MP = glGetUniformLocation(Program, "ViewProjectionMatrix");
uniform_VM = glGetUniformLocation(Program, "InverseViewMatrix");
uniform_tex = glGetUniformLocation(Program, "tex"); uniform_tex = glGetUniformLocation(Program, "tex");
GLuint uniform_ViewProjectionMatrixesUBO = glGetUniformBlockIndex(Program, "MatrixesData");
glUniformBlockBinding(Program, uniform_ViewProjectionMatrixesUBO, 0);
} }
void InstancedObjectRefPass1Shader::setUniforms(const core::matrix4 &ModelViewProjectionMatrix, const core::matrix4 &ViewMatrix, unsigned TU_tex) void InstancedObjectRefPass1Shader::setUniforms(unsigned TU_tex)
{ {
glUniformMatrix4fv(uniform_MP, 1, GL_FALSE, ModelViewProjectionMatrix.pointer());
glUniformMatrix4fv(uniform_VM, 1, GL_FALSE, ViewMatrix.pointer());
glUniform1i(uniform_tex, TU_tex); glUniform1i(uniform_tex, TU_tex);
} }
@ -597,8 +595,6 @@ namespace MeshShader
GLuint InstancedGrassPass1Shader::attrib_scale; GLuint InstancedGrassPass1Shader::attrib_scale;
GLuint InstancedGrassPass1Shader::attrib_texcoord; GLuint InstancedGrassPass1Shader::attrib_texcoord;
GLuint InstancedGrassPass1Shader::attrib_color; GLuint InstancedGrassPass1Shader::attrib_color;
GLuint InstancedGrassPass1Shader::uniform_MP;
GLuint InstancedGrassPass1Shader::uniform_IVM;
GLuint InstancedGrassPass1Shader::uniform_windDir; GLuint InstancedGrassPass1Shader::uniform_windDir;
GLuint InstancedGrassPass1Shader::uniform_tex; GLuint InstancedGrassPass1Shader::uniform_tex;
@ -616,16 +612,14 @@ namespace MeshShader
attrib_normal = glGetAttribLocation(Program, "Normal"); attrib_normal = glGetAttribLocation(Program, "Normal");
attrib_color = glGetAttribLocation(Program, "Color"); attrib_color = glGetAttribLocation(Program, "Color");
attrib_texcoord = glGetAttribLocation(Program, "Texcoord"); attrib_texcoord = glGetAttribLocation(Program, "Texcoord");
uniform_MP = glGetUniformLocation(Program, "ViewProjectionMatrix");
uniform_IVM = glGetUniformLocation(Program, "InverseViewMatrix");
uniform_windDir = glGetUniformLocation(Program, "windDir"); uniform_windDir = glGetUniformLocation(Program, "windDir");
uniform_tex = glGetUniformLocation(Program, "tex"); uniform_tex = glGetUniformLocation(Program, "tex");
GLuint uniform_ViewProjectionMatrixesUBO = glGetUniformBlockIndex(Program, "MatrixesData");
glUniformBlockBinding(Program, uniform_ViewProjectionMatrixesUBO, 0);
} }
void InstancedGrassPass1Shader::setUniforms(const core::matrix4 &ModelViewProjectionMatrix, const core::matrix4 &InverseViewMatrix, const core::vector3df &windDir, unsigned TU_tex) void InstancedGrassPass1Shader::setUniforms(const core::vector3df &windDir, unsigned TU_tex)
{ {
glUniformMatrix4fv(uniform_MP, 1, GL_FALSE, ModelViewProjectionMatrix.pointer());
glUniformMatrix4fv(uniform_IVM, 1, GL_FALSE, InverseViewMatrix.pointer());
glUniform3f(uniform_windDir, windDir.X, windDir.Y, windDir.Z); glUniform3f(uniform_windDir, windDir.X, windDir.Y, windDir.Z);
glUniform1i(uniform_tex, TU_tex); glUniform1i(uniform_tex, TU_tex);
} }
@ -635,7 +629,7 @@ namespace MeshShader
GLuint ObjectPass2Shader::Program; GLuint ObjectPass2Shader::Program;
GLuint ObjectPass2Shader::attrib_position; GLuint ObjectPass2Shader::attrib_position;
GLuint ObjectPass2Shader::attrib_texcoord; GLuint ObjectPass2Shader::attrib_texcoord;
GLuint ObjectPass2Shader::uniform_MVP; GLuint ObjectPass2Shader::uniform_MM;
GLuint ObjectPass2Shader::uniform_TM; GLuint ObjectPass2Shader::uniform_TM;
GLuint ObjectPass2Shader::uniform_screen; GLuint ObjectPass2Shader::uniform_screen;
GLuint ObjectPass2Shader::uniform_ambient; GLuint ObjectPass2Shader::uniform_ambient;
@ -649,7 +643,7 @@ namespace MeshShader
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/object_pass2.frag").c_str()); GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/object_pass2.frag").c_str());
attrib_position = glGetAttribLocation(Program, "Position"); attrib_position = glGetAttribLocation(Program, "Position");
attrib_texcoord = glGetAttribLocation(Program, "Texcoord"); attrib_texcoord = glGetAttribLocation(Program, "Texcoord");
uniform_MVP = glGetUniformLocation(Program, "ModelViewProjectionMatrix"); uniform_MM = glGetUniformLocation(Program, "ModelMatrix");
uniform_TM = glGetUniformLocation(Program, "TextureMatrix"); uniform_TM = glGetUniformLocation(Program, "TextureMatrix");
GLuint uniform_Albedo = glGetUniformLocation(Program, "Albedo"); GLuint uniform_Albedo = glGetUniformLocation(Program, "Albedo");
GLuint uniform_DiffuseMap = glGetUniformLocation(Program, "DiffuseMap"); GLuint uniform_DiffuseMap = glGetUniformLocation(Program, "DiffuseMap");
@ -657,6 +651,8 @@ namespace MeshShader
GLuint uniform_SSAO = glGetUniformLocation(Program, "SSAO"); GLuint uniform_SSAO = glGetUniformLocation(Program, "SSAO");
uniform_screen = glGetUniformLocation(Program, "screen"); uniform_screen = glGetUniformLocation(Program, "screen");
uniform_ambient = glGetUniformLocation(Program, "ambient"); uniform_ambient = glGetUniformLocation(Program, "ambient");
GLuint uniform_ViewProjectionMatrixesUBO = glGetUniformBlockIndex(Program, "MatrixesData");
glUniformBlockBinding(Program, uniform_ViewProjectionMatrixesUBO, 0);
TU_Albedo = 3; TU_Albedo = 3;
glUseProgram(Program); glUseProgram(Program);
@ -667,9 +663,9 @@ namespace MeshShader
glUseProgram(0); glUseProgram(0);
} }
void ObjectPass2Shader::setUniforms(const core::matrix4 &ModelViewProjectionMatrix, const core::matrix4 &TextureMatrix) void ObjectPass2Shader::setUniforms(const core::matrix4 &ModelMatrix, const core::matrix4 &TextureMatrix)
{ {
glUniformMatrix4fv(uniform_MVP, 1, GL_FALSE, ModelViewProjectionMatrix.pointer()); glUniformMatrix4fv(uniform_MM, 1, GL_FALSE, ModelMatrix.pointer());
glUniformMatrix4fv(uniform_TM, 1, GL_FALSE, TextureMatrix.pointer()); glUniformMatrix4fv(uniform_TM, 1, GL_FALSE, TextureMatrix.pointer());
glUniform2f(uniform_screen, float(UserConfigParams::m_width), float(UserConfigParams::m_height)); glUniform2f(uniform_screen, float(UserConfigParams::m_width), float(UserConfigParams::m_height));
const video::SColorf s = irr_driver->getSceneManager()->getAmbientLight(); const video::SColorf s = irr_driver->getSceneManager()->getAmbientLight();
@ -716,6 +712,9 @@ namespace MeshShader
glUniform1i(uniform_SSAO, 2); glUniform1i(uniform_SSAO, 2);
glUniform1i(uniform_Albedo, TU_Albedo); glUniform1i(uniform_Albedo, TU_Albedo);
glUseProgram(0); glUseProgram(0);
GLuint uniform_ViewProjectionMatrixesUBO = glGetUniformBlockIndex(Program, "MatrixesData");
glUniformBlockBinding(Program, uniform_ViewProjectionMatrixesUBO, 0);
} }
void InstancedObjectPass2Shader::setUniforms(const core::matrix4 &ViewProjectionMatrix, const core::matrix4 &TextureMatrix) void InstancedObjectPass2Shader::setUniforms(const core::matrix4 &ViewProjectionMatrix, const core::matrix4 &TextureMatrix)
@ -767,6 +766,9 @@ namespace MeshShader
glUniform1i(uniform_SSAO, 2); glUniform1i(uniform_SSAO, 2);
glUniform1i(uniform_Albedo, TU_Albedo); glUniform1i(uniform_Albedo, TU_Albedo);
glUseProgram(0); glUseProgram(0);
GLuint uniform_ViewProjectionMatrixesUBO = glGetUniformBlockIndex(Program, "MatrixesData");
glUniformBlockBinding(Program, uniform_ViewProjectionMatrixesUBO, 0);
} }
void InstancedObjectRefPass2Shader::setUniforms(const core::matrix4 &ViewProjectionMatrix, const core::matrix4 &TextureMatrix) void InstancedObjectRefPass2Shader::setUniforms(const core::matrix4 &ViewProjectionMatrix, const core::matrix4 &TextureMatrix)
@ -782,7 +784,7 @@ namespace MeshShader
GLuint DetailledObjectPass2Shader::attrib_position; GLuint DetailledObjectPass2Shader::attrib_position;
GLuint DetailledObjectPass2Shader::attrib_texcoord; GLuint DetailledObjectPass2Shader::attrib_texcoord;
GLuint DetailledObjectPass2Shader::attrib_second_texcoord; GLuint DetailledObjectPass2Shader::attrib_second_texcoord;
GLuint DetailledObjectPass2Shader::uniform_MVP; GLuint DetailledObjectPass2Shader::uniform_MM;
GLuint DetailledObjectPass2Shader::uniform_screen; GLuint DetailledObjectPass2Shader::uniform_screen;
GLuint DetailledObjectPass2Shader::uniform_ambient; GLuint DetailledObjectPass2Shader::uniform_ambient;
GLuint DetailledObjectPass2Shader::TU_Albedo; GLuint DetailledObjectPass2Shader::TU_Albedo;
@ -797,7 +799,7 @@ namespace MeshShader
attrib_position = glGetAttribLocation(Program, "Position"); attrib_position = glGetAttribLocation(Program, "Position");
attrib_texcoord = glGetAttribLocation(Program, "Texcoord"); attrib_texcoord = glGetAttribLocation(Program, "Texcoord");
attrib_second_texcoord = glGetAttribLocation(Program, "SecondTexcoord"); attrib_second_texcoord = glGetAttribLocation(Program, "SecondTexcoord");
uniform_MVP = glGetUniformLocation(Program, "ModelViewProjectionMatrix"); uniform_MM = glGetUniformLocation(Program, "ModelMatrix");
GLuint uniform_Albedo = glGetUniformLocation(Program, "Albedo"); GLuint uniform_Albedo = glGetUniformLocation(Program, "Albedo");
GLuint uniform_Detail = glGetUniformLocation(Program, "Detail"); GLuint uniform_Detail = glGetUniformLocation(Program, "Detail");
GLuint uniform_DiffuseMap = glGetUniformLocation(Program, "DiffuseMap"); GLuint uniform_DiffuseMap = glGetUniformLocation(Program, "DiffuseMap");
@ -805,6 +807,8 @@ namespace MeshShader
GLuint uniform_SSAO = glGetUniformLocation(Program, "SSAO"); GLuint uniform_SSAO = glGetUniformLocation(Program, "SSAO");
uniform_screen = glGetUniformLocation(Program, "screen"); uniform_screen = glGetUniformLocation(Program, "screen");
uniform_ambient = glGetUniformLocation(Program, "ambient"); uniform_ambient = glGetUniformLocation(Program, "ambient");
GLuint uniform_ViewProjectionMatrixesUBO = glGetUniformBlockIndex(Program, "MatrixesData");
glUniformBlockBinding(Program, uniform_ViewProjectionMatrixesUBO, 0);
TU_Albedo = 3; TU_Albedo = 3;
TU_detail = 4; TU_detail = 4;
@ -815,6 +819,7 @@ namespace MeshShader
glUniform1i(uniform_Albedo, TU_Albedo); glUniform1i(uniform_Albedo, TU_Albedo);
glUniform1i(uniform_Detail, TU_detail); glUniform1i(uniform_Detail, TU_detail);
glUseProgram(0); glUseProgram(0);
<<<<<<< HEAD
} }
void DetailledObjectPass2Shader::setUniforms(const core::matrix4 &ModelViewProjectionMatrix) void DetailledObjectPass2Shader::setUniforms(const core::matrix4 &ModelViewProjectionMatrix)
@ -834,12 +839,35 @@ namespace MeshShader
void ObjectUnlitShader::init() void ObjectUnlitShader::init()
{ {
Program = LoadProgram( Program = LoadProgram(
=======
}
void DetailledObjectPass2Shader::setUniforms(const core::matrix4 &ModelMatrix)
{
glUniformMatrix4fv(uniform_MM, 1, GL_FALSE, ModelMatrix.pointer());
glUniform2f(uniform_screen, UserConfigParams::m_width, UserConfigParams::m_height);
const video::SColorf s = irr_driver->getSceneManager()->getAmbientLight();
glUniform3f(uniform_ambient, s.r, s.g, s.b);
}
GLuint ObjectUnlitShader::Program;
GLuint ObjectUnlitShader::attrib_position;
GLuint ObjectUnlitShader::attrib_texcoord;
GLuint ObjectUnlitShader::uniform_MM;
GLuint ObjectUnlitShader::TU_tex;
void ObjectUnlitShader::init()
{
Program = LoadProgram(
>>>>>>> cbc677febb2646c09ebc13a778ce0bdf4f7a2442
GL_VERTEX_SHADER, file_manager->getAsset("shaders/object_pass.vert").c_str(), GL_VERTEX_SHADER, file_manager->getAsset("shaders/object_pass.vert").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/object_unlit.frag").c_str()); GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/object_unlit.frag").c_str());
attrib_position = glGetAttribLocation(Program, "Position"); attrib_position = glGetAttribLocation(Program, "Position");
attrib_texcoord = glGetAttribLocation(Program, "Texcoord"); attrib_texcoord = glGetAttribLocation(Program, "Texcoord");
uniform_MVP = glGetUniformLocation(Program, "ModelViewProjectionMatrix"); uniform_MM = glGetUniformLocation(Program, "ModelMatrix");
GLuint uniform_tex = glGetUniformLocation(Program, "tex"); GLuint uniform_tex = glGetUniformLocation(Program, "tex");
GLuint uniform_ViewProjectionMatrixesUBO = glGetUniformBlockIndex(Program, "MatrixesData");
glUniformBlockBinding(Program, uniform_ViewProjectionMatrixesUBO, 0);
TU_tex = 3; TU_tex = 3;
glUseProgram(Program); glUseProgram(Program);
@ -847,17 +875,17 @@ namespace MeshShader
glUseProgram(0); glUseProgram(0);
} }
void ObjectUnlitShader::setUniforms(const core::matrix4 &ModelViewProjectionMatrix) void ObjectUnlitShader::setUniforms(const core::matrix4 &ModelMatrix)
{ {
glUniformMatrix4fv(uniform_MVP, 1, GL_FALSE, ModelViewProjectionMatrix.pointer()); glUniformMatrix4fv(uniform_MM, 1, GL_FALSE, ModelMatrix.pointer());
} }
GLuint ObjectRimLimitShader::Program; GLuint ObjectRimLimitShader::Program;
GLuint ObjectRimLimitShader::attrib_position; GLuint ObjectRimLimitShader::attrib_position;
GLuint ObjectRimLimitShader::attrib_texcoord; GLuint ObjectRimLimitShader::attrib_texcoord;
GLuint ObjectRimLimitShader::attrib_normal; GLuint ObjectRimLimitShader::attrib_normal;
GLuint ObjectRimLimitShader::uniform_MVP; GLuint ObjectRimLimitShader::uniform_MM;
GLuint ObjectRimLimitShader::uniform_TIMV; GLuint ObjectRimLimitShader::uniform_IMM;
GLuint ObjectRimLimitShader::uniform_TM; GLuint ObjectRimLimitShader::uniform_TM;
GLuint ObjectRimLimitShader::uniform_screen; GLuint ObjectRimLimitShader::uniform_screen;
GLuint ObjectRimLimitShader::uniform_ambient; GLuint ObjectRimLimitShader::uniform_ambient;
@ -866,13 +894,13 @@ namespace MeshShader
void ObjectRimLimitShader::init() void ObjectRimLimitShader::init()
{ {
Program = LoadProgram( Program = LoadProgram(
GL_VERTEX_SHADER, file_manager->getAsset("shaders/objectpass_rimlit.vert").c_str(), GL_VERTEX_SHADER, file_manager->getAsset("shaders/object_pass.vert").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/objectpass_rimlit.frag").c_str()); GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/objectpass_rimlit.frag").c_str());
attrib_position = glGetAttribLocation(Program, "Position"); attrib_position = glGetAttribLocation(Program, "Position");
attrib_texcoord = glGetAttribLocation(Program, "Texcoord"); attrib_texcoord = glGetAttribLocation(Program, "Texcoord");
attrib_normal = glGetAttribLocation(Program, "Normal"); attrib_normal = glGetAttribLocation(Program, "Normal");
uniform_MVP = glGetUniformLocation(Program, "ModelViewProjectionMatrix"); uniform_MM = glGetUniformLocation(Program, "ModelMatrix");
uniform_TIMV = glGetUniformLocation(Program, "TransposeInverseModelView"); uniform_IMM = glGetUniformLocation(Program, "InverseModelMatrix");
uniform_TM = glGetUniformLocation(Program, "TextureMatrix"); uniform_TM = glGetUniformLocation(Program, "TextureMatrix");
GLuint uniform_Albedo = glGetUniformLocation(Program, "Albedo"); GLuint uniform_Albedo = glGetUniformLocation(Program, "Albedo");
GLuint uniform_DiffuseMap = glGetUniformLocation(Program, "DiffuseMap"); GLuint uniform_DiffuseMap = glGetUniformLocation(Program, "DiffuseMap");
@ -880,6 +908,9 @@ namespace MeshShader
GLuint uniform_SSAO = glGetUniformLocation(Program, "SSAO"); GLuint uniform_SSAO = glGetUniformLocation(Program, "SSAO");
uniform_screen = glGetUniformLocation(Program, "screen"); uniform_screen = glGetUniformLocation(Program, "screen");
uniform_ambient = glGetUniformLocation(Program, "ambient"); uniform_ambient = glGetUniformLocation(Program, "ambient");
GLuint uniform_tex = glGetUniformLocation(Program, "tex");
GLuint uniform_ViewProjectionMatrixesUBO = glGetUniformBlockIndex(Program, "MatrixesData");
glUniformBlockBinding(Program, uniform_ViewProjectionMatrixesUBO, 0);
TU_Albedo = 3; TU_Albedo = 3;
glUseProgram(Program); glUseProgram(Program);
@ -890,11 +921,12 @@ namespace MeshShader
glUseProgram(0); glUseProgram(0);
} }
void ObjectRimLimitShader::setUniforms(const core::matrix4 &ModelViewProjectionMatrix, const core::matrix4 &TransposeInverseModelView, const core::matrix4 &TextureMatrix) void ObjectRimLimitShader::setUniforms(const core::matrix4 &ModelMatrix, const core::matrix4 &InverseModelMatrix, const core::matrix4 &TextureMatrix)
{ {
glUniformMatrix4fv(uniform_MVP, 1, GL_FALSE, ModelViewProjectionMatrix.pointer()); glUniformMatrix4fv(uniform_MM, 1, GL_FALSE, ModelMatrix.pointer());
glUniformMatrix4fv(uniform_TIMV, 1, GL_FALSE, TransposeInverseModelView.pointer()); glUniformMatrix4fv(uniform_IMM, 1, GL_FALSE, InverseModelMatrix.pointer());
glUniformMatrix4fv(uniform_TM, 1, GL_FALSE, TextureMatrix.pointer()); glUniformMatrix4fv(uniform_TM, 1, GL_FALSE, TextureMatrix.pointer());
<<<<<<< HEAD
glUniform2f(uniform_screen, float(UserConfigParams::m_width), float(UserConfigParams::m_height)); glUniform2f(uniform_screen, float(UserConfigParams::m_width), float(UserConfigParams::m_height));
const video::SColorf s = irr_driver->getSceneManager()->getAmbientLight(); const video::SColorf s = irr_driver->getSceneManager()->getAmbientLight();
glUniform3f(uniform_ambient, s.r, s.g, s.b); glUniform3f(uniform_ambient, s.r, s.g, s.b);
@ -942,6 +974,57 @@ namespace MeshShader
GLuint ObjectRefPass2Shader::attrib_position; GLuint ObjectRefPass2Shader::attrib_position;
GLuint ObjectRefPass2Shader::attrib_texcoord; GLuint ObjectRefPass2Shader::attrib_texcoord;
GLuint ObjectRefPass2Shader::uniform_MVP; GLuint ObjectRefPass2Shader::uniform_MVP;
=======
glUniform2f(uniform_screen, UserConfigParams::m_width, UserConfigParams::m_height);
const video::SColorf s = irr_driver->getSceneManager()->getAmbientLight();
glUniform3f(uniform_ambient, s.r, s.g, s.b);
}
GLuint UntexturedObjectShader::Program;
GLuint UntexturedObjectShader::attrib_position;
GLuint UntexturedObjectShader::attrib_color;
GLuint UntexturedObjectShader::uniform_MM;
GLuint UntexturedObjectShader::uniform_screen;
GLuint UntexturedObjectShader::uniform_ambient;
void UntexturedObjectShader::init()
{
Program = LoadProgram(
GL_VERTEX_SHADER, file_manager->getAsset("shaders/object_pass.vert").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/utils/getLightFactor.frag").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/untextured_object.frag").c_str());
attrib_position = glGetAttribLocation(Program, "Position");
attrib_color = glGetAttribLocation(Program, "Color");
uniform_MM = glGetUniformLocation(Program, "ModelMatrix");
GLuint uniform_DiffuseMap = glGetUniformLocation(Program, "DiffuseMap");
GLuint uniform_SpecularMap = glGetUniformLocation(Program, "SpecularMap");
GLuint uniform_SSAO = glGetUniformLocation(Program, "SSAO");
uniform_screen = glGetUniformLocation(Program, "screen");
uniform_ambient = glGetUniformLocation(Program, "ambient");
GLuint uniform_ViewProjectionMatrixesUBO = glGetUniformBlockIndex(Program, "MatrixesData");
glUniformBlockBinding(Program, uniform_ViewProjectionMatrixesUBO, 0);
glUseProgram(Program);
glUniform1i(uniform_DiffuseMap, 0);
glUniform1i(uniform_SpecularMap, 1);
glUniform1i(uniform_SSAO, 2);
glUseProgram(0);
}
void UntexturedObjectShader::setUniforms(const core::matrix4 &ModelMatrix)
{
glUniformMatrix4fv(uniform_MM, 1, GL_FALSE, ModelMatrix.pointer());
glUniform2f(uniform_screen, UserConfigParams::m_width, UserConfigParams::m_height);
const video::SColorf s = irr_driver->getSceneManager()->getAmbientLight();
glUniform3f(uniform_ambient, s.r, s.g, s.b);
}
GLuint ObjectRefPass2Shader::Program;
GLuint ObjectRefPass2Shader::attrib_position;
GLuint ObjectRefPass2Shader::attrib_texcoord;
GLuint ObjectRefPass2Shader::uniform_MM;
>>>>>>> cbc677febb2646c09ebc13a778ce0bdf4f7a2442
GLuint ObjectRefPass2Shader::uniform_TM; GLuint ObjectRefPass2Shader::uniform_TM;
GLuint ObjectRefPass2Shader::uniform_screen; GLuint ObjectRefPass2Shader::uniform_screen;
GLuint ObjectRefPass2Shader::uniform_ambient; GLuint ObjectRefPass2Shader::uniform_ambient;
@ -956,7 +1039,7 @@ namespace MeshShader
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/objectref_pass2.frag").c_str()); GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/objectref_pass2.frag").c_str());
attrib_position = glGetAttribLocation(Program, "Position"); attrib_position = glGetAttribLocation(Program, "Position");
attrib_texcoord = glGetAttribLocation(Program, "Texcoord"); attrib_texcoord = glGetAttribLocation(Program, "Texcoord");
uniform_MVP = glGetUniformLocation(Program, "ModelViewProjectionMatrix"); uniform_MM = glGetUniformLocation(Program, "ModelMatrix");
uniform_TM = glGetUniformLocation(Program, "TextureMatrix"); uniform_TM = glGetUniformLocation(Program, "TextureMatrix");
GLuint uniform_Albedo = glGetUniformLocation(Program, "Albedo"); GLuint uniform_Albedo = glGetUniformLocation(Program, "Albedo");
GLuint uniform_DiffuseMap = glGetUniformLocation(Program, "DiffuseMap"); GLuint uniform_DiffuseMap = glGetUniformLocation(Program, "DiffuseMap");
@ -964,6 +1047,8 @@ namespace MeshShader
GLuint uniform_SSAO = glGetUniformLocation(Program, "SSAO"); GLuint uniform_SSAO = glGetUniformLocation(Program, "SSAO");
uniform_screen = glGetUniformLocation(Program, "screen"); uniform_screen = glGetUniformLocation(Program, "screen");
uniform_ambient = glGetUniformLocation(Program, "ambient"); uniform_ambient = glGetUniformLocation(Program, "ambient");
GLuint uniform_ViewProjectionMatrixesUBO = glGetUniformBlockIndex(Program, "MatrixesData");
glUniformBlockBinding(Program, uniform_ViewProjectionMatrixesUBO, 0);
TU_Albedo = 3; TU_Albedo = 3;
glUseProgram(Program); glUseProgram(Program);
@ -974,10 +1059,11 @@ namespace MeshShader
glUseProgram(0); glUseProgram(0);
} }
void ObjectRefPass2Shader::setUniforms(const core::matrix4 &ModelViewProjectionMatrix, const core::matrix4 &TextureMatrix) void ObjectRefPass2Shader::setUniforms(const core::matrix4 &ModelMatrix, const core::matrix4 &TextureMatrix)
{ {
glUniformMatrix4fv(uniform_MVP, 1, GL_FALSE, ModelViewProjectionMatrix.pointer()); glUniformMatrix4fv(uniform_MM, 1, GL_FALSE, ModelMatrix.pointer());
glUniformMatrix4fv(uniform_TM, 1, GL_FALSE, TextureMatrix.pointer()); glUniformMatrix4fv(uniform_TM, 1, GL_FALSE, TextureMatrix.pointer());
<<<<<<< HEAD
glUniform2f(uniform_screen, float(UserConfigParams::m_width), float(UserConfigParams::m_height)); glUniform2f(uniform_screen, float(UserConfigParams::m_width), float(UserConfigParams::m_height));
const video::SColorf s = irr_driver->getSceneManager()->getAmbientLight(); const video::SColorf s = irr_driver->getSceneManager()->getAmbientLight();
glUniform3f(uniform_ambient, s.r, s.g, s.b); glUniform3f(uniform_ambient, s.r, s.g, s.b);
@ -991,6 +1077,21 @@ namespace MeshShader
GLuint GrassPass2Shader::uniform_screen; GLuint GrassPass2Shader::uniform_screen;
GLuint GrassPass2Shader::uniform_ambient; GLuint GrassPass2Shader::uniform_ambient;
GLuint GrassPass2Shader::uniform_windDir; GLuint GrassPass2Shader::uniform_windDir;
=======
glUniform2f(uniform_screen, UserConfigParams::m_width, UserConfigParams::m_height);
const video::SColorf s = irr_driver->getSceneManager()->getAmbientLight();
glUniform3f(uniform_ambient, s.r, s.g, s.b);
}
GLuint GrassPass2Shader::Program;
GLuint GrassPass2Shader::attrib_position;
GLuint GrassPass2Shader::attrib_texcoord;
GLuint GrassPass2Shader::attrib_color;
GLuint GrassPass2Shader::uniform_MVP;
GLuint GrassPass2Shader::uniform_screen;
GLuint GrassPass2Shader::uniform_ambient;
GLuint GrassPass2Shader::uniform_windDir;
>>>>>>> cbc677febb2646c09ebc13a778ce0bdf4f7a2442
GLuint GrassPass2Shader::TU_Albedo; GLuint GrassPass2Shader::TU_Albedo;
void GrassPass2Shader::init() void GrassPass2Shader::init()
@ -1020,6 +1121,7 @@ namespace MeshShader
glUseProgram(0); glUseProgram(0);
} }
<<<<<<< HEAD
void GrassPass2Shader::setUniforms(const core::matrix4 &ModelViewProjectionMatrix, const core::vector3df &windDirection) void GrassPass2Shader::setUniforms(const core::matrix4 &ModelViewProjectionMatrix, const core::vector3df &windDirection)
{ {
glUniformMatrix4fv(uniform_MVP, 1, GL_FALSE, ModelViewProjectionMatrix.pointer()); glUniformMatrix4fv(uniform_MVP, 1, GL_FALSE, ModelViewProjectionMatrix.pointer());
@ -1028,6 +1130,16 @@ namespace MeshShader
glUniform3f(uniform_ambient, s.r, s.g, s.b); glUniform3f(uniform_ambient, s.r, s.g, s.b);
glUniform3f(uniform_windDir, windDirection.X, windDirection.Y, windDirection.Z); glUniform3f(uniform_windDir, windDirection.X, windDirection.Y, windDirection.Z);
} }
=======
void GrassPass2Shader::setUniforms(const core::matrix4 &ModelViewProjectionMatrix, const core::vector3df &windDirection)
{
glUniformMatrix4fv(uniform_MVP, 1, GL_FALSE, ModelViewProjectionMatrix.pointer());
glUniform2f(uniform_screen, UserConfigParams::m_width, UserConfigParams::m_height);
const video::SColorf s = irr_driver->getSceneManager()->getAmbientLight();
glUniform3f(uniform_ambient, s.r, s.g, s.b);
glUniform3f(uniform_windDir, windDirection.X, windDirection.Y, windDirection.Z);
}
>>>>>>> cbc677febb2646c09ebc13a778ce0bdf4f7a2442
GLuint InstancedGrassPass2Shader::Program; GLuint InstancedGrassPass2Shader::Program;
GLuint InstancedGrassPass2Shader::attrib_position; GLuint InstancedGrassPass2Shader::attrib_position;
@ -1083,6 +1195,9 @@ namespace MeshShader
glUniform1i(uniform_Albedo, TU_Albedo); glUniform1i(uniform_Albedo, TU_Albedo);
glUniform1i(uniform_dtex, TU_dtex); glUniform1i(uniform_dtex, TU_dtex);
glUseProgram(0); glUseProgram(0);
GLuint uniform_ViewProjectionMatrixesUBO = glGetUniformBlockIndex(Program, "MatrixesData");
glUniformBlockBinding(Program, uniform_ViewProjectionMatrixesUBO, 0);
} }
void InstancedGrassPass2Shader::setUniforms(const core::matrix4 &ViewProjectionMatrix, const core::matrix4 &InverseViewMatrix, const core::matrix4 &invproj, const core::vector3df &windDirection, const core::vector3df &SunDir) void InstancedGrassPass2Shader::setUniforms(const core::matrix4 &ViewProjectionMatrix, const core::matrix4 &InverseViewMatrix, const core::matrix4 &invproj, const core::vector3df &windDirection, const core::vector3df &SunDir)
@ -1100,10 +1215,8 @@ namespace MeshShader
GLuint SphereMapShader::Program; GLuint SphereMapShader::Program;
GLuint SphereMapShader::attrib_position; GLuint SphereMapShader::attrib_position;
GLuint SphereMapShader::attrib_normal; GLuint SphereMapShader::attrib_normal;
GLuint SphereMapShader::uniform_MVP; GLuint SphereMapShader::uniform_MM;
GLuint SphereMapShader::uniform_TIMV; GLuint SphereMapShader::uniform_IMM;
GLuint SphereMapShader::uniform_TVM;
GLuint SphereMapShader::uniform_invproj;
GLuint SphereMapShader::uniform_screen; GLuint SphereMapShader::uniform_screen;
GLuint SphereMapShader::TU_tex; GLuint SphereMapShader::TU_tex;
@ -1114,11 +1227,9 @@ namespace MeshShader
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/objectpass_spheremap.frag").c_str()); GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/objectpass_spheremap.frag").c_str());
attrib_position = glGetAttribLocation(Program, "Position"); attrib_position = glGetAttribLocation(Program, "Position");
attrib_normal = glGetAttribLocation(Program, "Normal"); attrib_normal = glGetAttribLocation(Program, "Normal");
uniform_MVP = glGetUniformLocation(Program, "ModelViewProjectionMatrix"); uniform_MM = glGetUniformLocation(Program, "ModelMatrix");
uniform_TIMV = glGetUniformLocation(Program, "TransposeInverseModelView"); uniform_IMM = glGetUniformLocation(Program, "InverseModelMatrix");
uniform_TVM = glGetUniformLocation(Program, "TransposeViewMatrix");
GLuint uniform_tex = glGetUniformLocation(Program, "tex"); GLuint uniform_tex = glGetUniformLocation(Program, "tex");
uniform_invproj = glGetUniformLocation(Program, "invproj");
uniform_screen = glGetUniformLocation(Program, "screen"); uniform_screen = glGetUniformLocation(Program, "screen");
TU_tex = 3; TU_tex = 3;
@ -1127,12 +1238,10 @@ namespace MeshShader
glUseProgram(0); glUseProgram(0);
} }
void SphereMapShader::setUniforms(const core::matrix4 &ModelViewProjectionMatrix, const core::matrix4 &TransposeViewMatrix, const core::matrix4 &TransposeInverseModelView, const core::matrix4 &InvProj, const core::vector2df& screen) void SphereMapShader::setUniforms(const core::matrix4 &ModelMatrix, const core::matrix4 &InverseModelMatrix, const core::vector2df& screen)
{ {
glUniformMatrix4fv(uniform_MVP, 1, GL_FALSE, ModelViewProjectionMatrix.pointer()); glUniformMatrix4fv(uniform_MM, 1, GL_FALSE, ModelMatrix.pointer());
glUniformMatrix4fv(uniform_TIMV, 1, GL_FALSE, TransposeInverseModelView.pointer()); glUniformMatrix4fv(uniform_IMM, 1, GL_FALSE, InverseModelMatrix.pointer());
glUniformMatrix4fv(uniform_TVM, 1, GL_FALSE, TransposeViewMatrix.pointer());
glUniformMatrix4fv(uniform_invproj, 1, GL_FALSE, InvProj.pointer());
glUniform2f(uniform_screen, screen.X, screen.Y); glUniform2f(uniform_screen, screen.X, screen.Y);
} }
@ -1140,7 +1249,7 @@ namespace MeshShader
GLuint SplattingShader::attrib_position; GLuint SplattingShader::attrib_position;
GLuint SplattingShader::attrib_texcoord; GLuint SplattingShader::attrib_texcoord;
GLuint SplattingShader::attrib_second_texcoord; GLuint SplattingShader::attrib_second_texcoord;
GLuint SplattingShader::uniform_MVP; GLuint SplattingShader::uniform_MM;
GLuint SplattingShader::uniform_screen; GLuint SplattingShader::uniform_screen;
GLuint SplattingShader::uniform_ambient; GLuint SplattingShader::uniform_ambient;
GLuint SplattingShader::TU_tex_layout; GLuint SplattingShader::TU_tex_layout;
@ -1152,12 +1261,12 @@ namespace MeshShader
void SplattingShader::init() void SplattingShader::init()
{ {
Program = LoadProgram( Program = LoadProgram(
GL_VERTEX_SHADER, file_manager->getAsset("shaders/splatting.vert").c_str(), GL_VERTEX_SHADER, file_manager->getAsset("shaders/object_pass.vert").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/splatting.frag").c_str()); GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/splatting.frag").c_str());
attrib_position = glGetAttribLocation(Program, "Position"); attrib_position = glGetAttribLocation(Program, "Position");
attrib_texcoord = glGetAttribLocation(Program, "Texcoord"); attrib_texcoord = glGetAttribLocation(Program, "Texcoord");
attrib_second_texcoord = glGetAttribLocation(Program, "SecondTexcoord"); attrib_second_texcoord = glGetAttribLocation(Program, "SecondTexcoord");
uniform_MVP = glGetUniformLocation(Program, "ModelViewProjectionMatrix"); uniform_MM = glGetUniformLocation(Program, "ModelMatrix");
GLuint uniform_tex_layout = glGetUniformLocation(Program, "tex_layout"); GLuint uniform_tex_layout = glGetUniformLocation(Program, "tex_layout");
GLuint uniform_tex_detail0 = glGetUniformLocation(Program, "tex_detail0"); GLuint uniform_tex_detail0 = glGetUniformLocation(Program, "tex_detail0");
GLuint uniform_tex_detail1 = glGetUniformLocation(Program, "tex_detail1"); GLuint uniform_tex_detail1 = glGetUniformLocation(Program, "tex_detail1");
@ -1186,6 +1295,7 @@ namespace MeshShader
glUseProgram(0); glUseProgram(0);
} }
<<<<<<< HEAD
void SplattingShader::setUniforms(const core::matrix4 &ModelViewProjectionMatrix) void SplattingShader::setUniforms(const core::matrix4 &ModelViewProjectionMatrix)
{ {
glUniformMatrix4fv(uniform_MVP, 1, GL_FALSE, ModelViewProjectionMatrix.pointer()); glUniformMatrix4fv(uniform_MVP, 1, GL_FALSE, ModelViewProjectionMatrix.pointer());
@ -1193,6 +1303,15 @@ namespace MeshShader
const video::SColorf s = irr_driver->getSceneManager()->getAmbientLight(); const video::SColorf s = irr_driver->getSceneManager()->getAmbientLight();
glUniform3f(uniform_ambient, s.r, s.g, s.b); glUniform3f(uniform_ambient, s.r, s.g, s.b);
} }
=======
void SplattingShader::setUniforms(const core::matrix4 &ModelMatrix)
{
glUniformMatrix4fv(uniform_MM, 1, GL_FALSE, ModelMatrix.pointer());
glUniform2f(uniform_screen, UserConfigParams::m_width, UserConfigParams::m_height);
const video::SColorf s = irr_driver->getSceneManager()->getAmbientLight();
glUniform3f(uniform_ambient, s.r, s.g, s.b);
}
>>>>>>> cbc677febb2646c09ebc13a778ce0bdf4f7a2442
GLuint CausticsShader::Program; GLuint CausticsShader::Program;
GLuint CausticsShader::attrib_position; GLuint CausticsShader::attrib_position;
@ -1626,10 +1745,9 @@ namespace MeshShader
GLuint SkyboxShader::Program; GLuint SkyboxShader::Program;
GLuint SkyboxShader::attrib_position; GLuint SkyboxShader::attrib_position;
GLuint SkyboxShader::uniform_MVP; GLuint SkyboxShader::uniform_MM;
GLuint SkyboxShader::uniform_tex; GLuint SkyboxShader::uniform_tex;
GLuint SkyboxShader::uniform_screen; GLuint SkyboxShader::uniform_screen;
GLuint SkyboxShader::uniform_InvProjView;
GLuint SkyboxShader::cubevao; GLuint SkyboxShader::cubevao;
void SkyboxShader::init() void SkyboxShader::init()
@ -1638,10 +1756,11 @@ namespace MeshShader
GL_VERTEX_SHADER, file_manager->getAsset("shaders/object_pass.vert").c_str(), GL_VERTEX_SHADER, file_manager->getAsset("shaders/object_pass.vert").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/sky.frag").c_str()); GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/sky.frag").c_str());
attrib_position = glGetAttribLocation(Program, "Position"); attrib_position = glGetAttribLocation(Program, "Position");
uniform_MVP = glGetUniformLocation(Program, "ModelViewProjectionMatrix"); uniform_MM = glGetUniformLocation(Program, "ModelMatrix");
uniform_InvProjView = glGetUniformLocation(Program, "InvProjView");
uniform_tex = glGetUniformLocation(Program, "tex"); uniform_tex = glGetUniformLocation(Program, "tex");
uniform_screen = glGetUniformLocation(Program, "screen"); uniform_screen = glGetUniformLocation(Program, "screen");
GLuint uniform_ViewProjectionMatrixesUBO = glGetUniformBlockIndex(Program, "MatrixesData");
glUniformBlockBinding(Program, uniform_ViewProjectionMatrixesUBO, 0);
glGenVertexArrays(1, &cubevao); glGenVertexArrays(1, &cubevao);
glBindVertexArray(cubevao); glBindVertexArray(cubevao);
@ -1652,10 +1771,9 @@ namespace MeshShader
glBindVertexArray(0); glBindVertexArray(0);
} }
void SkyboxShader::setUniforms(const core::matrix4 &ModelViewProjectionMatrix, const core::matrix4 &InvProjView, const core::vector2df &screen, unsigned TU_tex) void SkyboxShader::setUniforms(const core::matrix4 &ModelMatrix, const core::vector2df &screen, unsigned TU_tex)
{ {
glUniformMatrix4fv(uniform_MVP, 1, GL_FALSE, ModelViewProjectionMatrix.pointer()); glUniformMatrix4fv(uniform_MM, 1, GL_FALSE, ModelMatrix.pointer());
glUniformMatrix4fv(uniform_InvProjView, 1, GL_FALSE, InvProjView.pointer());
glUniform1i(uniform_tex, TU_tex); glUniform1i(uniform_tex, TU_tex);
glUniform2f(uniform_screen, screen.X, screen.Y); glUniform2f(uniform_screen, screen.X, screen.Y);
} }
@ -2365,7 +2483,7 @@ namespace FullScreenShader
SSAOSamples[63] = 0.772942f; SSAOSamples[63] = 0.772942f;
// Generate another random distribution, if needed // Generate another random distribution, if needed
/* for (unsigned i = 0; i < 16; i++) { /* for (unsigned i = 0; i < 16; i++) {
// Use double to avoid denorm and get a true uniform distribution // Use double to avoid denorm and get a true uniform distribution
// Generate z component between [0.1; 1] to avoid being too close from surface // Generate z component between [0.1; 1] to avoid being too close from surface
double z = rand(); double z = rand();

60
src/graphics/shaders.hpp
View File

@ -39,10 +39,10 @@ class ObjectPass1Shader
public: public:
static GLuint Program; static GLuint Program;
static GLuint attrib_position, attrib_texcoord, attrib_normal; static GLuint attrib_position, attrib_texcoord, attrib_normal;
static GLuint uniform_MVP, uniform_TIMV, uniform_tex; static GLuint uniform_MM, uniform_IMM, uniform_tex;
static void init(); static void init();
static void setUniforms(const core::matrix4 &ModelViewProjectionMatrix, const core::matrix4 &TransposeInverseModelView, unsigned TU_tex); static void setUniforms(const core::matrix4 &ModelMatrix, const core::matrix4 &InverseModelMatrix, unsigned TU_tex);
}; };
class ObjectRefPass1Shader class ObjectRefPass1Shader
@ -50,10 +50,10 @@ class ObjectRefPass1Shader
public: public:
static GLuint Program; static GLuint Program;
static GLuint attrib_position, attrib_normal, attrib_texcoord; static GLuint attrib_position, attrib_normal, attrib_texcoord;
static GLuint uniform_MVP, uniform_TM, uniform_TIMV, uniform_tex; static GLuint uniform_MM, uniform_TM, uniform_IMM, uniform_tex;
static void init(); static void init();
static void setUniforms(const core::matrix4 &ModelViewProjectionMatrix, const core::matrix4 &TransposeInverseModelView, const core::matrix4 &TextureMatrix, unsigned TU_texture); static void setUniforms(const core::matrix4 &ModelMatrix, const core::matrix4 &InverseModelMatrix, const core::matrix4 &TextureMatrix, unsigned TU_texture);
}; };
class GrassPass1Shader class GrassPass1Shader
@ -72,10 +72,10 @@ class NormalMapShader
public: public:
static GLuint Program; static GLuint Program;
static GLuint attrib_position, attrib_texcoord, attrib_tangent, attrib_bitangent; static GLuint attrib_position, attrib_texcoord, attrib_tangent, attrib_bitangent;
static GLuint uniform_MVP, uniform_TIMV, uniform_normalMap; static GLuint uniform_MM, uniform_IMM, uniform_normalMap;
static void init(); static void init();
static void setUniforms(const core::matrix4 &ModelViewProjectionMatrix, const core::matrix4 &TransposeInverseModelView, unsigned TU_normalMap); static void setUniforms(const core::matrix4 &ModelMatrix, const core::matrix4 &InverseModelMatrix, unsigned TU_normalMap);
}; };
class InstancedObjectPass1Shader class InstancedObjectPass1Shader
@ -83,10 +83,10 @@ class InstancedObjectPass1Shader
public: public:
static GLuint Program; static GLuint Program;
static GLuint attrib_position, attrib_normal, attrib_origin, attrib_orientation, attrib_scale; static GLuint attrib_position, attrib_normal, attrib_origin, attrib_orientation, attrib_scale;
static GLuint uniform_MP, uniform_VM, uniform_tex; static GLuint uniform_tex;
static void init(); static void init();
static void setUniforms(const core::matrix4 &ViewProjectionMatrix, const core::matrix4 &ViewMatrix, unsigned TU_tex); static void setUniforms(unsigned TU_tex);
}; };
class InstancedObjectRefPass1Shader class InstancedObjectRefPass1Shader
@ -94,10 +94,10 @@ class InstancedObjectRefPass1Shader
public: public:
static GLuint Program; static GLuint Program;
static GLuint attrib_position, attrib_normal, attrib_texcoord, attrib_origin, attrib_orientation, attrib_scale; static GLuint attrib_position, attrib_normal, attrib_texcoord, attrib_origin, attrib_orientation, attrib_scale;
static GLuint uniform_MP, uniform_VM, uniform_tex; static GLuint uniform_tex;
static void init(); static void init();
static void setUniforms(const core::matrix4 &ViewProjectionMatrix, const core::matrix4 &ViewMatrix, unsigned TU_tex); static void setUniforms(unsigned TU_tex);
}; };
class InstancedGrassPass1Shader class InstancedGrassPass1Shader
@ -105,10 +105,10 @@ class InstancedGrassPass1Shader
public: public:
static GLuint Program; static GLuint Program;
static GLuint attrib_position, attrib_normal, attrib_origin, attrib_orientation, attrib_scale, attrib_color, attrib_texcoord; static GLuint attrib_position, attrib_normal, attrib_origin, attrib_orientation, attrib_scale, attrib_color, attrib_texcoord;
static GLuint uniform_MP, uniform_IVM, uniform_windDir, uniform_tex; static GLuint uniform_windDir, uniform_tex;
static void init(); static void init();
static void setUniforms(const core::matrix4 &ViewProjectionMatrix, const core::matrix4 &InverseViewMatrix, const core::vector3df &windDir, unsigned TU_tex); static void setUniforms(const core::vector3df &windDir, unsigned TU_tex);
}; };
class ObjectPass2Shader class ObjectPass2Shader
@ -116,11 +116,11 @@ class ObjectPass2Shader
public: public:
static GLuint Program; static GLuint Program;
static GLuint attrib_position, attrib_texcoord; static GLuint attrib_position, attrib_texcoord;
static GLuint uniform_MVP, uniform_TM, uniform_screen, uniform_ambient; static GLuint uniform_MM, uniform_TM, uniform_screen, uniform_ambient;
static GLuint TU_Albedo; static GLuint TU_Albedo;
static void init(); static void init();
static void setUniforms(const core::matrix4 &ModelViewProjectionMatrix, const core::matrix4 &TextureMatrix); static void setUniforms(const core::matrix4 &ModelMatrix, const core::matrix4 &TextureMatrix);
}; };
class InstancedObjectPass2Shader class InstancedObjectPass2Shader
@ -152,11 +152,11 @@ class DetailledObjectPass2Shader
public: public:
static GLuint Program; static GLuint Program;
static GLuint attrib_position, attrib_texcoord, attrib_second_texcoord; static GLuint attrib_position, attrib_texcoord, attrib_second_texcoord;
static GLuint uniform_MVP, uniform_screen, uniform_ambient; static GLuint uniform_MM, uniform_screen, uniform_ambient;
static GLuint TU_Albedo, TU_detail; static GLuint TU_Albedo, TU_detail;
static void init(); static void init();
static void setUniforms(const core::matrix4 &ModelViewProjectionMatrix); static void setUniforms(const core::matrix4 &ModelMatrix);
}; };
class ObjectRimLimitShader class ObjectRimLimitShader
@ -164,11 +164,11 @@ class ObjectRimLimitShader
public: public:
static GLuint Program; static GLuint Program;
static GLuint attrib_position, attrib_normal, attrib_texcoord; static GLuint attrib_position, attrib_normal, attrib_texcoord;
static GLuint uniform_MVP, uniform_TIMV, uniform_TM, uniform_screen, uniform_ambient; static GLuint uniform_MM, uniform_IMM, uniform_TM, uniform_screen, uniform_ambient;
static GLuint TU_Albedo; static GLuint TU_Albedo;
static void init(); static void init();
static void setUniforms(const core::matrix4 &ModelViewProjectionMatrix, const core::matrix4 &TransposeInverseModelView, const core::matrix4 &TextureMatrix); static void setUniforms(const core::matrix4 &ModelMatrix, const core::matrix4 &InverseModelMatrix, const core::matrix4 &TextureMatrix);
}; };
class UntexturedObjectShader class UntexturedObjectShader
@ -176,10 +176,10 @@ class UntexturedObjectShader
public: public:
static GLuint Program; static GLuint Program;
static GLuint attrib_position, attrib_color; static GLuint attrib_position, attrib_color;
static GLuint uniform_MVP, uniform_screen, uniform_ambient; static GLuint uniform_MM, uniform_screen, uniform_ambient;
static void init(); static void init();
static void setUniforms(const core::matrix4 &ModelViewProjectionMatrix); static void setUniforms(const core::matrix4 &ModelMatrix);
}; };
class ObjectUnlitShader class ObjectUnlitShader
@ -187,11 +187,11 @@ class ObjectUnlitShader
public: public:
static GLuint Program; static GLuint Program;
static GLuint attrib_position, attrib_texcoord; static GLuint attrib_position, attrib_texcoord;
static GLuint uniform_MVP; static GLuint uniform_MM;
static GLuint TU_tex; static GLuint TU_tex;
static void init(); static void init();
static void setUniforms(const core::matrix4 &ModelViewProjectionMatrix); static void setUniforms(const core::matrix4 &ModelMatrix);
}; };
class ObjectRefPass2Shader class ObjectRefPass2Shader
@ -199,11 +199,11 @@ class ObjectRefPass2Shader
public: public:
static GLuint Program; static GLuint Program;
static GLuint attrib_position, attrib_texcoord; static GLuint attrib_position, attrib_texcoord;
static GLuint uniform_MVP, uniform_TM, uniform_screen, uniform_ambient; static GLuint uniform_MM, uniform_TM, uniform_screen, uniform_ambient;
static GLuint TU_Albedo; static GLuint TU_Albedo;
static void init(); static void init();
static void setUniforms(const core::matrix4 &ModelViewProjectionMatrix, const core::matrix4 &TextureMatrix); static void setUniforms(const core::matrix4 &ModelMatrix, const core::matrix4 &TextureMatrix);
}; };
class GrassPass2Shader class GrassPass2Shader
@ -235,11 +235,11 @@ class SphereMapShader
public: public:
static GLuint Program; static GLuint Program;
static GLuint attrib_position, attrib_normal; static GLuint attrib_position, attrib_normal;
static GLuint uniform_MVP, uniform_TIMV, uniform_TVM, uniform_invproj, uniform_screen; static GLuint uniform_MM, uniform_IMM, uniform_screen;
static GLuint TU_tex; static GLuint TU_tex;
static void init(); static void init();
static void setUniforms(const core::matrix4 &ModelViewProjectionMatrix, const core::matrix4 &TransposeViewMatrix, const core::matrix4 &TransposeInverseModelView, const core::matrix4 &InvProj, const core::vector2df& screen); static void setUniforms(const core::matrix4 &ModelMatrix, const core::matrix4 &InverseModelMatrix, const core::vector2df& screen);
}; };
class SplattingShader class SplattingShader
@ -247,11 +247,11 @@ class SplattingShader
public: public:
static GLuint Program; static GLuint Program;
static GLuint attrib_position, attrib_texcoord, attrib_second_texcoord; static GLuint attrib_position, attrib_texcoord, attrib_second_texcoord;
static GLuint uniform_MVP, uniform_screen, uniform_ambient; static GLuint uniform_MM, uniform_screen, uniform_ambient;
static GLuint TU_tex_layout, TU_tex_detail0, TU_tex_detail1, TU_tex_detail2, TU_tex_detail3; static GLuint TU_tex_layout, TU_tex_detail0, TU_tex_detail1, TU_tex_detail2, TU_tex_detail3;
static void init(); static void init();
static void setUniforms(const core::matrix4 &ModelViewProjectionMatrix); static void setUniforms(const core::matrix4 &ModelMatrix);
}; };
class CausticsShader class CausticsShader
@ -403,11 +403,11 @@ class SkyboxShader
public: public:
static GLuint Program; static GLuint Program;
static GLuint attrib_position; static GLuint attrib_position;
static GLuint uniform_MVP, uniform_InvProjView, uniform_tex, uniform_screen; static GLuint uniform_MM, uniform_tex, uniform_screen;
static GLuint cubevao; static GLuint cubevao;
static void init(); static void init();
static void setUniforms(const core::matrix4 &ModelViewProjectionMatrix, const core::matrix4 &InvProjView, const core::vector2df &screen, unsigned TU_tex); static void setUniforms(const core::matrix4 &ModelMatrix, const core::vector2df &screen, unsigned TU_tex);
}; };
} }

106
src/graphics/stkanimatedmesh.cpp
View File

@ -54,47 +54,6 @@ void STKAnimatedMesh::setMesh(scene::IAnimatedMesh* mesh)
CAnimatedMeshSceneNode::setMesh(mesh); CAnimatedMeshSceneNode::setMesh(mesh);
} }
void STKAnimatedMesh::drawSolidPass1(const GLMesh &mesh, GeometricMaterial type)
{
switch (type)
{
case FPSM_ALPHA_REF_TEXTURE:
drawObjectRefPass1(mesh, ModelViewProjectionMatrix, TransposeInverseModelView, mesh.TextureMatrix);
break;
case FPSM_DEFAULT:
drawObjectPass1(mesh, ModelViewProjectionMatrix, TransposeInverseModelView);
break;
default:
assert(0 && "Wrong geometric material");
break;
}
}
void STKAnimatedMesh::drawSolidPass2(const GLMesh &mesh, ShadedMaterial type)
{
switch (type)
{
case SM_ALPHA_REF_TEXTURE:
drawObjectRefPass2(mesh, ModelViewProjectionMatrix, mesh.TextureMatrix);
break;
case SM_RIMLIT:
drawObjectRimLimit(mesh, ModelViewProjectionMatrix, TransposeInverseModelView, mesh.TextureMatrix);
break;
case SM_UNLIT:
drawObjectUnlit(mesh, ModelViewProjectionMatrix);
break;
case SM_DETAILS:
drawDetailledObjectPass2(mesh, ModelViewProjectionMatrix);
break;
case SM_DEFAULT:
drawObjectPass2(mesh, ModelViewProjectionMatrix, mesh.TextureMatrix);
break;
default:
assert(0 && "Wrong shaded material");
break;
}
}
void STKAnimatedMesh::render() void STKAnimatedMesh::render()
{ {
video::IVideoDriver* driver = SceneManager->getVideoDriver(); video::IVideoDriver* driver = SceneManager->getVideoDriver();
@ -186,46 +145,65 @@ void STKAnimatedMesh::render()
{ {
ModelViewProjectionMatrix = computeMVP(AbsoluteTransformation); ModelViewProjectionMatrix = computeMVP(AbsoluteTransformation);
TransposeInverseModelView = computeTIMV(AbsoluteTransformation); TransposeInverseModelView = computeTIMV(AbsoluteTransformation);
core::matrix4 invmodel;
AbsoluteTransformation.getInverse(invmodel);
if (!GeometricMesh[FPSM_DEFAULT].empty())
glUseProgram(MeshShader::ObjectPass1Shader::Program);
for (unsigned i = 0; i < GeometricMesh[FPSM_DEFAULT].size(); i++) for (unsigned i = 0; i < GeometricMesh[FPSM_DEFAULT].size(); i++)
drawSolidPass1(*GeometricMesh[FPSM_DEFAULT][i], FPSM_DEFAULT); {
GroupedFPSM<FPSM_DEFAULT>::MeshSet.push_back(GeometricMesh[FPSM_DEFAULT][i]);
GroupedFPSM<FPSM_DEFAULT>::MVPSet.push_back(AbsoluteTransformation);
GroupedFPSM<FPSM_DEFAULT>::TIMVSet.push_back(invmodel);
}
if (!GeometricMesh[FPSM_ALPHA_REF_TEXTURE].empty())
glUseProgram(MeshShader::ObjectRefPass1Shader::Program);
for (unsigned i = 0; i < GeometricMesh[FPSM_ALPHA_REF_TEXTURE].size(); i++) for (unsigned i = 0; i < GeometricMesh[FPSM_ALPHA_REF_TEXTURE].size(); i++)
drawSolidPass1(*GeometricMesh[FPSM_ALPHA_REF_TEXTURE][i], FPSM_ALPHA_REF_TEXTURE); {
GroupedFPSM<FPSM_ALPHA_REF_TEXTURE>::MeshSet.push_back(GeometricMesh[FPSM_ALPHA_REF_TEXTURE][i]);
GroupedFPSM<FPSM_ALPHA_REF_TEXTURE>::MVPSet.push_back(AbsoluteTransformation);
GroupedFPSM<FPSM_ALPHA_REF_TEXTURE>::TIMVSet.push_back(invmodel);
}
return; return;
} }
if (irr_driver->getPhase() == SOLID_LIT_PASS) if (irr_driver->getPhase() == SOLID_LIT_PASS)
{ {
if (!ShadedMesh[SM_DEFAULT].empty()) core::matrix4 invmodel;
glUseProgram(MeshShader::ObjectPass2Shader::Program); AbsoluteTransformation.getInverse(invmodel);
for (unsigned i = 0; i < ShadedMesh[SM_DEFAULT].size(); i++) for (unsigned i = 0; i < ShadedMesh[SM_DEFAULT].size(); i++)
drawSolidPass2(*ShadedMesh[SM_DEFAULT][i], SM_DEFAULT); {
GroupedSM<SM_DEFAULT>::MeshSet.push_back(ShadedMesh[SM_DEFAULT][i]);
GroupedSM<SM_DEFAULT>::MVPSet.push_back(AbsoluteTransformation);
GroupedSM<SM_DEFAULT>::TIMVSet.push_back(invmodel);
}
if (!ShadedMesh[SM_ALPHA_REF_TEXTURE].empty())
glUseProgram(MeshShader::ObjectRefPass2Shader::Program);
for (unsigned i = 0; i < ShadedMesh[SM_ALPHA_REF_TEXTURE].size(); i++) for (unsigned i = 0; i < ShadedMesh[SM_ALPHA_REF_TEXTURE].size(); i++)
drawSolidPass2(*ShadedMesh[SM_ALPHA_REF_TEXTURE][i], SM_ALPHA_REF_TEXTURE); {
GroupedSM<SM_ALPHA_REF_TEXTURE>::MeshSet.push_back(ShadedMesh[SM_ALPHA_REF_TEXTURE][i]);
GroupedSM<SM_ALPHA_REF_TEXTURE>::MVPSet.push_back(AbsoluteTransformation);
GroupedSM<SM_ALPHA_REF_TEXTURE>::TIMVSet.push_back(invmodel);
}
if (!ShadedMesh[SM_RIMLIT].empty())
glUseProgram(MeshShader::ObjectRimLimitShader::Program);
for (unsigned i = 0; i < ShadedMesh[SM_RIMLIT].size(); i++) for (unsigned i = 0; i < ShadedMesh[SM_RIMLIT].size(); i++)
drawSolidPass2(*ShadedMesh[SM_RIMLIT][i], SM_RIMLIT); {
GroupedSM<SM_RIMLIT>::MeshSet.push_back(ShadedMesh[SM_RIMLIT][i]);
GroupedSM<SM_RIMLIT>::MVPSet.push_back(AbsoluteTransformation);
GroupedSM<SM_RIMLIT>::TIMVSet.push_back(invmodel);
}
if (!ShadedMesh[SM_UNLIT].empty()) for (GLMesh *mesh : ShadedMesh[SM_UNLIT])
glUseProgram(MeshShader::ObjectUnlitShader::Program); {
for (unsigned i = 0; i < ShadedMesh[SM_UNLIT].size(); i++) GroupedSM<SM_UNLIT>::MeshSet.push_back(mesh);
drawSolidPass2(*ShadedMesh[SM_UNLIT][i], SM_UNLIT); GroupedSM<SM_UNLIT>::MVPSet.push_back(AbsoluteTransformation);
GroupedSM<SM_UNLIT>::TIMVSet.push_back(invmodel);
}
if (!ShadedMesh[SM_DETAILS].empty()) for (GLMesh *mesh : ShadedMesh[SM_DETAILS])
glUseProgram(MeshShader::DetailledObjectPass2Shader::Program); {
for (unsigned i = 0; i < ShadedMesh[SM_DETAILS].size(); i++) GroupedSM<SM_DETAILS>::MeshSet.push_back(mesh);
drawSolidPass2(*ShadedMesh[SM_DETAILS][i], SM_DETAILS); GroupedSM<SM_DETAILS>::MVPSet.push_back(AbsoluteTransformation);
GroupedSM<SM_DETAILS>::TIMVSet.push_back(invmodel);
}
return; return;
} }

2
src/graphics/stkanimatedmesh.hpp
View File

@ -16,8 +16,6 @@ protected:
std::vector<GLMesh *> TransparentMesh[TM_COUNT]; std::vector<GLMesh *> TransparentMesh[TM_COUNT];
std::vector<GLMesh> GLmeshes; std::vector<GLMesh> GLmeshes;
core::matrix4 ModelViewProjectionMatrix, TransposeInverseModelView; core::matrix4 ModelViewProjectionMatrix, TransposeInverseModelView;
void drawSolidPass1(const GLMesh &mesh, GeometricMaterial type);
void drawSolidPass2(const GLMesh &mesh, ShadedMaterial type);
void cleanGLMeshes(); void cleanGLMeshes();
public: public:
STKAnimatedMesh(irr::scene::IAnimatedMesh* mesh, irr::scene::ISceneNode* parent, STKAnimatedMesh(irr::scene::IAnimatedMesh* mesh, irr::scene::ISceneNode* parent,

18
src/graphics/stkinstancedscenenode.cpp
View File

@ -179,7 +179,7 @@ void STKInstancedSceneNode::addInstance(const core::vector3df &origin, const cor
instance_pos.push_back(scale.Z); instance_pos.push_back(scale.Z);
} }
static void drawFSPMDefault(GLMesh &mesh, const core::matrix4 &ModelViewProjectionMatrix, size_t instance_count) static void drawFSPMDefault(GLMesh &mesh, size_t instance_count)
{ {
irr_driver->IncreaseObjectCount(); irr_driver->IncreaseObjectCount();
GLenum ptype = mesh.PrimitiveType; GLenum ptype = mesh.PrimitiveType;
@ -187,7 +187,7 @@ static void drawFSPMDefault(GLMesh &mesh, const core::matrix4 &ModelViewProjecti
size_t count = mesh.IndexCount; size_t count = mesh.IndexCount;
setTexture(0, mesh.textures[0], GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true); setTexture(0, mesh.textures[0], GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true);
MeshShader::InstancedObjectPass1Shader::setUniforms(ModelViewProjectionMatrix, irr_driver->getInvViewMatrix(), 0); MeshShader::InstancedObjectPass1Shader::setUniforms(0);
glBindVertexArray(mesh.vao_first_pass); glBindVertexArray(mesh.vao_first_pass);
glDrawElementsInstanced(ptype, count, itype, 0, instance_count); glDrawElementsInstanced(ptype, count, itype, 0, instance_count);
@ -207,7 +207,7 @@ static void drawShadowDefault(GLMesh &mesh, size_t instance_count)
glDrawElementsInstanced(ptype, count, itype, 0, instance_count); glDrawElementsInstanced(ptype, count, itype, 0, instance_count);
} }
static void drawFSPMAlphaRefTexture(GLMesh &mesh, const core::matrix4 &ModelViewProjectionMatrix, size_t instance_count) static void drawFSPMAlphaRefTexture(GLMesh &mesh, size_t instance_count)
{ {
irr_driver->IncreaseObjectCount(); irr_driver->IncreaseObjectCount();
GLenum ptype = mesh.PrimitiveType; GLenum ptype = mesh.PrimitiveType;
@ -215,7 +215,7 @@ static void drawFSPMAlphaRefTexture(GLMesh &mesh, const core::matrix4 &ModelView
size_t count = mesh.IndexCount; size_t count = mesh.IndexCount;
setTexture(0, mesh.textures[0], GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true); setTexture(0, mesh.textures[0], GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true);
MeshShader::InstancedObjectRefPass1Shader::setUniforms(ModelViewProjectionMatrix, irr_driver->getInvViewMatrix(), 0); MeshShader::InstancedObjectRefPass1Shader::setUniforms(0);
glBindVertexArray(mesh.vao_first_pass); glBindVertexArray(mesh.vao_first_pass);
glDrawElementsInstanced(ptype, count, itype, 0, instance_count); glDrawElementsInstanced(ptype, count, itype, 0, instance_count);
@ -236,7 +236,7 @@ static void drawShadowAlphaRefTexture(GLMesh &mesh, size_t instance_count)
glDrawElementsInstanced(ptype, count, itype, 0, instance_count); glDrawElementsInstanced(ptype, count, itype, 0, instance_count);
} }
static void drawFSPMGrass(GLMesh &mesh, const core::matrix4 &ModelViewProjectionMatrix, const core::vector3df &windDir, size_t instance_count) static void drawFSPMGrass(GLMesh &mesh, const core::vector3df &windDir, size_t instance_count)
{ {
irr_driver->IncreaseObjectCount(); irr_driver->IncreaseObjectCount();
GLenum ptype = mesh.PrimitiveType; GLenum ptype = mesh.PrimitiveType;
@ -244,7 +244,7 @@ static void drawFSPMGrass(GLMesh &mesh, const core::matrix4 &ModelViewProjection
size_t count = mesh.IndexCount; size_t count = mesh.IndexCount;
setTexture(0, mesh.textures[0], GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true); setTexture(0, mesh.textures[0], GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true);
MeshShader::InstancedGrassPass1Shader::setUniforms(ModelViewProjectionMatrix, irr_driver->getInvViewMatrix(), windDir, 0); MeshShader::InstancedGrassPass1Shader::setUniforms(windDir, 0);
glBindVertexArray(mesh.vao_first_pass); glBindVertexArray(mesh.vao_first_pass);
glDrawElementsInstanced(ptype, count, itype, 0, instance_count); glDrawElementsInstanced(ptype, count, itype, 0, instance_count);
@ -315,18 +315,18 @@ void STKInstancedSceneNode::render()
if (!GeometricMesh[FPSM_DEFAULT].empty()) if (!GeometricMesh[FPSM_DEFAULT].empty())
glUseProgram(MeshShader::InstancedObjectPass1Shader::Program); glUseProgram(MeshShader::InstancedObjectPass1Shader::Program);
for (unsigned i = 0; i < GeometricMesh[FPSM_DEFAULT].size(); i++) for (unsigned i = 0; i < GeometricMesh[FPSM_DEFAULT].size(); i++)
drawFSPMDefault(*GeometricMesh[FPSM_DEFAULT][i], ModelViewProjectionMatrix, instance_pos.size() / 9); drawFSPMDefault(*GeometricMesh[FPSM_DEFAULT][i], instance_pos.size() / 9);
if (!GeometricMesh[FPSM_ALPHA_REF_TEXTURE].empty()) if (!GeometricMesh[FPSM_ALPHA_REF_TEXTURE].empty())
glUseProgram(MeshShader::InstancedObjectRefPass1Shader::Program); glUseProgram(MeshShader::InstancedObjectRefPass1Shader::Program);
for (unsigned i = 0; i < GeometricMesh[FPSM_ALPHA_REF_TEXTURE].size(); i++) for (unsigned i = 0; i < GeometricMesh[FPSM_ALPHA_REF_TEXTURE].size(); i++)
drawFSPMAlphaRefTexture(*GeometricMesh[FPSM_ALPHA_REF_TEXTURE][i], ModelViewProjectionMatrix, instance_pos.size() / 9); drawFSPMAlphaRefTexture(*GeometricMesh[FPSM_ALPHA_REF_TEXTURE][i], instance_pos.size() / 9);
windDir = getWind(); windDir = getWind();
if (!GeometricMesh[FPSM_GRASS].empty()) if (!GeometricMesh[FPSM_GRASS].empty())
glUseProgram(MeshShader::InstancedGrassPass1Shader::Program); glUseProgram(MeshShader::InstancedGrassPass1Shader::Program);
for (unsigned i = 0; i < GeometricMesh[FPSM_GRASS].size(); i++) for (unsigned i = 0; i < GeometricMesh[FPSM_GRASS].size(); i++)
drawFSPMGrass(*GeometricMesh[FPSM_GRASS][i], ModelViewProjectionMatrix, windDir, instance_pos.size() / 9); drawFSPMGrass(*GeometricMesh[FPSM_GRASS][i], windDir, instance_pos.size() / 9);
return; return;
} }

20
src/graphics/stkmesh.cpp
View File

@ -219,6 +219,8 @@ core::vector3df getWind()
return m_speed * vector3df(1., 0., 0.) * cos(time); return m_speed * vector3df(1., 0., 0.) * cos(time);
} }
void drawObjectPass1(const GLMesh &mesh, const core::matrix4 & ModelViewProjectionMatrix, const core::matrix4 &TransposeInverseModelView) void drawObjectPass1(const GLMesh &mesh, const core::matrix4 & ModelViewProjectionMatrix, const core::matrix4 &TransposeInverseModelView)
{ {
irr_driver->IncreaseObjectCount(); irr_driver->IncreaseObjectCount();
@ -267,7 +269,7 @@ void drawGrassPass1(const GLMesh &mesh, const core::matrix4 & ModelViewProjectio
glDrawElements(ptype, count, itype, 0); glDrawElements(ptype, count, itype, 0);
} }
void drawNormalPass(const GLMesh &mesh, const core::matrix4 & ModelViewProjectionMatrix, const core::matrix4 &TransposeInverseModelView) void drawNormalPass(const GLMesh &mesh, const core::matrix4 & ModelMatrix, const core::matrix4 &InverseModelMatrix)
{ {
irr_driver->IncreaseObjectCount(); irr_driver->IncreaseObjectCount();
GLenum ptype = mesh.PrimitiveType; GLenum ptype = mesh.PrimitiveType;
@ -277,14 +279,14 @@ void drawNormalPass(const GLMesh &mesh, const core::matrix4 & ModelViewProjectio
assert(mesh.textures[1]); assert(mesh.textures[1]);
setTexture(0, mesh.textures[1], GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true); setTexture(0, mesh.textures[1], GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true);
MeshShader::NormalMapShader::setUniforms(ModelViewProjectionMatrix, TransposeInverseModelView, 0); MeshShader::NormalMapShader::setUniforms(ModelMatrix, InverseModelMatrix, 0);
assert(mesh.vao_first_pass); assert(mesh.vao_first_pass);
glBindVertexArray(mesh.vao_first_pass); glBindVertexArray(mesh.vao_first_pass);
glDrawElements(ptype, count, itype, 0); glDrawElements(ptype, count, itype, 0);
} }
void drawSphereMap(const GLMesh &mesh, const core::matrix4 &ModelViewProjectionMatrix, const core::matrix4 &TransposeInverseModelView) void drawSphereMap(const GLMesh &mesh, const core::matrix4 &ModelMatrix, const core::matrix4 &InverseModelMatrix)
{ {
irr_driver->IncreaseObjectCount(); irr_driver->IncreaseObjectCount();
GLenum ptype = mesh.PrimitiveType; GLenum ptype = mesh.PrimitiveType;
@ -304,11 +306,9 @@ void drawSphereMap(const GLMesh &mesh, const core::matrix4 &ModelViewProjectionM
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
} }
MeshShader::SphereMapShader MeshShader::SphereMapShader::setUniforms(ModelMatrix, InverseModelMatrix,
::setUniforms(ModelViewProjectionMatrix, irr_driver->getViewMatrix().getTransposed(), core::vector2df(float(UserConfigParams::m_width),
TransposeInverseModelView, irr_driver->getInvProjMatrix(), float(UserConfigParams::m_height)));
core::vector2df(float(UserConfigParams::m_width), float(UserConfigParams::m_height)));
assert(mesh.vao_second_pass); assert(mesh.vao_second_pass);
glBindVertexArray(mesh.vao_second_pass); glBindVertexArray(mesh.vao_second_pass);
glDrawElements(ptype, count, itype, 0); glDrawElements(ptype, count, itype, 0);
@ -479,14 +479,14 @@ void drawGrassPass2(const GLMesh &mesh, const core::matrix4 & ModelViewProjectio
glDrawElements(ptype, count, itype, 0); glDrawElements(ptype, count, itype, 0);
} }
void drawUntexturedObject(const GLMesh &mesh, const core::matrix4 &ModelViewProjectionMatrix) void drawUntexturedObject(const GLMesh &mesh, const core::matrix4 &ModelMatrix)
{ {
irr_driver->IncreaseObjectCount(); irr_driver->IncreaseObjectCount();
GLenum ptype = mesh.PrimitiveType; GLenum ptype = mesh.PrimitiveType;
GLenum itype = mesh.IndexType; GLenum itype = mesh.IndexType;
size_t count = mesh.IndexCount; size_t count = mesh.IndexCount;
MeshShader::UntexturedObjectShader::setUniforms(ModelViewProjectionMatrix); MeshShader::UntexturedObjectShader::setUniforms(ModelMatrix);
assert(mesh.vao_second_pass); assert(mesh.vao_second_pass);
glBindVertexArray(mesh.vao_second_pass); glBindVertexArray(mesh.vao_second_pass);

46
src/graphics/stkmesh.hpp
View File

@ -67,12 +67,56 @@ bool isObject(video::E_MATERIAL_TYPE type);
core::vector3df getWind(); core::vector3df getWind();
// Pass 1 shader (ie shaders that outputs normals and depth) // Pass 1 shader (ie shaders that outputs normals and depth)
template<enum GeometricMaterial T>
class GroupedFPSM
{
public:
static std::vector<GLMesh *> MeshSet;
static std::vector<core::matrix4> MVPSet, TIMVSet;
static void reset()
{
MeshSet.clear();
MVPSet.clear();
TIMVSet.clear();
}
};
template<enum GeometricMaterial T>
std::vector<GLMesh *> GroupedFPSM<T>::MeshSet;
template<enum GeometricMaterial T>
std::vector<core::matrix4> GroupedFPSM<T>::MVPSet;
template<enum GeometricMaterial T>
std::vector<core::matrix4> GroupedFPSM<T>::TIMVSet;
void drawObjectPass1(const GLMesh &mesh, const core::matrix4 & ModelViewProjectionMatrix, const core::matrix4 &TransposeInverseModelView); void drawObjectPass1(const GLMesh &mesh, const core::matrix4 & ModelViewProjectionMatrix, const core::matrix4 &TransposeInverseModelView);
void drawNormalPass(const GLMesh &mesh, const core::matrix4 & ModelViewProjectionMatrix, const core::matrix4 &TransposeInverseModelView); void drawNormalPass(const GLMesh &mesh, const core::matrix4 & ModelMatrix, const core::matrix4 &InverseModelMatrix);
void drawObjectRefPass1(const GLMesh &mesh, const core::matrix4 & ModelViewProjectionMatrix, const core::matrix4 &TransposeInverseModelView, const core::matrix4 &TextureMatrix); void drawObjectRefPass1(const GLMesh &mesh, const core::matrix4 & ModelViewProjectionMatrix, const core::matrix4 &TransposeInverseModelView, const core::matrix4 &TextureMatrix);
void drawGrassPass1(const GLMesh &mesh, const core::matrix4 & ModelViewProjectionMatrix, const core::matrix4 &TransposeInverseModelView, core::vector3df windDir); void drawGrassPass1(const GLMesh &mesh, const core::matrix4 & ModelViewProjectionMatrix, const core::matrix4 &TransposeInverseModelView, core::vector3df windDir);
// Pass 2 shader (ie shaders that outputs final color) // Pass 2 shader (ie shaders that outputs final color)
template<enum ShadedMaterial T>
class GroupedSM
{
public:
static std::vector<GLMesh *> MeshSet;
static std::vector<core::matrix4> MVPSet, TIMVSet;
static void reset()
{
MeshSet.clear();
MVPSet.clear();
TIMVSet.clear();
}
};
template<enum ShadedMaterial T>
std::vector<GLMesh *> GroupedSM<T>::MeshSet;
template<enum ShadedMaterial T>
std::vector<core::matrix4> GroupedSM<T>::MVPSet;
template<enum ShadedMaterial T>
std::vector<core::matrix4> GroupedSM<T>::TIMVSet;
void drawDetailledObjectPass2(const GLMesh &mesh, const core::matrix4 &ModelViewProjectionMatrix); void drawDetailledObjectPass2(const GLMesh &mesh, const core::matrix4 &ModelViewProjectionMatrix);
void drawObjectPass2(const GLMesh &mesh, const core::matrix4 &ModelViewProjectionMatrix, const core::matrix4 &TextureMatrix); void drawObjectPass2(const GLMesh &mesh, const core::matrix4 &ModelViewProjectionMatrix, const core::matrix4 &TextureMatrix);
void drawUntexturedObject(const GLMesh &mesh, const core::matrix4 &ModelViewProjectionMatrix); void drawUntexturedObject(const GLMesh &mesh, const core::matrix4 &ModelViewProjectionMatrix);

110
src/graphics/stkmeshscenenode.cpp
View File

@ -341,21 +341,29 @@ void STKMeshSceneNode::render()
glDisable(GL_CULL_FACE); glDisable(GL_CULL_FACE);
ModelViewProjectionMatrix = computeMVP(AbsoluteTransformation); ModelViewProjectionMatrix = computeMVP(AbsoluteTransformation);
TransposeInverseModelView = computeTIMV(AbsoluteTransformation); TransposeInverseModelView = computeTIMV(AbsoluteTransformation);
core::matrix4 invmodel;
if (!GeometricMesh[FPSM_DEFAULT].empty()) AbsoluteTransformation.getInverse(invmodel);
glUseProgram(MeshShader::ObjectPass1Shader::Program);
for (unsigned i = 0; i < GeometricMesh[FPSM_DEFAULT].size(); i++) for (unsigned i = 0; i < GeometricMesh[FPSM_DEFAULT].size(); i++)
drawSolidPass1(*GeometricMesh[FPSM_DEFAULT][i], FPSM_DEFAULT); {
GroupedFPSM<FPSM_DEFAULT>::MeshSet.push_back(GeometricMesh[FPSM_DEFAULT][i]);
GroupedFPSM<FPSM_DEFAULT>::MVPSet.push_back(AbsoluteTransformation);
GroupedFPSM<FPSM_DEFAULT>::TIMVSet.push_back(invmodel);
}
if (!GeometricMesh[FPSM_ALPHA_REF_TEXTURE].empty())
glUseProgram(MeshShader::ObjectRefPass1Shader::Program);
for (unsigned i = 0; i < GeometricMesh[FPSM_ALPHA_REF_TEXTURE].size(); i++) for (unsigned i = 0; i < GeometricMesh[FPSM_ALPHA_REF_TEXTURE].size(); i++)
drawSolidPass1(*GeometricMesh[FPSM_ALPHA_REF_TEXTURE][i], FPSM_ALPHA_REF_TEXTURE); {
GroupedFPSM<FPSM_ALPHA_REF_TEXTURE>::MeshSet.push_back(GeometricMesh[FPSM_ALPHA_REF_TEXTURE][i]);
GroupedFPSM<FPSM_ALPHA_REF_TEXTURE>::MVPSet.push_back(AbsoluteTransformation);
GroupedFPSM<FPSM_ALPHA_REF_TEXTURE>::TIMVSet.push_back(invmodel);
}
if (!GeometricMesh[FPSM_NORMAL_MAP].empty())
glUseProgram(MeshShader::NormalMapShader::Program);
for (unsigned i = 0; i < GeometricMesh[FPSM_NORMAL_MAP].size(); i++) for (unsigned i = 0; i < GeometricMesh[FPSM_NORMAL_MAP].size(); i++)
drawSolidPass1(*GeometricMesh[FPSM_NORMAL_MAP][i], FPSM_NORMAL_MAP); {
GroupedFPSM<FPSM_NORMAL_MAP>::MeshSet.push_back(GeometricMesh[FPSM_NORMAL_MAP][i]);
GroupedFPSM<FPSM_NORMAL_MAP>::MVPSet.push_back(AbsoluteTransformation);
GroupedFPSM<FPSM_NORMAL_MAP>::TIMVSet.push_back(invmodel);
}
if (!GeometricMesh[FPSM_GRASS].empty()) if (!GeometricMesh[FPSM_GRASS].empty())
glUseProgram(MeshShader::GrassPass1Shader::Program); glUseProgram(MeshShader::GrassPass1Shader::Program);
@ -372,56 +380,76 @@ void STKMeshSceneNode::render()
if (reload_each_frame) if (reload_each_frame)
glDisable(GL_CULL_FACE); glDisable(GL_CULL_FACE);
if (!ShadedMesh[SM_DEFAULT].empty()) core::matrix4 invmodel;
glUseProgram(MeshShader::ObjectPass2Shader::Program); AbsoluteTransformation.getInverse(invmodel);
for (unsigned i = 0; i < ShadedMesh[SM_DEFAULT].size(); i++) for (unsigned i = 0; i < ShadedMesh[SM_DEFAULT].size(); i++)
drawSolidPass2(*ShadedMesh[SM_DEFAULT][i], SM_DEFAULT); {
GroupedSM<SM_DEFAULT>::MeshSet.push_back(ShadedMesh[SM_DEFAULT][i]);
GroupedSM<SM_DEFAULT>::MVPSet.push_back(AbsoluteTransformation);
GroupedSM<SM_DEFAULT>::TIMVSet.push_back(invmodel);
}
if (!ShadedMesh[SM_ALPHA_REF_TEXTURE].empty())
glUseProgram(MeshShader::ObjectRefPass2Shader::Program);
for (unsigned i = 0; i < ShadedMesh[SM_ALPHA_REF_TEXTURE].size(); i++) for (unsigned i = 0; i < ShadedMesh[SM_ALPHA_REF_TEXTURE].size(); i++)
drawSolidPass2(*ShadedMesh[SM_ALPHA_REF_TEXTURE][i], SM_ALPHA_REF_TEXTURE); {
GroupedSM<SM_ALPHA_REF_TEXTURE>::MeshSet.push_back(ShadedMesh[SM_ALPHA_REF_TEXTURE][i]);
GroupedSM<SM_ALPHA_REF_TEXTURE>::MVPSet.push_back(AbsoluteTransformation);
GroupedSM<SM_ALPHA_REF_TEXTURE>::TIMVSet.push_back(invmodel);
}
if (!ShadedMesh[SM_RIMLIT].empty())
glUseProgram(MeshShader::ObjectRimLimitShader::Program);
for (unsigned i = 0; i < ShadedMesh[SM_RIMLIT].size(); i++) for (unsigned i = 0; i < ShadedMesh[SM_RIMLIT].size(); i++)
drawSolidPass2(*ShadedMesh[SM_RIMLIT][i], SM_RIMLIT); {
GroupedSM<SM_RIMLIT>::MeshSet.push_back(ShadedMesh[SM_RIMLIT][i]);
GroupedSM<SM_RIMLIT>::MVPSet.push_back(AbsoluteTransformation);
GroupedSM<SM_RIMLIT>::TIMVSet.push_back(invmodel);
}
if (!ShadedMesh[SM_SPHEREMAP].empty())
glUseProgram(MeshShader::SphereMapShader::Program);
for (unsigned i = 0; i < ShadedMesh[SM_SPHEREMAP].size(); i++) for (unsigned i = 0; i < ShadedMesh[SM_SPHEREMAP].size(); i++)
drawSolidPass2(*ShadedMesh[SM_SPHEREMAP][i], SM_SPHEREMAP); {
GroupedSM<SM_SPHEREMAP>::MeshSet.push_back(ShadedMesh[SM_SPHEREMAP][i]);
GroupedSM<SM_SPHEREMAP>::MVPSet.push_back(AbsoluteTransformation);
GroupedSM<SM_SPHEREMAP>::TIMVSet.push_back(invmodel);
}
if (!ShadedMesh[SM_SPLATTING].empty()) for (GLMesh *mesh : ShadedMesh[SM_SPLATTING])
glUseProgram(MeshShader::SplattingShader::Program); {
for (unsigned i = 0; i < ShadedMesh[SM_SPLATTING].size(); i++) GroupedSM<SM_SPLATTING>::MeshSet.push_back(mesh);
drawSolidPass2(*ShadedMesh[SM_SPLATTING][i], SM_SPLATTING); GroupedSM<SM_SPLATTING>::MVPSet.push_back(AbsoluteTransformation);
GroupedSM<SM_SPLATTING>::TIMVSet.push_back(invmodel);
}
for (GLMesh *mesh : ShadedMesh[SM_UNLIT])
{
GroupedSM<SM_UNLIT>::MeshSet.push_back(mesh);
GroupedSM<SM_UNLIT>::MVPSet.push_back(AbsoluteTransformation);
GroupedSM<SM_UNLIT>::TIMVSet.push_back(invmodel);
}
for (GLMesh *mesh : ShadedMesh[SM_DETAILS])
{
GroupedSM<SM_DETAILS>::MeshSet.push_back(mesh);
GroupedSM<SM_DETAILS>::MVPSet.push_back(AbsoluteTransformation);
GroupedSM<SM_DETAILS>::TIMVSet.push_back(invmodel);
}
for (GLMesh *mesh : ShadedMesh[SM_UNTEXTURED])
{
GroupedSM<SM_UNTEXTURED>::MeshSet.push_back(mesh);
GroupedSM<SM_UNTEXTURED>::MVPSet.push_back(AbsoluteTransformation);
GroupedSM<SM_UNTEXTURED>::TIMVSet.push_back(invmodel);
}
if (!ShadedMesh[SM_GRASS].empty()) if (!ShadedMesh[SM_GRASS].empty())
glUseProgram(MeshShader::GrassPass2Shader::Program); glUseProgram(MeshShader::GrassPass2Shader::Program);
for (unsigned i = 0; i < ShadedMesh[SM_GRASS].size(); i++) for (unsigned i = 0; i < ShadedMesh[SM_GRASS].size(); i++)
drawSolidPass2(*ShadedMesh[SM_GRASS][i], SM_GRASS); drawSolidPass2(*ShadedMesh[SM_GRASS][i], SM_GRASS);
if (!ShadedMesh[SM_UNLIT].empty())
glUseProgram(MeshShader::ObjectUnlitShader::Program);
for (unsigned i = 0; i < ShadedMesh[SM_UNLIT].size(); i++)
drawSolidPass2(*ShadedMesh[SM_UNLIT][i], SM_UNLIT);
if (!ShadedMesh[SM_CAUSTICS].empty()) if (!ShadedMesh[SM_CAUSTICS].empty())
glUseProgram(MeshShader::CausticsShader::Program); glUseProgram(MeshShader::CausticsShader::Program);
for (unsigned i = 0; i < ShadedMesh[SM_CAUSTICS].size(); i++) for (unsigned i = 0; i < ShadedMesh[SM_CAUSTICS].size(); i++)
drawSolidPass2(*ShadedMesh[SM_CAUSTICS][i], SM_CAUSTICS); drawSolidPass2(*ShadedMesh[SM_CAUSTICS][i], SM_CAUSTICS);
if (!ShadedMesh[SM_DETAILS].empty())
glUseProgram(MeshShader::DetailledObjectPass2Shader::Program);
for (unsigned i = 0; i < ShadedMesh[SM_DETAILS].size(); i++)
drawSolidPass2(*ShadedMesh[SM_DETAILS][i], SM_DETAILS);
if (!ShadedMesh[SM_UNTEXTURED].empty())
glUseProgram(MeshShader::UntexturedObjectShader::Program);
for (unsigned i = 0; i < ShadedMesh[SM_UNTEXTURED].size(); i++)
drawSolidPass2(*ShadedMesh[SM_UNTEXTURED][i], SM_UNTEXTURED);
if (reload_each_frame) if (reload_each_frame)
glEnable(GL_CULL_FACE); glEnable(GL_CULL_FACE);
return; return;

12
src/tracks/track.cpp
View File

@ -839,17 +839,21 @@ bool Track::loadMainTrack(const XMLNode &root)
merged_mesh->addMesh(mesh); merged_mesh->addMesh(mesh);
merged_mesh->finalize(); merged_mesh->finalize();
adjustForFog(merged_mesh, NULL); scene::IMeshManipulator* manip = irr_driver->getVideoDriver()->getMeshManipulator();
// TODO: memory leak?
scene::IMesh* tangent_mesh = manip->createMeshWithTangents(merged_mesh);
adjustForFog(tangent_mesh, NULL);
// The merged mesh is grabbed by the octtree, so we don't need // The merged mesh is grabbed by the octtree, so we don't need
// to keep a reference to it. // to keep a reference to it.
scene::ISceneNode *scene_node = irr_driver->addMesh(merged_mesh); scene::ISceneNode *scene_node = irr_driver->addMesh(tangent_mesh);
//scene::IMeshSceneNode *scene_node = irr_driver->addOctTree(merged_mesh); //scene::IMeshSceneNode *scene_node = irr_driver->addOctTree(merged_mesh);
// We should drop the merged mesh (since it's now referred to in the // We should drop the merged mesh (since it's now referred to in the
// scene node), but then we need to grab it since it's in the // scene node), but then we need to grab it since it's in the
// m_all_cached_meshes. // m_all_cached_meshes.
m_all_cached_meshes.push_back(merged_mesh); m_all_cached_meshes.push_back(tangent_mesh);
irr_driver->grabAllTextures(merged_mesh); irr_driver->grabAllTextures(tangent_mesh);
// The reference count of the mesh is 1, since it is in irrlicht's // The reference count of the mesh is 1, since it is in irrlicht's
// cache. So we only have to remove it from the cache. // cache. So we only have to remove it from the cache.