Ykkrosh
994ebd9836
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.
1041 lines
29 KiB
C++
1041 lines
29 KiB
C++
/* Copyright (C) 2012 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/>.
|
|
*/
|
|
|
|
#include "precompiled.h"
|
|
|
|
#include "ShaderProgram.h"
|
|
|
|
#include "graphics/ShaderDefines.h"
|
|
#include "graphics/TextureManager.h"
|
|
#include "lib/res/graphics/ogl_tex.h"
|
|
#include "maths/Matrix3D.h"
|
|
#include "maths/Vector3D.h"
|
|
#include "ps/CLogger.h"
|
|
#include "ps/Overlay.h"
|
|
#include "renderer/Renderer.h"
|
|
|
|
#if !CONFIG2_GLES
|
|
|
|
/**
|
|
* CShaderProgramFFP allows rendering code to use the shader-based API
|
|
* even if the 'shader' is actually implemented with the fixed-function
|
|
* pipeline instead of anything programmable.
|
|
*
|
|
* Currently we just hard-code a number of FFP programs as subclasses of this.
|
|
* If we have lots, it might be nicer to abstract out the common functionality
|
|
* and load these from text files or something.
|
|
*/
|
|
class CShaderProgramFFP : public CShaderProgram
|
|
{
|
|
public:
|
|
CShaderProgramFFP(int streamflags) :
|
|
CShaderProgram(streamflags)
|
|
{
|
|
}
|
|
|
|
~CShaderProgramFFP()
|
|
{
|
|
}
|
|
|
|
virtual void Reload()
|
|
{
|
|
m_IsValid = true;
|
|
}
|
|
|
|
int GetUniformIndex(CStrIntern id)
|
|
{
|
|
std::map<CStrIntern, int>::iterator it = m_UniformIndexes.find(id);
|
|
if (it == m_UniformIndexes.end())
|
|
return -1;
|
|
return it->second;
|
|
}
|
|
|
|
virtual Binding GetTextureBinding(uniform_id_t id)
|
|
{
|
|
int index = GetUniformIndex(CStrIntern(id));
|
|
if (index == -1)
|
|
return Binding();
|
|
else
|
|
return Binding((int)GL_TEXTURE_2D, index);
|
|
}
|
|
|
|
virtual void BindTexture(texture_id_t id, Handle tex)
|
|
{
|
|
int index = GetUniformIndex(CStrIntern(id));
|
|
if (index != -1)
|
|
ogl_tex_bind(tex, index);
|
|
}
|
|
|
|
virtual void BindTexture(texture_id_t id, GLuint tex)
|
|
{
|
|
int index = GetUniformIndex(CStrIntern(id));
|
|
if (index != -1)
|
|
{
|
|
pglActiveTextureARB((int)(GL_TEXTURE0+index));
|
|
glBindTexture(GL_TEXTURE_2D, tex);
|
|
}
|
|
}
|
|
|
|
virtual void BindTexture(Binding id, Handle tex)
|
|
{
|
|
int index = id.second;
|
|
if (index != -1)
|
|
ogl_tex_bind(tex, index);
|
|
}
|
|
|
|
virtual Binding GetUniformBinding(uniform_id_t id)
|
|
{
|
|
return Binding(-1, GetUniformIndex(id));
|
|
}
|
|
|
|
virtual void Uniform(Binding UNUSED(id), float UNUSED(v0), float UNUSED(v1), float UNUSED(v2), float UNUSED(v3))
|
|
{
|
|
}
|
|
|
|
virtual void Uniform(Binding UNUSED(id), const CMatrix3D& UNUSED(v))
|
|
{
|
|
}
|
|
|
|
virtual void Uniform(Binding UNUSED(id), size_t UNUSED(count), const CMatrix3D* UNUSED(v))
|
|
{
|
|
}
|
|
|
|
protected:
|
|
std::map<CStrIntern, int> m_UniformIndexes;
|
|
|
|
void SetUniformIndex(const char* id, int value)
|
|
{
|
|
m_UniformIndexes[CStrIntern(id)] = value;
|
|
}
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
/**
|
|
* A shader that does nothing but provide a shader-compatible interface to
|
|
* fixed-function features, for compatibility with existing fixed-function
|
|
* code that isn't fully ported to the shader API.
|
|
*/
|
|
class CShaderProgramFFP_Dummy : public CShaderProgramFFP
|
|
{
|
|
public:
|
|
CShaderProgramFFP_Dummy() :
|
|
CShaderProgramFFP(0)
|
|
{
|
|
// Texture units, for when this shader is used with terrain:
|
|
SetUniformIndex("baseTex", 0);
|
|
}
|
|
|
|
virtual void Bind()
|
|
{
|
|
BindClientStates();
|
|
}
|
|
|
|
virtual void Unbind()
|
|
{
|
|
UnbindClientStates();
|
|
}
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
class CShaderProgramFFP_OverlayLine : public CShaderProgramFFP
|
|
{
|
|
// Uniforms
|
|
enum
|
|
{
|
|
ID_losTransform,
|
|
ID_objectColor
|
|
};
|
|
|
|
bool m_IgnoreLos;
|
|
bool m_UseObjectColor;
|
|
|
|
public:
|
|
CShaderProgramFFP_OverlayLine(const CShaderDefines& defines) :
|
|
CShaderProgramFFP(0) // will be set manually in initializer below
|
|
{
|
|
SetUniformIndex("losTransform", ID_losTransform);
|
|
SetUniformIndex("objectColor", ID_objectColor);
|
|
|
|
// Texture units:
|
|
SetUniformIndex("baseTex", 0);
|
|
SetUniformIndex("maskTex", 1);
|
|
SetUniformIndex("losTex", 2);
|
|
|
|
m_IgnoreLos = (defines.GetInt("IGNORE_LOS") != 0);
|
|
m_UseObjectColor = (defines.GetInt("USE_OBJECTCOLOR") != 0);
|
|
|
|
m_StreamFlags = STREAM_POS | STREAM_UV0 | STREAM_UV1;
|
|
if (!m_UseObjectColor)
|
|
m_StreamFlags |= STREAM_COLOR;
|
|
}
|
|
|
|
bool IsIgnoreLos()
|
|
{
|
|
return m_IgnoreLos;
|
|
}
|
|
|
|
virtual void Uniform(Binding id, float v0, float v1, float v2, float v3)
|
|
{
|
|
if (id.second == ID_losTransform)
|
|
{
|
|
pglActiveTextureARB(GL_TEXTURE2);
|
|
GLfloat texgenS1[4] = { v0, 0, 0, v1 };
|
|
GLfloat texgenT1[4] = { 0, 0, v0, v1 };
|
|
glTexGenfv(GL_S, GL_OBJECT_PLANE, texgenS1);
|
|
glTexGenfv(GL_T, GL_OBJECT_PLANE, texgenT1);
|
|
}
|
|
else if (id.second == ID_objectColor)
|
|
{
|
|
float c[] = { v0, v1, v2, v3 };
|
|
pglActiveTextureARB(GL_TEXTURE1);
|
|
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, c);
|
|
}
|
|
else
|
|
{
|
|
debug_warn(L"Invalid id");
|
|
}
|
|
}
|
|
|
|
virtual void Uniform(Binding UNUSED(id), const CMatrix3D& UNUSED(v))
|
|
{
|
|
debug_warn(L"Not implemented");
|
|
}
|
|
|
|
virtual void Bind()
|
|
{
|
|
// RGB channels:
|
|
// Unit 0: Sample base texture
|
|
// Unit 1: Sample mask texture; interpolate with [objectColor or vertexColor] and base, depending on USE_OBJECTCOLOR
|
|
// Unit 2: (Load LOS texture; multiply) if not #IGNORE_LOS, pass through otherwise
|
|
// Alpha channel:
|
|
// Unit 0: Sample base texture
|
|
// Unit 1: Multiply by objectColor
|
|
// Unit 2: Pass through
|
|
|
|
pglActiveTextureARB(GL_TEXTURE0);
|
|
glEnable(GL_TEXTURE_2D);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
|
|
|
|
// Sample base texture RGB
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_REPLACE);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR);
|
|
|
|
// Sample base texture Alpha
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_REPLACE);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_TEXTURE);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB, GL_SRC_ALPHA);
|
|
|
|
// -----------------------------------------------------------------------------
|
|
|
|
pglActiveTextureARB(GL_TEXTURE1);
|
|
glEnable(GL_TEXTURE_2D);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
|
|
|
|
// RGB: interpolate component-wise between [objectColor or vertexColor] and base using mask:
|
|
// a0 * a2 + a1 * (1 - a2)
|
|
// Overridden implementation of Uniform() sets GL_TEXTURE_ENV_COLOR to objectColor, which
|
|
// is referenced as GL_CONSTANT (see spec)
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_INTERPOLATE);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, m_UseObjectColor ? GL_CONSTANT : GL_PRIMARY_COLOR);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PREVIOUS);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, GL_SRC_COLOR);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB_ARB, GL_TEXTURE);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB_ARB, GL_SRC_COLOR);
|
|
|
|
// ALPHA: Multiply base alpha with [objectColor or vertexColor] alpha
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_MODULATE);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, m_UseObjectColor ? GL_CONSTANT : GL_PRIMARY_COLOR);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB, GL_SRC_ALPHA);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_ARB, GL_PREVIOUS);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA_ARB, GL_SRC_ALPHA);
|
|
|
|
// -----------------------------------------------------------------------------
|
|
|
|
pglActiveTextureARB(GL_TEXTURE2);
|
|
glEnable(GL_TEXTURE_2D);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
|
|
|
|
bool ignoreLos = IsIgnoreLos();
|
|
if (ignoreLos)
|
|
{
|
|
// RGB pass through
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_REPLACE);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_PREVIOUS);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR);
|
|
}
|
|
else
|
|
{
|
|
// Multiply RGB result up till now with LoS texture alpha channel
|
|
glEnable(GL_TEXTURE_GEN_S);
|
|
glEnable(GL_TEXTURE_GEN_T);
|
|
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
|
|
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
|
|
// Overridden implementation of Uniform() sets GL_OBJECT_PLANE values
|
|
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_MODULATE);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_PREVIOUS);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_TEXTURE);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, GL_SRC_ALPHA);
|
|
}
|
|
|
|
// alpha pass through
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_REPLACE);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_PREVIOUS);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB, GL_SRC_ALPHA);
|
|
|
|
BindClientStates();
|
|
}
|
|
|
|
virtual void Unbind()
|
|
{
|
|
UnbindClientStates();
|
|
|
|
pglActiveTextureARB(GL_TEXTURE2);
|
|
glDisable(GL_TEXTURE_2D);
|
|
|
|
glDisable(GL_TEXTURE_GEN_S);
|
|
glDisable(GL_TEXTURE_GEN_T);
|
|
|
|
pglActiveTextureARB(GL_TEXTURE1);
|
|
glDisable(GL_TEXTURE_2D);
|
|
|
|
pglActiveTextureARB(GL_TEXTURE0);
|
|
glDisable(GL_TEXTURE_2D);
|
|
}
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
class CShaderProgramFFP_GuiText : public CShaderProgramFFP
|
|
{
|
|
// Uniforms
|
|
enum
|
|
{
|
|
ID_transform,
|
|
ID_colorMul
|
|
};
|
|
|
|
public:
|
|
CShaderProgramFFP_GuiText() :
|
|
CShaderProgramFFP(STREAM_POS | STREAM_UV0)
|
|
{
|
|
SetUniformIndex("transform", ID_transform);
|
|
SetUniformIndex("colorMul", ID_colorMul);
|
|
|
|
// Texture units:
|
|
SetUniformIndex("tex", 0);
|
|
}
|
|
|
|
virtual void Uniform(Binding id, float v0, float v1, float v2, float v3)
|
|
{
|
|
if (id.second == ID_colorMul)
|
|
glColor4f(v0, v1, v2, v3);
|
|
}
|
|
|
|
virtual void Uniform(Binding id, const CMatrix3D& v)
|
|
{
|
|
if (id.second == ID_transform)
|
|
glLoadMatrixf(&v._11);
|
|
}
|
|
|
|
virtual void Bind()
|
|
{
|
|
glMatrixMode(GL_PROJECTION);
|
|
glPushMatrix();
|
|
glLoadIdentity();
|
|
glMatrixMode(GL_MODELVIEW);
|
|
glPushMatrix();
|
|
|
|
pglActiveTextureARB(GL_TEXTURE0);
|
|
glEnable(GL_TEXTURE_2D);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
|
|
|
|
BindClientStates();
|
|
}
|
|
|
|
virtual void Unbind()
|
|
{
|
|
UnbindClientStates();
|
|
|
|
pglActiveTextureARB(GL_TEXTURE0);
|
|
glDisable(GL_TEXTURE_2D);
|
|
|
|
glMatrixMode(GL_PROJECTION);
|
|
glPopMatrix();
|
|
glMatrixMode(GL_MODELVIEW);
|
|
glPopMatrix();
|
|
}
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
class CShaderProgramFFP_Gui_Base : public CShaderProgramFFP
|
|
{
|
|
protected:
|
|
// Uniforms
|
|
enum
|
|
{
|
|
ID_transform,
|
|
ID_color
|
|
};
|
|
|
|
public:
|
|
CShaderProgramFFP_Gui_Base(int streamflags) :
|
|
CShaderProgramFFP(streamflags)
|
|
{
|
|
SetUniformIndex("transform", ID_transform);
|
|
SetUniformIndex("color", ID_color);
|
|
|
|
// Texture units:
|
|
SetUniformIndex("tex", 0);
|
|
}
|
|
|
|
virtual void Uniform(Binding id, const CMatrix3D& v)
|
|
{
|
|
if (id.second == ID_transform)
|
|
glLoadMatrixf(&v._11);
|
|
}
|
|
|
|
virtual void Bind()
|
|
{
|
|
glMatrixMode(GL_PROJECTION);
|
|
glPushMatrix();
|
|
glLoadIdentity();
|
|
glMatrixMode(GL_MODELVIEW);
|
|
glPushMatrix();
|
|
|
|
BindClientStates();
|
|
}
|
|
|
|
virtual void Unbind()
|
|
{
|
|
UnbindClientStates();
|
|
|
|
glMatrixMode(GL_PROJECTION);
|
|
glPopMatrix();
|
|
glMatrixMode(GL_MODELVIEW);
|
|
glPopMatrix();
|
|
}
|
|
};
|
|
|
|
class CShaderProgramFFP_GuiBasic : public CShaderProgramFFP_Gui_Base
|
|
{
|
|
public:
|
|
CShaderProgramFFP_GuiBasic() :
|
|
CShaderProgramFFP_Gui_Base(STREAM_POS | STREAM_UV0)
|
|
{
|
|
}
|
|
|
|
virtual void Bind()
|
|
{
|
|
CShaderProgramFFP_Gui_Base::Bind();
|
|
|
|
pglActiveTextureARB(GL_TEXTURE0);
|
|
glEnable(GL_TEXTURE_2D);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
|
|
}
|
|
|
|
virtual void Unbind()
|
|
{
|
|
pglActiveTextureARB(GL_TEXTURE0);
|
|
glDisable(GL_TEXTURE_2D);
|
|
|
|
CShaderProgramFFP_Gui_Base::Unbind();
|
|
}
|
|
};
|
|
|
|
class CShaderProgramFFP_GuiAdd : public CShaderProgramFFP_Gui_Base
|
|
{
|
|
public:
|
|
CShaderProgramFFP_GuiAdd() :
|
|
CShaderProgramFFP_Gui_Base(STREAM_POS | STREAM_UV0)
|
|
{
|
|
}
|
|
|
|
virtual void Uniform(Binding id, float v0, float v1, float v2, float v3)
|
|
{
|
|
if (id.second == ID_color)
|
|
glColor4f(v0, v1, v2, v3);
|
|
}
|
|
|
|
virtual void Bind()
|
|
{
|
|
CShaderProgramFFP_Gui_Base::Bind();
|
|
|
|
pglActiveTextureARB(GL_TEXTURE0);
|
|
glEnable(GL_TEXTURE_2D);
|
|
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
|
|
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_ADD);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_ADD);
|
|
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_TEXTURE);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_TEXTURE);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
|
|
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_PREVIOUS);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA, GL_PREVIOUS);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA, GL_SRC_ALPHA);
|
|
}
|
|
|
|
virtual void Unbind()
|
|
{
|
|
glColor4f(1.f, 1.f, 1.f, 1.f);
|
|
|
|
pglActiveTextureARB(GL_TEXTURE0);
|
|
glDisable(GL_TEXTURE_2D);
|
|
|
|
CShaderProgramFFP_Gui_Base::Unbind();
|
|
}
|
|
};
|
|
|
|
class CShaderProgramFFP_GuiGrayscale : public CShaderProgramFFP_Gui_Base
|
|
{
|
|
public:
|
|
CShaderProgramFFP_GuiGrayscale() :
|
|
CShaderProgramFFP_Gui_Base(STREAM_POS | STREAM_UV0)
|
|
{
|
|
}
|
|
|
|
virtual void Bind()
|
|
{
|
|
CShaderProgramFFP_Gui_Base::Bind();
|
|
|
|
/*
|
|
|
|
For the main conversion, use GL_DOT3_RGB, which is defined as
|
|
L = 4 * ((Arg0r - 0.5) * (Arg1r - 0.5)+
|
|
(Arg0g - 0.5) * (Arg1g - 0.5)+
|
|
(Arg0b - 0.5) * (Arg1b - 0.5))
|
|
where each of the RGB components is given the value 'L'.
|
|
|
|
Use the magical luminance formula
|
|
L = 0.3R + 0.59G + 0.11B
|
|
to calculate the greyscale value.
|
|
|
|
But to work around the annoying "Arg0-0.5", we need to calculate
|
|
Arg0+0.5. But we also need to scale it into the range 0.5-1.0, else
|
|
Arg0>0.5 will be clamped to 1.0. So use GL_INTERPOLATE, which outputs:
|
|
A0 * A2 + A1 * (1 - A2)
|
|
and set A2 = 0.5, A1 = 1.0, and A0 = texture (i.e. interpolating halfway
|
|
between the texture and {1,1,1}) giving
|
|
A0/2 + 0.5
|
|
and use that as Arg0.
|
|
|
|
So L = 4*(A0/2 * (Arg1-.5))
|
|
= 2 (Rx+Gy+Bz) (where Arg1 = {x+0.5, y+0.5, z+0.5})
|
|
= 2x R + 2y G + 2z B
|
|
= 0.3R + 0.59G + 0.11B
|
|
so e.g. 2y = 0.59 = 2(Arg1g-0.5) => Arg1g = 0.59/2+0.5
|
|
which fortunately doesn't get clamped.
|
|
|
|
So, just implement that:
|
|
|
|
*/
|
|
|
|
static const float GreyscaleDotColor[4] = {
|
|
0.3f / 2.f + 0.5f,
|
|
0.59f / 2.f + 0.5f,
|
|
0.11f / 2.f + 0.5f,
|
|
1.0f
|
|
};
|
|
static const float GreyscaleInterpColor0[4] = { 1.0f, 1.0f, 1.0f, 1.0f };
|
|
static const float GreyscaleInterpColor1[4] = { 0.5f, 0.5f, 0.5f, 1.0f };
|
|
|
|
pglActiveTextureARB(GL_TEXTURE0);
|
|
glEnable(GL_TEXTURE_2D);
|
|
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
|
|
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_TEXTURE);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
|
|
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_INTERPOLATE);
|
|
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_CONSTANT);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR);
|
|
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, GreyscaleInterpColor0);
|
|
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB, GL_PREVIOUS);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB, GL_SRC_COLOR);
|
|
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_REPLACE);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_TEXTURE);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
|
|
|
|
glColor4fv(GreyscaleInterpColor1);
|
|
|
|
pglActiveTextureARB(GL_TEXTURE1);
|
|
glEnable(GL_TEXTURE_2D);
|
|
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
|
|
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_PREVIOUS);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_PREVIOUS);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
|
|
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_DOT3_RGB);
|
|
|
|
// GL_DOT3_RGB requires GL_(EXT|ARB)_texture_env_dot3.
|
|
// We currently don't bother implementing a fallback because it's
|
|
// only lacking on Riva-class HW, but at least want the rest of the
|
|
// game to run there without errors. Therefore, squelch the
|
|
// OpenGL error that's raised if they aren't actually present.
|
|
// Note: higher-level code checks for this extension, but
|
|
// allows users the choice of continuing even if not present.
|
|
ogl_SquelchError(GL_INVALID_ENUM);
|
|
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_REPLACE);
|
|
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_CONSTANT);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR);
|
|
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, GreyscaleDotColor);
|
|
|
|
// To activate the second texture unit, we have to have some kind
|
|
// of texture bound into it, but we don't actually use the texture data,
|
|
// so bind a dummy texture
|
|
g_Renderer.GetTextureManager().GetErrorTexture()->Bind(1);
|
|
}
|
|
|
|
virtual void Unbind()
|
|
{
|
|
glColor4f(1.f, 1.f, 1.f, 1.f);
|
|
|
|
pglActiveTextureARB(GL_TEXTURE1);
|
|
glDisable(GL_TEXTURE_2D);
|
|
|
|
pglActiveTextureARB(GL_TEXTURE0);
|
|
glDisable(GL_TEXTURE_2D);
|
|
|
|
CShaderProgramFFP_Gui_Base::Unbind();
|
|
}
|
|
};
|
|
|
|
class CShaderProgramFFP_GuiSolid : public CShaderProgramFFP_Gui_Base
|
|
{
|
|
public:
|
|
CShaderProgramFFP_GuiSolid() :
|
|
CShaderProgramFFP_Gui_Base(STREAM_POS)
|
|
{
|
|
}
|
|
|
|
virtual void Uniform(Binding id, float v0, float v1, float v2, float v3)
|
|
{
|
|
if (id.second == ID_color)
|
|
glColor4f(v0, v1, v2, v3);
|
|
}
|
|
|
|
virtual void Bind()
|
|
{
|
|
CShaderProgramFFP_Gui_Base::Bind();
|
|
|
|
pglActiveTextureARB(GL_TEXTURE0);
|
|
glDisable(GL_TEXTURE_2D);
|
|
}
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
/**
|
|
* Common functionality for model rendering in the fixed renderpath.
|
|
*/
|
|
class CShaderProgramFFP_Model_Base : public CShaderProgramFFP
|
|
{
|
|
protected:
|
|
// Uniforms
|
|
enum
|
|
{
|
|
ID_transform,
|
|
ID_objectColor,
|
|
ID_playerColor,
|
|
ID_losTransform
|
|
};
|
|
|
|
bool m_IgnoreLos;
|
|
|
|
public:
|
|
CShaderProgramFFP_Model_Base(const CShaderDefines& defines, int streamflags)
|
|
: CShaderProgramFFP(streamflags)
|
|
{
|
|
SetUniformIndex("transform", ID_transform);
|
|
SetUniformIndex("losTransform", ID_losTransform);
|
|
|
|
if (defines.GetInt("USE_OBJECTCOLOR"))
|
|
SetUniformIndex("objectColor", ID_objectColor);
|
|
|
|
if (defines.GetInt("USE_PLAYERCOLOR"))
|
|
SetUniformIndex("playerColor", ID_playerColor);
|
|
|
|
m_IgnoreLos = (defines.GetInt("IGNORE_LOS") != 0);
|
|
|
|
// Texture units:
|
|
SetUniformIndex("baseTex", 0);
|
|
SetUniformIndex("losTex", 3);
|
|
}
|
|
|
|
virtual void Uniform(Binding id, const CMatrix3D& v)
|
|
{
|
|
if (id.second == ID_transform)
|
|
glLoadMatrixf(&v._11);
|
|
}
|
|
|
|
virtual void Uniform(Binding id, float v0, float v1, float UNUSED(v2), float UNUSED(v3))
|
|
{
|
|
if (id.second == ID_losTransform)
|
|
{
|
|
pglActiveTextureARB(GL_TEXTURE3);
|
|
GLfloat texgenS1[4] = { v0, 0, 0, v1 };
|
|
GLfloat texgenT1[4] = { 0, 0, v0, v1 };
|
|
glTexGenfv(GL_S, GL_OBJECT_PLANE, texgenS1);
|
|
glTexGenfv(GL_T, GL_OBJECT_PLANE, texgenT1);
|
|
}
|
|
}
|
|
|
|
virtual void Bind()
|
|
{
|
|
glMatrixMode(GL_PROJECTION);
|
|
glPushMatrix();
|
|
glLoadIdentity();
|
|
glMatrixMode(GL_MODELVIEW);
|
|
glPushMatrix();
|
|
|
|
// -----------------------------------------------------------------------------
|
|
|
|
pglActiveTextureARB(GL_TEXTURE3);
|
|
glEnable(GL_TEXTURE_2D);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
|
|
|
|
if (m_IgnoreLos)
|
|
{
|
|
// RGB pass through
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_REPLACE);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_PREVIOUS);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR);
|
|
}
|
|
else
|
|
{
|
|
// Multiply RGB result up till now with LoS texture alpha channel
|
|
glEnable(GL_TEXTURE_GEN_S);
|
|
glEnable(GL_TEXTURE_GEN_T);
|
|
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
|
|
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
|
|
// Overridden implementation of Uniform() sets GL_OBJECT_PLANE values
|
|
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_MODULATE);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_PREVIOUS);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_TEXTURE);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, GL_SRC_ALPHA);
|
|
}
|
|
|
|
// alpha pass through
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_REPLACE);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_PREVIOUS);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB, GL_SRC_ALPHA);
|
|
|
|
// -----------------------------------------------------------------------------
|
|
|
|
BindClientStates();
|
|
}
|
|
|
|
virtual void Unbind()
|
|
{
|
|
UnbindClientStates();
|
|
|
|
pglActiveTextureARB(GL_TEXTURE3);
|
|
glDisable(GL_TEXTURE_2D);
|
|
|
|
glDisable(GL_TEXTURE_GEN_S);
|
|
glDisable(GL_TEXTURE_GEN_T);
|
|
|
|
pglActiveTextureARB(GL_TEXTURE0);
|
|
|
|
glMatrixMode(GL_PROJECTION);
|
|
glPopMatrix();
|
|
glMatrixMode(GL_MODELVIEW);
|
|
glPopMatrix();
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Basic non-recolored diffuse-textured model rendering.
|
|
*/
|
|
class CShaderProgramFFP_Model : public CShaderProgramFFP_Model_Base
|
|
{
|
|
public:
|
|
CShaderProgramFFP_Model(const CShaderDefines& defines)
|
|
: CShaderProgramFFP_Model_Base(defines, STREAM_POS | STREAM_COLOR | STREAM_UV0)
|
|
{
|
|
}
|
|
|
|
virtual void Bind()
|
|
{
|
|
// Set up texture environment for base pass - modulate texture and vertex color
|
|
pglActiveTextureARB(GL_TEXTURE0);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_MODULATE);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_TEXTURE);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_PRIMARY_COLOR);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR);
|
|
|
|
// Copy alpha channel from texture
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_REPLACE);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_TEXTURE);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
|
|
|
|
// The vertex color is scaled by 0.5 to permit overbrightness without clamping.
|
|
// We therefore need to scale by 2.0 after the modulation, and before any
|
|
// further clamping, to get the right color.
|
|
float scale2[] = { 2.0f, 2.0f, 2.0f };
|
|
glTexEnvfv(GL_TEXTURE_ENV, GL_RGB_SCALE, scale2);
|
|
|
|
CShaderProgramFFP_Model_Base::Bind();
|
|
}
|
|
|
|
virtual void Unbind()
|
|
{
|
|
CShaderProgramFFP_Model_Base::Unbind();
|
|
|
|
pglActiveTextureARB(GL_TEXTURE0);
|
|
|
|
// Revert the scaling to default
|
|
float scale1[] = { 1.0f, 1.0f, 1.0f };
|
|
glTexEnvfv(GL_TEXTURE_ENV, GL_RGB_SCALE, scale1);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Player-coloring diffuse-textured model rendering.
|
|
*/
|
|
class CShaderProgramFFP_ModelColor : public CShaderProgramFFP_Model_Base
|
|
{
|
|
public:
|
|
CShaderProgramFFP_ModelColor(const CShaderDefines& defines)
|
|
: CShaderProgramFFP_Model_Base(defines, STREAM_POS | STREAM_COLOR | STREAM_UV0)
|
|
{
|
|
}
|
|
|
|
virtual void Uniform(Binding id, float v0, float v1, float v2, float v3)
|
|
{
|
|
if (id.second == ID_objectColor || id.second == ID_playerColor)
|
|
{
|
|
// (Player color and object color are mutually exclusive)
|
|
float color[] = { v0, v1, v2, v3 };
|
|
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, color);
|
|
}
|
|
}
|
|
|
|
virtual void Bind()
|
|
{
|
|
// Player color uses a single pass with three texture environments
|
|
// Note: This uses ARB_texture_env_crossbar (which is checked in GameSetup),
|
|
// and it requires MAX_TEXTURE_IMAGE_UNITS >= 3 (which only excludes GF2MX/GF4MX)
|
|
//
|
|
// We calculate: Result = Color*Texture*(PlayerColor*(1-Texture.a) + 1.0*Texture.a)
|
|
// Algebra gives us:
|
|
// Result = (1 - ((1 - PlayerColor) * (1 - Texture.a)))*Texture*Color
|
|
|
|
// TexEnv #0
|
|
pglActiveTextureARB(GL_TEXTURE0);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_MODULATE);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_TEXTURE);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_ONE_MINUS_SRC_ALPHA);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_CONSTANT);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_ONE_MINUS_SRC_COLOR);
|
|
|
|
// Don't care about alpha; set it to something harmless
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_REPLACE);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_PREVIOUS);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
|
|
|
|
// TexEnv #1
|
|
pglActiveTextureARB(GL_TEXTURE1);
|
|
glEnable(GL_TEXTURE_2D);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_MODULATE);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_PREVIOUS);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_ONE_MINUS_SRC_COLOR);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_PRIMARY_COLOR);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR);
|
|
|
|
// Don't care about alpha; set it to something harmless
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_REPLACE);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_PREVIOUS);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
|
|
|
|
// TexEnv #2
|
|
pglActiveTextureARB(GL_TEXTURE2);
|
|
glEnable(GL_TEXTURE_2D);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_MODULATE);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_PREVIOUS);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_TEXTURE0);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR);
|
|
|
|
// Don't care about alpha; set it to something harmless
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_REPLACE);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_PREVIOUS);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
|
|
|
|
float color[] = { 1.0f, 1.0f, 1.0f, 1.0f };
|
|
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, color);
|
|
|
|
// Scale colors at the end of all the computation (see CShaderProgramFFP_Model::Bind)
|
|
float scale[] = { 2.0f, 2.0f, 2.0f };
|
|
glTexEnvfv(GL_TEXTURE_ENV, GL_RGB_SCALE, scale);
|
|
|
|
// Need to bind some kind of texture to enable the texture units.
|
|
// Unit 0 has baseTex, but the others need a texture.
|
|
g_Renderer.GetTextureManager().GetErrorTexture()->Bind(1);
|
|
g_Renderer.GetTextureManager().GetErrorTexture()->Bind(2);
|
|
|
|
CShaderProgramFFP_Model_Base::Bind();
|
|
}
|
|
|
|
virtual void Unbind()
|
|
{
|
|
CShaderProgramFFP_Model_Base::Unbind();
|
|
|
|
pglActiveTextureARB(GL_TEXTURE2);
|
|
glDisable(GL_TEXTURE_2D);
|
|
|
|
float scale[] = { 1.0f, 1.0f, 1.0f };
|
|
glTexEnvfv(GL_TEXTURE_ENV, GL_RGB_SCALE, scale);
|
|
|
|
pglActiveTextureARB(GL_TEXTURE1);
|
|
glDisable(GL_TEXTURE_2D);
|
|
|
|
pglActiveTextureARB(GL_TEXTURE0);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Optionally-player-colored untextured model rendering.
|
|
*/
|
|
class CShaderProgramFFP_ModelSolid : public CShaderProgramFFP_Model_Base
|
|
{
|
|
public:
|
|
CShaderProgramFFP_ModelSolid(const CShaderDefines& defines)
|
|
: CShaderProgramFFP_Model_Base(defines, STREAM_POS)
|
|
{
|
|
}
|
|
|
|
virtual void Uniform(Binding id, float v0, float v1, float v2, float v3)
|
|
{
|
|
if (id.second == ID_playerColor)
|
|
{
|
|
float color[] = { v0, v1, v2, v3 };
|
|
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, color);
|
|
}
|
|
}
|
|
|
|
virtual void Bind()
|
|
{
|
|
float color[] = { 1.0f, 1.0f, 1.0f, 1.0f };
|
|
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, color);
|
|
|
|
pglActiveTextureARB(GL_TEXTURE0);
|
|
glEnable(GL_TEXTURE_2D);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_REPLACE);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_CONSTANT);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_REPLACE);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_CONSTANT);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
|
|
|
|
CShaderProgramFFP_Model_Base::Bind();
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Plain unlit texture model rendering, for e.g. alpha-blended shadow casters.
|
|
*/
|
|
class CShaderProgramFFP_ModelSolidTex : public CShaderProgramFFP_Model_Base
|
|
{
|
|
public:
|
|
CShaderProgramFFP_ModelSolidTex(const CShaderDefines& defines)
|
|
: CShaderProgramFFP_Model_Base(defines, STREAM_POS | STREAM_UV0)
|
|
{
|
|
}
|
|
|
|
virtual void Bind()
|
|
{
|
|
pglActiveTextureARB(GL_TEXTURE0);
|
|
glEnable(GL_TEXTURE_2D);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
|
|
|
|
CShaderProgramFFP_Model_Base::Bind();
|
|
}
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
/*static*/ CShaderProgram* CShaderProgram::ConstructFFP(const std::string& id, const CShaderDefines& defines)
|
|
{
|
|
if (id == "dummy")
|
|
return new CShaderProgramFFP_Dummy();
|
|
if (id == "overlayline")
|
|
return new CShaderProgramFFP_OverlayLine(defines);
|
|
if (id == "gui_text")
|
|
return new CShaderProgramFFP_GuiText();
|
|
if (id == "gui_basic")
|
|
return new CShaderProgramFFP_GuiBasic();
|
|
if (id == "gui_add")
|
|
return new CShaderProgramFFP_GuiAdd();
|
|
if (id == "gui_grayscale")
|
|
return new CShaderProgramFFP_GuiGrayscale();
|
|
if (id == "gui_solid")
|
|
return new CShaderProgramFFP_GuiSolid();
|
|
if (id == "solid")
|
|
return new CShaderProgramFFP_GuiSolid(); // works for non-GUI objects too
|
|
if (id == "model")
|
|
return new CShaderProgramFFP_Model(defines);
|
|
if (id == "model_color")
|
|
return new CShaderProgramFFP_ModelColor(defines);
|
|
if (id == "model_solid")
|
|
return new CShaderProgramFFP_ModelSolid(defines);
|
|
if (id == "model_solid_tex")
|
|
return new CShaderProgramFFP_ModelSolidTex(defines);
|
|
|
|
LOGERROR(L"CShaderProgram::ConstructFFP: '%hs': Invalid id", id.c_str());
|
|
debug_warn(L"CShaderProgram::ConstructFFP: Invalid id");
|
|
return NULL;
|
|
}
|
|
|
|
#else // CONFIG2_GLES
|
|
|
|
/*static*/ CShaderProgram* CShaderProgram::ConstructFFP(const std::string& UNUSED(id), const CShaderDefines& UNUSED(defines))
|
|
{
|
|
debug_warn(L"CShaderProgram::ConstructFFP: FFP not supported on this device");
|
|
return NULL;
|
|
}
|
|
|
|
#endif // CONFIG2_GLES
|