Itms/0ad
1
0
Fork 0
forked from 0ad/0ad
Code Pull Requests Activity

Add a list of statically-constructed CStrIntern strings

Browse Source 
Switch all the constant strings in graphics code to use the new
variables.
This avoids the cost of instantiating CStrInterns at runtime every
frame.

This was SVN commit r13906.
This commit is contained in:
Ykkrosh 2013-09-29 13:19:52 +00:00
parent 08f431fa0d
commit 994ebd9836
40 changed files with 451 additions and 308 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
source/graphics/Decal.cpp
View File

@ -110,5 +110,5 @@ void CModelDecal::SetTransform(const CMatrix3D& transform)
void CModelDecal::RemoveShadows()
{
m_Decal.m_Material.AddShaderDefine("DISABLE_RECEIVE_SHADOWS", "1");
m_Decal.m_Material.AddShaderDefine(str_DISABLE_RECEIVE_SHADOWS, str_1);
}

8
source/graphics/LOSTexture.cpp
View File

@ -55,7 +55,7 @@ CLOSTexture::CLOSTexture(CSimulation2& simulation) :
{
if (CRenderer::IsInitialised() && g_Renderer.m_Options.m_SmoothLOS)
{
m_smoothShader = g_Renderer.GetShaderManager().LoadEffect("los_interp");
m_smoothShader = g_Renderer.GetShaderManager().LoadEffect(str_los_interp);
CShaderProgramPtr shader = m_smoothShader->GetShader();
if (m_smoothShader && shader)
@ -142,10 +142,10 @@ void CLOSTexture::InterpolateLOS()
shader->Bind();
shader->BindTexture("losTex1", m_Texture);
shader->BindTexture("losTex2", whichTex ? m_TextureSmooth1 : m_TextureSmooth2);
shader->BindTexture(str_losTex1, m_Texture);
shader->BindTexture(str_losTex2, whichTex ? m_TextureSmooth1 : m_TextureSmooth2);
shader->Uniform("delta", (float)g_Renderer.GetTimeManager().GetFrameDelta() * 4.0f, 0.0f, 0.0f, 0.0f);
shader->Uniform(str_delta, (float)g_Renderer.GetTimeManager().GetFrameDelta() * 4.0f, 0.0f, 0.0f, 0.0f);
glPushAttrib(GL_VIEWPORT_BIT);
glViewport(0, 0, m_TextureSize, m_TextureSize);

6
source/graphics/Material.cpp
View File

@ -32,7 +32,7 @@ void CMaterial::SetShaderEffect(const CStr& effect)
m_ShaderEffect = CStrIntern(effect);
}
void CMaterial::AddShaderDefine(const char* key, const char* value)
void CMaterial::AddShaderDefine(CStrIntern key, CStrIntern value)
{
m_ShaderDefines.Add(key, value);
m_CombinedShaderDefines.clear();
@ -52,7 +52,7 @@ void CMaterial::AddStaticUniform(const char* key, const CVector4D& value)
void CMaterial::AddSampler(const TextureSampler& texture)
{
m_Samplers.push_back(texture);
if (texture.Name == CStrIntern("baseTex"))
if (texture.Name == str_baseTex)
m_DiffuseTexture = texture.Sampler;
}
@ -81,7 +81,7 @@ void CMaterial::RecomputeCombinedShaderDefines()
if (i & (1 << j))
{
const CShaderConditionalDefines::CondDefine& def = m_ConditionalDefines.GetItem(j);
defs.Add(def.m_DefName.c_str(), def.m_DefValue.c_str());
defs.Add(def.m_DefName, def.m_DefValue);
}
}
m_CombinedShaderDefines.push_back(defs);

2
source/graphics/Material.h
View File

@ -52,7 +52,7 @@ public:
void SetShaderEffect(const CStr& effect);
CStrIntern GetShaderEffect() const { return m_ShaderEffect; }
void AddShaderDefine(const char* key, const char* value);
void AddShaderDefine(CStrIntern key, CStrIntern value);
// conditionFlags is a bitmask representing which indexes of the
// GetConditionalDefines() list are currently matching.

6
source/graphics/MaterialManager.cpp
View File

@ -114,7 +114,7 @@ CMaterial CMaterialManager::LoadMaterial(const VfsPath& pathname)
}
else if (token == el_define)
{
material.AddShaderDefine(attrs.GetNamedItem(at_name).c_str(), attrs.GetNamedItem(at_value).c_str());
material.AddShaderDefine(CStrIntern(attrs.GetNamedItem(at_name)), CStrIntern(attrs.GetNamedItem(at_value)));
}
else if (token == el_conditional_define)
{
@ -154,14 +154,14 @@ CMaterial CMaterialManager::LoadMaterial(const VfsPath& pathname)
{
std::stringstream sstr;
sstr << valmin;
material.AddShaderDefine((conf + "_MIN").c_str(), sstr.str().c_str());
material.AddShaderDefine(CStrIntern(conf + "_MIN"), CStrIntern(sstr.str()));
}
if (valmax >= 0.0f)
{
std::stringstream sstr;
sstr << valmax;
material.AddShaderDefine((conf + "_MAX").c_str(), sstr.str().c_str());
material.AddShaderDefine(CStrIntern(conf + "_MAX"), CStrIntern(sstr.str()));
}
}

4
source/graphics/Model.cpp
View File

@ -626,7 +626,7 @@ void CModel::AddFlagsRec(int flags)
m_Flags |= flags;
if (flags & MODELFLAG_IGNORE_LOS)
m_Material.AddShaderDefine("IGNORE_LOS", "1");
m_Material.AddShaderDefine(str_IGNORE_LOS, str_1);
for (size_t i = 0; i < m_Props.size(); ++i)
if (m_Props[i].m_Model->ToCModel())
@ -637,7 +637,7 @@ void CModel::RemoveShadowsRec()
{
m_Flags &= ~MODELFLAG_CASTSHADOWS;
m_Material.AddShaderDefine("DISABLE_RECEIVE_SHADOWS", "1");
m_Material.AddShaderDefine(str_DISABLE_RECEIVE_SHADOWS, str_1);
for (size_t i = 0; i < m_Props.size(); ++i)
{

12
source/graphics/ParticleEmitter.cpp
View File

@ -167,15 +167,15 @@ void CParticleEmitter::UpdateArrayData()
void CParticleEmitter::Bind(const CShaderProgramPtr& shader)
{
CLOSTexture& los = g_Renderer.GetScene().GetLOSTexture();
shader->BindTexture("losTex", los.GetTextureSmooth());
shader->Uniform("losTransform", los.GetTextureMatrix()[0], los.GetTextureMatrix()[12], 0.f, 0.f);
shader->BindTexture(str_losTex, los.GetTextureSmooth());
shader->Uniform(str_losTransform, los.GetTextureMatrix()[0], los.GetTextureMatrix()[12], 0.f, 0.f);
const CLightEnv& lightEnv = g_Renderer.GetLightEnv();
shader->Uniform("sunColor", lightEnv.m_SunColor);
shader->Uniform("fogColor", lightEnv.m_FogColor);
shader->Uniform("fogParams", lightEnv.m_FogFactor, lightEnv.m_FogMax, 0.f, 0.f);
shader->Uniform(str_sunColor, lightEnv.m_SunColor);
shader->Uniform(str_fogColor, lightEnv.m_FogColor);
shader->Uniform(str_fogParams, lightEnv.m_FogFactor, lightEnv.m_FogMax, 0.f, 0.f);
shader->BindTexture("baseTex", m_Type->m_Texture);
shader->BindTexture(str_baseTex, m_Type->m_Texture);
pglBlendEquationEXT(m_Type->m_BlendEquation);
glBlendFunc(m_Type->m_BlendFuncSrc, m_Type->m_BlendFuncDst);
}

4
source/graphics/ShaderDefines.cpp
View File

@ -180,9 +180,9 @@ void CShaderParams<value_t>::SItems::RecalcHash()
}
void CShaderDefines::Add(const char* name, const char* value)
void CShaderDefines::Add(CStrIntern name, CStrIntern value)
{
Set(CStrIntern(name), CStrIntern(value));
Set(name, value);
}
int CShaderDefines::GetInt(const char* name) const

2
source/graphics/ShaderDefines.h
View File

@ -133,7 +133,7 @@ public:
* Add a name and associated value to the map of defines.
* If the name is already defined, its value will be replaced.
*/
void Add(const char* name, const char* value);
void Add(CStrIntern name, CStrIntern value);
/**
* Return the value for the given name as an integer, or 0 if not defined.

10
source/graphics/ShaderManager.cpp
View File

@ -183,7 +183,7 @@ bool CShaderManager::NewProgram(const char* name, const CShaderDefines& baseDefi
{
if (Child.GetNodeName() == el_define)
{
defines.Add(Child.GetAttributes().GetNamedItem(at_name).c_str(), Child.GetAttributes().GetNamedItem(at_value).c_str());
defines.Add(CStrIntern(Child.GetAttributes().GetNamedItem(at_name)), CStrIntern(Child.GetAttributes().GetNamedItem(at_value)));
}
else if (Child.GetNodeName() == el_vertex)
{
@ -347,9 +347,9 @@ bool CShaderManager::EffectCacheKey::operator==(const EffectCacheKey& b) const
return (name == b.name && defines1 == b.defines1 && defines2 == b.defines2);
}
CShaderTechniquePtr CShaderManager::LoadEffect(const char* name)
CShaderTechniquePtr CShaderManager::LoadEffect(CStrIntern name)
{
return LoadEffect(CStrIntern(name), g_Renderer.GetSystemShaderDefines(), CShaderDefines());
return LoadEffect(name, g_Renderer.GetSystemShaderDefines(), CShaderDefines());
}
CShaderTechniquePtr CShaderManager::LoadEffect(CStrIntern name, const CShaderDefines& defines1, const CShaderDefines& defines2)
@ -499,7 +499,7 @@ bool CShaderManager::NewEffect(const char* name, const CShaderDefines& baseDefin
{
if (Child.GetNodeName() == el_define)
{
techDefines.Add(Child.GetAttributes().GetNamedItem(at_name).c_str(), Child.GetAttributes().GetNamedItem(at_value).c_str());
techDefines.Add(CStrIntern(Child.GetAttributes().GetNamedItem(at_name)), CStrIntern(Child.GetAttributes().GetNamedItem(at_value)));
}
else if (Child.GetNodeName() == el_sort_by_distance)
{
@ -515,7 +515,7 @@ bool CShaderManager::NewEffect(const char* name, const CShaderDefines& baseDefin
{
if (Element.GetNodeName() == el_define)
{
passDefines.Add(Element.GetAttributes().GetNamedItem(at_name).c_str(), Element.GetAttributes().GetNamedItem(at_value).c_str());
passDefines.Add(CStrIntern(Element.GetAttributes().GetNamedItem(at_name)), CStrIntern(Element.GetAttributes().GetNamedItem(at_value)));
}
else if (Element.GetNodeName() == el_alpha)
{

2
source/graphics/ShaderManager.h
View File

@ -65,7 +65,7 @@ public:
/**
* Load a shader effect, with default system defines (from CRenderer::GetSystemShaderDefines).
*/
CShaderTechniquePtr LoadEffect(const char* name);
CShaderTechniquePtr LoadEffect(CStrIntern name);
/**
* Returns the number of shader effects that are currently loaded.

33
source/graphics/ShaderProgram.cpp
View File

@ -157,7 +157,7 @@ public:
virtual Binding GetTextureBinding(texture_id_t id)
{
frag_index_pair_t fPair = GetUniformFragmentIndex(CStrIntern(id));
frag_index_pair_t fPair = GetUniformFragmentIndex(id);
int index = fPair.first;
if (index == -1)
return Binding();
@ -167,7 +167,7 @@ public:
virtual void BindTexture(texture_id_t id, Handle tex)
{
frag_index_pair_t fPair = GetUniformFragmentIndex(CStrIntern(id));
frag_index_pair_t fPair = GetUniformFragmentIndex(id);
int index = fPair.first;
if (index != -1)
{
@ -180,7 +180,7 @@ public:
virtual void BindTexture(texture_id_t id, GLuint tex)
{
frag_index_pair_t fPair = GetUniformFragmentIndex(CStrIntern(id));
frag_index_pair_t fPair = GetUniformFragmentIndex(id);
int index = fPair.first;
if (index != -1)
{
@ -197,12 +197,6 @@ public:
}
virtual Binding GetUniformBinding(uniform_id_t id)
{
CStrIntern idIntern(id);
return Binding(GetUniformVertexIndex(idIntern), GetUniformFragmentIndex(idIntern).first);
}
virtual Binding GetUniformBinding(CStrIntern id)
{
return Binding(GetUniformVertexIndex(id), GetUniformFragmentIndex(id).first);
}
@ -546,15 +540,6 @@ public:
}
virtual Binding GetUniformBinding(uniform_id_t id)
{
std::map<CStrIntern, std::pair<int, GLenum> >::iterator it = m_Uniforms.find(CStrIntern(id));
if (it == m_Uniforms.end())
return Binding();
else
return Binding(it->second.first, (int)it->second.second);
}
virtual Binding GetUniformBinding(CStrIntern id)
{
std::map<CStrIntern, std::pair<int, GLenum> >::iterator it = m_Uniforms.find(id);
if (it == m_Uniforms.end())
@ -629,18 +614,18 @@ public:
m_ValidStreams |= STREAM_UV0 << (texture - GL_TEXTURE0);
}
virtual void VertexAttribPointer(const char* id, GLint size, GLenum type, GLboolean normalized, GLsizei stride, void* pointer)
virtual void VertexAttribPointer(attrib_id_t id, GLint size, GLenum type, GLboolean normalized, GLsizei stride, void* pointer)
{
std::map<CStrIntern, int>::iterator it = m_VertexAttribs.find(CStrIntern(id));
std::map<CStrIntern, int>::iterator it = m_VertexAttribs.find(id);
if (it != m_VertexAttribs.end())
{
pglVertexAttribPointerARB(it->second, size, type, normalized, stride, pointer);
}
}
virtual void VertexAttribIPointer(const char* id, GLint size, GLenum type, GLsizei stride, void* pointer)
virtual void VertexAttribIPointer(attrib_id_t id, GLint size, GLenum type, GLsizei stride, void* pointer)
{
std::map<CStrIntern, int>::iterator it = m_VertexAttribs.find(CStrIntern(id));
std::map<CStrIntern, int>::iterator it = m_VertexAttribs.find(id);
if (it != m_VertexAttribs.end())
{
#if CONFIG2_GLES
@ -784,13 +769,13 @@ void CShaderProgram::Uniform(uniform_id_t id, size_t count, const CMatrix3D* v)
// These should all be overridden by CShaderProgramGLSL, and not used
// if a non-GLSL shader was loaded instead:
void CShaderProgram::VertexAttribPointer(const char* UNUSED(id), GLint UNUSED(size), GLenum UNUSED(type),
void CShaderProgram::VertexAttribPointer(attrib_id_t UNUSED(id), GLint UNUSED(size), GLenum UNUSED(type),
GLboolean UNUSED(normalized), GLsizei UNUSED(stride), void* UNUSED(pointer))
{
debug_warn("Shader type doesn't support VertexAttribPointer");
}
void CShaderProgram::VertexAttribIPointer(const char* UNUSED(id), GLint UNUSED(size), GLenum UNUSED(type),
void CShaderProgram::VertexAttribIPointer(attrib_id_t UNUSED(id), GLint UNUSED(size), GLenum UNUSED(type),
GLsizei UNUSED(stride), void* UNUSED(pointer))
{
debug_warn("Shader type doesn't support VertexAttribIPointer");

14
source/graphics/ShaderProgram.h
View File

@ -67,9 +67,9 @@ class CShaderProgram
NONCOPYABLE(CShaderProgram);
public:
typedef const char* attrib_id_t;
typedef const char* texture_id_t;
typedef const char* uniform_id_t;
typedef CStrIntern attrib_id_t;
typedef CStrIntern texture_id_t;
typedef CStrIntern uniform_id_t;
typedef std::pair<int, GLenum> frag_index_pair_t;
/**
@ -144,9 +144,6 @@ public:
*/
int GetStreamFlags() const;
// TODO: implement vertex attributes
GLuint GetAttribIndex(attrib_id_t id);
virtual Binding GetTextureBinding(texture_id_t id) = 0;
@ -158,7 +155,6 @@ public:
virtual Binding GetUniformBinding(uniform_id_t id) = 0;
virtual Binding GetUniformBinding(CStrIntern id) = 0;
// Uniform-setting methods that subclasses must define:
virtual void Uniform(Binding id, float v0, float v1, float v2, float v3) = 0;
@ -188,8 +184,8 @@ public:
virtual void NormalPointer(GLenum type, GLsizei stride, void* pointer);
virtual void ColorPointer(GLint size, GLenum type, GLsizei stride, void* pointer);
virtual void TexCoordPointer(GLenum texture, GLint size, GLenum type, GLsizei stride, void* pointer);
virtual void VertexAttribPointer(const char* id, GLint size, GLenum type, GLboolean normalized, GLsizei stride, void* pointer);
virtual void VertexAttribIPointer(const char* id, GLint size, GLenum type, GLsizei stride, void* pointer);
virtual void VertexAttribPointer(attrib_id_t id, GLint size, GLenum type, GLboolean normalized, GLsizei stride, void* pointer);
virtual void VertexAttribIPointer(attrib_id_t id, GLint size, GLenum type, GLsizei stride, void* pointer);
/**
* Checks that all the required vertex attributes have been set.

5
source/graphics/ShaderProgramFFP.cpp
View File

@ -98,11 +98,6 @@ public:
}
virtual Binding GetUniformBinding(uniform_id_t id)
{
return Binding(-1, GetUniformIndex(CStrIntern(id)));
}
virtual Binding GetUniformBinding(CStrIntern id)
{
return Binding(-1, GetUniformIndex(id));
}

11
source/graphics/TextRenderer.cpp
View File

@ -21,6 +21,7 @@
#include "lib/ogl.h"
#include "lib/res/graphics/unifont.h"
#include "ps/CStrIntern.h"
#include "ps/Font.h"
extern int g_xres, g_yres;
@ -156,18 +157,18 @@ void CTextRenderer::Render()
const std::map<u16, UnifontGlyphData>& glyphs = batch.font->GetGlyphs();
m_Shader->BindTexture("tex", batch.font->GetTexture());
m_Shader->BindTexture(str_tex, batch.font->GetTexture());
m_Shader->Uniform("transform", batch.transform);
m_Shader->Uniform(str_transform, batch.transform);
// ALPHA-only textures will have .rgb sampled as 0, so we need to
// replace it with white (but not affect RGBA textures)
if (batch.font->HasRGB())
m_Shader->Uniform("colorAdd", CColor(0.0f, 0.0f, 0.0f, 0.0f));
m_Shader->Uniform(str_colorAdd, CColor(0.0f, 0.0f, 0.0f, 0.0f));
else
m_Shader->Uniform("colorAdd", CColor(1.0f, 1.0f, 1.0f, 0.0f));
m_Shader->Uniform(str_colorAdd, CColor(1.0f, 1.0f, 1.0f, 0.0f));
m_Shader->Uniform("colorMul", batch.color);
m_Shader->Uniform(str_colorMul, batch.color);
vertexes.clear();
vertexes.resize(batch.text.size()*4);

30
source/graphics/tests/test_ShaderManager.h
View File

@ -33,7 +33,7 @@ public:
TS_ASSERT(defines1.GetHash() == defines2.GetHash());
TS_ASSERT(!(defines1 < defines2 || defines2 < defines1));
defines1.Add("FOO", "1");
defines1.Add(CStrIntern("FOO"), CStrIntern("1"));
TS_ASSERT_EQUALS(defines1.GetInt("FOO"), 1);
TS_ASSERT_EQUALS(defines2.GetInt("FOO"), 0);
@ -42,7 +42,7 @@ public:
TS_ASSERT(!(defines1.GetHash() == defines2.GetHash()));
TS_ASSERT(defines1 < defines2 || defines2 < defines1);
defines2.Add("FOO", "2");
defines2.Add(CStrIntern("FOO"), CStrIntern("2"));
TS_ASSERT_EQUALS(defines1.GetInt("FOO"), 1);
TS_ASSERT_EQUALS(defines2.GetInt("FOO"), 2);
@ -51,7 +51,7 @@ public:
TS_ASSERT(!(defines1.GetHash() == defines2.GetHash()));
defines3 = defines2;
defines2.Add("FOO", "1"); // override old value
defines2.Add(CStrIntern("FOO"), CStrIntern("1")); // override old value
TS_ASSERT_EQUALS(defines1.GetInt("FOO"), 1);
TS_ASSERT_EQUALS(defines2.GetInt("FOO"), 1);
@ -64,20 +64,20 @@ public:
void test_defines_order()
{
CShaderDefines defines1;
defines1.Add("A", "1");
defines1.Add("B", "1");
defines1.Add("C", "1");
defines1.Add("D", "1");
defines1.Add(CStrIntern("A"), CStrIntern("1"));
defines1.Add(CStrIntern("B"), CStrIntern("1"));
defines1.Add(CStrIntern("C"), CStrIntern("1"));
defines1.Add(CStrIntern("D"), CStrIntern("1"));
CShaderDefines defines2;
defines2.Add("C", "2");
defines2.Add("C", "1");
defines2.Add("B", "2");
defines2.Add("B", "1");
defines2.Add("D", "2");
defines2.Add("D", "1");
defines2.Add("A", "2");
defines2.Add("A", "1");
defines2.Add(CStrIntern("C"), CStrIntern("2"));
defines2.Add(CStrIntern("C"), CStrIntern("1"));
defines2.Add(CStrIntern("B"), CStrIntern("2"));
defines2.Add(CStrIntern("B"), CStrIntern("1"));
defines2.Add(CStrIntern("D"), CStrIntern("2"));
defines2.Add(CStrIntern("D"), CStrIntern("1"));
defines2.Add(CStrIntern("A"), CStrIntern("2"));
defines2.Add(CStrIntern("A"), CStrIntern("1"));
TS_ASSERT(defines1 == defines2);

2
source/gui/CGUI.cpp
View File

@ -941,7 +941,7 @@ SGUIText CGUI::GenerateText(const CGUIString &string,
void CGUI::DrawText(SGUIText &Text, const CColor &DefaultColor,
const CPos &pos, const float &z, const CRect &clipping)
{
CShaderTechniquePtr tech = g_Renderer.GetShaderManager().LoadEffect("gui_text");
CShaderTechniquePtr tech = g_Renderer.GetShaderManager().LoadEffect(str_gui_text);
tech->BeginPass();

2
source/gui/CInput.cpp
View File

@ -1102,7 +1102,7 @@ void CInput::Draw()
float h = (float)font.GetHeight();
float ls = (float)font.GetLineSpacing();
CShaderTechniquePtr tech = g_Renderer.GetShaderManager().LoadEffect("gui_text");
CShaderTechniquePtr tech = g_Renderer.GetShaderManager().LoadEffect(str_gui_text);
CTextRenderer textRenderer(tech->GetShader());
textRenderer.Font(font_name);

20
source/gui/GUIRenderer.cpp
View File

@ -225,13 +225,13 @@ void GUIRenderer::UpdateDrawCallCache(DrawCalls &Calls, const CStr& SpriteName,
if (!Call.m_HasTexture)
{
Call.m_Shader = g_Renderer.GetShaderManager().LoadEffect("gui_solid");
Call.m_Shader = g_Renderer.GetShaderManager().LoadEffect(str_gui_solid);
}
else if (cit->m_Effects)
{
if (cit->m_Effects->m_AddColor != CColor())
{
Call.m_Shader = g_Renderer.GetShaderManager().LoadEffect("gui_add");
Call.m_Shader = g_Renderer.GetShaderManager().LoadEffect(str_gui_add);
Call.m_ShaderColorParameter = cit->m_Effects->m_AddColor;
// Always enable blending if something's being subtracted from
// the alpha channel
@ -240,16 +240,16 @@ void GUIRenderer::UpdateDrawCallCache(DrawCalls &Calls, const CStr& SpriteName,
}
else if (cit->m_Effects->m_Greyscale)
{
Call.m_Shader = g_Renderer.GetShaderManager().LoadEffect("gui_grayscale");
Call.m_Shader = g_Renderer.GetShaderManager().LoadEffect(str_gui_grayscale);
}
else /* Slight confusion - why no effects? */
{
Call.m_Shader = g_Renderer.GetShaderManager().LoadEffect("gui_basic");
Call.m_Shader = g_Renderer.GetShaderManager().LoadEffect(str_gui_basic);
}
}
else
{
Call.m_Shader = g_Renderer.GetShaderManager().LoadEffect("gui_basic");
Call.m_Shader = g_Renderer.GetShaderManager().LoadEffect(str_gui_basic);
}
Calls.push_back(Call);
@ -350,12 +350,12 @@ void GUIRenderer::Draw(DrawCalls &Calls, float Z)
{
cit->m_Shader->BeginPass();
CShaderProgramPtr shader = cit->m_Shader->GetShader();
shader->Uniform("transform", matrix);
shader->Uniform(str_transform, matrix);
if (cit->m_HasTexture)
{
shader->Uniform("color", cit->m_ShaderColorParameter);
shader->BindTexture("tex", cit->m_Texture);
shader->Uniform(str_color, cit->m_ShaderColorParameter);
shader->BindTexture(str_tex, cit->m_Texture);
if (cit->m_EnableBlending || cit->m_Texture->HasAlpha()) // (shouldn't call HasAlpha before BindTexture)
{
@ -395,7 +395,7 @@ void GUIRenderer::Draw(DrawCalls &Calls, float Z)
}
else
{
shader->Uniform("color", cit->m_BackColor);
shader->Uniform(str_color, cit->m_BackColor);
if (cit->m_EnableBlending)
{
@ -425,7 +425,7 @@ void GUIRenderer::Draw(DrawCalls &Calls, float Z)
if (cit->m_BorderColor != CColor())
{
shader->Uniform("color", cit->m_BorderColor);
shader->Uniform(str_color, cit->m_BorderColor);
data.clear();
ADD(Verts.left + 0.5f, Verts.top + 0.5f, Z + cit->m_DeltaZ);

22
source/gui/MiniMap.cpp
View File

@ -384,8 +384,8 @@ void CMiniMap::Draw()
if (g_Renderer.GetRenderPath() == CRenderer::RP_SHADER)
{
CShaderDefines defines;
defines.Add("MINIMAP_BASE", "1");
tech = g_Renderer.GetShaderManager().LoadEffect(CStrIntern("minimap"), g_Renderer.GetSystemShaderDefines(), defines);
defines.Add(str_MINIMAP_BASE, str_1);
tech = g_Renderer.GetShaderManager().LoadEffect(str_minimap, g_Renderer.GetSystemShaderDefines(), defines);
tech->BeginPass();
shader = tech->GetShader();
}
@ -398,7 +398,7 @@ void CMiniMap::Draw()
// Draw the main textured quad
if (g_Renderer.GetRenderPath() == CRenderer::RP_SHADER)
shader->BindTexture("baseTex", m_TerrainTexture);
shader->BindTexture(str_baseTex, m_TerrainTexture);
else
g_Renderer.BindTexture(0, m_TerrainTexture);
@ -412,7 +412,7 @@ void CMiniMap::Draw()
CTerritoryTexture& territoryTexture = g_Game->GetView()->GetTerritoryTexture();
if (g_Renderer.GetRenderPath() == CRenderer::RP_SHADER)
shader->BindTexture("baseTex", territoryTexture.GetTexture());
shader->BindTexture(str_baseTex, territoryTexture.GetTexture());
else
territoryTexture.BindTexture(0);
@ -437,11 +437,11 @@ void CMiniMap::Draw()
tech->EndPass();
CShaderDefines defines;
defines.Add("MINIMAP_LOS", "1");
tech = g_Renderer.GetShaderManager().LoadEffect(CStrIntern("minimap"), g_Renderer.GetSystemShaderDefines(), defines);
defines.Add(str_MINIMAP_LOS, str_1);
tech = g_Renderer.GetShaderManager().LoadEffect(str_minimap, g_Renderer.GetSystemShaderDefines(), defines);
tech->BeginPass();
shader = tech->GetShader();
shader->BindTexture("baseTex", losTexture.GetTexture());
shader->BindTexture(str_baseTex, losTexture.GetTexture());
}
else
{
@ -476,8 +476,8 @@ void CMiniMap::Draw()
tech->EndPass();
CShaderDefines defines;
defines.Add("MINIMAP_POINT", "1");
tech = g_Renderer.GetShaderManager().LoadEffect(CStrIntern("minimap"), g_Renderer.GetSystemShaderDefines(), defines);
defines.Add(str_MINIMAP_POINT, str_1);
tech = g_Renderer.GetShaderManager().LoadEffect(str_minimap, g_Renderer.GetSystemShaderDefines(), defines);
tech->BeginPass();
shader = tech->GetShader();
}
@ -585,8 +585,8 @@ void CMiniMap::Draw()
tech->EndPass();
CShaderDefines defines;
defines.Add("MINIMAP_LINE", "1");
tech = g_Renderer.GetShaderManager().LoadEffect(CStrIntern("minimap"), g_Renderer.GetSystemShaderDefines(), defines);
defines.Add(str_MINIMAP_LINE, str_1);
tech = g_Renderer.GetShaderManager().LoadEffect(str_minimap, g_Renderer.GetSystemShaderDefines(), defines);
tech->BeginPass();
shader = tech->GetShader();
}

10
source/ps/CConsole.cpp
View File

@ -196,7 +196,7 @@ void CConsole::Render()
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
CShaderTechniquePtr solidTech = g_Renderer.GetShaderManager().LoadEffect("gui_solid");
CShaderTechniquePtr solidTech = g_Renderer.GetShaderManager().LoadEffect(str_gui_solid);
solidTech->BeginPass();
CShaderProgramPtr solidShader = solidTech->GetShader();
@ -205,13 +205,13 @@ void CConsole::Render()
// animation: slide in from top of screen
const float DeltaY = (1.0f - m_fVisibleFrac) * m_fHeight;
transform.PostTranslate(m_fX, m_fY - DeltaY, 0.0f); // move to window position
solidShader->Uniform("transform", transform);
solidShader->Uniform(str_transform, transform);
DrawWindow(solidShader);
solidTech->EndPass();
CShaderTechniquePtr textTech = g_Renderer.GetShaderManager().LoadEffect("gui_text");
CShaderTechniquePtr textTech = g_Renderer.GetShaderManager().LoadEffect(str_gui_text);
textTech->BeginPass();
CTextRenderer textRenderer(textTech->GetShader());
textRenderer.Font(CONSOLE_FONT);
@ -241,13 +241,13 @@ void CConsole::DrawWindow(CShaderProgramPtr& shader)
// Draw Background
// Set the color to a translucent blue
shader->Uniform("color", 0.0f, 0.0f, 0.5f, 0.6f);
shader->Uniform(str_color, 0.0f, 0.0f, 0.5f, 0.6f);
shader->AssertPointersBound();
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
// Draw Border
// Set the color to a translucent yellow
shader->Uniform("color", 0.5f, 0.5f, 0.0f, 0.6f);
shader->Uniform(str_color, 0.5f, 0.5f, 0.0f, 0.6f);
shader->AssertPointersBound();
glDrawArrays(GL_LINE_LOOP, 0, 4);

2
source/ps/CLogger.cpp
View File

@ -284,7 +284,7 @@ void CLogger::Render()
CFont font(font_name);
int lineSpacing = font.GetLineSpacing();
CShaderTechniquePtr textTech = g_Renderer.GetShaderManager().LoadEffect("gui_text");
CShaderTechniquePtr textTech = g_Renderer.GetShaderManager().LoadEffect(str_gui_text);
textTech->BeginPass();
CTextRenderer textRenderer(textTech->GetShader());

7
source/ps/CStrIntern.cpp
View File

@ -86,6 +86,11 @@ struct StringsKeyProxyEq
static boost::unordered_map<StringsKey, shared_ptr<CStrInternInternals>, StringsKeyHash> g_Strings;
#define X(id) CStrIntern str_##id(#id);
#define X2(id, str) CStrIntern str_##id(str);
#include "CStrInternStatic.h"
#undef X
#undef X2
static CStrInternInternals* GetString(const char* str, size_t len)
{
@ -114,7 +119,7 @@ static CStrInternInternals* GetString(const char* str, size_t len)
CStrIntern::CStrIntern()
{
m = GetString("", 0);
*this = str__emptystring;
}
CStrIntern::CStrIntern(const char* str)

6
source/ps/CStrIntern.h
View File

@ -83,4 +83,10 @@ private:
CStrInternInternals* m;
};
#define X(id) extern CStrIntern str_##id;
#define X2(id, str) extern CStrIntern str_##id;
#include "CStrInternStatic.h"
#undef X
#undef X2
#endif // INCLUDED_CSTRINTERN

148
source/ps/CStrInternStatic.h Normal file
View File

@ -0,0 +1,148 @@
/* Copyright (C) 2013 Wildfire Games.
* This file is part of 0 A.D.
*
* 0 A.D. 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 2 of the License, or
* (at your option) any later version.
*
* 0 A.D. 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 0 A.D. If not, see <http://www.gnu.org/licenses/>.
*/
// This file defines global CStrIntern variables, to avoid the cost of
// constructing CStrInterns frequently at runtime.
//
// A line like
// X(foo)
// defines a variable str_foo with value "foo".
//
// A line like
// X2(foo_0, "foo[0]")
// defines a variable str_foo_0 with value "foo[0]".
X(0)
X(1)
X(2)
X(ALPHABLEND_PASS_BLEND)
X(ALPHABLEND_PASS_OPAQUE)
X(BLEND)
X(BLOOM_NOP)
X(BLOOM_PASS_H)
X(BLOOM_PASS_V)
X(DECAL)
X(DISABLE_RECEIVE_SHADOWS)
X(Foam)
X(IGNORE_LOS)
X(MINIMAP_BASE)
X(MINIMAP_LINE)
X(MINIMAP_LOS)
X(MINIMAP_POINT)
X(MODE_SHADOWCAST)
X(MODE_SILHOUETTEDISPLAY)
X(MODE_SILHOUETTEOCCLUDER)
X(MODE_WIREFRAME)
X(SYS_HAS_ARB)
X(SYS_HAS_GLSL)
X(SYS_PREFER_GLSL)
X(USE_FOAM)
X(USE_FP_SHADOW)
X(USE_GPU_SKINNING)
X(USE_INSTANCING)
X(USE_NORMALS)
X(USE_OBJECTCOLOR)
X(USE_REAL_DEPTH)
X(USE_REFLECTION)
X(USE_REFRACTION)
X(USE_SHADOW)
X(USE_SHADOWS)
X(USE_SHADOW_PCF)
X(USE_SHADOW_SAMPLER)
X(USE_WAVES)
X2(_emptystring, "")
X(a_skinJoints)
X(a_skinWeights)
X(a_tangent)
X(ambient)
X(baseTex)
X(blendTex)
X(bloom)
X(blurTex2)
X(blurTex4)
X(blurTex8)
X(brightness)
X(cameraPos)
X(color)
X(colorAdd)
X(colorMul)
X(delta)
X(depthTex)
X(fogColor)
X(fogParams)
X(foreground_overlay)
X(gui_add)
X(gui_basic)
X(gui_grayscale)
X(gui_solid)
X(gui_text)
X(hdr)
X(height)
X(instancingTransform)
X(losMap)
X(losMatrix)
X(losTex)
X(losTex1)
X(losTex2)
X(losTransform)
X(los_interp)
X(mapSize)
X(maskTex)
X(minimap)
X(murkiness)
X(normalMap)
X(normalMap2)
X(objectColor)
X(particle)
X(particle_solid)
X(playerColor)
X(qualityLevel)
X(reflectionMap)
X(reflectionMatrix)
X(reflectionTint)
X(reflectionTintStrength)
X(refractionMap)
X(refractionMatrix)
X(renderedTex)
X(repeatScale)
X(saturation)
X(screenSize)
X(shadingColor)
X(shadowScale)
X(shadowTex)
X(shadowTransform)
X(shininess)
X(skinBlendMatrices)
X2(skinBlendMatrices_0, "skinBlendMatrices[0]")
X(skyCube)
X(sky_simple)
X(specularStrength)
X(sunColor)
X(sunDir)
X(tex)
X(texSize)
X(textureTransform)
X(time)
X(tint)
X(transform)
X(translation)
X(waterTex)
X(waveTex)
X(waviness)
X(width)
X(zFar)
X(zNear)

16
source/ps/ProfileViewer.cpp
View File

@ -187,14 +187,14 @@ void CProfileViewer::RenderProfile()
estimate_height += 2;
estimate_height = lineSpacing*estimate_height;
CShaderTechniquePtr solidTech = g_Renderer.GetShaderManager().LoadEffect("gui_solid");
CShaderTechniquePtr solidTech = g_Renderer.GetShaderManager().LoadEffect(str_gui_solid);
solidTech->BeginPass();
CShaderProgramPtr solidShader = solidTech->GetShader();
solidShader->Uniform("color", 0.0f, 0.0f, 0.0f, 0.5f);
solidShader->Uniform(str_color, 0.0f, 0.0f, 0.0f, 0.5f);
CMatrix3D transform = GetDefaultGuiMatrix();
solidShader->Uniform("transform", transform);
solidShader->Uniform(str_transform, transform);
float backgroundVerts[] = {
(float)estimate_width, 0.0f,
@ -209,15 +209,15 @@ void CProfileViewer::RenderProfile()
glDrawArrays(GL_TRIANGLES, 0, 6);
transform.PostTranslate(22.0f, lineSpacing*3.0f, 0.0f);
solidShader->Uniform("transform", transform);
solidShader->Uniform(str_transform, transform);
// Draw row backgrounds
for (size_t row = 0; row < numrows; ++row)
{
if (row % 2)
solidShader->Uniform("color", 1.0f, 1.0f, 1.0f, 0.1f);
solidShader->Uniform(str_color, 1.0f, 1.0f, 1.0f, 0.1f);
else
solidShader->Uniform("color", 0.0f, 0.0f, 0.0f, 0.1f);
solidShader->Uniform(str_color, 0.0f, 0.0f, 0.0f, 0.1f);
float rowVerts[] = {
-22.f, 2.f,
@ -233,14 +233,14 @@ void CProfileViewer::RenderProfile()
glDrawArrays(GL_TRIANGLES, 0, 6);
transform.PostTranslate(0.0f, lineSpacing, 0.0f);
solidShader->Uniform("transform", transform);
solidShader->Uniform(str_transform, transform);
}
solidTech->EndPass();
// Print table and column titles
CShaderTechniquePtr textTech = g_Renderer.GetShaderManager().LoadEffect("gui_text");
CShaderTechniquePtr textTech = g_Renderer.GetShaderManager().LoadEffect(str_gui_text);
textTech->BeginPass();
CTextRenderer textRenderer(textTech->GetShader());

7
source/ps/ThreadUtil.cpp
View File

@ -19,14 +19,21 @@
#include "ThreadUtil.h"
static bool g_MainThreadSet;
static pthread_t g_MainThread;
bool ThreadUtil::IsMainThread()
{
// If SetMainThread hasn't been called yet, this is probably being
// called at static initialisation time, so it must be the main thread
if (!g_MainThreadSet)
return true;
return pthread_equal(pthread_self(), g_MainThread) ? true : false;
}
void ThreadUtil::SetMainThread()
{
g_MainThread = pthread_self();
g_MainThreadSet = true;
}

6
source/renderer/DecalRData.cpp
View File

@ -74,7 +74,7 @@ void CDecalRData::RenderDecals(std::vector<CDecalRData*>& decals, const CShaderD
ShadowMap* shadow, bool isDummyShader, const CShaderProgramPtr& dummy)
{
CShaderDefines contextDecal = context;
contextDecal.Add("DECAL", "1");
contextDecal.Add(str_DECAL, str_1);
for (size_t i = 0; i < decals.size(); ++i)
{
@ -127,7 +127,7 @@ void CDecalRData::RenderDecals(std::vector<CDecalRData*>& decals, const CShaderD
for (size_t s = 0; s < samplersNum; ++s)
{
CMaterial::TextureSampler &samp = samplers[s];
shader->BindTexture(samp.Name.c_str(), samp.Sampler);
shader->BindTexture(samp.Name, samp.Sampler);
}
material.GetStaticUniforms().BindUniforms(shader);
@ -157,7 +157,7 @@ void CDecalRData::RenderDecals(std::vector<CDecalRData*>& decals, const CShaderD
#endif
{
shader->Uniform("shadingColor", decal->m_Decal->GetShadingColor());
shader->Uniform(str_shadingColor, decal->m_Decal->GetShadingColor());
}
shader->VertexPointer(3, GL_FLOAT, stride, base + decal->m_Position.offset);

10
source/renderer/InstancingModelRenderer.cpp
View File

@ -335,7 +335,7 @@ void InstancingModelRenderer::PrepareModelDef(const CShaderProgramPtr& shader, i
shader->NormalPointer(GL_FLOAT, stride, base + m->imodeldef->m_Normal.offset);
if (m->calculateTangents)
shader->VertexAttribPointer("a_tangent", 4, GL_FLOAT, GL_TRUE, stride, base + m->imodeldef->m_Tangent.offset);
shader->VertexAttribPointer(str_a_tangent, 4, GL_FLOAT, GL_TRUE, stride, base + m->imodeldef->m_Tangent.offset);
if (streamflags & STREAM_UV0)
shader->TexCoordPointer(GL_TEXTURE0, 2, GL_FLOAT, stride, base + m->imodeldef->m_UVs[0].offset);
@ -346,8 +346,8 @@ void InstancingModelRenderer::PrepareModelDef(const CShaderProgramPtr& shader, i
// GPU skinning requires extra attributes to compute positions/normals
if (m->gpuSkinning)
{
shader->VertexAttribPointer("a_skinJoints", 4, GL_UNSIGNED_BYTE, GL_FALSE, stride, base + m->imodeldef->m_BlendJoints.offset);
shader->VertexAttribPointer("a_skinWeights", 4, GL_UNSIGNED_BYTE, GL_TRUE, stride, base + m->imodeldef->m_BlendWeights.offset);
shader->VertexAttribPointer(str_a_skinJoints, 4, GL_UNSIGNED_BYTE, GL_FALSE, stride, base + m->imodeldef->m_BlendJoints.offset);
shader->VertexAttribPointer(str_a_skinWeights, 4, GL_UNSIGNED_BYTE, GL_TRUE, stride, base + m->imodeldef->m_BlendWeights.offset);
}
shader->AssertPointersBound();
@ -366,8 +366,8 @@ void InstancingModelRenderer::RenderModel(const CShaderProgramPtr& shader, int U
// HACK: NVIDIA drivers return uniform name with "[0]", Intel Windows drivers without;
// try uploading both names since one of them should work, and this is easier than
// canonicalising the uniform names in CShaderProgramGLSL
shader->Uniform("skinBlendMatrices[0]", mdldef->GetNumBones() + 1, model->GetAnimatedBoneMatrices());
shader->Uniform("skinBlendMatrices", mdldef->GetNumBones() + 1, model->GetAnimatedBoneMatrices());
shader->Uniform(str_skinBlendMatrices_0, mdldef->GetNumBones() + 1, model->GetAnimatedBoneMatrices());
shader->Uniform(str_skinBlendMatrices, mdldef->GetNumBones() + 1, model->GetAnimatedBoneMatrices());
}
// render the lot

8
source/renderer/ModelRenderer.cpp
View File

@ -664,7 +664,7 @@ void ShaderModelRenderer::Render(const RenderModifierPtr& modifier, const CShade
}
else
{
bind = shader->GetTextureBinding(samp.Name.c_str());
bind = shader->GetTextureBinding(samp.Name);
texBindings[s] = bind;
texBindingNames[s] = samp.Name;
}
@ -716,13 +716,13 @@ void ShaderModelRenderer::Render(const RenderModifierPtr& modifier, const CShade
int curTex = (int)(time*60/period) % 60;
if (WaterMgr->m_RenderWater && WaterMgr->WillRenderFancyWater())
shader->BindTexture("waterTex", WaterMgr->m_NormalMap[curTex]);
shader->BindTexture(str_waterTex, WaterMgr->m_NormalMap[curTex]);
else
shader->BindTexture("waterTex", g_Renderer.GetTextureManager().GetErrorTexture());
shader->BindTexture(str_waterTex, g_Renderer.GetTextureManager().GetErrorTexture());
}
else if (rq.first == RQUERY_SKY_CUBE)
{
shader->BindTexture("skyCube", g_Renderer.GetSkyManager()->GetSkyCube());
shader->BindTexture(str_skyCube, g_Renderer.GetSkyManager()->GetSkyCube());
}
}

26
source/renderer/OverlayRenderer.cpp
View File

@ -138,9 +138,9 @@ OverlayRendererInternals::OverlayRendererInternals()
// is because their code is almost identical; the only difference is that for the quad overlays
// we want to use a vertex color stream as opposed to an objectColor uniform. To this end, the
// shader has been set up to switch between the two behaviours based on the USE_OBJECTCOLOR define.
defsOverlayLineNormal.Add("USE_OBJECTCOLOR", "1");
defsOverlayLineAlwaysVisible.Add("USE_OBJECTCOLOR", "1");
defsOverlayLineAlwaysVisible.Add("IGNORE_LOS", "1");
defsOverlayLineNormal.Add(str_USE_OBJECTCOLOR, str_1);
defsOverlayLineAlwaysVisible.Add(str_USE_OBJECTCOLOR, str_1);
defsOverlayLineAlwaysVisible.Add(str_IGNORE_LOS, str_1);
}
void OverlayRendererInternals::Initialize()
@ -418,8 +418,8 @@ void OverlayRenderer::RenderTexturedOverlayLines()
if (shaderTexLineNormal)
{
shaderTexLineNormal->Bind();
shaderTexLineNormal->BindTexture("losTex", los.GetTexture());
shaderTexLineNormal->Uniform("losTransform", los.GetTextureMatrix()[0], los.GetTextureMatrix()[12], 0.f, 0.f);
shaderTexLineNormal->BindTexture(str_losTex, los.GetTexture());
shaderTexLineNormal->Uniform(str_losTransform, los.GetTextureMatrix()[0], los.GetTextureMatrix()[12], 0.f, 0.f);
// batch render only the non-always-visible overlay lines using the normal shader
RenderTexturedOverlayLines(shaderTexLineNormal, false);
@ -433,8 +433,8 @@ void OverlayRenderer::RenderTexturedOverlayLines()
{
shaderTexLineAlwaysVisible->Bind();
// TODO: losTex and losTransform are unused in the always visible shader; see if these can be safely omitted
shaderTexLineAlwaysVisible->BindTexture("losTex", los.GetTexture());
shaderTexLineAlwaysVisible->Uniform("losTransform", los.GetTextureMatrix()[0], los.GetTextureMatrix()[12], 0.f, 0.f);
shaderTexLineAlwaysVisible->BindTexture(str_losTex, los.GetTexture());
shaderTexLineAlwaysVisible->Uniform(str_losTransform, los.GetTextureMatrix()[0], los.GetTextureMatrix()[12], 0.f, 0.f);
// batch render only the always-visible overlay lines using the LoS-ignored shader
RenderTexturedOverlayLines(shaderTexLineAlwaysVisible, true);
@ -496,8 +496,8 @@ void OverlayRenderer::RenderQuadOverlays()
if (shader)
{
shader->Bind();
shader->BindTexture("losTex", los.GetTexture());
shader->Uniform("losTransform", los.GetTextureMatrix()[0], los.GetTextureMatrix()[12], 0.f, 0.f);
shader->BindTexture(str_losTex, los.GetTexture());
shader->Uniform(str_losTransform, los.GetTextureMatrix()[0], los.GetTextureMatrix()[12], 0.f, 0.f);
// Base offsets (in bytes) of the two backing stores relative to their owner VBO
u8* indexBase = m->quadIndices.Bind();
@ -516,8 +516,8 @@ void OverlayRenderer::RenderQuadOverlays()
const QuadBatchKey& maskPair = it->first;
shader->BindTexture("baseTex", maskPair.m_Texture->GetHandle());
shader->BindTexture("maskTex", maskPair.m_TextureMask->GetHandle());
shader->BindTexture(str_baseTex, maskPair.m_Texture->GetHandle());
shader->BindTexture(str_maskTex, maskPair.m_TextureMask->GetHandle());
int streamflags = shader->GetStreamFlags();
@ -579,7 +579,7 @@ void OverlayRenderer::RenderForegroundOverlays(const CCamera& viewCamera)
if (g_Renderer.GetRenderPath() == CRenderer::RP_SHADER)
{
tech = g_Renderer.GetShaderManager().LoadEffect("foreground_overlay");
tech = g_Renderer.GetShaderManager().LoadEffect(str_foreground_overlay);
tech->BeginPass();
shader = tech->GetShader();
}
@ -596,7 +596,7 @@ void OverlayRenderer::RenderForegroundOverlays(const CCamera& viewCamera)
SOverlaySprite* sprite = m->sprites[i];
if (g_Renderer.GetRenderPath() == CRenderer::RP_SHADER)
shader->BindTexture("baseTex", sprite->m_Texture);
shader->BindTexture(str_baseTex, sprite->m_Texture);
else
sprite->m_Texture->Bind();

6
source/renderer/ParticleRenderer.cpp
View File

@ -86,8 +86,8 @@ void ParticleRenderer::PrepareForRendering(const CShaderDefines& context)
// RenderParticles will never be called so it's safe to leave the shaders as null
if (g_Renderer.GetRenderPath() == CRenderer::RP_SHADER)
{
m->shader = g_Renderer.GetShaderManager().LoadEffect(CStrIntern("particle"), context, CShaderDefines());
m->shaderSolid = g_Renderer.GetShaderManager().LoadEffect(CStrIntern("particle_solid"), context, CShaderDefines());
m->shader = g_Renderer.GetShaderManager().LoadEffect(str_particle, context, CShaderDefines());
m->shaderSolid = g_Renderer.GetShaderManager().LoadEffect(str_particle_solid, context, CShaderDefines());
}
}
@ -117,7 +117,7 @@ void ParticleRenderer::RenderParticles(bool solidColor)
shader->BeginPass();
shader->GetShader()->Uniform("transform", g_Renderer.GetViewCamera().GetViewProjection());
shader->GetShader()->Uniform(str_transform, g_Renderer.GetViewCamera().GetViewProjection());
if (!solidColor)
glEnable(GL_BLEND);

16
source/renderer/PatchRData.cpp
View File

@ -793,7 +793,7 @@ void CPatchRData::RenderBases(const std::vector<CPatchRData*>& patches, const CS
for (size_t s = 0; s < samplersNum; ++s)
{
CMaterial::TextureSampler &samp = samplers[s];
shader->BindTexture(samp.Name.c_str(), samp.Sampler);
shader->BindTexture(samp.Name, samp.Sampler);
}
itt->first->GetMaterial().GetStaticUniforms().BindUniforms(shader);
@ -810,12 +810,12 @@ void CPatchRData::RenderBases(const std::vector<CPatchRData*>& patches, const CS
{
float c = itt->first->GetTextureMatrix()[0];
float ms = itt->first->GetTextureMatrix()[8];
shader->Uniform("textureTransform", c, ms, -ms, 0.f);
shader->Uniform(str_textureTransform, c, ms, -ms, 0.f);
}
}
else
{
shader->BindTexture("baseTex", g_Renderer.GetTextureManager().GetErrorTexture());
shader->BindTexture(str_baseTex, g_Renderer.GetTextureManager().GetErrorTexture());
}
for (VertexBufferBatches::iterator itv = itt->second.begin(); itv != itt->second.end(); ++itv)
@ -906,7 +906,7 @@ void CPatchRData::RenderBlends(const std::vector<CPatchRData*>& patches, const C
BatchesStack batches((BatchesStack::allocator_type(arena)));
CShaderDefines contextBlend = context;
contextBlend.Add("BLEND", "1");
contextBlend.Add(str_BLEND, str_1);
PROFILE_START("compute batches");
@ -1023,10 +1023,10 @@ void CPatchRData::RenderBlends(const std::vector<CPatchRData*>& patches, const C
for (size_t s = 0; s < samplersNum; ++s)
{
CMaterial::TextureSampler &samp = samplers[s];
shader->BindTexture(samp.Name.c_str(), samp.Sampler);
shader->BindTexture(samp.Name, samp.Sampler);
}
shader->BindTexture("blendTex", itt->m_Texture->m_TerrainAlpha->second.m_hCompositeAlphaMap);
shader->BindTexture(str_blendTex, itt->m_Texture->m_TerrainAlpha->second.m_hCompositeAlphaMap);
itt->m_Texture->GetMaterial().GetStaticUniforms().BindUniforms(shader);
@ -1043,12 +1043,12 @@ void CPatchRData::RenderBlends(const std::vector<CPatchRData*>& patches, const C
{
float c = itt->m_Texture->GetTextureMatrix()[0];
float ms = itt->m_Texture->GetTextureMatrix()[8];
shader->Uniform("textureTransform", c, ms, -ms, 0.f);
shader->Uniform(str_textureTransform, c, ms, -ms, 0.f);
}
}
else
{
shader->BindTexture("baseTex", g_Renderer.GetTextureManager().GetErrorTexture());
shader->BindTexture(str_baseTex, g_Renderer.GetTextureManager().GetErrorTexture());
}
for (VertexBufferBatches::iterator itv = itt->m_Batches.begin(); itv != itt->m_Batches.end(); ++itv)

52
source/renderer/PostprocManager.cpp
View File

@ -175,8 +175,8 @@ void CPostprocManager::ApplyBlurDownscale2x(GLuint inTex, GLuint outTex, int inW
// Get bloom shader with instructions to simply copy texels.
CShaderDefines defines;
defines.Add("BLOOM_NOP", "1");
CShaderTechniquePtr tech = g_Renderer.GetShaderManager().LoadEffect(CStrIntern("bloom"),
defines.Add(str_BLOOM_NOP, str_1);
CShaderTechniquePtr tech = g_Renderer.GetShaderManager().LoadEffect(str_bloom,
g_Renderer.GetSystemShaderDefines(), defines);
tech->BeginPass();
@ -192,7 +192,7 @@ void CPostprocManager::ApplyBlurDownscale2x(GLuint inTex, GLuint outTex, int inW
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glBindTexture(GL_TEXTURE_2D, 0);
shader->BindTexture("renderedTex", renderedTex);
shader->BindTexture(str_renderedTex, renderedTex);
glPushAttrib(GL_VIEWPORT_BIT);
glViewport(0, 0, inWidth / 2, inHeight / 2);
@ -217,14 +217,14 @@ void CPostprocManager::ApplyBlurGauss(GLuint inOutTex, GLuint tempTex, int inWid
// Get bloom shader, for a horizontal Gaussian blur pass.
CShaderDefines defines2;
defines2.Add("BLOOM_PASS_H", "1");
CShaderTechniquePtr tech = g_Renderer.GetShaderManager().LoadEffect(CStrIntern("bloom"),
defines2.Add(str_BLOOM_PASS_H, str_1);
CShaderTechniquePtr tech = g_Renderer.GetShaderManager().LoadEffect(str_bloom,
g_Renderer.GetSystemShaderDefines(), defines2);
tech->BeginPass();
CShaderProgramPtr shader = tech->GetShader();
shader->BindTexture("renderedTex", inOutTex);
shader->Uniform("texSize", inWidth, inHeight, 0.0f, 0.0f);
shader->BindTexture(str_renderedTex, inOutTex);
shader->Uniform(str_texSize, inWidth, inHeight, 0.0f, 0.0f);
glPushAttrib(GL_VIEWPORT_BIT);
glViewport(0, 0, inWidth, inHeight);
@ -246,16 +246,16 @@ void CPostprocManager::ApplyBlurGauss(GLuint inOutTex, GLuint tempTex, int inWid
// Get bloom shader, for a vertical Gaussian blur pass.
CShaderDefines defines3;
defines3.Add("BLOOM_PASS_V", "1");
tech = g_Renderer.GetShaderManager().LoadEffect(CStrIntern("bloom"),
defines3.Add(str_BLOOM_PASS_V, str_1);
tech = g_Renderer.GetShaderManager().LoadEffect(str_bloom,
g_Renderer.GetSystemShaderDefines(), defines3);
tech->BeginPass();
shader = tech->GetShader();
// Our input texture to the shader is the output of the horizontal pass.
shader->BindTexture("renderedTex", tempTex);
shader->Uniform("texSize", inWidth, inHeight, 0.0f, 0.0f);
shader->BindTexture(str_renderedTex, tempTex);
shader->Uniform(str_texSize, inWidth, inHeight, 0.0f, 0.0f);
glPushAttrib(GL_VIEWPORT_BIT);
glViewport(0, 0, inWidth, inHeight);
@ -344,7 +344,7 @@ void CPostprocManager::LoadEffect(CStrW &name)
if (name != L"default")
{
CStrW n = L"postproc/" + name;
m_PostProcTech = g_Renderer.GetShaderManager().LoadEffect(n.ToUTF8().c_str());
m_PostProcTech = g_Renderer.GetShaderManager().LoadEffect(CStrIntern(n.ToUTF8()));
}
m_PostProcEffect = name;
@ -371,25 +371,25 @@ void CPostprocManager::ApplyEffect(CShaderTechniquePtr &shaderTech1, int pass)
// We also bind a bunch of other textures and parameters, but since
// this only happens once per frame the overhead is negligible.
if (m_WhichBuffer)
shader->BindTexture("renderedTex", m_ColourTex1);
shader->BindTexture(str_renderedTex, m_ColourTex1);
else
shader->BindTexture("renderedTex", m_ColourTex2);
shader->BindTexture(str_renderedTex, m_ColourTex2);
shader->BindTexture("depthTex", m_DepthTex);
shader->BindTexture(str_depthTex, m_DepthTex);
shader->BindTexture("blurTex2", m_BlurTex2a);
shader->BindTexture("blurTex4", m_BlurTex4a);
shader->BindTexture("blurTex8", m_BlurTex8a);
shader->BindTexture(str_blurTex2, m_BlurTex2a);
shader->BindTexture(str_blurTex4, m_BlurTex4a);
shader->BindTexture(str_blurTex8, m_BlurTex8a);
shader->Uniform("width", m_Width);
shader->Uniform("height", m_Height);
shader->Uniform("zNear", g_Game->GetView()->GetNear());
shader->Uniform("zFar", g_Game->GetView()->GetFar());
shader->Uniform(str_width, m_Width);
shader->Uniform(str_height, m_Height);
shader->Uniform(str_zNear, g_Game->GetView()->GetNear());
shader->Uniform(str_zFar, g_Game->GetView()->GetFar());
shader->Uniform("brightness", g_LightEnv.m_Brightness);
shader->Uniform("hdr", g_LightEnv.m_Contrast);
shader->Uniform("saturation", g_LightEnv.m_Saturation);
shader->Uniform("bloom", g_LightEnv.m_Bloom);
shader->Uniform(str_brightness, g_LightEnv.m_Brightness);
shader->Uniform(str_hdr, g_LightEnv.m_Contrast);
shader->Uniform(str_saturation, g_LightEnv.m_Saturation);
shader->Uniform(str_bloom, g_LightEnv.m_Bloom);
glBegin(GL_QUADS);
glColor4f(1.f, 1.f, 1.f, 1.f);

34
source/renderer/RenderModifiers.cpp
View File

@ -73,39 +73,39 @@ ShaderRenderModifier::ShaderRenderModifier()
void ShaderRenderModifier::BeginPass(const CShaderProgramPtr& shader)
{
shader->Uniform("transform", g_Renderer.GetViewCamera().GetViewProjection());
shader->Uniform("cameraPos", g_Renderer.GetViewCamera().GetOrientation().GetTranslation());
shader->Uniform(str_transform, g_Renderer.GetViewCamera().GetViewProjection());
shader->Uniform(str_cameraPos, g_Renderer.GetViewCamera().GetOrientation().GetTranslation());
if (GetShadowMap() && shader->GetTextureBinding("shadowTex").Active())
if (GetShadowMap() && shader->GetTextureBinding(str_shadowTex).Active())
{
shader->BindTexture("shadowTex", GetShadowMap()->GetTexture());
shader->Uniform("shadowTransform", GetShadowMap()->GetTextureMatrix());
shader->BindTexture(str_shadowTex, GetShadowMap()->GetTexture());
shader->Uniform(str_shadowTransform, GetShadowMap()->GetTextureMatrix());
int width = GetShadowMap()->GetWidth();
int height = GetShadowMap()->GetHeight();
shader->Uniform("shadowScale", width, height, 1.0f / width, 1.0f / height);
shader->Uniform(str_shadowScale, width, height, 1.0f / width, 1.0f / height);
}
if (GetLightEnv())
{
shader->Uniform("ambient", GetLightEnv()->m_UnitsAmbientColor);
shader->Uniform("sunDir", GetLightEnv()->GetSunDir());
shader->Uniform("sunColor", GetLightEnv()->m_SunColor);
shader->Uniform(str_ambient, GetLightEnv()->m_UnitsAmbientColor);
shader->Uniform(str_sunDir, GetLightEnv()->GetSunDir());
shader->Uniform(str_sunColor, GetLightEnv()->m_SunColor);
shader->Uniform("fogColor", GetLightEnv()->m_FogColor);
shader->Uniform("fogParams", GetLightEnv()->m_FogFactor, GetLightEnv()->m_FogMax, 0.f, 0.f);
shader->Uniform(str_fogColor, GetLightEnv()->m_FogColor);
shader->Uniform(str_fogParams, GetLightEnv()->m_FogFactor, GetLightEnv()->m_FogMax, 0.f, 0.f);
}
if (shader->GetTextureBinding("losTex").Active())
if (shader->GetTextureBinding(str_losTex).Active())
{
CLOSTexture& los = g_Renderer.GetScene().GetLOSTexture();
shader->BindTexture("losTex", los.GetTextureSmooth());
shader->BindTexture(str_losTex, los.GetTextureSmooth());
// Don't bother sending the whole matrix, we just need two floats (scale and translation)
shader->Uniform("losTransform", los.GetTextureMatrix()[0], los.GetTextureMatrix()[12], 0.f, 0.f);
shader->Uniform(str_losTransform, los.GetTextureMatrix()[0], los.GetTextureMatrix()[12], 0.f, 0.f);
}
m_BindingInstancingTransform = shader->GetUniformBinding("instancingTransform");
m_BindingShadingColor = shader->GetUniformBinding("shadingColor");
m_BindingPlayerColor = shader->GetUniformBinding("playerColor");
m_BindingInstancingTransform = shader->GetUniformBinding(str_instancingTransform);
m_BindingShadingColor = shader->GetUniformBinding(str_shadingColor);
m_BindingPlayerColor = shader->GetUniformBinding(str_playerColor);
}
void ShaderRenderModifier::PrepareModel(const CShaderProgramPtr& shader, CModel* model)

48
source/renderer/Renderer.cpp
View File

@ -352,15 +352,15 @@ public:
CShaderDefines contextSkinned = context;
if (g_Renderer.m_Options.m_GPUSkinning)
{
contextSkinned.Add("USE_INSTANCING", "1");
contextSkinned.Add("USE_GPU_SKINNING", "1");
contextSkinned.Add(str_USE_INSTANCING, str_1);
contextSkinned.Add(str_USE_GPU_SKINNING, str_1);
}
Model.NormalSkinned->Render(Model.ModShader, contextSkinned, flags);
if (Model.NormalUnskinned != Model.NormalSkinned)
{
CShaderDefines contextUnskinned = context;
contextUnskinned.Add("USE_INSTANCING", "1");
contextUnskinned.Add(str_USE_INSTANCING, str_1);
Model.NormalUnskinned->Render(Model.ModShader, contextUnskinned, flags);
}
}
@ -373,15 +373,15 @@ public:
CShaderDefines contextSkinned = context;
if (g_Renderer.m_Options.m_GPUSkinning)
{
contextSkinned.Add("USE_INSTANCING", "1");
contextSkinned.Add("USE_GPU_SKINNING", "1");
contextSkinned.Add(str_USE_INSTANCING, str_1);
contextSkinned.Add(str_USE_GPU_SKINNING, str_1);
}
Model.TranspSkinned->Render(Model.ModShader, contextSkinned, flags);
if (Model.TranspUnskinned != Model.TranspSkinned)
{
CShaderDefines contextUnskinned = context;
contextUnskinned.Add("USE_INSTANCING", "1");
contextUnskinned.Add(str_USE_INSTANCING, str_1);
Model.TranspUnskinned->Render(Model.ModShader, contextUnskinned, flags);
}
}
@ -539,13 +539,13 @@ CShaderDefines CRenderer::ComputeSystemShaderDefines()
CShaderDefines defines;
if (GetRenderPath() == RP_SHADER && m_Caps.m_ARBProgram)
defines.Add("SYS_HAS_ARB", "1");
defines.Add(str_SYS_HAS_ARB, str_1);
if (GetRenderPath() == RP_SHADER && m_Caps.m_VertexShader && m_Caps.m_FragmentShader)
defines.Add("SYS_HAS_GLSL", "1");
defines.Add(str_SYS_HAS_GLSL, str_1);
if (m_Options.m_PreferGLSL)
defines.Add("SYS_PREFER_GLSL", "1");
defines.Add(str_SYS_PREFER_GLSL, str_1);
return defines;
}
@ -560,18 +560,18 @@ void CRenderer::ReloadShaders()
if (m_Caps.m_Shadows && m_Options.m_Shadows)
{
m->globalContext.Add("USE_SHADOW", "1");
m->globalContext.Add(str_USE_SHADOW, str_1);
if (m_Caps.m_ARBProgramShadow && m_Options.m_ARBProgramShadow)
m->globalContext.Add("USE_FP_SHADOW", "1");
m->globalContext.Add(str_USE_FP_SHADOW, str_1);
if (m_Options.m_ShadowPCF)
m->globalContext.Add("USE_SHADOW_PCF", "1");
m->globalContext.Add(str_USE_SHADOW_PCF, str_1);
#if !CONFIG2_GLES
m->globalContext.Add("USE_SHADOW_SAMPLER", "1");
m->globalContext.Add(str_USE_SHADOW_SAMPLER, str_1);
#endif
}
if (m_LightEnv)
m->globalContext.Add(("LIGHTING_MODEL_" + m_LightEnv->GetLightingModel()).c_str(), "1");
m->globalContext.Add(CStrIntern("LIGHTING_MODEL_" + m_LightEnv->GetLightingModel()), str_1);
m->Model.ModShader = LitRenderModifierPtr(new ShaderRenderModifier());
@ -875,7 +875,7 @@ void CRenderer::RenderShadowMap(const CShaderDefines& context)
}
CShaderDefines contextCast = context;
contextCast.Add("MODE_SHADOWCAST", "1");
contextCast.Add(str_MODE_SHADOWCAST, str_1);
{
PROFILE("render models");
@ -1003,7 +1003,7 @@ void CRenderer::RenderModels(const CShaderDefines& context, const CFrustum* frus
else if (m_ModelRenderMode == EDGED_FACES)
{
CShaderDefines contextWireframe = context;
contextWireframe.Add("MODE_WIREFRAME", "1");
contextWireframe.Add(str_MODE_WIREFRAME, str_1);
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
glDisable(GL_TEXTURE_2D);
@ -1040,10 +1040,10 @@ void CRenderer::RenderTransparentModels(const CShaderDefines& context, ETranspar
glDisable(GL_CULL_FACE);
CShaderDefines contextOpaque = context;
contextOpaque.Add("ALPHABLEND_PASS_OPAQUE", "1");
contextOpaque.Add(str_ALPHABLEND_PASS_OPAQUE, str_1);
CShaderDefines contextBlend = context;
contextBlend.Add("ALPHABLEND_PASS_BLEND", "1");
contextBlend.Add(str_ALPHABLEND_PASS_BLEND, str_1);
if (transparentMode == TRANSPARENT || transparentMode == TRANSPARENT_OPAQUE)
m->CallTranspModelRenderers(contextOpaque, flags);
@ -1063,7 +1063,7 @@ void CRenderer::RenderTransparentModels(const CShaderDefines& context, ETranspar
else if (m_ModelRenderMode == EDGED_FACES)
{
CShaderDefines contextWireframe = contextOpaque;
contextWireframe.Add("MODE_WIREFRAME", "1");
contextWireframe.Add(str_MODE_WIREFRAME, str_1);
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
glDisable(GL_TEXTURE_2D);
@ -1284,10 +1284,10 @@ void CRenderer::RenderSilhouettes(const CShaderDefines& context)
PROFILE3_GPU("silhouettes");
CShaderDefines contextOccluder = context;
contextOccluder.Add("MODE_SILHOUETTEOCCLUDER", "1");
contextOccluder.Add(str_MODE_SILHOUETTEOCCLUDER, str_1);
CShaderDefines contextDisplay = context;
contextDisplay.Add("MODE_SILHOUETTEDISPLAY", "1");
contextDisplay.Add(str_MODE_SILHOUETTEDISPLAY, str_1);
// Render silhouettes of units hidden behind terrain or occluders.
// To avoid breaking the standard rendering of alpha-blended objects, this
@ -1401,11 +1401,11 @@ void CRenderer::RenderParticles()
m->particleRenderer.RenderParticles(true);
CShaderTechniquePtr shaderTech = g_Renderer.GetShaderManager().LoadEffect("gui_solid");
CShaderTechniquePtr shaderTech = g_Renderer.GetShaderManager().LoadEffect(str_gui_solid);
shaderTech->BeginPass();
CShaderProgramPtr shader = shaderTech->GetShader();
shader->Uniform("color", 0.0f, 1.0f, 0.0f, 1.0f);
shader->Uniform("transform", m_ViewCamera.GetViewProjection());
shader->Uniform(str_color, 0.0f, 1.0f, 0.0f, 1.0f);
shader->Uniform(str_transform, m_ViewCamera.GetViewProjection());
m->particleRenderer.RenderBounds(shader);

14
source/renderer/ShadowMap.cpp
View File

@ -570,7 +570,7 @@ int ShadowMap::GetHeight() const
void ShadowMap::RenderDebugBounds()
{
CShaderTechniquePtr shaderTech = g_Renderer.GetShaderManager().LoadEffect("gui_solid");
CShaderTechniquePtr shaderTech = g_Renderer.GetShaderManager().LoadEffect(str_gui_solid);
shaderTech->BeginPass();
CShaderProgramPtr shader = shaderTech->GetShader();
@ -578,15 +578,15 @@ void ShadowMap::RenderDebugBounds()
glDisable(GL_CULL_FACE);
// Render shadow bound
shader->Uniform("transform", g_Renderer.GetViewCamera().GetViewProjection() * m->InvLightTransform);
shader->Uniform(str_transform, g_Renderer.GetViewCamera().GetViewProjection() * m->InvLightTransform);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
shader->Uniform("color", 0.0f, 0.0f, 1.0f, 0.25f);
shader->Uniform(str_color, 0.0f, 0.0f, 1.0f, 0.25f);
m->ShadowBound.Render(shader);
glDisable(GL_BLEND);
shader->Uniform("color", 0.0f, 0.0f, 1.0f, 1.0f);
shader->Uniform(str_color, 0.0f, 0.0f, 1.0f, 1.0f);
m->ShadowBound.RenderOutline(shader);
// Draw a funny line/triangle direction indicator thing for unknown reasons
@ -656,12 +656,12 @@ void ShadowMap::RenderDebugTexture()
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_NONE);
#endif
CShaderTechniquePtr texTech = g_Renderer.GetShaderManager().LoadEffect("gui_basic");
CShaderTechniquePtr texTech = g_Renderer.GetShaderManager().LoadEffect(str_gui_basic);
texTech->BeginPass();
CShaderProgramPtr texShader = texTech->GetShader();
texShader->Uniform("transform", GetDefaultGuiMatrix());
texShader->BindTexture("tex", m->Texture);
texShader->Uniform(str_transform, GetDefaultGuiMatrix());
texShader->BindTexture(str_tex, m->Texture);
float s = 256.f;
float boxVerts[] = {

4
source/renderer/SkyManager.cpp
View File

@ -260,10 +260,10 @@ void SkyManager::RenderSky()
if (g_Renderer.GetRenderPath() == CRenderer::RP_SHADER)
{
skytech = g_Renderer.GetShaderManager().LoadEffect("sky_simple");
skytech = g_Renderer.GetShaderManager().LoadEffect(str_sky_simple);
skytech->BeginPass();
shader = skytech->GetShader();
shader->BindTexture("baseTex", m_SkyCubeMap);
shader->BindTexture(str_baseTex, m_SkyCubeMap);
}
else
{

136
source/renderer/TerrainRenderer.cpp
View File

@ -468,30 +468,30 @@ void TerrainRenderer::RenderTerrainOverlayTexture(CMatrix3D& textureMatrix)
*/
void TerrainRenderer::PrepareShader(const CShaderProgramPtr& shader, ShadowMap* shadow)
{
shader->Uniform("transform", g_Renderer.GetViewCamera().GetViewProjection());
shader->Uniform("cameraPos", g_Renderer.GetViewCamera().GetOrientation().GetTranslation());
shader->Uniform(str_transform, g_Renderer.GetViewCamera().GetViewProjection());
shader->Uniform(str_cameraPos, g_Renderer.GetViewCamera().GetOrientation().GetTranslation());
const CLightEnv& lightEnv = g_Renderer.GetLightEnv();
if (shadow)
{
shader->BindTexture("shadowTex", shadow->GetTexture());
shader->Uniform("shadowTransform", shadow->GetTextureMatrix());
shader->BindTexture(str_shadowTex, shadow->GetTexture());
shader->Uniform(str_shadowTransform, shadow->GetTextureMatrix());
int width = shadow->GetWidth();
int height = shadow->GetHeight();
shader->Uniform("shadowScale", width, height, 1.0f / width, 1.0f / height);
shader->Uniform(str_shadowScale, width, height, 1.0f / width, 1.0f / height);
}
CLOSTexture& los = g_Renderer.GetScene().GetLOSTexture();
shader->BindTexture("losTex", los.GetTextureSmooth());
shader->Uniform("losTransform", los.GetTextureMatrix()[0], los.GetTextureMatrix()[12], 0.f, 0.f);
shader->BindTexture(str_losTex, los.GetTextureSmooth());
shader->Uniform(str_losTransform, los.GetTextureMatrix()[0], los.GetTextureMatrix()[12], 0.f, 0.f);
shader->Uniform("ambient", lightEnv.m_TerrainAmbientColor);
shader->Uniform("sunColor", lightEnv.m_SunColor);
shader->Uniform("sunDir", lightEnv.GetSunDir());
shader->Uniform(str_ambient, lightEnv.m_TerrainAmbientColor);
shader->Uniform(str_sunColor, lightEnv.m_SunColor);
shader->Uniform(str_sunDir, lightEnv.GetSunDir());
shader->Uniform("fogColor", lightEnv.m_FogColor);
shader->Uniform("fogParams", lightEnv.m_FogFactor, lightEnv.m_FogMax, 0.f, 0.f);
shader->Uniform(str_fogColor, lightEnv.m_FogColor);
shader->Uniform(str_fogParams, lightEnv.m_FogFactor, lightEnv.m_FogMax, 0.f, 0.f);
}
void TerrainRenderer::RenderTerrainShader(const CShaderDefines& context, ShadowMap* shadow, bool filtered)
@ -504,11 +504,11 @@ void TerrainRenderer::RenderTerrainShader(const CShaderDefines& context, ShadowM
return;
// render the solid black sides of the map first
CShaderTechniquePtr techSolid = g_Renderer.GetShaderManager().LoadEffect("gui_solid");
CShaderTechniquePtr techSolid = g_Renderer.GetShaderManager().LoadEffect(str_gui_solid);
techSolid->BeginPass();
CShaderProgramPtr shaderSolid = techSolid->GetShader();
shaderSolid->Uniform("transform", g_Renderer.GetViewCamera().GetViewProjection());
shaderSolid->Uniform("color", 0.0f, 0.0f, 0.0f, 1.0f);
shaderSolid->Uniform(str_transform, g_Renderer.GetViewCamera().GetViewProjection());
shaderSolid->Uniform(str_color, 0.0f, 0.0f, 0.0f, 1.0f);
PROFILE_START("render terrain sides");
for (size_t i = 0; i < visiblePatches.size(); ++i)
@ -655,27 +655,27 @@ bool TerrainRenderer::RenderFancyWater(const CShaderDefines& context, ShadowMap*
// If we're using fancy water, make sure its shader is loaded
if (!m->fancyWaterShader || WaterMgr->m_NeedsReloading)
{
if(WaterMgr->m_WaterNormal)
defines.Add("USE_NORMALS","1");
if(WaterMgr->m_WaterRealDepth)
defines.Add("USE_REAL_DEPTH","1");
if(WaterMgr->m_WaterFoam && !g_AtlasGameLoop->running)
defines.Add("USE_FOAM","1");
if(WaterMgr->m_WaterCoastalWaves && !g_AtlasGameLoop->running)
defines.Add("USE_WAVES","1");
if(WaterMgr->m_WaterRefraction)
defines.Add("USE_REFRACTION","1");
if(WaterMgr->m_WaterReflection)
defines.Add("USE_REFLECTION","1");
if(shadow && WaterMgr->m_WaterShadows)
defines.Add("USE_SHADOWS","1");
if (WaterMgr->m_WaterNormal)
defines.Add(str_USE_NORMALS, str_1);
if (WaterMgr->m_WaterRealDepth)
defines.Add(str_USE_REAL_DEPTH, str_1);
if (WaterMgr->m_WaterFoam && !g_AtlasGameLoop->running)
defines.Add(str_USE_FOAM, str_1);
if (WaterMgr->m_WaterCoastalWaves && !g_AtlasGameLoop->running)
defines.Add(str_USE_WAVES, str_1);
if (WaterMgr->m_WaterRefraction)
defines.Add(str_USE_REFRACTION, str_1);
if (WaterMgr->m_WaterReflection)
defines.Add(str_USE_REFLECTION, str_1);
if (shadow && WaterMgr->m_WaterShadows)
defines.Add(str_USE_SHADOWS, str_1);
m->wavesShader = g_Renderer.GetShaderManager().LoadProgram("glsl/waves", defines);
if (!m->wavesShader)
{
LOGERROR(L"Failed to load waves shader. Deactivating waves.\n");
g_Renderer.SetOptionBool(CRenderer::OPT_WATERCOASTALWAVES, false);
defines.Add("USE_WAVES","0");
defines.Add(str_USE_WAVES, str_0);
}
// haven't updated the ARB shader yet so I'll always load the GLSL
@ -771,10 +771,10 @@ bool TerrainRenderer::RenderFancyWater(const CShaderDefines& context, ShadowMap*
// rendering
m->wavesShader->Bind();
m->wavesShader->BindTexture("waveTex", WaterMgr->m_Wave);
m->wavesShader->Uniform("time", (float)time);
m->wavesShader->Uniform("waviness", WaterMgr->m_Waviness);
m->wavesShader->Uniform("mapSize", (float)(WaterMgr->m_TexSize));
m->wavesShader->BindTexture(str_waveTex, WaterMgr->m_Wave);
m->wavesShader->Uniform(str_time, (float)time);
m->wavesShader->Uniform(str_waviness, WaterMgr->m_Waviness);
m->wavesShader->Uniform(str_mapSize, (float)(WaterMgr->m_TexSize));
SWavesVertex *base=(SWavesVertex *)WaterMgr->m_VBWaves->m_Owner->Bind();
GLsizei stride = sizeof(SWavesVertex);
@ -805,57 +805,57 @@ bool TerrainRenderer::RenderFancyWater(const CShaderDefines& context, ShadowMap*
const CCamera& camera = g_Renderer.GetViewCamera();
CVector3D camPos = camera.m_Orientation.GetTranslation();
m->fancyWaterShader->BindTexture("normalMap", WaterMgr->m_NormalMap[curTex]);
m->fancyWaterShader->BindTexture("normalMap2", WaterMgr->m_NormalMap[nexTex]);
m->fancyWaterShader->BindTexture(str_normalMap, WaterMgr->m_NormalMap[curTex]);
m->fancyWaterShader->BindTexture(str_normalMap2, WaterMgr->m_NormalMap[nexTex]);
if (WaterMgr->m_WaterFoam || WaterMgr->m_WaterCoastalWaves)
{
m->fancyWaterShader->BindTexture("Foam", WaterMgr->m_Foam);
m->fancyWaterShader->Uniform("mapSize", (float)(WaterMgr->m_TexSize));
m->fancyWaterShader->BindTexture(str_Foam, WaterMgr->m_Foam);
m->fancyWaterShader->Uniform(str_mapSize, (float)(WaterMgr->m_TexSize));
}
if (WaterMgr->m_WaterRealDepth)
m->fancyWaterShader->BindTexture("depthTex", WaterMgr->m_depthTT);
m->fancyWaterShader->BindTexture(str_depthTex, WaterMgr->m_depthTT);
if (WaterMgr->m_WaterCoastalWaves)
m->fancyWaterShader->BindTexture("waveTex", WaterMgr->m_waveTT);
m->fancyWaterShader->BindTexture(str_waveTex, WaterMgr->m_waveTT);
if (WaterMgr->m_WaterReflection)
m->fancyWaterShader->BindTexture("reflectionMap", WaterMgr->m_ReflectionTexture);
m->fancyWaterShader->BindTexture(str_reflectionMap, WaterMgr->m_ReflectionTexture);
if (WaterMgr->m_WaterRefraction)
m->fancyWaterShader->BindTexture("refractionMap", WaterMgr->m_RefractionTexture);
m->fancyWaterShader->BindTexture(str_refractionMap, WaterMgr->m_RefractionTexture);
m->fancyWaterShader->BindTexture("losMap", losTexture.GetTextureSmooth());
m->fancyWaterShader->BindTexture(str_losMap, losTexture.GetTextureSmooth());
const CLightEnv& lightEnv = g_Renderer.GetLightEnv();
// TODO: only bind what's really needed for that.
m->fancyWaterShader->Uniform("sunDir", lightEnv.GetSunDir());
m->fancyWaterShader->Uniform("sunColor", lightEnv.m_SunColor.X);
m->fancyWaterShader->Uniform("color", WaterMgr->m_WaterColor);
m->fancyWaterShader->Uniform("shininess", WaterMgr->m_Shininess);
m->fancyWaterShader->Uniform("specularStrength", WaterMgr->m_SpecularStrength);
m->fancyWaterShader->Uniform("waviness", WaterMgr->m_Waviness);
m->fancyWaterShader->Uniform("murkiness", WaterMgr->m_Murkiness);
m->fancyWaterShader->Uniform("tint", WaterMgr->m_WaterTint);
m->fancyWaterShader->Uniform("reflectionTintStrength", WaterMgr->m_ReflectionTintStrength);
m->fancyWaterShader->Uniform("reflectionTint", WaterMgr->m_ReflectionTint);
m->fancyWaterShader->Uniform("translation", tx, ty);
m->fancyWaterShader->Uniform("repeatScale", 1.0f / repeatPeriod);
m->fancyWaterShader->Uniform("reflectionMatrix", WaterMgr->m_ReflectionMatrix);
m->fancyWaterShader->Uniform("refractionMatrix", WaterMgr->m_RefractionMatrix);
m->fancyWaterShader->Uniform("losMatrix", losTexture.GetTextureMatrix());
m->fancyWaterShader->Uniform("cameraPos", camPos);
m->fancyWaterShader->Uniform("fogColor", lightEnv.m_FogColor);
m->fancyWaterShader->Uniform("fogParams", lightEnv.m_FogFactor, lightEnv.m_FogMax, 0.f, 0.f);
m->fancyWaterShader->Uniform("time", (float)time);
m->fancyWaterShader->Uniform("screenSize", (float)g_Renderer.GetWidth(), (float)g_Renderer.GetHeight(), 0.0f, 0.0f);
m->fancyWaterShader->BindTexture("skyCube", g_Renderer.GetSkyManager()->GetSkyCube());
m->fancyWaterShader->Uniform(str_sunDir, lightEnv.GetSunDir());
m->fancyWaterShader->Uniform(str_sunColor, lightEnv.m_SunColor.X);
m->fancyWaterShader->Uniform(str_color, WaterMgr->m_WaterColor);
m->fancyWaterShader->Uniform(str_shininess, WaterMgr->m_Shininess);
m->fancyWaterShader->Uniform(str_specularStrength, WaterMgr->m_SpecularStrength);
m->fancyWaterShader->Uniform(str_waviness, WaterMgr->m_Waviness);
m->fancyWaterShader->Uniform(str_murkiness, WaterMgr->m_Murkiness);
m->fancyWaterShader->Uniform(str_tint, WaterMgr->m_WaterTint);
m->fancyWaterShader->Uniform(str_reflectionTintStrength, WaterMgr->m_ReflectionTintStrength);
m->fancyWaterShader->Uniform(str_reflectionTint, WaterMgr->m_ReflectionTint);
m->fancyWaterShader->Uniform(str_translation, tx, ty);
m->fancyWaterShader->Uniform(str_repeatScale, 1.0f / repeatPeriod);
m->fancyWaterShader->Uniform(str_reflectionMatrix, WaterMgr->m_ReflectionMatrix);
m->fancyWaterShader->Uniform(str_refractionMatrix, WaterMgr->m_RefractionMatrix);
m->fancyWaterShader->Uniform(str_losMatrix, losTexture.GetTextureMatrix());
m->fancyWaterShader->Uniform(str_cameraPos, camPos);
m->fancyWaterShader->Uniform(str_fogColor, lightEnv.m_FogColor);
m->fancyWaterShader->Uniform(str_fogParams, lightEnv.m_FogFactor, lightEnv.m_FogMax, 0.f, 0.f);
m->fancyWaterShader->Uniform(str_time, (float)time);
m->fancyWaterShader->Uniform(str_screenSize, (float)g_Renderer.GetWidth(), (float)g_Renderer.GetHeight(), 0.0f, 0.0f);
m->fancyWaterShader->BindTexture(str_skyCube, g_Renderer.GetSkyManager()->GetSkyCube());
if (shadow && WaterMgr->m_WaterShadows)
{
m->fancyWaterShader->BindTexture("shadowTex", shadow->GetTexture());
m->fancyWaterShader->Uniform("shadowTransform", shadow->GetTextureMatrix());
m->fancyWaterShader->BindTexture(str_shadowTex, shadow->GetTexture());
m->fancyWaterShader->Uniform(str_shadowTransform, shadow->GetTextureMatrix());
int width = shadow->GetWidth();
int height = shadow->GetHeight();
m->fancyWaterShader->Uniform("shadowScale", width, height, 1.0f / width, 1.0f / height);
m->fancyWaterShader->Uniform(str_shadowScale, width, height, 1.0f / width, 1.0f / height);
}
for (size_t i = 0; i < m->visiblePatches.size(); ++i)
@ -996,7 +996,7 @@ void TerrainRenderer::RenderPriorities()
ENSURE(m->phase == Phase_Render);
CShaderTechniquePtr tech = g_Renderer.GetShaderManager().LoadEffect("gui_text");
CShaderTechniquePtr tech = g_Renderer.GetShaderManager().LoadEffect(str_gui_text);
tech->BeginPass();
CTextRenderer textRenderer(tech->GetShader());

6
source/renderer/TexturedLineRData.cpp
View File

@ -41,9 +41,9 @@ void CTexturedLineRData::Render(const SOverlayTexturedLine& line, const CShaderP
const int streamFlags = shader->GetStreamFlags();
shader->BindTexture("baseTex", line.m_TextureBase->GetHandle());
shader->BindTexture("maskTex", line.m_TextureMask->GetHandle());
shader->Uniform("objectColor", line.m_Color);
shader->BindTexture(str_baseTex, line.m_TextureBase->GetHandle());
shader->BindTexture(str_maskTex, line.m_TextureMask->GetHandle());
shader->Uniform(str_objectColor, line.m_Color);
GLsizei stride = sizeof(CTexturedLineRData::SVertex);
CTexturedLineRData::SVertex* vertexBase = reinterpret_cast<CTexturedLineRData::SVertex*>(m_VB->m_Owner->Bind());