forked from 0ad/0ad
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.
893 lines
25 KiB
C++
893 lines
25 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/ShaderManager.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/Filesystem.h"
|
|
#include "ps/Overlay.h"
|
|
#include "ps/PreprocessorWrapper.h"
|
|
|
|
#if !CONFIG2_GLES
|
|
|
|
class CShaderProgramARB : public CShaderProgram
|
|
{
|
|
public:
|
|
CShaderProgramARB(const VfsPath& vertexFile, const VfsPath& fragmentFile,
|
|
const CShaderDefines& defines,
|
|
const std::map<CStrIntern, int>& vertexIndexes, const std::map<CStrIntern, frag_index_pair_t>& fragmentIndexes,
|
|
int streamflags) :
|
|
CShaderProgram(streamflags),
|
|
m_VertexFile(vertexFile), m_FragmentFile(fragmentFile),
|
|
m_Defines(defines),
|
|
m_VertexIndexes(vertexIndexes), m_FragmentIndexes(fragmentIndexes)
|
|
{
|
|
pglGenProgramsARB(1, &m_VertexProgram);
|
|
pglGenProgramsARB(1, &m_FragmentProgram);
|
|
}
|
|
|
|
~CShaderProgramARB()
|
|
{
|
|
Unload();
|
|
|
|
pglDeleteProgramsARB(1, &m_VertexProgram);
|
|
pglDeleteProgramsARB(1, &m_FragmentProgram);
|
|
}
|
|
|
|
bool Compile(GLuint target, const char* targetName, GLuint program, const VfsPath& file, const CStr& code)
|
|
{
|
|
ogl_WarnIfError();
|
|
|
|
pglBindProgramARB(target, program);
|
|
|
|
ogl_WarnIfError();
|
|
|
|
pglProgramStringARB(target, GL_PROGRAM_FORMAT_ASCII_ARB, (GLsizei)code.length(), code.c_str());
|
|
|
|
if (ogl_SquelchError(GL_INVALID_OPERATION))
|
|
{
|
|
GLint errPos = 0;
|
|
glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &errPos);
|
|
int errLine = std::count(code.begin(), code.begin() + std::min((int)code.length(), errPos + 1), '\n') + 1;
|
|
char* errStr = (char*)glGetString(GL_PROGRAM_ERROR_STRING_ARB);
|
|
LOGERROR(L"Failed to compile %hs program '%ls' (line %d):\n%hs", targetName, file.string().c_str(), errLine, errStr);
|
|
return false;
|
|
}
|
|
|
|
pglBindProgramARB(target, 0);
|
|
|
|
ogl_WarnIfError();
|
|
|
|
return true;
|
|
}
|
|
|
|
virtual void Reload()
|
|
{
|
|
Unload();
|
|
|
|
CVFSFile vertexFile;
|
|
if (vertexFile.Load(g_VFS, m_VertexFile) != PSRETURN_OK)
|
|
return;
|
|
|
|
CVFSFile fragmentFile;
|
|
if (fragmentFile.Load(g_VFS, m_FragmentFile) != PSRETURN_OK)
|
|
return;
|
|
|
|
CPreprocessorWrapper preprocessor;
|
|
preprocessor.AddDefines(m_Defines);
|
|
|
|
CStr vertexCode = preprocessor.Preprocess(vertexFile.GetAsString());
|
|
CStr fragmentCode = preprocessor.Preprocess(fragmentFile.GetAsString());
|
|
|
|
// printf(">>>\n%s<<<\n", vertexCode.c_str());
|
|
// printf(">>>\n%s<<<\n", fragmentCode.c_str());
|
|
|
|
if (!Compile(GL_VERTEX_PROGRAM_ARB, "vertex", m_VertexProgram, m_VertexFile, vertexCode))
|
|
return;
|
|
|
|
if (!Compile(GL_FRAGMENT_PROGRAM_ARB, "fragment", m_FragmentProgram, m_FragmentFile, fragmentCode))
|
|
return;
|
|
|
|
m_IsValid = true;
|
|
}
|
|
|
|
void Unload()
|
|
{
|
|
m_IsValid = false;
|
|
}
|
|
|
|
virtual void Bind()
|
|
{
|
|
glEnable(GL_VERTEX_PROGRAM_ARB);
|
|
glEnable(GL_FRAGMENT_PROGRAM_ARB);
|
|
pglBindProgramARB(GL_VERTEX_PROGRAM_ARB, m_VertexProgram);
|
|
pglBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, m_FragmentProgram);
|
|
|
|
BindClientStates();
|
|
}
|
|
|
|
virtual void Unbind()
|
|
{
|
|
glDisable(GL_VERTEX_PROGRAM_ARB);
|
|
glDisable(GL_FRAGMENT_PROGRAM_ARB);
|
|
pglBindProgramARB(GL_VERTEX_PROGRAM_ARB, 0);
|
|
pglBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, 0);
|
|
|
|
UnbindClientStates();
|
|
|
|
// TODO: should unbind textures, probably
|
|
}
|
|
|
|
int GetUniformVertexIndex(CStrIntern id)
|
|
{
|
|
std::map<CStrIntern, int>::iterator it = m_VertexIndexes.find(id);
|
|
if (it == m_VertexIndexes.end())
|
|
return -1;
|
|
return it->second;
|
|
}
|
|
|
|
frag_index_pair_t GetUniformFragmentIndex(CStrIntern id)
|
|
{
|
|
std::map<CStrIntern, frag_index_pair_t>::iterator it = m_FragmentIndexes.find(id);
|
|
if (it == m_FragmentIndexes.end())
|
|
return std::make_pair(-1, 0);
|
|
return it->second;
|
|
}
|
|
|
|
virtual Binding GetTextureBinding(texture_id_t id)
|
|
{
|
|
frag_index_pair_t fPair = GetUniformFragmentIndex(id);
|
|
int index = fPair.first;
|
|
if (index == -1)
|
|
return Binding();
|
|
else
|
|
return Binding((int)fPair.second, index);
|
|
}
|
|
|
|
virtual void BindTexture(texture_id_t id, Handle tex)
|
|
{
|
|
frag_index_pair_t fPair = GetUniformFragmentIndex(id);
|
|
int index = fPair.first;
|
|
if (index != -1)
|
|
{
|
|
GLuint h;
|
|
ogl_tex_get_texture_id(tex, &h);
|
|
pglActiveTextureARB(GL_TEXTURE0+index);
|
|
glBindTexture(fPair.second, h);
|
|
}
|
|
}
|
|
|
|
virtual void BindTexture(texture_id_t id, GLuint tex)
|
|
{
|
|
frag_index_pair_t fPair = GetUniformFragmentIndex(id);
|
|
int index = fPair.first;
|
|
if (index != -1)
|
|
{
|
|
pglActiveTextureARB(GL_TEXTURE0+index);
|
|
glBindTexture(fPair.second, 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(GetUniformVertexIndex(id), GetUniformFragmentIndex(id).first);
|
|
}
|
|
|
|
virtual void Uniform(Binding id, float v0, float v1, float v2, float v3)
|
|
{
|
|
if (id.first != -1)
|
|
pglProgramLocalParameter4fARB(GL_VERTEX_PROGRAM_ARB, (GLuint)id.first, v0, v1, v2, v3);
|
|
|
|
if (id.second != -1)
|
|
pglProgramLocalParameter4fARB(GL_FRAGMENT_PROGRAM_ARB, (GLuint)id.second, v0, v1, v2, v3);
|
|
}
|
|
|
|
virtual void Uniform(Binding id, const CMatrix3D& v)
|
|
{
|
|
if (id.first != -1)
|
|
{
|
|
pglProgramLocalParameter4fARB(GL_VERTEX_PROGRAM_ARB, (GLuint)id.first+0, v._11, v._12, v._13, v._14);
|
|
pglProgramLocalParameter4fARB(GL_VERTEX_PROGRAM_ARB, (GLuint)id.first+1, v._21, v._22, v._23, v._24);
|
|
pglProgramLocalParameter4fARB(GL_VERTEX_PROGRAM_ARB, (GLuint)id.first+2, v._31, v._32, v._33, v._34);
|
|
pglProgramLocalParameter4fARB(GL_VERTEX_PROGRAM_ARB, (GLuint)id.first+3, v._41, v._42, v._43, v._44);
|
|
}
|
|
|
|
if (id.second != -1)
|
|
{
|
|
pglProgramLocalParameter4fARB(GL_FRAGMENT_PROGRAM_ARB, (GLuint)id.second+0, v._11, v._12, v._13, v._14);
|
|
pglProgramLocalParameter4fARB(GL_FRAGMENT_PROGRAM_ARB, (GLuint)id.second+1, v._21, v._22, v._23, v._24);
|
|
pglProgramLocalParameter4fARB(GL_FRAGMENT_PROGRAM_ARB, (GLuint)id.second+2, v._31, v._32, v._33, v._34);
|
|
pglProgramLocalParameter4fARB(GL_FRAGMENT_PROGRAM_ARB, (GLuint)id.second+3, v._41, v._42, v._43, v._44);
|
|
}
|
|
}
|
|
|
|
virtual void Uniform(Binding id, size_t count, const CMatrix3D* v)
|
|
{
|
|
ENSURE(count == 1);
|
|
Uniform(id, v[0]);
|
|
}
|
|
|
|
private:
|
|
VfsPath m_VertexFile;
|
|
VfsPath m_FragmentFile;
|
|
CShaderDefines m_Defines;
|
|
|
|
GLuint m_VertexProgram;
|
|
GLuint m_FragmentProgram;
|
|
|
|
std::map<CStrIntern, int> m_VertexIndexes;
|
|
|
|
// pair contains <index, gltype>
|
|
std::map<CStrIntern, frag_index_pair_t> m_FragmentIndexes;
|
|
};
|
|
|
|
#endif // #if !CONFIG2_GLES
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
TIMER_ADD_CLIENT(tc_ShaderGLSLCompile);
|
|
TIMER_ADD_CLIENT(tc_ShaderGLSLLink);
|
|
|
|
class CShaderProgramGLSL : public CShaderProgram
|
|
{
|
|
public:
|
|
CShaderProgramGLSL(const VfsPath& vertexFile, const VfsPath& fragmentFile,
|
|
const CShaderDefines& defines,
|
|
const std::map<CStrIntern, int>& vertexAttribs,
|
|
int streamflags) :
|
|
CShaderProgram(streamflags),
|
|
m_VertexFile(vertexFile), m_FragmentFile(fragmentFile),
|
|
m_Defines(defines),
|
|
m_VertexAttribs(vertexAttribs)
|
|
{
|
|
m_Program = 0;
|
|
m_VertexShader = pglCreateShaderObjectARB(GL_VERTEX_SHADER);
|
|
m_FragmentShader = pglCreateShaderObjectARB(GL_FRAGMENT_SHADER);
|
|
}
|
|
|
|
~CShaderProgramGLSL()
|
|
{
|
|
Unload();
|
|
|
|
pglDeleteShader(m_VertexShader);
|
|
pglDeleteShader(m_FragmentShader);
|
|
}
|
|
|
|
bool Compile(GLhandleARB shader, const VfsPath& file, const CStr& code)
|
|
{
|
|
TIMER_ACCRUE(tc_ShaderGLSLCompile);
|
|
|
|
ogl_WarnIfError();
|
|
|
|
const char* code_string = code.c_str();
|
|
GLint code_length = code.length();
|
|
pglShaderSourceARB(shader, 1, &code_string, &code_length);
|
|
|
|
pglCompileShaderARB(shader);
|
|
|
|
GLint ok = 0;
|
|
pglGetShaderiv(shader, GL_COMPILE_STATUS, &ok);
|
|
|
|
GLint length = 0;
|
|
pglGetShaderiv(shader, GL_INFO_LOG_LENGTH, &length);
|
|
|
|
// Apparently sometimes GL_INFO_LOG_LENGTH is incorrectly reported as 0
|
|
// (http://code.google.com/p/android/issues/detail?id=9953)
|
|
if (!ok && length == 0)
|
|
length = 4096;
|
|
|
|
if (length > 1)
|
|
{
|
|
char* infolog = new char[length];
|
|
pglGetShaderInfoLog(shader, length, NULL, infolog);
|
|
|
|
if (ok)
|
|
LOGMESSAGE(L"Info when compiling shader '%ls':\n%hs", file.string().c_str(), infolog);
|
|
else
|
|
LOGERROR(L"Failed to compile shader '%ls':\n%hs", file.string().c_str(), infolog);
|
|
|
|
delete[] infolog;
|
|
}
|
|
|
|
ogl_WarnIfError();
|
|
|
|
return (ok ? true : false);
|
|
}
|
|
|
|
bool Link()
|
|
{
|
|
TIMER_ACCRUE(tc_ShaderGLSLLink);
|
|
|
|
ENSURE(!m_Program);
|
|
m_Program = pglCreateProgramObjectARB();
|
|
|
|
pglAttachObjectARB(m_Program, m_VertexShader);
|
|
ogl_WarnIfError();
|
|
pglAttachObjectARB(m_Program, m_FragmentShader);
|
|
ogl_WarnIfError();
|
|
|
|
// Set up the attribute bindings explicitly, since apparently drivers
|
|
// don't always pick the most efficient bindings automatically,
|
|
// and also this lets us hardcode indexes into VertexPointer etc
|
|
for (std::map<CStrIntern, int>::iterator it = m_VertexAttribs.begin(); it != m_VertexAttribs.end(); ++it)
|
|
pglBindAttribLocationARB(m_Program, it->second, it->first.c_str());
|
|
|
|
pglLinkProgramARB(m_Program);
|
|
|
|
GLint ok = 0;
|
|
pglGetProgramiv(m_Program, GL_LINK_STATUS, &ok);
|
|
|
|
GLint length = 0;
|
|
pglGetProgramiv(m_Program, GL_INFO_LOG_LENGTH, &length);
|
|
|
|
if (!ok && length == 0)
|
|
length = 4096;
|
|
|
|
if (length > 1)
|
|
{
|
|
char* infolog = new char[length];
|
|
pglGetProgramInfoLog(m_Program, length, NULL, infolog);
|
|
|
|
if (ok)
|
|
LOGMESSAGE(L"Info when linking program '%ls'+'%ls':\n%hs", m_VertexFile.string().c_str(), m_FragmentFile.string().c_str(), infolog);
|
|
else
|
|
LOGERROR(L"Failed to link program '%ls'+'%ls':\n%hs", m_VertexFile.string().c_str(), m_FragmentFile.string().c_str(), infolog);
|
|
|
|
delete[] infolog;
|
|
}
|
|
|
|
ogl_WarnIfError();
|
|
|
|
if (!ok)
|
|
return false;
|
|
|
|
m_Uniforms.clear();
|
|
m_Samplers.clear();
|
|
|
|
Bind();
|
|
|
|
ogl_WarnIfError();
|
|
|
|
GLint numUniforms = 0;
|
|
pglGetProgramiv(m_Program, GL_ACTIVE_UNIFORMS, &numUniforms);
|
|
ogl_WarnIfError();
|
|
for (GLint i = 0; i < numUniforms; ++i)
|
|
{
|
|
char name[256] = {0};
|
|
GLsizei nameLength = 0;
|
|
GLint size = 0;
|
|
GLenum type = 0;
|
|
pglGetActiveUniformARB(m_Program, i, ARRAY_SIZE(name), &nameLength, &size, &type, name);
|
|
ogl_WarnIfError();
|
|
|
|
GLint loc = pglGetUniformLocationARB(m_Program, name);
|
|
|
|
CStrIntern nameIntern(name);
|
|
m_Uniforms[nameIntern] = std::make_pair(loc, type);
|
|
|
|
// Assign sampler uniforms to sequential texture units
|
|
if (type == GL_SAMPLER_2D
|
|
|| type == GL_SAMPLER_CUBE
|
|
#if !CONFIG2_GLES
|
|
|| type == GL_SAMPLER_2D_SHADOW
|
|
#endif
|
|
)
|
|
{
|
|
int unit = (int)m_Samplers.size();
|
|
m_Samplers[nameIntern].first = (type == GL_SAMPLER_CUBE ? GL_TEXTURE_CUBE_MAP : GL_TEXTURE_2D);
|
|
m_Samplers[nameIntern].second = unit;
|
|
pglUniform1iARB(loc, unit); // link uniform to unit
|
|
ogl_WarnIfError();
|
|
}
|
|
}
|
|
|
|
// TODO: verify that we're not using more samplers than is supported
|
|
|
|
Unbind();
|
|
|
|
ogl_WarnIfError();
|
|
|
|
return true;
|
|
}
|
|
|
|
virtual void Reload()
|
|
{
|
|
Unload();
|
|
|
|
CVFSFile vertexFile;
|
|
if (vertexFile.Load(g_VFS, m_VertexFile) != PSRETURN_OK)
|
|
return;
|
|
|
|
CVFSFile fragmentFile;
|
|
if (fragmentFile.Load(g_VFS, m_FragmentFile) != PSRETURN_OK)
|
|
return;
|
|
|
|
CPreprocessorWrapper preprocessor;
|
|
preprocessor.AddDefines(m_Defines);
|
|
|
|
#if CONFIG2_GLES
|
|
// GLES defines the macro "GL_ES" in its GLSL preprocessor,
|
|
// but since we run our own preprocessor first, we need to explicitly
|
|
// define it here
|
|
preprocessor.AddDefine("GL_ES", "1");
|
|
#endif
|
|
|
|
CStr vertexCode = preprocessor.Preprocess(vertexFile.GetAsString());
|
|
CStr fragmentCode = preprocessor.Preprocess(fragmentFile.GetAsString());
|
|
|
|
#if CONFIG2_GLES
|
|
// Ugly hack to replace desktop GLSL 1.10/1.20 with GLSL ES 1.00,
|
|
// and also to set default float precision for fragment shaders
|
|
vertexCode.Replace("#version 110\n", "#version 100\n");
|
|
vertexCode.Replace("#version 110\r\n", "#version 100\n");
|
|
vertexCode.Replace("#version 120\n", "#version 100\n");
|
|
vertexCode.Replace("#version 120\r\n", "#version 100\n");
|
|
fragmentCode.Replace("#version 110\n", "#version 100\nprecision mediump float;\n");
|
|
fragmentCode.Replace("#version 110\r\n", "#version 100\nprecision mediump float;\n");
|
|
fragmentCode.Replace("#version 120\n", "#version 100\nprecision mediump float;\n");
|
|
fragmentCode.Replace("#version 120\r\n", "#version 100\nprecision mediump float;\n");
|
|
#endif
|
|
|
|
if (!Compile(m_VertexShader, m_VertexFile, vertexCode))
|
|
return;
|
|
|
|
if (!Compile(m_FragmentShader, m_FragmentFile, fragmentCode))
|
|
return;
|
|
|
|
if (!Link())
|
|
return;
|
|
|
|
m_IsValid = true;
|
|
}
|
|
|
|
void Unload()
|
|
{
|
|
m_IsValid = false;
|
|
|
|
if (m_Program)
|
|
pglDeleteProgram(m_Program);
|
|
m_Program = 0;
|
|
|
|
// The shader objects can be reused and don't need to be deleted here
|
|
}
|
|
|
|
virtual void Bind()
|
|
{
|
|
pglUseProgramObjectARB(m_Program);
|
|
|
|
for (std::map<CStrIntern, int>::iterator it = m_VertexAttribs.begin(); it != m_VertexAttribs.end(); ++it)
|
|
pglEnableVertexAttribArrayARB(it->second);
|
|
}
|
|
|
|
virtual void Unbind()
|
|
{
|
|
pglUseProgramObjectARB(0);
|
|
|
|
for (std::map<CStrIntern, int>::iterator it = m_VertexAttribs.begin(); it != m_VertexAttribs.end(); ++it)
|
|
pglDisableVertexAttribArrayARB(it->second);
|
|
|
|
// TODO: should unbind textures, probably
|
|
}
|
|
|
|
virtual Binding GetTextureBinding(texture_id_t id)
|
|
{
|
|
std::map<CStrIntern, std::pair<GLenum, int> >::iterator it = m_Samplers.find(CStrIntern(id));
|
|
if (it == m_Samplers.end())
|
|
return Binding();
|
|
else
|
|
return Binding((int)it->second.first, it->second.second);
|
|
}
|
|
|
|
virtual void BindTexture(texture_id_t id, Handle tex)
|
|
{
|
|
std::map<CStrIntern, std::pair<GLenum, int> >::iterator it = m_Samplers.find(CStrIntern(id));
|
|
if (it == m_Samplers.end())
|
|
return;
|
|
|
|
GLuint h;
|
|
ogl_tex_get_texture_id(tex, &h);
|
|
pglActiveTextureARB(GL_TEXTURE0 + it->second.second);
|
|
glBindTexture(it->second.first, h);
|
|
}
|
|
|
|
virtual void BindTexture(texture_id_t id, GLuint tex)
|
|
{
|
|
std::map<CStrIntern, std::pair<GLenum, int> >::iterator it = m_Samplers.find(CStrIntern(id));
|
|
if (it == m_Samplers.end())
|
|
return;
|
|
|
|
pglActiveTextureARB(GL_TEXTURE0 + it->second.second);
|
|
glBindTexture(it->second.first, tex);
|
|
}
|
|
|
|
virtual void BindTexture(Binding id, Handle tex)
|
|
{
|
|
if (id.second == -1)
|
|
return;
|
|
|
|
GLuint h;
|
|
ogl_tex_get_texture_id(tex, &h);
|
|
pglActiveTextureARB(GL_TEXTURE0 + id.second);
|
|
glBindTexture(id.first, h);
|
|
}
|
|
|
|
virtual Binding GetUniformBinding(uniform_id_t id)
|
|
{
|
|
std::map<CStrIntern, std::pair<int, GLenum> >::iterator it = m_Uniforms.find(id);
|
|
if (it == m_Uniforms.end())
|
|
return Binding();
|
|
else
|
|
return Binding(it->second.first, (int)it->second.second);
|
|
}
|
|
|
|
virtual void Uniform(Binding id, float v0, float v1, float v2, float v3)
|
|
{
|
|
if (id.first != -1)
|
|
{
|
|
if (id.second == GL_FLOAT)
|
|
pglUniform1fARB(id.first, v0);
|
|
else if (id.second == GL_FLOAT_VEC2)
|
|
pglUniform2fARB(id.first, v0, v1);
|
|
else if (id.second == GL_FLOAT_VEC3)
|
|
pglUniform3fARB(id.first, v0, v1, v2);
|
|
else if (id.second == GL_FLOAT_VEC4)
|
|
pglUniform4fARB(id.first, v0, v1, v2, v3);
|
|
else
|
|
LOGERROR(L"CShaderProgramGLSL::Uniform(): Invalid uniform type (expected float, vec2, vec3, vec4)");
|
|
}
|
|
}
|
|
|
|
virtual void Uniform(Binding id, const CMatrix3D& v)
|
|
{
|
|
if (id.first != -1)
|
|
{
|
|
if (id.second == GL_FLOAT_MAT4)
|
|
pglUniformMatrix4fvARB(id.first, 1, GL_FALSE, &v._11);
|
|
else
|
|
LOGERROR(L"CShaderProgramGLSL::Uniform(): Invalid uniform type (expected mat4)");
|
|
}
|
|
}
|
|
|
|
virtual void Uniform(Binding id, size_t count, const CMatrix3D* v)
|
|
{
|
|
if (id.first != -1)
|
|
{
|
|
if (id.second == GL_FLOAT_MAT4)
|
|
pglUniformMatrix4fvARB(id.first, count, GL_FALSE, &v->_11);
|
|
else
|
|
LOGERROR(L"CShaderProgramGLSL::Uniform(): Invalid uniform type (expected mat4)");
|
|
}
|
|
}
|
|
|
|
// Map the various fixed-function Pointer functions onto generic vertex attributes
|
|
// (matching the attribute indexes from ShaderManager's ParseAttribSemantics):
|
|
|
|
virtual void VertexPointer(GLint size, GLenum type, GLsizei stride, void* pointer)
|
|
{
|
|
pglVertexAttribPointerARB(0, size, type, GL_FALSE, stride, pointer);
|
|
m_ValidStreams |= STREAM_POS;
|
|
}
|
|
|
|
virtual void NormalPointer(GLenum type, GLsizei stride, void* pointer)
|
|
{
|
|
pglVertexAttribPointerARB(2, 3, type, GL_TRUE, stride, pointer);
|
|
m_ValidStreams |= STREAM_NORMAL;
|
|
}
|
|
|
|
virtual void ColorPointer(GLint size, GLenum type, GLsizei stride, void* pointer)
|
|
{
|
|
pglVertexAttribPointerARB(3, size, type, GL_TRUE, stride, pointer);
|
|
m_ValidStreams |= STREAM_COLOR;
|
|
}
|
|
|
|
virtual void TexCoordPointer(GLenum texture, GLint size, GLenum type, GLsizei stride, void* pointer)
|
|
{
|
|
pglVertexAttribPointerARB(8 + texture - GL_TEXTURE0, size, type, GL_FALSE, stride, pointer);
|
|
m_ValidStreams |= STREAM_UV0 << (texture - GL_TEXTURE0);
|
|
}
|
|
|
|
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(id);
|
|
if (it != m_VertexAttribs.end())
|
|
{
|
|
pglVertexAttribPointerARB(it->second, size, type, normalized, stride, 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(id);
|
|
if (it != m_VertexAttribs.end())
|
|
{
|
|
#if CONFIG2_GLES
|
|
debug_warn(L"glVertexAttribIPointer not supported on GLES");
|
|
#else
|
|
pglVertexAttribIPointerEXT(it->second, size, type, stride, pointer);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
private:
|
|
VfsPath m_VertexFile;
|
|
VfsPath m_FragmentFile;
|
|
CShaderDefines m_Defines;
|
|
std::map<CStrIntern, int> m_VertexAttribs;
|
|
|
|
GLhandleARB m_Program;
|
|
GLhandleARB m_VertexShader;
|
|
GLhandleARB m_FragmentShader;
|
|
|
|
std::map<CStrIntern, std::pair<int, GLenum> > m_Uniforms;
|
|
std::map<CStrIntern, std::pair<GLenum, int> > m_Samplers; // texture target & unit chosen for each uniform sampler
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
CShaderProgram::CShaderProgram(int streamflags)
|
|
: m_IsValid(false), m_StreamFlags(streamflags), m_ValidStreams(0)
|
|
{
|
|
}
|
|
|
|
#if CONFIG2_GLES
|
|
/*static*/ CShaderProgram* CShaderProgram::ConstructARB(const VfsPath& vertexFile, const VfsPath& fragmentFile,
|
|
const CShaderDefines& UNUSED(defines),
|
|
const std::map<CStrIntern, int>& UNUSED(vertexIndexes), const std::map<CStrIntern, int>& UNUSED(fragmentIndexes),
|
|
int UNUSED(streamflags))
|
|
{
|
|
LOGERROR(L"CShaderProgram::ConstructARB: '%ls'+'%ls': ARB shaders not supported on this device",
|
|
vertexFile.string().c_str(), fragmentFile.string().c_str());
|
|
return NULL;
|
|
}
|
|
#else
|
|
/*static*/ CShaderProgram* CShaderProgram::ConstructARB(const VfsPath& vertexFile, const VfsPath& fragmentFile,
|
|
const CShaderDefines& defines,
|
|
const std::map<CStrIntern, int>& vertexIndexes, const std::map<CStrIntern, frag_index_pair_t>& fragmentIndexes,
|
|
int streamflags)
|
|
{
|
|
return new CShaderProgramARB(vertexFile, fragmentFile, defines, vertexIndexes, fragmentIndexes, streamflags);
|
|
}
|
|
#endif
|
|
|
|
/*static*/ CShaderProgram* CShaderProgram::ConstructGLSL(const VfsPath& vertexFile, const VfsPath& fragmentFile,
|
|
const CShaderDefines& defines,
|
|
const std::map<CStrIntern, int>& vertexAttribs,
|
|
int streamflags)
|
|
{
|
|
return new CShaderProgramGLSL(vertexFile, fragmentFile, defines, vertexAttribs, streamflags);
|
|
}
|
|
|
|
bool CShaderProgram::IsValid() const
|
|
{
|
|
return m_IsValid;
|
|
}
|
|
|
|
int CShaderProgram::GetStreamFlags() const
|
|
{
|
|
return m_StreamFlags;
|
|
}
|
|
|
|
void CShaderProgram::BindTexture(texture_id_t id, CTexturePtr tex)
|
|
{
|
|
BindTexture(id, tex->GetHandle());
|
|
}
|
|
|
|
void CShaderProgram::Uniform(Binding id, int v)
|
|
{
|
|
Uniform(id, (float)v, (float)v, (float)v, (float)v);
|
|
}
|
|
|
|
void CShaderProgram::Uniform(Binding id, float v)
|
|
{
|
|
Uniform(id, v, v, v, v);
|
|
}
|
|
|
|
void CShaderProgram::Uniform(Binding id, float v0, float v1)
|
|
{
|
|
Uniform(id, v0, v1, 0.0f, 0.0f);
|
|
}
|
|
|
|
void CShaderProgram::Uniform(Binding id, const CVector3D& v)
|
|
{
|
|
Uniform(id, v.X, v.Y, v.Z, 0.0f);
|
|
}
|
|
|
|
void CShaderProgram::Uniform(Binding id, const CColor& v)
|
|
{
|
|
Uniform(id, v.r, v.g, v.b, v.a);
|
|
}
|
|
|
|
void CShaderProgram::Uniform(uniform_id_t id, int v)
|
|
{
|
|
Uniform(GetUniformBinding(id), (float)v, (float)v, (float)v, (float)v);
|
|
}
|
|
|
|
void CShaderProgram::Uniform(uniform_id_t id, float v)
|
|
{
|
|
Uniform(GetUniformBinding(id), v, v, v, v);
|
|
}
|
|
|
|
void CShaderProgram::Uniform(uniform_id_t id, float v0, float v1)
|
|
{
|
|
Uniform(GetUniformBinding(id), v0, v1, 0.0f, 0.0f);
|
|
}
|
|
|
|
void CShaderProgram::Uniform(uniform_id_t id, const CVector3D& v)
|
|
{
|
|
Uniform(GetUniformBinding(id), v.X, v.Y, v.Z, 0.0f);
|
|
}
|
|
|
|
void CShaderProgram::Uniform(uniform_id_t id, const CColor& v)
|
|
{
|
|
Uniform(GetUniformBinding(id), v.r, v.g, v.b, v.a);
|
|
}
|
|
|
|
void CShaderProgram::Uniform(uniform_id_t id, float v0, float v1, float v2, float v3)
|
|
{
|
|
Uniform(GetUniformBinding(id), v0, v1, v2, v3);
|
|
}
|
|
|
|
void CShaderProgram::Uniform(uniform_id_t id, const CMatrix3D& v)
|
|
{
|
|
Uniform(GetUniformBinding(id), v);
|
|
}
|
|
|
|
void CShaderProgram::Uniform(uniform_id_t id, size_t count, const CMatrix3D* v)
|
|
{
|
|
Uniform(GetUniformBinding(id), count, v);
|
|
}
|
|
|
|
|
|
// These should all be overridden by CShaderProgramGLSL, and not used
|
|
// if a non-GLSL shader was loaded instead:
|
|
|
|
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(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");
|
|
}
|
|
|
|
#if CONFIG2_GLES
|
|
|
|
// These should all be overridden by CShaderProgramGLSL
|
|
// (GLES doesn't support any other types of shader program):
|
|
|
|
void CShaderProgram::VertexPointer(GLint UNUSED(size), GLenum UNUSED(type), GLsizei UNUSED(stride), void* UNUSED(pointer))
|
|
{
|
|
debug_warn("CShaderProgram::VertexPointer should be overridden");
|
|
}
|
|
void CShaderProgram::NormalPointer(GLenum UNUSED(type), GLsizei UNUSED(stride), void* UNUSED(pointer))
|
|
{
|
|
debug_warn("CShaderProgram::NormalPointer should be overridden");
|
|
}
|
|
void CShaderProgram::ColorPointer(GLint UNUSED(size), GLenum UNUSED(type), GLsizei UNUSED(stride), void* UNUSED(pointer))
|
|
{
|
|
debug_warn("CShaderProgram::ColorPointer should be overridden");
|
|
}
|
|
void CShaderProgram::TexCoordPointer(GLenum UNUSED(texture), GLint UNUSED(size), GLenum UNUSED(type), GLsizei UNUSED(stride), void* UNUSED(pointer))
|
|
{
|
|
debug_warn("CShaderProgram::TexCoordPointer should be overridden");
|
|
}
|
|
|
|
#else
|
|
|
|
// These are overridden by CShaderProgramGLSL, but fixed-function and ARB shaders
|
|
// both use the fixed-function vertex attribute pointers so we'll share their
|
|
// definitions here:
|
|
|
|
void CShaderProgram::VertexPointer(GLint size, GLenum type, GLsizei stride, void* pointer)
|
|
{
|
|
glVertexPointer(size, type, stride, pointer);
|
|
m_ValidStreams |= STREAM_POS;
|
|
}
|
|
|
|
void CShaderProgram::NormalPointer(GLenum type, GLsizei stride, void* pointer)
|
|
{
|
|
glNormalPointer(type, stride, pointer);
|
|
m_ValidStreams |= STREAM_NORMAL;
|
|
}
|
|
|
|
void CShaderProgram::ColorPointer(GLint size, GLenum type, GLsizei stride, void* pointer)
|
|
{
|
|
glColorPointer(size, type, stride, pointer);
|
|
m_ValidStreams |= STREAM_COLOR;
|
|
}
|
|
|
|
void CShaderProgram::TexCoordPointer(GLenum texture, GLint size, GLenum type, GLsizei stride, void* pointer)
|
|
{
|
|
pglClientActiveTextureARB(texture);
|
|
glTexCoordPointer(size, type, stride, pointer);
|
|
pglClientActiveTextureARB(GL_TEXTURE0);
|
|
m_ValidStreams |= STREAM_UV0 << (texture - GL_TEXTURE0);
|
|
}
|
|
|
|
void CShaderProgram::BindClientStates()
|
|
{
|
|
ENSURE(m_StreamFlags == (m_StreamFlags & (STREAM_POS|STREAM_NORMAL|STREAM_COLOR|STREAM_UV0|STREAM_UV1)));
|
|
|
|
// Enable all the desired client states for non-GLSL rendering
|
|
|
|
if (m_StreamFlags & STREAM_POS) glEnableClientState(GL_VERTEX_ARRAY);
|
|
if (m_StreamFlags & STREAM_NORMAL) glEnableClientState(GL_NORMAL_ARRAY);
|
|
if (m_StreamFlags & STREAM_COLOR) glEnableClientState(GL_COLOR_ARRAY);
|
|
|
|
if (m_StreamFlags & STREAM_UV0)
|
|
{
|
|
pglClientActiveTextureARB(GL_TEXTURE0);
|
|
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
|
|
}
|
|
|
|
if (m_StreamFlags & STREAM_UV1)
|
|
{
|
|
pglClientActiveTextureARB(GL_TEXTURE1);
|
|
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
|
|
pglClientActiveTextureARB(GL_TEXTURE0);
|
|
}
|
|
|
|
// Rendering code must subsequently call VertexPointer etc for all of the streams
|
|
// that were activated in this function, else AssertPointersBound will complain
|
|
// that some arrays were unspecified
|
|
m_ValidStreams = 0;
|
|
}
|
|
|
|
void CShaderProgram::UnbindClientStates()
|
|
{
|
|
if (m_StreamFlags & STREAM_POS) glDisableClientState(GL_VERTEX_ARRAY);
|
|
if (m_StreamFlags & STREAM_NORMAL) glDisableClientState(GL_NORMAL_ARRAY);
|
|
if (m_StreamFlags & STREAM_COLOR) glDisableClientState(GL_COLOR_ARRAY);
|
|
|
|
if (m_StreamFlags & STREAM_UV0)
|
|
{
|
|
pglClientActiveTextureARB(GL_TEXTURE0);
|
|
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
|
|
}
|
|
|
|
if (m_StreamFlags & STREAM_UV1)
|
|
{
|
|
pglClientActiveTextureARB(GL_TEXTURE1);
|
|
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
|
|
pglClientActiveTextureARB(GL_TEXTURE0);
|
|
}
|
|
}
|
|
|
|
#endif // !CONFIG2_GLES
|
|
|
|
void CShaderProgram::AssertPointersBound()
|
|
{
|
|
ENSURE((m_StreamFlags & ~m_ValidStreams) == 0);
|
|
}
|