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

Try to use a smarter approach

Browse Source
This commit is contained in:
Benau 2016-12-18 09:27:50 +08:00
parent 90a556fe9c
commit 7894e5c864
18 changed files with 116 additions and 584 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
src/graphics/2dutils.cpp
View File

@ -24,7 +24,6 @@
#include "graphics/shader.hpp" #include "graphics/shader.hpp"
#include "graphics/shaders.hpp" #include "graphics/shaders.hpp"
#include "graphics/shared_gpu_objects.hpp" #include "graphics/shared_gpu_objects.hpp"
#include "graphics/shared_shaders.hpp"
#include "graphics/texture_manager.hpp" #include "graphics/texture_manager.hpp"
#include "graphics/texture_shader.hpp" #include "graphics/texture_shader.hpp"
#include "utils/cpp2011.hpp" #include "utils/cpp2011.hpp"
@ -44,7 +43,7 @@ public:
Primitive2DList() Primitive2DList()
{ {
loadProgram(OBJECT, GL_VERTEX_SHADER, "primitive2dlist.vert", loadProgram(OBJECT, GL_VERTEX_SHADER, "primitive2dlist.vert",
GET_SS(SharedTransparent)); GL_FRAGMENT_SHADER, "transparent.frag");
assignUniforms("custom_alpha"); assignUniforms("custom_alpha");
assignSamplerNames(0, "tex", ST_BILINEAR_FILTERED); assignSamplerNames(0, "tex", ST_BILINEAR_FILTERED);
} // Primitive2DList } // Primitive2DList
@ -59,7 +58,7 @@ class UniformColoredTextureRectShader : public TextureShader<UniformColoredTextu
public: public:
UniformColoredTextureRectShader() UniformColoredTextureRectShader()
{ {
loadProgram(OBJECT, GET_SS(SharedTexturedQuad), loadProgram(OBJECT, GL_VERTEX_SHADER, "texturedquad.vert",
GL_FRAGMENT_SHADER, "uniformcolortexturedquad.frag"); GL_FRAGMENT_SHADER, "uniformcolortexturedquad.frag");
assignUniforms("center", "size", "texcenter", "texsize", "color"); assignUniforms("center", "size", "texcenter", "texsize", "color");
@ -76,7 +75,7 @@ class TextureRectShader : public TextureShader<TextureRectShader, 1,
public: public:
TextureRectShader() TextureRectShader()
{ {
loadProgram(OBJECT, GET_SS(SharedTexturedQuad), loadProgram(OBJECT, GL_VERTEX_SHADER, "texturedquad.vert",
GL_FRAGMENT_SHADER, "texturedquad.frag"); GL_FRAGMENT_SHADER, "texturedquad.frag");
assignUniforms("center", "size", "texcenter", "texsize"); assignUniforms("center", "size", "texcenter", "texsize");
@ -92,7 +91,7 @@ public:
ColoredRectShader() ColoredRectShader()
{ {
loadProgram(OBJECT, GL_VERTEX_SHADER, "coloredquad.vert", loadProgram(OBJECT, GL_VERTEX_SHADER, "coloredquad.vert",
GET_SS(SharedColoredQuad)); GL_FRAGMENT_SHADER, "coloredquad.frag");
assignUniforms("center", "size", "color"); assignUniforms("center", "size", "color");
} // ColoredRectShader } // ColoredRectShader
}; // ColoredRectShader }; // ColoredRectShader

2
src/graphics/irr_driver.cpp
View File

@ -919,6 +919,7 @@ void IrrDriver::applyResolutionSettings()
// FIXME: this load sequence is (mostly) duplicated from main.cpp!! // FIXME: this load sequence is (mostly) duplicated from main.cpp!!
// That's just error prone // That's just error prone
// (we're sure to update main.cpp at some point and forget this one...) // (we're sure to update main.cpp at some point and forget this one...)
ShaderBase::updateShaders();
VAOManager::getInstance()->kill(); VAOManager::getInstance()->kill();
resetTextureTable(); resetTextureTable();
cleanUnicolorTextures(); cleanUnicolorTextures();
@ -929,7 +930,6 @@ void IrrDriver::applyResolutionSettings()
} }
delete m_renderer; delete m_renderer;
initDevice(); initDevice();
ShaderBase::updateShaders();
font_manager = new FontManager(); font_manager = new FontManager();
font_manager->loadFonts(); font_manager->loadFonts();

19
src/graphics/lighting_passes.cpp
View File

@ -27,7 +27,6 @@
#include "graphics/rtts.hpp" #include "graphics/rtts.hpp"
#include "graphics/shaders.hpp" #include "graphics/shaders.hpp"
#include "graphics/shadow_matrices.hpp" #include "graphics/shadow_matrices.hpp"
#include "graphics/shared_shaders.hpp"
#include "modes/world.hpp" #include "modes/world.hpp"
#include "tracks/track.hpp" #include "tracks/track.hpp"
#include "utils/profiler.hpp" #include "utils/profiler.hpp"
@ -64,7 +63,7 @@ class FogShader : public TextureShader<FogShader, 1, float, core::vector3df>
public: public:
FogShader() FogShader()
{ {
loadProgram(OBJECT, GET_SS(SharedScreenQuad), loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
GL_FRAGMENT_SHADER, "fog.frag"); GL_FRAGMENT_SHADER, "fog.frag");
assignUniforms("density", "col"); assignUniforms("density", "col");
assignSamplerNames(0, "tex", ST_NEAREST_FILTERED); assignSamplerNames(0, "tex", ST_NEAREST_FILTERED);
@ -191,12 +190,12 @@ public:
{ {
if (CVS->isAMDVertexShaderLayerUsable()) if (CVS->isAMDVertexShaderLayerUsable())
{ {
loadProgram(OBJECT, GET_SS(SharedSlicedScreenQuad), loadProgram(OBJECT, GL_VERTEX_SHADER, "slicedscreenquad.vert",
GL_FRAGMENT_SHADER, "rh.frag"); GL_FRAGMENT_SHADER, "rh.frag");
} }
else else
{ {
loadProgram(OBJECT, GET_SS(SharedSlicedScreenQuad), loadProgram(OBJECT, GL_VERTEX_SHADER, "slicedscreenquad.vert",
GL_GEOMETRY_SHADER, "rhpassthrough.geom", GL_GEOMETRY_SHADER, "rhpassthrough.geom",
GL_FRAGMENT_SHADER, "rh.frag"); GL_FRAGMENT_SHADER, "rh.frag");
} }
@ -239,7 +238,7 @@ class GlobalIlluminationReconstructionShader
public: public:
GlobalIlluminationReconstructionShader() GlobalIlluminationReconstructionShader()
{ {
loadProgram(OBJECT, GET_SS(SharedScreenQuad), loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
GL_FRAGMENT_SHADER, "gi.frag"); GL_FRAGMENT_SHADER, "gi.frag");
assignUniforms("rh_matrix", "inv_rh_matrix", "extents"); assignUniforms("rh_matrix", "inv_rh_matrix", "extents");
@ -272,7 +271,7 @@ class IBLShader : public TextureShader<IBLShader, 3>
public: public:
IBLShader() IBLShader()
{ {
loadProgram(OBJECT, GET_SS(SharedScreenQuad), loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
GL_FRAGMENT_SHADER, "IBL.frag"); GL_FRAGMENT_SHADER, "IBL.frag");
assignUniforms(); assignUniforms();
assignSamplerNames(0, "ntex", ST_NEAREST_FILTERED, assignSamplerNames(0, "ntex", ST_NEAREST_FILTERED,
@ -287,7 +286,7 @@ class DegradedIBLShader : public TextureShader<DegradedIBLShader, 1>
public: public:
DegradedIBLShader() DegradedIBLShader()
{ {
loadProgram(OBJECT, GET_SS(SharedScreenQuad), loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
GL_FRAGMENT_SHADER, "degraded_ibl.frag"); GL_FRAGMENT_SHADER, "degraded_ibl.frag");
assignUniforms(); assignUniforms();
assignSamplerNames(0, "ntex", ST_NEAREST_FILTERED); assignSamplerNames(0, "ntex", ST_NEAREST_FILTERED);
@ -302,7 +301,7 @@ class ShadowedSunLightShaderPCF : public TextureShader<ShadowedSunLightShaderPCF
public: public:
ShadowedSunLightShaderPCF() ShadowedSunLightShaderPCF()
{ {
loadProgram(OBJECT, GET_SS(SharedScreenQuad), loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
GL_FRAGMENT_SHADER, "sunlightshadow.frag"); GL_FRAGMENT_SHADER, "sunlightshadow.frag");
// Use 8 to circumvent a catalyst bug when binding sampler // Use 8 to circumvent a catalyst bug when binding sampler
@ -336,7 +335,7 @@ class ShadowedSunLightShaderESM : public TextureShader<ShadowedSunLightShaderESM
public: public:
ShadowedSunLightShaderESM() ShadowedSunLightShaderESM()
{ {
loadProgram(OBJECT, GET_SS(SharedScreenQuad), loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
GL_FRAGMENT_SHADER, "sunlightshadowesm.frag"); GL_FRAGMENT_SHADER, "sunlightshadowesm.frag");
// Use 8 to circumvent a catalyst bug when binding sampler // Use 8 to circumvent a catalyst bug when binding sampler
@ -369,7 +368,7 @@ class SunLightShader : public TextureShader<SunLightShader, 2,
public: public:
SunLightShader() SunLightShader()
{ {
loadProgram(OBJECT, GET_SS(SharedScreenQuad), loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
GL_FRAGMENT_SHADER, "sunlight.frag"); GL_FRAGMENT_SHADER, "sunlight.frag");
assignSamplerNames(0, "ntex", ST_NEAREST_FILTERED, assignSamplerNames(0, "ntex", ST_NEAREST_FILTERED,

110
src/graphics/materials.hpp
View File

@ -22,18 +22,18 @@
#include "graphics/shader.hpp" #include "graphics/shader.hpp"
#include "graphics/shaders.hpp" #include "graphics/shaders.hpp"
#include "graphics/shared_shaders.hpp"
#include "graphics/stk_mesh.hpp" #include "graphics/stk_mesh.hpp"
#include "graphics/vao_manager.hpp" #include "graphics/vao_manager.hpp"
// ============================================================================ // ============================================================================
class InstancedObjectPass1Shader : public TextureShader<InstancedObjectPass1Shader, 1> class InstancedObjectPass1Shader : public TextureShader<InstancedObjectPass1Shader, 1>
{ {
public: public:
InstancedObjectPass1Shader() InstancedObjectPass1Shader()
{ {
loadProgram(OBJECT, GET_SS(SharedInstanced), loadProgram(OBJECT, GL_VERTEX_SHADER, "instanced_object_pass.vert",
GET_SS(SharedInstancedPass1)); GL_FRAGMENT_SHADER, "instanced_object_pass1.frag");
assignUniforms(); assignUniforms();
assignSamplerNames(0, "glosstex", ST_TRILINEAR_ANISOTROPIC_FILTERED); assignSamplerNames(0, "glosstex", ST_TRILINEAR_ANISOTROPIC_FILTERED);
@ -46,8 +46,8 @@ class InstancedObjectRefPass1Shader : public TextureShader<InstancedObjectRefPas
public: public:
InstancedObjectRefPass1Shader() InstancedObjectRefPass1Shader()
{ {
loadProgram(OBJECT, GET_SS(SharedInstanced), loadProgram(OBJECT, GL_VERTEX_SHADER, "instanced_object_pass.vert",
GET_SS(SharedInstancedRefPass1)); GL_FRAGMENT_SHADER, "instanced_objectref_pass1.frag");
assignUniforms(); assignUniforms();
assignSamplerNames(0, "tex", ST_TRILINEAR_ANISOTROPIC_FILTERED, assignSamplerNames(0, "tex", ST_TRILINEAR_ANISOTROPIC_FILTERED,
@ -64,7 +64,7 @@ class ObjectRefPass2Shader : public TextureShader<ObjectRefPass2Shader, 6,
public: public:
ObjectRefPass2Shader() ObjectRefPass2Shader()
{ {
loadProgram(OBJECT, GET_SS(SharedObject), loadProgram(OBJECT, GL_VERTEX_SHADER, "object_pass.vert",
GL_FRAGMENT_SHADER, "objectref_pass2.frag"); GL_FRAGMENT_SHADER, "objectref_pass2.frag");
assignUniforms("ModelMatrix", "texture_trans", "color_change"); assignUniforms("ModelMatrix", "texture_trans", "color_change");
assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED, assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED,
@ -82,8 +82,8 @@ class InstancedObjectPass2Shader : public TextureShader<InstancedObjectPass2Shad
public: public:
InstancedObjectPass2Shader() InstancedObjectPass2Shader()
{ {
loadProgram(OBJECT, GET_SS(SharedInstanced), loadProgram(OBJECT, GL_VERTEX_SHADER, "instanced_object_pass.vert",
GET_SS(SharedInstancedPass2)); GL_FRAGMENT_SHADER, "instanced_object_pass2.frag");
assignUniforms(); assignUniforms();
assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED, assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED,
1, "SpecularMap", ST_NEAREST_FILTERED, 1, "SpecularMap", ST_NEAREST_FILTERED,
@ -100,8 +100,8 @@ class InstancedObjectRefPass2Shader : public TextureShader<InstancedObjectRefPas
public: public:
InstancedObjectRefPass2Shader() InstancedObjectRefPass2Shader()
{ {
loadProgram(OBJECT, GET_SS(SharedInstanced), loadProgram(OBJECT, GL_VERTEX_SHADER, "instanced_object_pass.vert",
GET_SS(SharedInstancedRefPass2)); GL_FRAGMENT_SHADER, "instanced_objectref_pass2.frag");
assignUniforms(); assignUniforms();
assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED, assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED,
1, "SpecularMap", ST_NEAREST_FILTERED, 1, "SpecularMap", ST_NEAREST_FILTERED,
@ -150,12 +150,12 @@ public:
return; return;
if (CVS->isAMDVertexShaderLayerUsable()) if (CVS->isAMDVertexShaderLayerUsable())
{ {
loadProgram(OBJECT, GET_SS(SharedInstancedShadow), loadProgram(OBJECT, GL_VERTEX_SHADER, "instanciedshadow.vert",
GL_FRAGMENT_SHADER, "shadow.frag"); GL_FRAGMENT_SHADER, "shadow.frag");
} }
else else
{ {
loadProgram(OBJECT, GET_SS(SharedInstancedShadow), loadProgram(OBJECT, GL_VERTEX_SHADER, "instanciedshadow.vert",
GL_GEOMETRY_SHADER, "instanced_shadow.geom", GL_GEOMETRY_SHADER, "instanced_shadow.geom",
GL_FRAGMENT_SHADER, "shadow.frag"); GL_FRAGMENT_SHADER, "shadow.frag");
} }
@ -222,7 +222,7 @@ class SphereMapShader : public TextureShader<SphereMapShader, 4, core::matrix4,
public: public:
SphereMapShader() SphereMapShader()
{ {
loadProgram(OBJECT, GET_SS(SharedObject), loadProgram(OBJECT, GL_VERTEX_SHADER, "object_pass.vert",
GL_FRAGMENT_SHADER, "objectpass_spheremap.frag"); GL_FRAGMENT_SHADER, "objectpass_spheremap.frag");
assignUniforms("ModelMatrix", "InverseModelMatrix"); assignUniforms("ModelMatrix", "InverseModelMatrix");
assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED, assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED,
@ -239,7 +239,7 @@ public:
InstancedSphereMapShader() InstancedSphereMapShader()
{ {
loadProgram(OBJECT, loadProgram(OBJECT,
GET_SS(SharedInstanced), GL_VERTEX_SHADER, "instanced_object_pass.vert",
GL_FRAGMENT_SHADER, "instanced_objectpass_spheremap.frag"); GL_FRAGMENT_SHADER, "instanced_objectpass_spheremap.frag");
assignUniforms(); assignUniforms();
assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED, assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED,
@ -255,7 +255,7 @@ class SplattingShader : public TextureShader<SplattingShader, 8, core::matrix4>
public: public:
SplattingShader() SplattingShader()
{ {
loadProgram(OBJECT, GET_SS(SharedObject), loadProgram(OBJECT, GL_VERTEX_SHADER, "object_pass.vert",
GL_FRAGMENT_SHADER, "splatting.frag"); GL_FRAGMENT_SHADER, "splatting.frag");
assignUniforms("ModelMatrix"); assignUniforms("ModelMatrix");
@ -277,7 +277,7 @@ class ObjectRefPass1Shader : public TextureShader<ObjectRefPass1Shader, 2, core:
public: public:
ObjectRefPass1Shader() ObjectRefPass1Shader()
{ {
loadProgram(OBJECT, GET_SS(SharedObject), loadProgram(OBJECT, GL_VERTEX_SHADER, "object_pass.vert",
GL_FRAGMENT_SHADER, "objectref_pass1.frag"); GL_FRAGMENT_SHADER, "objectref_pass1.frag");
assignUniforms("ModelMatrix", "InverseModelMatrix", "texture_trans"); assignUniforms("ModelMatrix", "InverseModelMatrix", "texture_trans");
assignSamplerNames(0, "tex", ST_TRILINEAR_ANISOTROPIC_FILTERED, assignSamplerNames(0, "tex", ST_TRILINEAR_ANISOTROPIC_FILTERED,
@ -293,7 +293,7 @@ class NormalMapShader : public TextureShader<NormalMapShader, 2, core::matrix4,
public: public:
NormalMapShader() NormalMapShader()
{ {
loadProgram(OBJECT, GET_SS(SharedObject), loadProgram(OBJECT, GL_VERTEX_SHADER, "object_pass.vert",
GL_FRAGMENT_SHADER, "normalmap.frag"); GL_FRAGMENT_SHADER, "normalmap.frag");
assignUniforms("ModelMatrix", "InverseModelMatrix"); assignUniforms("ModelMatrix", "InverseModelMatrix");
assignSamplerNames(0, "normalMap", ST_TRILINEAR_ANISOTROPIC_FILTERED, assignSamplerNames(0, "normalMap", ST_TRILINEAR_ANISOTROPIC_FILTERED,
@ -308,8 +308,8 @@ class InstancedNormalMapShader : public TextureShader<InstancedNormalMapShader,
public: public:
InstancedNormalMapShader() InstancedNormalMapShader()
{ {
loadProgram(OBJECT, GET_SS(SharedInstanced), loadProgram(OBJECT, GL_VERTEX_SHADER, "instanced_object_pass.vert",
GET_SS(SharedInstancedNormal)); GL_FRAGMENT_SHADER, "instanced_normalmap.frag");
assignUniforms(); assignUniforms();
assignSamplerNames(0, "normalMap", ST_TRILINEAR_ANISOTROPIC_FILTERED, assignSamplerNames(0, "normalMap", ST_TRILINEAR_ANISOTROPIC_FILTERED,
1, "glossMap", ST_TRILINEAR_ANISOTROPIC_FILTERED); 1, "glossMap", ST_TRILINEAR_ANISOTROPIC_FILTERED);
@ -323,7 +323,7 @@ class ObjectUnlitShader : public TextureShader<ObjectUnlitShader, 4, core::matri
public: public:
ObjectUnlitShader() ObjectUnlitShader()
{ {
loadProgram(OBJECT, GET_SS(SharedObject), loadProgram(OBJECT, GL_VERTEX_SHADER, "object_pass.vert",
GL_FRAGMENT_SHADER, "object_unlit.frag"); GL_FRAGMENT_SHADER, "object_unlit.frag");
assignUniforms("ModelMatrix", "texture_trans"); assignUniforms("ModelMatrix", "texture_trans");
assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED, assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED,
@ -339,8 +339,8 @@ class InstancedObjectUnlitShader : public TextureShader<InstancedObjectUnlitShad
public: public:
InstancedObjectUnlitShader() InstancedObjectUnlitShader()
{ {
loadProgram(OBJECT, GET_SS(SharedInstanced), loadProgram(OBJECT, GL_VERTEX_SHADER, "instanced_object_pass.vert",
GET_SS(SharedInstancedUnlit)); GL_FRAGMENT_SHADER, "instanced_object_unlit.frag");
assignUniforms(); assignUniforms();
assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED, assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED,
1, "SpecularMap", ST_NEAREST_FILTERED, 1, "SpecularMap", ST_NEAREST_FILTERED,
@ -390,12 +390,12 @@ public:
return; return;
if (CVS->isAMDVertexShaderLayerUsable()) if (CVS->isAMDVertexShaderLayerUsable())
{ {
loadProgram(OBJECT,GET_SS(SharedInstancedShadow), loadProgram(OBJECT,GL_VERTEX_SHADER, "instanciedshadow.vert",
GL_FRAGMENT_SHADER, "instanced_shadowref.frag"); GL_FRAGMENT_SHADER, "instanced_shadowref.frag");
} }
else else
{ {
loadProgram(OBJECT,GET_SS(SharedInstancedShadow), loadProgram(OBJECT,GL_VERTEX_SHADER, "instanciedshadow.vert",
GL_GEOMETRY_SHADER, "instanced_shadow.geom", GL_GEOMETRY_SHADER, "instanced_shadow.geom",
GL_FRAGMENT_SHADER, "instanced_shadowref.frag"); GL_FRAGMENT_SHADER, "instanced_shadowref.frag");
} }
@ -442,9 +442,9 @@ public:
NormalVisualizer() NormalVisualizer()
{ {
#if !defined(USE_GLES2) #if !defined(USE_GLES2)
loadProgram(OBJECT, GET_SS(SharedInstanced), loadProgram(OBJECT, GL_VERTEX_SHADER, "instanced_object_pass.vert",
GL_GEOMETRY_SHADER, "normal_visualizer.geom", GL_GEOMETRY_SHADER, "normal_visualizer.geom",
GET_SS(SharedColoredQuad)); GL_FRAGMENT_SHADER, "coloredquad.frag");
assignUniforms("color"); assignUniforms("color");
#endif #endif
} // NormalVisualizer } // NormalVisualizer
@ -473,8 +473,8 @@ class InstancedGrassPass1Shader : public TextureShader<InstancedGrassPass1Shader
public: public:
InstancedGrassPass1Shader() InstancedGrassPass1Shader()
{ {
loadProgram(OBJECT, GET_SS(SharedInstancedGrass), loadProgram(OBJECT, GL_VERTEX_SHADER, "instanced_grass.vert",
GET_SS(SharedInstancedRefPass1)); GL_FRAGMENT_SHADER, "instanced_objectref_pass1.frag");
assignUniforms("windDir"); assignUniforms("windDir");
assignSamplerNames(0, "tex", ST_TRILINEAR_ANISOTROPIC_FILTERED, assignSamplerNames(0, "tex", ST_TRILINEAR_ANISOTROPIC_FILTERED,
1, "glosstex", ST_TRILINEAR_ANISOTROPIC_FILTERED); 1, "glosstex", ST_TRILINEAR_ANISOTROPIC_FILTERED);
@ -566,8 +566,8 @@ class InstancedGrassPass2Shader : public TextureShader<InstancedGrassPass2Shader
public: public:
InstancedGrassPass2Shader() InstancedGrassPass2Shader()
{ {
loadProgram(OBJECT, GET_SS(SharedInstancedGrass), loadProgram(OBJECT, GL_VERTEX_SHADER, "instanced_grass.vert",
GET_SS(SharedInstancedGrassPass2)); GL_FRAGMENT_SHADER, "instanced_grass_pass2.frag");
assignUniforms("windDir"); assignUniforms("windDir");
assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED, assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED,
1, "SpecularMap", ST_NEAREST_FILTERED, 1, "SpecularMap", ST_NEAREST_FILTERED,
@ -586,7 +586,7 @@ class DetailedObjectPass2Shader : public TextureShader<DetailedObjectPass2Shader
public: public:
DetailedObjectPass2Shader() DetailedObjectPass2Shader()
{ {
loadProgram(OBJECT, GET_SS(SharedObject), loadProgram(OBJECT, GL_VERTEX_SHADER, "object_pass.vert",
GL_FRAGMENT_SHADER, "detailed_object_pass2.frag"); GL_FRAGMENT_SHADER, "detailed_object_pass2.frag");
assignUniforms("ModelMatrix"); assignUniforms("ModelMatrix");
assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED, assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED,
@ -605,7 +605,7 @@ public:
InstancedDetailedObjectPass2Shader() InstancedDetailedObjectPass2Shader()
{ {
loadProgram(OBJECT, loadProgram(OBJECT,
GET_SS(SharedInstanced), GL_VERTEX_SHADER, "instanced_object_pass.vert",
GL_FRAGMENT_SHADER, "instanced_detailed_object_pass2.frag"); GL_FRAGMENT_SHADER, "instanced_detailed_object_pass2.frag");
assignUniforms(); assignUniforms();
assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED, assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED,
@ -626,8 +626,8 @@ public:
SkinnedPass1Shader() SkinnedPass1Shader()
{ {
if (!CVS->supportsHardwareSkinning()) return; if (!CVS->supportsHardwareSkinning()) return;
loadProgram(OBJECT, GET_SS(SharedSkinning), loadProgram(OBJECT, GL_VERTEX_SHADER, "skinning.vert",
GET_SS(SharedPass1)); GL_FRAGMENT_SHADER, "object_pass1.frag");
assignUniforms("ModelMatrix", "InverseModelMatrix", "skinning_offset"); assignUniforms("ModelMatrix", "InverseModelMatrix", "skinning_offset");
assignSamplerNames(0, "tex", ST_TRILINEAR_ANISOTROPIC_FILTERED); assignSamplerNames(0, "tex", ST_TRILINEAR_ANISOTROPIC_FILTERED);
} // SkinnedPass1Shader } // SkinnedPass1Shader
@ -640,8 +640,8 @@ public:
InstancedSkinnedPass1Shader() InstancedSkinnedPass1Shader()
{ {
if (!CVS->supportsHardwareSkinning()) return; if (!CVS->supportsHardwareSkinning()) return;
loadProgram(OBJECT, GET_SS(SharedInstancedSkinning), loadProgram(OBJECT, GL_VERTEX_SHADER, "instanced_skinning.vert",
GET_SS(SharedInstancedPass1)); GL_FRAGMENT_SHADER, "instanced_object_pass1.frag");
assignUniforms(); assignUniforms();
assignSamplerNames(0, "glosstex", ST_TRILINEAR_ANISOTROPIC_FILTERED); assignSamplerNames(0, "glosstex", ST_TRILINEAR_ANISOTROPIC_FILTERED);
} // InstancedSkinnedPass1Shader } // InstancedSkinnedPass1Shader
@ -656,7 +656,7 @@ public:
SkinnedPass2Shader() SkinnedPass2Shader()
{ {
if (!CVS->supportsHardwareSkinning()) return; if (!CVS->supportsHardwareSkinning()) return;
loadProgram(OBJECT, GET_SS(SharedSkinning), loadProgram(OBJECT, GL_VERTEX_SHADER, "skinning.vert",
GL_FRAGMENT_SHADER, "object_pass2.frag"); GL_FRAGMENT_SHADER, "object_pass2.frag");
assignUniforms("ModelMatrix", "texture_trans", "color_change", assignUniforms("ModelMatrix", "texture_trans", "color_change",
"skinning_offset"); "skinning_offset");
@ -676,8 +676,8 @@ public:
InstancedSkinnedPass2Shader() InstancedSkinnedPass2Shader()
{ {
if (!CVS->supportsHardwareSkinning()) return; if (!CVS->supportsHardwareSkinning()) return;
loadProgram(OBJECT, GET_SS(SharedInstancedSkinning), loadProgram(OBJECT, GL_VERTEX_SHADER, "instanced_skinning.vert",
GET_SS(SharedInstancedPass2)); GL_FRAGMENT_SHADER, "instanced_object_pass2.frag");
assignUniforms(); assignUniforms();
assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED, assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED,
1, "SpecularMap", ST_NEAREST_FILTERED, 1, "SpecularMap", ST_NEAREST_FILTERED,
@ -698,7 +698,7 @@ public:
SkinnedRefPass1Shader() SkinnedRefPass1Shader()
{ {
if (!CVS->supportsHardwareSkinning()) return; if (!CVS->supportsHardwareSkinning()) return;
loadProgram(OBJECT, GET_SS(SharedSkinning), loadProgram(OBJECT, GL_VERTEX_SHADER, "skinning.vert",
GL_FRAGMENT_SHADER, "objectref_pass1.frag"); GL_FRAGMENT_SHADER, "objectref_pass1.frag");
assignUniforms("ModelMatrix", "InverseModelMatrix", "texture_trans", assignUniforms("ModelMatrix", "InverseModelMatrix", "texture_trans",
"skinning_offset"); "skinning_offset");
@ -714,8 +714,8 @@ public:
InstancedSkinnedRefPass1Shader() InstancedSkinnedRefPass1Shader()
{ {
if (!CVS->supportsHardwareSkinning()) return; if (!CVS->supportsHardwareSkinning()) return;
loadProgram(OBJECT, GET_SS(SharedInstancedSkinning), loadProgram(OBJECT, GL_VERTEX_SHADER, "instanced_skinning.vert",
GET_SS(SharedInstancedRefPass1)); GL_FRAGMENT_SHADER, "instanced_objectref_pass1.frag");
assignUniforms(); assignUniforms();
assignSamplerNames(0, "tex", ST_TRILINEAR_ANISOTROPIC_FILTERED, assignSamplerNames(0, "tex", ST_TRILINEAR_ANISOTROPIC_FILTERED,
1, "glosstex", ST_TRILINEAR_ANISOTROPIC_FILTERED); 1, "glosstex", ST_TRILINEAR_ANISOTROPIC_FILTERED);
@ -732,7 +732,7 @@ public:
SkinnedRefPass2Shader() SkinnedRefPass2Shader()
{ {
if (!CVS->supportsHardwareSkinning()) return; if (!CVS->supportsHardwareSkinning()) return;
loadProgram(OBJECT, GET_SS(SharedSkinning), loadProgram(OBJECT, GL_VERTEX_SHADER, "skinning.vert",
GL_FRAGMENT_SHADER, "objectref_pass2.frag"); GL_FRAGMENT_SHADER, "objectref_pass2.frag");
assignUniforms("ModelMatrix", "texture_trans", "color_change", assignUniforms("ModelMatrix", "texture_trans", "color_change",
"skinning_offset"); "skinning_offset");
@ -752,8 +752,8 @@ public:
InstancedSkinnedRefPass2Shader() InstancedSkinnedRefPass2Shader()
{ {
if (!CVS->supportsHardwareSkinning()) return; if (!CVS->supportsHardwareSkinning()) return;
loadProgram(OBJECT, GET_SS(SharedInstancedSkinning), loadProgram(OBJECT, GL_VERTEX_SHADER, "instanced_skinning.vert",
GET_SS(SharedInstancedRefPass2)); GL_FRAGMENT_SHADER, "instanced_objectref_pass2.frag");
assignUniforms(); assignUniforms();
assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED, assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED,
1, "SpecularMap", ST_NEAREST_FILTERED, 1, "SpecularMap", ST_NEAREST_FILTERED,
@ -773,7 +773,7 @@ public:
SkinnedUnlitShader() SkinnedUnlitShader()
{ {
if (!CVS->supportsHardwareSkinning()) return; if (!CVS->supportsHardwareSkinning()) return;
loadProgram(OBJECT, GET_SS(SharedSkinning), loadProgram(OBJECT, GL_VERTEX_SHADER, "skinning.vert",
GL_FRAGMENT_SHADER, "object_unlit.frag"); GL_FRAGMENT_SHADER, "object_unlit.frag");
assignUniforms("ModelMatrix", "texture_trans", "skinning_offset"); assignUniforms("ModelMatrix", "texture_trans", "skinning_offset");
assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED, assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED,
@ -790,8 +790,8 @@ public:
InstancedSkinnedUnlitShader() InstancedSkinnedUnlitShader()
{ {
if (!CVS->supportsHardwareSkinning()) return; if (!CVS->supportsHardwareSkinning()) return;
loadProgram(OBJECT, GET_SS(SharedInstancedSkinning), loadProgram(OBJECT, GL_VERTEX_SHADER, "instanced_skinning.vert",
GET_SS(SharedInstancedUnlit)); GL_FRAGMENT_SHADER, "instanced_object_unlit.frag");
assignUniforms(); assignUniforms();
assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED, assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED,
1, "SpecularMap", ST_NEAREST_FILTERED, 1, "SpecularMap", ST_NEAREST_FILTERED,
@ -809,7 +809,7 @@ public:
SkinnedNormalMapShader() SkinnedNormalMapShader()
{ {
if (!CVS->supportsHardwareSkinning()) return; if (!CVS->supportsHardwareSkinning()) return;
loadProgram(OBJECT, GET_SS(SharedSkinning), loadProgram(OBJECT, GL_VERTEX_SHADER, "skinning.vert",
GL_FRAGMENT_SHADER, "normalmap.frag"); GL_FRAGMENT_SHADER, "normalmap.frag");
assignUniforms("ModelMatrix", "InverseModelMatrix", "skinning_offset"); assignUniforms("ModelMatrix", "InverseModelMatrix", "skinning_offset");
assignSamplerNames(0, "normalMap", ST_TRILINEAR_ANISOTROPIC_FILTERED, assignSamplerNames(0, "normalMap", ST_TRILINEAR_ANISOTROPIC_FILTERED,
@ -824,8 +824,8 @@ public:
InstancedSkinnedNormalMapShader() InstancedSkinnedNormalMapShader()
{ {
if (!CVS->supportsHardwareSkinning()) return; if (!CVS->supportsHardwareSkinning()) return;
loadProgram(OBJECT, GET_SS(SharedInstancedSkinning), loadProgram(OBJECT, GL_VERTEX_SHADER, "instanced_skinning.vert",
GET_SS(SharedInstancedNormal)); GL_FRAGMENT_SHADER, "instanced_normalmap.frag");
assignUniforms(); assignUniforms();
assignSamplerNames(0, "normalMap", ST_TRILINEAR_ANISOTROPIC_FILTERED, assignSamplerNames(0, "normalMap", ST_TRILINEAR_ANISOTROPIC_FILTERED,
1, "glossMap", ST_TRILINEAR_ANISOTROPIC_FILTERED); 1, "glossMap", ST_TRILINEAR_ANISOTROPIC_FILTERED);
@ -871,12 +871,12 @@ public:
return; return;
if (CVS->isAMDVertexShaderLayerUsable()) if (CVS->isAMDVertexShaderLayerUsable())
{ {
loadProgram(OBJECT, GET_SS(SharedInstancedSkinningShadow), loadProgram(OBJECT, GL_VERTEX_SHADER, "instanced_skinning_shadow.vert",
GL_FRAGMENT_SHADER, "shadow.frag"); GL_FRAGMENT_SHADER, "shadow.frag");
} }
else else
{ {
loadProgram(OBJECT, GET_SS(SharedInstancedSkinningShadow), loadProgram(OBJECT, GL_VERTEX_SHADER, "instanced_skinning_shadow.vert",
GL_GEOMETRY_SHADER, "instanced_shadow.geom", GL_GEOMETRY_SHADER, "instanced_shadow.geom",
GL_FRAGMENT_SHADER, "shadow.frag"); GL_FRAGMENT_SHADER, "shadow.frag");
} }
@ -926,12 +926,12 @@ public:
return; return;
if (CVS->isAMDVertexShaderLayerUsable()) if (CVS->isAMDVertexShaderLayerUsable())
{ {
loadProgram(OBJECT, GET_SS(SharedInstancedSkinningShadow), loadProgram(OBJECT, GL_VERTEX_SHADER, "instanced_skinning_shadow.vert",
GL_FRAGMENT_SHADER, "instanced_shadowref.frag"); GL_FRAGMENT_SHADER, "instanced_shadowref.frag");
} }
else else
{ {
loadProgram(OBJECT, GET_SS(SharedInstancedSkinningShadow), loadProgram(OBJECT, GL_VERTEX_SHADER, "instanced_skinning_shadow.vert",
GL_GEOMETRY_SHADER, "instanced_shadow.geom", GL_GEOMETRY_SHADER, "instanced_shadow.geom",
GL_FRAGMENT_SHADER, "instanced_shadowref.frag"); GL_FRAGMENT_SHADER, "instanced_shadowref.frag");
} }

47
src/graphics/post_processing.cpp
View File

@ -30,7 +30,6 @@
#include "graphics/rtts.hpp" #include "graphics/rtts.hpp"
#include "graphics/shaders.hpp" #include "graphics/shaders.hpp"
#include "graphics/shared_gpu_objects.hpp" #include "graphics/shared_gpu_objects.hpp"
#include "graphics/shared_shaders.hpp"
#include "graphics/stk_mesh_scene_node.hpp" #include "graphics/stk_mesh_scene_node.hpp"
#include "graphics/texture_manager.hpp" #include "graphics/texture_manager.hpp"
#include "graphics/weather.hpp" #include "graphics/weather.hpp"
@ -57,7 +56,7 @@ class Gaussian3HBlurShader : public TextureShader<Gaussian3HBlurShader, 1,
public: public:
Gaussian3HBlurShader() Gaussian3HBlurShader()
{ {
loadProgram(OBJECT, GET_SS(SharedScreenQuad), loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
GL_FRAGMENT_SHADER, "gaussian3h.frag"); GL_FRAGMENT_SHADER, "gaussian3h.frag");
assignUniforms("pixel"); assignUniforms("pixel");
@ -99,7 +98,7 @@ class Gaussian6VBlurShader : public TextureShader<Gaussian6VBlurShader, 1,
public: public:
Gaussian6VBlurShader() Gaussian6VBlurShader()
{ {
loadProgram(OBJECT, GET_SS(SharedScreenQuad), loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
GL_FRAGMENT_SHADER, "gaussian6v.frag"); GL_FRAGMENT_SHADER, "gaussian6v.frag");
assignUniforms("pixel", "sigma"); assignUniforms("pixel", "sigma");
@ -121,7 +120,7 @@ class Gaussian3VBlurShader : public TextureShader<Gaussian3VBlurShader, 1,
public: public:
Gaussian3VBlurShader() Gaussian3VBlurShader()
{ {
loadProgram(OBJECT, GET_SS(SharedScreenQuad), loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
GL_FRAGMENT_SHADER, "gaussian3v.frag"); GL_FRAGMENT_SHADER, "gaussian3v.frag");
assignUniforms("pixel"); assignUniforms("pixel");
@ -195,7 +194,7 @@ class Gaussian6HBlurShader : public TextureShader<Gaussian6HBlurShader, 1,
public: public:
Gaussian6HBlurShader() Gaussian6HBlurShader()
{ {
loadProgram(OBJECT, GET_SS(SharedScreenQuad), loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
GL_FRAGMENT_SHADER, "gaussian6h.frag"); GL_FRAGMENT_SHADER, "gaussian6h.frag");
assignUniforms("pixel", "sigma"); assignUniforms("pixel", "sigma");
@ -219,7 +218,7 @@ class Gaussian17TapHShader : public TextureShader<Gaussian17TapHShader, 2,
public: public:
Gaussian17TapHShader() Gaussian17TapHShader()
{ {
loadProgram(OBJECT, GET_SS(SharedScreenQuad), loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
GL_FRAGMENT_SHADER, "bilateralH.frag"); GL_FRAGMENT_SHADER, "bilateralH.frag");
assignUniforms("pixel"); assignUniforms("pixel");
assignSamplerNames(0, "tex", ST_BILINEAR_CLAMPED_FILTERED, assignSamplerNames(0, "tex", ST_BILINEAR_CLAMPED_FILTERED,
@ -279,7 +278,7 @@ class Gaussian17TapVShader : public TextureShader<Gaussian17TapVShader, 2,
public: public:
Gaussian17TapVShader() Gaussian17TapVShader()
{ {
loadProgram(OBJECT, GET_SS(SharedScreenQuad), loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
GL_FRAGMENT_SHADER, "bilateralV.frag"); GL_FRAGMENT_SHADER, "bilateralV.frag");
assignUniforms("pixel"); assignUniforms("pixel");
@ -341,7 +340,7 @@ class BloomShader : public TextureShader<BloomShader, 1, float>
public: public:
BloomShader() BloomShader()
{ {
loadProgram(OBJECT, GET_SS(SharedScreenQuad), loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
GL_FRAGMENT_SHADER, "bloom.frag"); GL_FRAGMENT_SHADER, "bloom.frag");
assignUniforms("scale"); assignUniforms("scale");
assignSamplerNames(0, "tex", ST_NEAREST_FILTERED); assignSamplerNames(0, "tex", ST_NEAREST_FILTERED);
@ -365,7 +364,7 @@ public:
if (!lensDustTex) if (!lensDustTex)
lensDustTex = irr_driver->getTexture(FileManager::TEXTURE, "gfx_lensDust_a.png"); lensDustTex = irr_driver->getTexture(FileManager::TEXTURE, "gfx_lensDust_a.png");
loadProgram(OBJECT, GET_SS(SharedScreenQuad), loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
GL_FRAGMENT_SHADER, "bloomblend.frag"); GL_FRAGMENT_SHADER, "bloomblend.frag");
assignUniforms(); assignUniforms();
assignSamplerNames(0, "tex_128", ST_BILINEAR_FILTERED, assignSamplerNames(0, "tex_128", ST_BILINEAR_FILTERED,
@ -392,7 +391,7 @@ class LensBlendShader : public TextureShader<LensBlendShader, 3>
public: public:
LensBlendShader() LensBlendShader()
{ {
loadProgram(OBJECT, GET_SS(SharedScreenQuad), loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
GL_FRAGMENT_SHADER, "lensblend.frag"); GL_FRAGMENT_SHADER, "lensblend.frag");
assignUniforms(); assignUniforms();
@ -420,7 +419,7 @@ public:
ToneMapShader() ToneMapShader()
{ {
loadProgram(OBJECT, GET_SS(SharedScreenQuad), loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
GL_FRAGMENT_SHADER, "tonemap.frag"); GL_FRAGMENT_SHADER, "tonemap.frag");
assignUniforms("vignette_weight"); assignUniforms("vignette_weight");
assignSamplerNames(0, "text", ST_NEAREST_FILTERED); assignSamplerNames(0, "text", ST_NEAREST_FILTERED);
@ -440,7 +439,7 @@ class DepthOfFieldShader : public TextureShader<DepthOfFieldShader, 2>
public: public:
DepthOfFieldShader() DepthOfFieldShader()
{ {
loadProgram(OBJECT, GET_SS(SharedScreenQuad), loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
GL_FRAGMENT_SHADER, "dof.frag"); GL_FRAGMENT_SHADER, "dof.frag");
assignUniforms(); assignUniforms();
@ -482,7 +481,7 @@ class PassThroughShader : public TextureShader<PassThroughShader, 1, int, int>
public: public:
PassThroughShader() PassThroughShader()
{ {
loadProgram(OBJECT, GET_SS(SharedScreenQuad), loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
GL_FRAGMENT_SHADER, "passthrough.frag"); GL_FRAGMENT_SHADER, "passthrough.frag");
assignUniforms("width", "height"); assignUniforms("width", "height");
assignSamplerNames(0, "tex", ST_BILINEAR_FILTERED); assignSamplerNames(0, "tex", ST_BILINEAR_FILTERED);
@ -506,7 +505,7 @@ private:
public: public:
LayerPassThroughShader() LayerPassThroughShader()
{ {
loadProgram(OBJECT, GET_SS(SharedScreenQuad), loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
GL_FRAGMENT_SHADER, "layertexturequad.frag"); GL_FRAGMENT_SHADER, "layertexturequad.frag");
m_tu_texture = 0; m_tu_texture = 0;
assignUniforms("layer"); assignUniforms("layer");
@ -532,7 +531,7 @@ class LinearizeDepthShader : public TextureShader<LinearizeDepthShader, 1,
public: public:
LinearizeDepthShader() LinearizeDepthShader()
{ {
loadProgram(OBJECT, GET_SS(SharedScreenQuad), loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
GL_FRAGMENT_SHADER, "linearizedepth.frag"); GL_FRAGMENT_SHADER, "linearizedepth.frag");
assignUniforms("zn", "zf"); assignUniforms("zn", "zf");
assignSamplerNames(0, "texture", ST_BILINEAR_FILTERED); assignSamplerNames(0, "texture", ST_BILINEAR_FILTERED);
@ -556,7 +555,7 @@ public:
GlowShader() GlowShader()
{ {
loadProgram(OBJECT, GET_SS(SharedScreenQuad), loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
GL_FRAGMENT_SHADER, "glow.frag"); GL_FRAGMENT_SHADER, "glow.frag");
assignUniforms(); assignUniforms();
assignSamplerNames(0, "tex", ST_BILINEAR_FILTERED); assignSamplerNames(0, "tex", ST_BILINEAR_FILTERED);
@ -579,7 +578,7 @@ class SSAOShader : public TextureShader<SSAOShader, 1, float, float, float>
public: public:
SSAOShader() SSAOShader()
{ {
loadProgram(OBJECT, GET_SS(SharedScreenQuad), loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
GL_FRAGMENT_SHADER, "ssao.frag"); GL_FRAGMENT_SHADER, "ssao.frag");
assignUniforms("radius", "k", "sigma"); assignUniforms("radius", "k", "sigma");
@ -606,7 +605,7 @@ class MotionBlurShader : public TextureShader<MotionBlurShader, 2,
public: public:
MotionBlurShader() MotionBlurShader()
{ {
loadProgram(OBJECT, GET_SS(SharedScreenQuad), loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
GL_FRAGMENT_SHADER, "motion_blur.frag"); GL_FRAGMENT_SHADER, "motion_blur.frag");
assignUniforms("previous_viewproj", "center", "boost_amount", assignUniforms("previous_viewproj", "center", "boost_amount",
"mask_radius"); "mask_radius");
@ -632,7 +631,7 @@ class GodFadeShader : public TextureShader<GodFadeShader, 1, video::SColorf>
public: public:
GodFadeShader() GodFadeShader()
{ {
loadProgram(OBJECT, GET_SS(SharedScreenQuad), loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
GL_FRAGMENT_SHADER, "godfade.frag"); GL_FRAGMENT_SHADER, "godfade.frag");
assignUniforms("col"); assignUniforms("col");
assignSamplerNames(0, "tex", ST_BILINEAR_FILTERED); assignSamplerNames(0, "tex", ST_BILINEAR_FILTERED);
@ -651,7 +650,7 @@ class GodRayShader : public TextureShader<GodRayShader, 1, core::vector2df>
public: public:
GodRayShader() GodRayShader()
{ {
loadProgram(OBJECT, GET_SS(SharedScreenQuad), loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
GL_FRAGMENT_SHADER, "godray.frag"); GL_FRAGMENT_SHADER, "godray.frag");
assignUniforms("sunpos"); assignUniforms("sunpos");
@ -672,7 +671,7 @@ class MLAAColorEdgeDetectionSHader
public: public:
MLAAColorEdgeDetectionSHader() MLAAColorEdgeDetectionSHader()
{ {
loadProgram(OBJECT, GET_SS(SharedScreenQuad), loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
GL_FRAGMENT_SHADER, "mlaa_color1.frag"); GL_FRAGMENT_SHADER, "mlaa_color1.frag");
assignUniforms("PIXEL_SIZE"); assignUniforms("PIXEL_SIZE");
assignSamplerNames(0, "colorMapG", ST_NEAREST_FILTERED); assignSamplerNames(0, "colorMapG", ST_NEAREST_FILTERED);
@ -693,7 +692,7 @@ class MLAABlendWeightSHader : public TextureShader<MLAABlendWeightSHader,
public: public:
MLAABlendWeightSHader() MLAABlendWeightSHader()
{ {
loadProgram(OBJECT, GET_SS(SharedScreenQuad), loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
GL_FRAGMENT_SHADER, "mlaa_blend2.frag"); GL_FRAGMENT_SHADER, "mlaa_blend2.frag");
assignUniforms("PIXEL_SIZE"); assignUniforms("PIXEL_SIZE");
@ -720,7 +719,7 @@ class MLAAGatherSHader : public TextureShader<MLAAGatherSHader, 2,
public: public:
MLAAGatherSHader() MLAAGatherSHader()
{ {
loadProgram(OBJECT, GET_SS(SharedScreenQuad), loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
GL_FRAGMENT_SHADER, "mlaa_neigh3.frag"); GL_FRAGMENT_SHADER, "mlaa_neigh3.frag");
assignUniforms("PIXEL_SIZE"); assignUniforms("PIXEL_SIZE");
assignSamplerNames(0, "blendMap", ST_NEAREST_FILTERED, assignSamplerNames(0, "blendMap", ST_NEAREST_FILTERED,
@ -746,7 +745,7 @@ class LightningShader : public TextureShader<LightningShader, 1,
public: public:
LightningShader() LightningShader()
{ {
loadProgram(OBJECT, GET_SS(SharedScreenQuad), loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
GL_FRAGMENT_SHADER, "lightning.frag"); GL_FRAGMENT_SHADER, "lightning.frag");
assignUniforms("intensity"); assignUniforms("intensity");
} // LightningShader } // LightningShader

25
src/graphics/shader.hpp
View File

@ -22,7 +22,6 @@
#include "graphics/central_settings.hpp" #include "graphics/central_settings.hpp"
#include "graphics/gl_headers.hpp" #include "graphics/gl_headers.hpp"
#include "graphics/shared_shader.hpp"
#include "graphics/shared_gpu_objects.hpp" #include "graphics/shared_gpu_objects.hpp"
#include "utils/singleton.hpp" #include "utils/singleton.hpp"
@ -82,18 +81,6 @@ protected:
loadAndAttachShader(args...); loadAndAttachShader(args...);
} // loadAndAttachShader } // loadAndAttachShader
// ------------------------------------------------------------------------ // ------------------------------------------------------------------------
template<typename ... Types>
void loadAndAttachShader(SharedShader* ss, Types ... args)
{
GLint shader_id = ss->getShaderID();
glAttachShader(m_program, shader_id);
GLint is_deleted = GL_TRUE;
glGetShaderiv(shader_id, GL_DELETE_STATUS, &is_deleted);
if (is_deleted == GL_FALSE)
glDeleteShader(shader_id);
loadAndAttachShader(args...);
} // loadAndAttachShader
// ------------------------------------------------------------------------
/** Convenience interface using const char. */ /** Convenience interface using const char. */
template<typename ... Types> template<typename ... Types>
void loadAndAttachShader(GLint shader_type, const char *name, void loadAndAttachShader(GLint shader_type, const char *name,
@ -103,12 +90,12 @@ protected:
} // loadAndAttachShader } // loadAndAttachShader
// ------------------------------------------------------------------------ // ------------------------------------------------------------------------
static const std::string& getHeader(); const std::string& getHeader();
GLuint loadShader(const std::string &file, unsigned type);
void setAttribute(AttributeType type); void setAttribute(AttributeType type);
public: public:
ShaderBase(); ShaderBase();
static GLuint loadShader(const std::string &file, unsigned type);
int loadTFBProgram(const std::string &vertex_file_path, int loadTFBProgram(const std::string &vertex_file_path,
const char **varyings, const char **varyings,
unsigned varyingscount); unsigned varyingscount);
@ -298,13 +285,7 @@ protected:
Log::error("shader", filepath); Log::error("shader", filepath);
printFileList(args...); printFileList(args...);
} // printFileList } // printFileList
// ------------------------------------------------------------------------
template<typename ...Types>
void printFileList(SharedShader* ss, Types ... args)
{
Log::error("shader", ss->getName());
printFileList(args...);
} // printFileList
// ------------------------------------------------------------------------ // ------------------------------------------------------------------------
/** End recursion for variadic template. */ /** End recursion for variadic template. */
private: private:

40
src/graphics/shader_based_renderer.cpp
View File

@ -31,7 +31,6 @@
#include "graphics/render_target.hpp" #include "graphics/render_target.hpp"
#include "graphics/rtts.hpp" #include "graphics/rtts.hpp"
#include "graphics/shaders.hpp" #include "graphics/shaders.hpp"
#include "graphics/shared_shaders.hpp"
#include "graphics/skybox.hpp" #include "graphics/skybox.hpp"
#include "graphics/spherical_harmonics.hpp" #include "graphics/spherical_harmonics.hpp"
#include "graphics/texture_manager.hpp" #include "graphics/texture_manager.hpp"
@ -642,7 +641,6 @@ ShaderBasedRenderer::ShaderBasedRenderer()
m_skybox = NULL; m_skybox = NULL;
m_spherical_harmonics = new SphericalHarmonics(irr_driver->getAmbientLight().toSColor()); m_spherical_harmonics = new SphericalHarmonics(irr_driver->getAmbientLight().toSColor());
m_nb_static_glowing = 0; m_nb_static_glowing = 0;
preloadSharedShaders();
if (CVS->isAZDOEnabled()) if (CVS->isAZDOEnabled())
{ {
@ -683,7 +681,6 @@ ShaderBasedRenderer::~ShaderBasedRenderer()
delete m_spherical_harmonics; delete m_spherical_harmonics;
delete m_skybox; delete m_skybox;
delete m_rtts; delete m_rtts;
SharedShaderManager::kill();
} }
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
@ -964,41 +961,4 @@ void ShaderBasedRenderer::renderToTexture(GL3RenderTarget *render_target,
} //renderToTexture } //renderToTexture
void ShaderBasedRenderer::preloadSharedShaders()
{
SharedShaderManager* ssm = SharedShaderManager::getInstance();
// Common shaders:
ssm->addSharedShader(new SharedObject());
ssm->addSharedShader(new SharedPass1());
if (CVS->supportsHardwareSkinning())
ssm->addSharedShader(new SharedSkinning());
ssm->addSharedShader(new SharedTransparent());
ssm->addSharedShader(new SharedTexturedQuad());
ssm->addSharedShader(new SharedColoredQuad());
ssm->addSharedShader(new SharedSlicedScreenQuad());
ssm->addSharedShader(new SharedScreenQuad());
if (CVS->supportsIndirectInstancingRendering())
{
ssm->addSharedShader(new SharedInstanced());
if (CVS->supportsHardwareSkinning())
ssm->addSharedShader(new SharedInstancedSkinning());
ssm->addSharedShader(new SharedInstancedPass1());
ssm->addSharedShader(new SharedInstancedPass2());
ssm->addSharedShader(new SharedInstancedRefPass1());
ssm->addSharedShader(new SharedInstancedRefPass2());
ssm->addSharedShader(new SharedInstancedUnlit());
ssm->addSharedShader(new SharedInstancedNormal());
ssm->addSharedShader(new SharedInstancedGrass());
ssm->addSharedShader(new SharedInstancedGrassPass2());
if (CVS->isShadowEnabled())
{
ssm->addSharedShader(new SharedInstancedShadow());
if (CVS->supportsHardwareSkinning())
ssm->addSharedShader(new SharedInstancedSkinningShadow());
}
}
} //preLoadSharedShaders
#endif // !SERVER_ONLY #endif // !SERVER_ONLY

2
src/graphics/shader_based_renderer.hpp
View File

@ -85,7 +85,7 @@ private:
void debugPhysics(); void debugPhysics();
void renderPostProcessing(Camera * const camera); void renderPostProcessing(Camera * const camera);
void preloadSharedShaders();
public: public:
ShaderBasedRenderer(); ShaderBasedRenderer();

22
src/graphics/shaders.cpp
View File

@ -100,7 +100,6 @@
#include "graphics/gpu_particles.hpp" #include "graphics/gpu_particles.hpp"
#include "graphics/irr_driver.hpp" #include "graphics/irr_driver.hpp"
#include "graphics/shared_gpu_objects.hpp" #include "graphics/shared_gpu_objects.hpp"
#include "graphics/shared_shaders.hpp"
#include "io/file_manager.hpp" #include "io/file_manager.hpp"
#include "utils/log.hpp" #include "utils/log.hpp"
@ -341,8 +340,8 @@ void Shaders::check(const int num)
// Solid Normal and depth pass shaders // Solid Normal and depth pass shaders
Shaders::ObjectPass1Shader::ObjectPass1Shader() Shaders::ObjectPass1Shader::ObjectPass1Shader()
{ {
loadProgram(OBJECT, GET_SS(SharedObject), loadProgram(OBJECT, GL_VERTEX_SHADER, "object_pass.vert",
GET_SS(SharedPass1)); GL_FRAGMENT_SHADER, "object_pass1.frag");
assignUniforms("ModelMatrix", "InverseModelMatrix"); assignUniforms("ModelMatrix", "InverseModelMatrix");
assignSamplerNames(0, "tex", ST_TRILINEAR_ANISOTROPIC_FILTERED); assignSamplerNames(0, "tex", ST_TRILINEAR_ANISOTROPIC_FILTERED);
} // ObjectPass1Shader } // ObjectPass1Shader
@ -351,7 +350,7 @@ Shaders::ObjectPass1Shader::ObjectPass1Shader()
// Solid Lit pass shaders // Solid Lit pass shaders
Shaders::ObjectPass2Shader::ObjectPass2Shader() Shaders::ObjectPass2Shader::ObjectPass2Shader()
{ {
loadProgram(OBJECT, GET_SS(SharedObject), loadProgram(OBJECT, GL_VERTEX_SHADER, "object_pass.vert",
GL_FRAGMENT_SHADER, "object_pass2.frag"); GL_FRAGMENT_SHADER, "object_pass2.frag");
assignUniforms("ModelMatrix", "texture_trans", "color_change"); assignUniforms("ModelMatrix", "texture_trans", "color_change");
assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED, assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED,
@ -366,8 +365,8 @@ Shaders::ObjectPass2Shader::ObjectPass2Shader()
Shaders::SkinnedTransparentShader::SkinnedTransparentShader() Shaders::SkinnedTransparentShader::SkinnedTransparentShader()
{ {
if (!CVS->supportsHardwareSkinning()) return; if (!CVS->supportsHardwareSkinning()) return;
loadProgram(OBJECT, GET_SS(SharedSkinning), loadProgram(OBJECT, GL_VERTEX_SHADER, "skinning.vert",
GET_SS(SharedTransparent)); GL_FRAGMENT_SHADER, "transparent.frag");
assignUniforms("ModelMatrix", "texture_trans", "skinning_offset", "custom_alpha"); assignUniforms("ModelMatrix", "texture_trans", "skinning_offset", "custom_alpha");
assignSamplerNames(0, "tex", ST_TRILINEAR_ANISOTROPIC_FILTERED); assignSamplerNames(0, "tex", ST_TRILINEAR_ANISOTROPIC_FILTERED);
} // SkinnedTransparentShader } // SkinnedTransparentShader
@ -375,8 +374,8 @@ Shaders::SkinnedTransparentShader::SkinnedTransparentShader()
// ============================================================================ // ============================================================================
Shaders::TransparentShader::TransparentShader() Shaders::TransparentShader::TransparentShader()
{ {
loadProgram(OBJECT, GET_SS(SharedObject), loadProgram(OBJECT, GL_VERTEX_SHADER, "object_pass.vert",
GET_SS(SharedTransparent)); GL_FRAGMENT_SHADER, "transparent.frag");
assignUniforms("ModelMatrix", "texture_trans", "custom_alpha"); assignUniforms("ModelMatrix", "texture_trans", "custom_alpha");
assignSamplerNames(0, "tex", ST_TRILINEAR_ANISOTROPIC_FILTERED); assignSamplerNames(0, "tex", ST_TRILINEAR_ANISOTROPIC_FILTERED);
} // TransparentShader } // TransparentShader
@ -384,7 +383,7 @@ Shaders::TransparentShader::TransparentShader()
// ============================================================================ // ============================================================================
Shaders::TransparentFogShader::TransparentFogShader() Shaders::TransparentFogShader::TransparentFogShader()
{ {
loadProgram(OBJECT, GET_SS(SharedObject), loadProgram(OBJECT, GL_VERTEX_SHADER, "object_pass.vert",
GL_FRAGMENT_SHADER, "transparentfog.frag"); GL_FRAGMENT_SHADER, "transparentfog.frag");
assignUniforms("ModelMatrix", "texture_trans", "fogmax", "startH", assignUniforms("ModelMatrix", "texture_trans", "fogmax", "startH",
"endH", "start", "end", "col"); "endH", "start", "end", "col");
@ -394,8 +393,9 @@ Shaders::TransparentFogShader::TransparentFogShader()
// ============================================================================ // ============================================================================
Shaders::ColoredLine::ColoredLine() Shaders::ColoredLine::ColoredLine()
{ {
loadProgram(OBJECT, GET_SS(SharedObject), loadProgram(OBJECT, GL_VERTEX_SHADER, "object_pass.vert",
GET_SS(SharedColoredQuad)); GL_FRAGMENT_SHADER, "coloredquad.frag");
assignUniforms("color"); assignUniforms("color");
glGenVertexArrays(1, &m_vao); glGenVertexArrays(1, &m_vao);

3
src/graphics/shadow_matrices.cpp
View File

@ -27,7 +27,6 @@
#include "graphics/rtts.hpp" #include "graphics/rtts.hpp"
#include "graphics/shaders.hpp" #include "graphics/shaders.hpp"
#include "graphics/shared_gpu_objects.hpp" #include "graphics/shared_gpu_objects.hpp"
#include "graphics/shared_shaders.hpp"
#include "modes/world.hpp" #include "modes/world.hpp"
#include "physics/triangle_mesh.hpp" #include "physics/triangle_mesh.hpp"
#include "tracks/track.hpp" #include "tracks/track.hpp"
@ -96,7 +95,7 @@ private:
public: ViewFrustrumShader() public: ViewFrustrumShader()
{ {
loadProgram(OBJECT, GL_VERTEX_SHADER, "frustrum.vert", loadProgram(OBJECT, GL_VERTEX_SHADER, "frustrum.vert",
GET_SS(SharedColoredQuad)); GL_FRAGMENT_SHADER, "coloredquad.frag");
assignUniforms("color", "idx"); assignUniforms("color", "idx");

28
src/graphics/shared_shader.cpp
View File

@ -1,28 +0,0 @@
// SuperTuxKart - a fun racing game with go-kart
// Copyright (C) 2016 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.
#ifndef SERVER_ONLY
#include "graphics/shared_shader.hpp"
#include "graphics/shader.hpp"
void SharedShader::loadSharedShader()
{
m_shader_id = ShaderBase::loadShader(getName(), getShaderType());
}; // loadSharedShader
#endif // !SERVER_ONLY

49
src/graphics/shared_shader.hpp
View File

@ -1,49 +0,0 @@
// SuperTuxKart - a fun racing game with go-kart
// Copyright (C) 2016 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.
#ifndef SERVER_ONLY
#ifndef HEADER_SHARED_SHADER_HPP
#define HEADER_SHARED_SHADER_HPP
#include "graphics/gl_headers.hpp"
#include "utils/no_copy.hpp"
class SharedShader : public NoCopy
{
private:
GLuint m_shader_id;
public:
// ------------------------------------------------------------------------
SharedShader() { m_shader_id = 0; }
// ------------------------------------------------------------------------
virtual ~SharedShader() {}
// ------------------------------------------------------------------------
GLuint getShaderID() const { return m_shader_id; }
// ------------------------------------------------------------------------
virtual const char* getName() = 0;
// ------------------------------------------------------------------------
virtual unsigned getShaderType() = 0;
// ------------------------------------------------------------------------
void loadSharedShader();
}; // SharedShader
#endif
#endif // !SERVER_ONLY

81
src/graphics/shared_shader_manager.hpp
View File

@ -1,81 +0,0 @@
// SuperTuxKart - a fun racing game with go-kart
// Copyright (C) 2016 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.
#ifndef SERVER_ONLY
#ifndef HEADER_SHARED_SHADER_MANAGER_HPP
#define HEADER_SHARED_SHADER_MANAGER_HPP
#include "graphics/shared_shader.hpp"
#include "utils/no_copy.hpp"
#include "utils/singleton.hpp"
#include <algorithm>
#include <typeindex>
#include <unordered_map>
#include <vector>
class SharedShaderManager : public Singleton<SharedShaderManager>, NoCopy
{
private:
std::unordered_map<std::type_index, int> m_shaders_map;
std::vector<SharedShader*> m_shared_shaders;
unsigned int m_shared_shader_loaded;
public:
// ------------------------------------------------------------------------
SharedShaderManager() { m_shared_shader_loaded = 0; }
// ------------------------------------------------------------------------
~SharedShaderManager()
{
for (SharedShader* ss : m_shared_shaders)
delete ss;
} // ~SharedShaderManager
// ------------------------------------------------------------------------
template <typename T>
void addSharedShader(T* ss)
{
ss->loadSharedShader();
m_shaders_map[std::type_index(typeid(T))] = m_shared_shader_loaded++;
m_shared_shaders.push_back(ss);
} // addSharedShader
// ------------------------------------------------------------------------
template <typename T> T* getSharedShader()
{
std::unordered_map<std::type_index, int>::const_iterator i =
m_shaders_map.find(std::type_index(typeid(T)));
if (i != m_shaders_map.end())
{
T* ss = dynamic_cast<T*>(m_shared_shaders[i->second]);
assert(ss != NULL);
return ss;
}
else
{
T* new_ss = new T();
addSharedShader(new_ss);
return new_ss;
}
} // getSharedShader
}; // SharedShaderManager
#endif
#endif // !SERVER_ONLY

244
src/graphics/shared_shaders.hpp
View File

@ -1,244 +0,0 @@
// SuperTuxKart - a fun racing game with go-kart
// Copyright (C) 2016 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.
#ifndef SERVER_ONLY
#ifndef HEADER_SHARED_SHADERS_HPP
#define HEADER_SHARED_SHADERS_HPP
#include "graphics/shared_shader_manager.hpp"
#include "utils/cpp2011.hpp"
#define GET_SS(SS) SharedShaderManager::getInstance()->getSharedShader<SS>()
// ============================================================================
// Common shaders:
class SharedObject : public SharedShader
{
public:
// ------------------------------------------------------------------------
virtual const char* getName() OVERRIDE { return "object_pass.vert"; }
// ------------------------------------------------------------------------
virtual unsigned getShaderType() OVERRIDE { return GL_VERTEX_SHADER; }
}; // SharedObject
// ============================================================================
class SharedPass1 : public SharedShader
{
public:
// ------------------------------------------------------------------------
virtual const char* getName() OVERRIDE { return "object_pass1.frag"; }
// ------------------------------------------------------------------------
virtual unsigned getShaderType() OVERRIDE { return GL_FRAGMENT_SHADER; }
}; // SharedPass1
// ============================================================================
class SharedSkinning : public SharedShader
{
public:
// ------------------------------------------------------------------------
virtual const char* getName() OVERRIDE { return "skinning.vert"; }
// ------------------------------------------------------------------------
virtual unsigned getShaderType() OVERRIDE { return GL_VERTEX_SHADER; }
}; // SharedSkinning
// ============================================================================
class SharedTransparent : public SharedShader
{
public:
// ------------------------------------------------------------------------
virtual const char* getName() OVERRIDE { return "transparent.frag"; }
// ------------------------------------------------------------------------
virtual unsigned getShaderType() OVERRIDE { return GL_FRAGMENT_SHADER; }
}; // SharedTransparent
// ============================================================================
class SharedTexturedQuad : public SharedShader
{
public:
// ------------------------------------------------------------------------
virtual const char* getName() OVERRIDE { return "texturedquad.vert"; }
// ------------------------------------------------------------------------
virtual unsigned getShaderType() OVERRIDE { return GL_VERTEX_SHADER; }
}; // SharedTexturedQuad
// ============================================================================
class SharedColoredQuad : public SharedShader
{
public:
// ------------------------------------------------------------------------
virtual const char* getName() OVERRIDE { return "coloredquad.frag"; }
// ------------------------------------------------------------------------
virtual unsigned getShaderType() OVERRIDE { return GL_FRAGMENT_SHADER; }
}; // SharedColoredQuad
// ============================================================================
class SharedSlicedScreenQuad : public SharedShader
{
public:
// ------------------------------------------------------------------------
virtual const char* getName() OVERRIDE { return "slicedscreenquad.vert"; }
// ------------------------------------------------------------------------
virtual unsigned getShaderType() OVERRIDE { return GL_VERTEX_SHADER; }
}; // SharedSlicedScreenQuad
// ============================================================================
class SharedScreenQuad : public SharedShader
{
public:
// ------------------------------------------------------------------------
virtual const char* getName() OVERRIDE { return "screenquad.vert"; }
// ------------------------------------------------------------------------
virtual unsigned getShaderType() OVERRIDE { return GL_VERTEX_SHADER; }
}; // SharedScreenQuad
// ============================================================================
// Instanced shaders:
class SharedInstanced : public SharedShader
{
public:
// ------------------------------------------------------------------------
virtual const char* getName() OVERRIDE
{ return "instanced_object_pass.vert"; }
// ------------------------------------------------------------------------
virtual unsigned getShaderType() OVERRIDE { return GL_VERTEX_SHADER; }
}; // SharedInstanced
// ============================================================================
class SharedInstancedSkinning : public SharedShader
{
public:
// ------------------------------------------------------------------------
virtual const char* getName() OVERRIDE
{ return "instanced_skinning.vert"; }
// ------------------------------------------------------------------------
virtual unsigned getShaderType() OVERRIDE { return GL_VERTEX_SHADER; }
}; // SharedInstancedSkinning
// ============================================================================
class SharedInstancedPass1 : public SharedShader
{
public:
// ------------------------------------------------------------------------
virtual const char* getName() OVERRIDE
{ return "instanced_object_pass1.frag"; }
// ------------------------------------------------------------------------
virtual unsigned getShaderType() OVERRIDE { return GL_FRAGMENT_SHADER; }
}; // SharedInstancedPass1
// ============================================================================
class SharedInstancedPass2 : public SharedShader
{
public:
// ------------------------------------------------------------------------
virtual const char* getName() OVERRIDE
{ return "instanced_object_pass2.frag"; }
// ------------------------------------------------------------------------
virtual unsigned getShaderType() OVERRIDE { return GL_FRAGMENT_SHADER; }
}; // SharedInstancedPass2
// ============================================================================
class SharedInstancedRefPass1 : public SharedShader
{
public:
// ------------------------------------------------------------------------
virtual const char* getName() OVERRIDE
{ return "instanced_objectref_pass1.frag"; }
// ------------------------------------------------------------------------
virtual unsigned getShaderType() OVERRIDE { return GL_FRAGMENT_SHADER; }
}; // SharedInstancedRefPass1
// ============================================================================
class SharedInstancedRefPass2 : public SharedShader
{
public:
// ------------------------------------------------------------------------
virtual const char* getName() OVERRIDE
{ return "instanced_objectref_pass2.frag"; }
// ------------------------------------------------------------------------
virtual unsigned getShaderType() OVERRIDE { return GL_FRAGMENT_SHADER; }
}; // SharedInstancedRefPass2
// ============================================================================
class SharedInstancedUnlit : public SharedShader
{
public:
// ------------------------------------------------------------------------
virtual const char* getName() OVERRIDE
{ return "instanced_object_unlit.frag"; }
// ------------------------------------------------------------------------
virtual unsigned getShaderType() OVERRIDE { return GL_FRAGMENT_SHADER; }
}; // SharedInstancedUnlit
// ============================================================================
class SharedInstancedNormal : public SharedShader
{
public:
// ------------------------------------------------------------------------
virtual const char* getName() OVERRIDE
{ return "instanced_normalmap.frag"; }
// ------------------------------------------------------------------------
virtual unsigned getShaderType() OVERRIDE { return GL_FRAGMENT_SHADER; }
}; // SharedInstancedNormal
// ============================================================================
class SharedInstancedGrass : public SharedShader
{
public:
// ------------------------------------------------------------------------
virtual const char* getName() OVERRIDE
{ return "instanced_grass.vert"; }
// ------------------------------------------------------------------------
virtual unsigned getShaderType() OVERRIDE { return GL_VERTEX_SHADER; }
}; // SharedInstancedGrass
// ============================================================================
class SharedInstancedGrassPass2 : public SharedShader
{
public:
// ------------------------------------------------------------------------
virtual const char* getName() OVERRIDE
{ return "instanced_grass_pass2.frag"; }
// ------------------------------------------------------------------------
virtual unsigned getShaderType() OVERRIDE { return GL_FRAGMENT_SHADER; }
}; // SharedInstancedGrassPass2
// ============================================================================
class SharedInstancedShadow : public SharedShader
{
public:
// ------------------------------------------------------------------------
virtual const char* getName() OVERRIDE { return "instanciedshadow.vert"; }
// ------------------------------------------------------------------------
virtual unsigned getShaderType() OVERRIDE { return GL_VERTEX_SHADER; }
}; // SharedInstancedShadow
// ============================================================================
class SharedInstancedSkinningShadow : public SharedShader
{
public:
// ------------------------------------------------------------------------
virtual const char* getName() OVERRIDE
{ return "instanced_skinning_shadow.vert"; }
// ------------------------------------------------------------------------
virtual unsigned getShaderType() OVERRIDE { return GL_VERTEX_SHADER; }
}; // SharedInstancedSkinningShadow
#endif
#endif // !SERVER_ONLY

4
src/graphics/skybox.cpp
View File

@ -21,7 +21,7 @@
#include "graphics/central_settings.hpp" #include "graphics/central_settings.hpp"
#include "graphics/irr_driver.hpp" #include "graphics/irr_driver.hpp"
#include "graphics/shaders.hpp" #include "graphics/shaders.hpp"
#include "graphics/shared_shaders.hpp"
#include <algorithm> #include <algorithm>
#include <cassert> #include <cassert>
@ -64,7 +64,7 @@ public:
GLuint m_tu_samples; GLuint m_tu_samples;
SpecularIBLGenerator() SpecularIBLGenerator()
{ {
loadProgram(OBJECT, GET_SS(SharedScreenQuad), loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
GL_FRAGMENT_SHADER, "importance_sampling_specular.frag"); GL_FRAGMENT_SHADER, "importance_sampling_specular.frag");
assignUniforms("PermutationMatrix", "ViewportSize"); assignUniforms("PermutationMatrix", "ViewportSize");
m_tu_samples = 1; m_tu_samples = 1;

3
src/graphics/stk_mesh_scene_node.cpp
View File

@ -24,7 +24,6 @@
#include "graphics/material_manager.hpp" #include "graphics/material_manager.hpp"
#include "graphics/render_info.hpp" #include "graphics/render_info.hpp"
#include "graphics/rtts.hpp" #include "graphics/rtts.hpp"
#include "graphics/shared_shaders.hpp"
#include "graphics/stk_mesh.hpp" #include "graphics/stk_mesh.hpp"
#include "graphics/texture_manager.hpp" #include "graphics/texture_manager.hpp"
#include "graphics/vao_manager.hpp" #include "graphics/vao_manager.hpp"
@ -41,7 +40,7 @@ class ColorizeShader : public Shader<ColorizeShader, core::matrix4,
public: public:
ColorizeShader() ColorizeShader()
{ {
loadProgram(OBJECT, GET_SS(SharedObject), loadProgram(OBJECT, GL_VERTEX_SHADER, "object_pass.vert",
GL_FRAGMENT_SHADER, "colorize.frag"); GL_FRAGMENT_SHADER, "colorize.frag");
assignUniforms("ModelMatrix", "col"); assignUniforms("ModelMatrix", "col");
} }

2
src/utils/debug.cpp
View File

@ -29,7 +29,6 @@
#include "graphics/irr_driver.hpp" #include "graphics/irr_driver.hpp"
#include "graphics/light.hpp" #include "graphics/light.hpp"
#include "graphics/shaders.hpp" #include "graphics/shaders.hpp"
#include "graphics/shared_shader_manager.hpp"
#include "items/powerup_manager.hpp" #include "items/powerup_manager.hpp"
#include "items/attachment.hpp" #include "items/attachment.hpp"
#include "karts/abstract_kart.hpp" #include "karts/abstract_kart.hpp"
@ -237,7 +236,6 @@ bool handleContextMenuAction(s32 cmd_id)
case DEBUG_GRAPHICS_RELOAD_SHADERS: case DEBUG_GRAPHICS_RELOAD_SHADERS:
#ifndef SERVER_ONLY #ifndef SERVER_ONLY
Log::info("Debug", "Reloading shaders..."); Log::info("Debug", "Reloading shaders...");
SharedShaderManager::kill();
ShaderBase::updateShaders(); ShaderBase::updateShaders();
#endif #endif
break; break;