source/graphics/ShaderProgram.cpp

   1 /* Copyright (C) 2022 Wildfire Games.
   2  * This file is part of 0 A.D.
   3  *
   4  * 0 A.D. is free software: you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation, either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * 0 A.D. is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 #include "precompiled.h"
  19
  20 #include "ShaderProgram.h"
  21
  22 #include "graphics/Color.h"
  23 #include "graphics/PreprocessorWrapper.h"
  24 #include "graphics/ShaderManager.h"
  25 #include "graphics/TextureManager.h"
  26 #include "lib/timer.h"
  27 #include "maths/Matrix3D.h"
  28 #include "maths/Vector3D.h"
  29 #include "ps/CLogger.h"
  30 #include "ps/Filesystem.h"
  31 #include "ps/Profile.h"
  32 #include "ps/XML/Xeromyces.h"
  33 #include "renderer/backend/gl/DeviceCommandContext.h"
  34 #include "renderer/Renderer.h"
  35
  36 #include <algorithm>
  37
  38 namespace
  39 {
  40
  41 GLint GLSizeFromFormat(const Renderer::Backend::Format format)
  42 {
  43         GLint size = 1;
  44         if (format == Renderer::Backend::Format::R32_SFLOAT ||
  45                 format == Renderer::Backend::Format::R16_SINT)
  46                 size = 1;
  47         else if (
  48                 format == Renderer::Backend::Format::R8G8_UNORM ||
  49                 format == Renderer::Backend::Format::R8G8_UINT ||
  50                 format == Renderer::Backend::Format::R16G16_SINT ||
  51                 format == Renderer::Backend::Format::R32G32_SFLOAT)
  52                 size = 2;
  53         else if (format == Renderer::Backend::Format::R32G32B32_SFLOAT)
  54                 size = 3;
  55         else if (
  56                 format == Renderer::Backend::Format::R32G32B32A32_SFLOAT ||
  57                 format == Renderer::Backend::Format::R8G8B8A8_UNORM ||
  58                 format == Renderer::Backend::Format::R8G8B8A8_UINT)
  59                 size = 4;
  60         else
  61                 debug_warn("Unsupported format.");
  62         return size;
  63 }
  64
  65 GLenum GLTypeFromFormat(const Renderer::Backend::Format format)
  66 {
  67         GLenum type = GL_FLOAT;
  68         if (format == Renderer::Backend::Format::R32_SFLOAT ||
  69                 format == Renderer::Backend::Format::R32G32_SFLOAT ||
  70                 format == Renderer::Backend::Format::R32G32B32_SFLOAT ||
  71                 format == Renderer::Backend::Format::R32G32B32A32_SFLOAT)
  72                 type = GL_FLOAT;
  73         else if (
  74                 format == Renderer::Backend::Format::R16_SINT ||
  75                 format == Renderer::Backend::Format::R16G16_SINT)
  76                 type = GL_SHORT;
  77         else if (
  78                 format == Renderer::Backend::Format::R8G8_UNORM ||
  79                 format == Renderer::Backend::Format::R8G8_UINT ||
  80                 format == Renderer::Backend::Format::R8G8B8A8_UNORM ||
  81                 format == Renderer::Backend::Format::R8G8B8A8_UINT)
  82                 type = GL_UNSIGNED_BYTE;
  83         else
  84                 debug_warn("Unsupported format.");
  85         return type;
  86 }
  87
  88 GLenum ParseAttribSemantics(const CStr& str)
  89 {
  90         // Map known semantics onto the attribute locations documented by NVIDIA
  91         if (str == "gl_Vertex") return 0;
  92         if (str == "gl_Normal") return 2;
  93         if (str == "gl_Color") return 3;
  94         if (str == "gl_SecondaryColor") return 4;
  95         if (str == "gl_FogCoord") return 5;
  96         if (str == "gl_MultiTexCoord0") return 8;
  97         if (str == "gl_MultiTexCoord1") return 9;
  98         if (str == "gl_MultiTexCoord2") return 10;
  99         if (str == "gl_MultiTexCoord3") return 11;
 100         if (str == "gl_MultiTexCoord4") return 12;
 101         if (str == "gl_MultiTexCoord5") return 13;
 102         if (str == "gl_MultiTexCoord6") return 14;
 103         if (str == "gl_MultiTexCoord7") return 15;
 104
 105         debug_warn("Invalid attribute semantics");
 106         return 0;
 107 }
 108
 109 } // anonymous namespace
 110
 111 #if !CONFIG2_GLES
 112
 113 class CShaderProgramARB : public CShaderProgram
 114 {
 115 public:
 116         CShaderProgramARB(const VfsPath& vertexFile, const VfsPath& fragmentFile,
 117                 const CShaderDefines& defines,
 118                 const std::map<CStrIntern, int>& vertexIndexes, const std::map<CStrIntern, frag_index_pair_t>& fragmentIndexes,
 119                 int streamflags) :
 120                 CShaderProgram(streamflags),
 121                 m_VertexFile(vertexFile), m_FragmentFile(fragmentFile),
 122                 m_Defines(defines),
 123                 m_VertexIndexes(vertexIndexes), m_FragmentIndexes(fragmentIndexes)
 124         {
 125                 glGenProgramsARB(1, &m_VertexProgram);
 126                 glGenProgramsARB(1, &m_FragmentProgram);
 127         }
 128
 129         ~CShaderProgramARB()
 130         {
 131                 Unload();
 132
 133                 glDeleteProgramsARB(1, &m_VertexProgram);
 134                 glDeleteProgramsARB(1, &m_FragmentProgram);
 135         }
 136
 137         bool Compile(GLuint target, const char* targetName, GLuint program, const VfsPath& file, const CStr& code)
 138         {
 139                 ogl_WarnIfError();
 140
 141                 glBindProgramARB(target, program);
 142
 143                 ogl_WarnIfError();
 144
 145                 glProgramStringARB(target, GL_PROGRAM_FORMAT_ASCII_ARB, (GLsizei)code.length(), code.c_str());
 146
 147                 if (ogl_SquelchError(GL_INVALID_OPERATION))
 148                 {
 149                         GLint errPos = 0;
 150                         glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &errPos);
 151                         int errLine = std::count(code.begin(), code.begin() + std::min((int)code.length(), errPos + 1), '\n') + 1;
 152                         char* errStr = (char*)glGetString(GL_PROGRAM_ERROR_STRING_ARB);
 153                         LOGERROR("Failed to compile %s program '%s' (line %d):\n%s", targetName, file.string8(), errLine, errStr);
 154                         return false;
 155                 }
 156
 157                 glBindProgramARB(target, 0);
 158
 159                 ogl_WarnIfError();
 160
 161                 return true;
 162         }
 163
 164         void Reload() override
 165         {
 166                 Unload();
 167
 168                 CVFSFile vertexFile;
 169                 if (vertexFile.Load(g_VFS, m_VertexFile) != PSRETURN_OK)
 170                         return;
 171
 172                 CVFSFile fragmentFile;
 173                 if (fragmentFile.Load(g_VFS, m_FragmentFile) != PSRETURN_OK)
 174                         return;
 175
 176                 CPreprocessorWrapper preprocessor;
 177                 preprocessor.AddDefines(m_Defines);
 178
 179                 CStr vertexCode = preprocessor.Preprocess(vertexFile.GetAsString());
 180                 CStr fragmentCode = preprocessor.Preprocess(fragmentFile.GetAsString());
 181
 182                 if (!Compile(GL_VERTEX_PROGRAM_ARB, "vertex", m_VertexProgram, m_VertexFile, vertexCode))
 183                         return;
 184
 185                 if (!Compile(GL_FRAGMENT_PROGRAM_ARB, "fragment", m_FragmentProgram, m_FragmentFile, fragmentCode))
 186                         return;
 187         }
 188
 189         void Unload()
 190         {
 191         }
 192
 193         void Bind() override
 194         {
 195                 glBindProgramARB(GL_VERTEX_PROGRAM_ARB, m_VertexProgram);
 196                 glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, m_FragmentProgram);
 197
 198                 BindClientStates();
 199         }
 200
 201         void Unbind() override
 202         {
 203                 glBindProgramARB(GL_VERTEX_PROGRAM_ARB, 0);
 204                 glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, 0);
 205
 206                 UnbindClientStates();
 207
 208                 // TODO: should unbind textures, probably
 209         }
 210
 211         int GetUniformVertexIndex(CStrIntern id)
 212         {
 213                 std::map<CStrIntern, int>::iterator it = m_VertexIndexes.find(id);
 214                 if (it == m_VertexIndexes.end())
 215                         return -1;
 216                 return it->second;
 217         }
 218
 219         frag_index_pair_t GetUniformFragmentIndex(CStrIntern id)
 220         {
 221                 std::map<CStrIntern, frag_index_pair_t>::iterator it = m_FragmentIndexes.find(id);
 222                 if (it == m_FragmentIndexes.end())
 223                         return std::make_pair(-1, 0);
 224                 return it->second;
 225         }
 226
 227         Binding GetTextureBinding(texture_id_t id) override
 228         {
 229                 frag_index_pair_t fPair = GetUniformFragmentIndex(id);
 230                 int index = fPair.first;
 231                 if (index == -1)
 232                         return Binding();
 233                 else
 234                         return Binding((int)fPair.second, index);
 235         }
 236
 237         void BindTexture(texture_id_t id, GLuint tex) override
 238         {
 239                 frag_index_pair_t fPair = GetUniformFragmentIndex(id);
 240                 int index = fPair.first;
 241                 if (index != -1)
 242                 {
 243                         g_Renderer.GetDeviceCommandContext()->BindTexture(index, fPair.second, tex);
 244                 }
 245         }
 246
 247         void BindTexture(Binding id, GLuint tex) override
 248         {
 249                 int index = id.second;
 250                 if (index != -1)
 251                 {
 252                         g_Renderer.GetDeviceCommandContext()->BindTexture(index, id.first, tex);
 253                 }
 254         }
 255
 256         Binding GetUniformBinding(uniform_id_t id) override
 257         {
 258                 return Binding(GetUniformVertexIndex(id), GetUniformFragmentIndex(id).first);
 259         }
 260
 261         void Uniform(Binding id, float v0, float v1, float v2, float v3) override
 262         {
 263                 if (id.first != -1)
 264                         glProgramLocalParameter4fARB(GL_VERTEX_PROGRAM_ARB, (GLuint)id.first, v0, v1, v2, v3);
 265
 266                 if (id.second != -1)
 267                         glProgramLocalParameter4fARB(GL_FRAGMENT_PROGRAM_ARB, (GLuint)id.second, v0, v1, v2, v3);
 268         }
 269
 270         void Uniform(Binding id, const CMatrix3D& v) override
 271         {
 272                 if (id.first != -1)
 273                 {
 274                         glProgramLocalParameter4fARB(GL_VERTEX_PROGRAM_ARB, (GLuint)id.first+0, v._11, v._12, v._13, v._14);
 275                         glProgramLocalParameter4fARB(GL_VERTEX_PROGRAM_ARB, (GLuint)id.first+1, v._21, v._22, v._23, v._24);
 276                         glProgramLocalParameter4fARB(GL_VERTEX_PROGRAM_ARB, (GLuint)id.first+2, v._31, v._32, v._33, v._34);
 277                         glProgramLocalParameter4fARB(GL_VERTEX_PROGRAM_ARB, (GLuint)id.first+3, v._41, v._42, v._43, v._44);
 278                 }
 279
 280                 if (id.second != -1)
 281                 {
 282                         glProgramLocalParameter4fARB(GL_FRAGMENT_PROGRAM_ARB, (GLuint)id.second+0, v._11, v._12, v._13, v._14);
 283                         glProgramLocalParameter4fARB(GL_FRAGMENT_PROGRAM_ARB, (GLuint)id.second+1, v._21, v._22, v._23, v._24);
 284                         glProgramLocalParameter4fARB(GL_FRAGMENT_PROGRAM_ARB, (GLuint)id.second+2, v._31, v._32, v._33, v._34);
 285                         glProgramLocalParameter4fARB(GL_FRAGMENT_PROGRAM_ARB, (GLuint)id.second+3, v._41, v._42, v._43, v._44);
 286                 }
 287         }
 288
 289         void Uniform(Binding id, size_t count, const CMatrix3D* v) override
 290         {
 291                 ENSURE(count == 1);
 292                 Uniform(id, v[0]);
 293         }
 294
 295         void Uniform(Binding id, size_t count, const float* v) override
 296         {
 297                 ENSURE(count == 4);
 298                 Uniform(id, v[0], v[1], v[2], v[3]);
 299         }
 300
 301         std::vector<VfsPath> GetFileDependencies() const override
 302         {
 303                 return {m_VertexFile, m_FragmentFile};
 304         }
 305
 306 private:
 307         VfsPath m_VertexFile;
 308         VfsPath m_FragmentFile;
 309         CShaderDefines m_Defines;
 310
 311         GLuint m_VertexProgram;
 312         GLuint m_FragmentProgram;
 313
 314         std::map<CStrIntern, int> m_VertexIndexes;
 315
 316         // pair contains <index, gltype>
 317         std::map<CStrIntern, frag_index_pair_t> m_FragmentIndexes;
 318 };
 319
 320 #endif // #if !CONFIG2_GLES
 321
 322 //////////////////////////////////////////////////////////////////////////
 323
 324 TIMER_ADD_CLIENT(tc_ShaderGLSLCompile);
 325 TIMER_ADD_CLIENT(tc_ShaderGLSLLink);
 326
 327 class CShaderProgramGLSL : public CShaderProgram
 328 {
 329 public:
 330         CShaderProgramGLSL(const VfsPath& vertexFile, const VfsPath& fragmentFile,
 331                 const CShaderDefines& defines,
 332                 const std::map<CStrIntern, int>& vertexAttribs,
 333                 int streamflags) :
 334         CShaderProgram(streamflags),
 335                 m_VertexFile(vertexFile), m_FragmentFile(fragmentFile),
 336                 m_Defines(defines),
 337                 m_VertexAttribs(vertexAttribs)
 338         {
 339                 m_Program = 0;
 340                 m_VertexShader = glCreateShader(GL_VERTEX_SHADER);
 341                 m_FragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
 342                 m_FileDependencies = {m_VertexFile, m_FragmentFile};
 343         }
 344
 345         ~CShaderProgramGLSL()
 346         {
 347                 Unload();
 348
 349                 glDeleteShader(m_VertexShader);
 350                 glDeleteShader(m_FragmentShader);
 351         }
 352
 353         bool Compile(GLhandleARB shader, const VfsPath& file, const CStr& code)
 354         {
 355                 TIMER_ACCRUE(tc_ShaderGLSLCompile);
 356
 357                 ogl_WarnIfError();
 358
 359                 const char* code_string = code.c_str();
 360                 GLint code_length = code.length();
 361                 glShaderSource(shader, 1, &code_string, &code_length);
 362
 363                 glCompileShader(shader);
 364
 365                 GLint ok = 0;
 366                 glGetShaderiv(shader, GL_COMPILE_STATUS, &ok);
 367
 368                 GLint length = 0;
 369                 glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &length);
 370
 371                 // Apparently sometimes GL_INFO_LOG_LENGTH is incorrectly reported as 0
 372                 // (http://code.google.com/p/android/issues/detail?id=9953)
 373                 if (!ok && length == 0)
 374                         length = 4096;
 375
 376                 if (length > 1)
 377                 {
 378                         char* infolog = new char[length];
 379                         glGetShaderInfoLog(shader, length, NULL, infolog);
 380
 381                         if (ok)
 382                                 LOGMESSAGE("Info when compiling shader '%s':\n%s", file.string8(), infolog);
 383                         else
 384                                 LOGERROR("Failed to compile shader '%s':\n%s", file.string8(), infolog);
 385
 386                         delete[] infolog;
 387                 }
 388
 389                 ogl_WarnIfError();
 390
 391                 return (ok ? true : false);
 392         }
 393
 394         bool Link()
 395         {
 396                 TIMER_ACCRUE(tc_ShaderGLSLLink);
 397
 398                 ENSURE(!m_Program);
 399                 m_Program = glCreateProgram();
 400
 401                 glAttachShader(m_Program, m_VertexShader);
 402                 ogl_WarnIfError();
 403                 glAttachShader(m_Program, m_FragmentShader);
 404                 ogl_WarnIfError();
 405
 406                 // Set up the attribute bindings explicitly, since apparently drivers
 407                 // don't always pick the most efficient bindings automatically,
 408                 // and also this lets us hardcode indexes into VertexPointer etc
 409                 for (std::map<CStrIntern, int>::iterator it = m_VertexAttribs.begin(); it != m_VertexAttribs.end(); ++it)
 410                         glBindAttribLocation(m_Program, it->second, it->first.c_str());
 411
 412                 glLinkProgram(m_Program);
 413
 414                 GLint ok = 0;
 415                 glGetProgramiv(m_Program, GL_LINK_STATUS, &ok);
 416
 417                 GLint length = 0;
 418                 glGetProgramiv(m_Program, GL_INFO_LOG_LENGTH, &length);
 419
 420                 if (!ok && length == 0)
 421                         length = 4096;
 422
 423                 if (length > 1)
 424                 {
 425                         char* infolog = new char[length];
 426                         glGetProgramInfoLog(m_Program, length, NULL, infolog);
 427
 428                         if (ok)
 429                                 LOGMESSAGE("Info when linking program '%s'+'%s':\n%s", m_VertexFile.string8(), m_FragmentFile.string8(), infolog);
 430                         else
 431                                 LOGERROR("Failed to link program '%s'+'%s':\n%s", m_VertexFile.string8(), m_FragmentFile.string8(), infolog);
 432
 433                         delete[] infolog;
 434                 }
 435
 436                 ogl_WarnIfError();
 437
 438                 if (!ok)
 439                         return false;
 440
 441                 m_Uniforms.clear();
 442                 m_Samplers.clear();
 443
 444                 Bind();
 445
 446                 ogl_WarnIfError();
 447
 448                 GLint numUniforms = 0;
 449                 glGetProgramiv(m_Program, GL_ACTIVE_UNIFORMS, &numUniforms);
 450                 ogl_WarnIfError();
 451                 for (GLint i = 0; i < numUniforms; ++i)
 452                 {
 453                         char name[256] = {0};
 454                         GLsizei nameLength = 0;
 455                         GLint size = 0;
 456                         GLenum type = 0;
 457                         glGetActiveUniform(m_Program, i, ARRAY_SIZE(name), &nameLength, &size, &type, name);
 458                         ogl_WarnIfError();
 459
 460                         GLint loc = glGetUniformLocation(m_Program, name);
 461
 462                         CStrIntern nameIntern(name);
 463                         m_Uniforms[nameIntern] = std::make_pair(loc, type);
 464
 465                         // Assign sampler uniforms to sequential texture units
 466                         if (type == GL_SAMPLER_2D
 467                          || type == GL_SAMPLER_CUBE
 468 #if !CONFIG2_GLES
 469                          || type == GL_SAMPLER_2D_SHADOW
 470 #endif
 471                         )
 472                         {
 473                                 int unit = (int)m_Samplers.size();
 474                                 m_Samplers[nameIntern].first = (type == GL_SAMPLER_CUBE ? GL_TEXTURE_CUBE_MAP : GL_TEXTURE_2D);
 475                                 m_Samplers[nameIntern].second = unit;
 476                                 glUniform1i(loc, unit); // link uniform to unit
 477                                 ogl_WarnIfError();
 478                         }
 479                 }
 480
 481                 // TODO: verify that we're not using more samplers than is supported
 482
 483                 Unbind();
 484
 485                 ogl_WarnIfError();
 486
 487                 return true;
 488         }
 489
 490         void Reload() override
 491         {
 492                 Unload();
 493
 494                 CVFSFile vertexFile;
 495                 if (vertexFile.Load(g_VFS, m_VertexFile) != PSRETURN_OK)
 496                         return;
 497
 498                 CVFSFile fragmentFile;
 499                 if (fragmentFile.Load(g_VFS, m_FragmentFile) != PSRETURN_OK)
 500                         return;
 501
 502                 std::vector<VfsPath> newFileDependencies = {m_VertexFile, m_FragmentFile};
 503
 504                 CPreprocessorWrapper preprocessor([&newFileDependencies](const CStr& includePath, CStr& out) -> bool {
 505                         const VfsPath includeFilePath(L"shaders/glsl/" + wstring_from_utf8(includePath));
 506                         // Add dependencies anyway to reload the shader when the file is
 507                         // appeared.
 508                         newFileDependencies.push_back(includeFilePath);
 509                         CVFSFile includeFile;
 510                         if (includeFile.Load(g_VFS, includeFilePath) != PSRETURN_OK)
 511                                 return false;
 512                         out = includeFile.GetAsString();
 513                         return true;
 514                 });
 515                 preprocessor.AddDefines(m_Defines);
 516
 517 #if CONFIG2_GLES
 518                 // GLES defines the macro "GL_ES" in its GLSL preprocessor,
 519                 // but since we run our own preprocessor first, we need to explicitly
 520                 // define it here
 521                 preprocessor.AddDefine("GL_ES", "1");
 522 #endif
 523
 524                 CStr vertexCode = preprocessor.Preprocess(vertexFile.GetAsString());
 525                 CStr fragmentCode = preprocessor.Preprocess(fragmentFile.GetAsString());
 526
 527                 m_FileDependencies = std::move(newFileDependencies);
 528
 529                 if (vertexCode.empty())
 530                         LOGERROR("Failed to preprocess vertex shader: '%s'", m_VertexFile.string8());
 531                 if (fragmentCode.empty())
 532                         LOGERROR("Failed to preprocess fragment shader: '%s'", m_FragmentFile.string8());
 533
 534 #if CONFIG2_GLES
 535                 // Ugly hack to replace desktop GLSL 1.10/1.20 with GLSL ES 1.00,
 536                 // and also to set default float precision for fragment shaders
 537                 vertexCode.Replace("#version 110\n", "#version 100\n");
 538                 vertexCode.Replace("#version 110\r\n", "#version 100\n");
 539                 vertexCode.Replace("#version 120\n", "#version 100\n");
 540                 vertexCode.Replace("#version 120\r\n", "#version 100\n");
 541                 fragmentCode.Replace("#version 110\n", "#version 100\nprecision mediump float;\n");
 542                 fragmentCode.Replace("#version 110\r\n", "#version 100\nprecision mediump float;\n");
 543                 fragmentCode.Replace("#version 120\n", "#version 100\nprecision mediump float;\n");
 544                 fragmentCode.Replace("#version 120\r\n", "#version 100\nprecision mediump float;\n");
 545 #endif
 546
 547                 if (!Compile(m_VertexShader, m_VertexFile, vertexCode))
 548                         return;
 549
 550                 if (!Compile(m_FragmentShader, m_FragmentFile, fragmentCode))
 551                         return;
 552
 553                 if (!Link())
 554                         return;
 555         }
 556
 557         void Unload()
 558         {
 559                 if (m_Program)
 560                         glDeleteProgram(m_Program);
 561                 m_Program = 0;
 562
 563                 // The shader objects can be reused and don't need to be deleted here
 564         }
 565
 566         void Bind() override
 567         {
 568                 glUseProgram(m_Program);
 569
 570                 for (std::map<CStrIntern, int>::iterator it = m_VertexAttribs.begin(); it != m_VertexAttribs.end(); ++it)
 571                         glEnableVertexAttribArray(it->second);
 572         }
 573
 574         void Unbind() override
 575         {
 576                 glUseProgram(0);
 577
 578                 for (std::map<CStrIntern, int>::iterator it = m_VertexAttribs.begin(); it != m_VertexAttribs.end(); ++it)
 579                         glDisableVertexAttribArray(it->second);
 580
 581                 // TODO: should unbind textures, probably
 582         }
 583
 584         Binding GetTextureBinding(texture_id_t id) override
 585         {
 586                 std::map<CStrIntern, std::pair<GLenum, int>>::iterator it = m_Samplers.find(CStrIntern(id));
 587                 if (it == m_Samplers.end())
 588                         return Binding();
 589                 else
 590                         return Binding((int)it->second.first, it->second.second);
 591         }
 592
 593         void BindTexture(texture_id_t id, GLuint tex) override
 594         {
 595                 std::map<CStrIntern, std::pair<GLenum, int>>::iterator it = m_Samplers.find(CStrIntern(id));
 596                 if (it == m_Samplers.end())
 597                         return;
 598
 599                 g_Renderer.GetDeviceCommandContext()->BindTexture(it->second.second, it->second.first, tex);
 600         }
 601
 602         void BindTexture(Binding id, GLuint tex) override
 603         {
 604                 if (id.second == -1)
 605                         return;
 606
 607                 g_Renderer.GetDeviceCommandContext()->BindTexture(id.second, id.first, tex);
 608         }
 609
 610         Binding GetUniformBinding(uniform_id_t id) override
 611         {
 612                 std::map<CStrIntern, std::pair<int, GLenum>>::iterator it = m_Uniforms.find(id);
 613                 if (it == m_Uniforms.end())
 614                         return Binding();
 615                 else
 616                         return Binding(it->second.first, (int)it->second.second);
 617         }
 618
 619         void Uniform(Binding id, float v0, float v1, float v2, float v3) override
 620         {
 621                 if (id.first != -1)
 622                 {
 623                         if (id.second == GL_FLOAT)
 624                                 glUniform1f(id.first, v0);
 625                         else if (id.second == GL_FLOAT_VEC2)
 626                                 glUniform2f(id.first, v0, v1);
 627                         else if (id.second == GL_FLOAT_VEC3)
 628                                 glUniform3f(id.first, v0, v1, v2);
 629                         else if (id.second == GL_FLOAT_VEC4)
 630                                 glUniform4f(id.first, v0, v1, v2, v3);
 631                         else
 632                                 LOGERROR("CShaderProgramGLSL::Uniform(): Invalid uniform type (expected float, vec2, vec3, vec4)");
 633                 }
 634         }
 635
 636         void Uniform(Binding id, const CMatrix3D& v) override
 637         {
 638                 if (id.first != -1)
 639                 {
 640                         if (id.second == GL_FLOAT_MAT4)
 641                                 glUniformMatrix4fv(id.first, 1, GL_FALSE, &v._11);
 642                         else
 643                                 LOGERROR("CShaderProgramGLSL::Uniform(): Invalid uniform type (expected mat4)");
 644                 }
 645         }
 646
 647         void Uniform(Binding id, size_t count, const CMatrix3D* v) override
 648         {
 649                 if (id.first != -1)
 650                 {
 651                         if (id.second == GL_FLOAT_MAT4)
 652                                 glUniformMatrix4fv(id.first, count, GL_FALSE, &v->_11);
 653                         else
 654                                 LOGERROR("CShaderProgramGLSL::Uniform(): Invalid uniform type (expected mat4)");
 655                 }
 656         }
 657
 658         void Uniform(Binding id, size_t count, const float* v) override
 659         {
 660                 if (id.first != -1)
 661                 {
 662                         if (id.second == GL_FLOAT)
 663                                 glUniform1fv(id.first, count, v);
 664                         else
 665                                 LOGERROR("CShaderProgramGLSL::Uniform(): Invalid uniform type (expected float)");
 666                 }
 667         }
 668
 669         // Map the various fixed-function Pointer functions onto generic vertex attributes
 670         // (matching the attribute indexes from ShaderManager's ParseAttribSemantics):
 671
 672         void VertexPointer(const Renderer::Backend::Format format, GLsizei stride, const void* pointer) override
 673         {
 674                 const GLint size = GLSizeFromFormat(format);
 675                 const GLenum type = GLTypeFromFormat(format);
 676                 glVertexAttribPointer(0, size, type, GL_FALSE, stride, pointer);
 677                 m_ValidStreams |= STREAM_POS;
 678         }
 679
 680         void NormalPointer(const Renderer::Backend::Format format, GLsizei stride, const void* pointer) override
 681         {
 682                 const GLint size = GLSizeFromFormat(format);
 683                 const GLenum type = GLTypeFromFormat(format);
 684                 glVertexAttribPointer(2, size, type, (type == GL_FLOAT ? GL_FALSE : GL_TRUE), stride, pointer);
 685                 m_ValidStreams |= STREAM_NORMAL;
 686         }
 687
 688         void ColorPointer(const Renderer::Backend::Format format, GLsizei stride, const void* pointer) override
 689         {
 690                 const GLint size = GLSizeFromFormat(format);
 691                 const GLenum type = GLTypeFromFormat(format);
 692                 glVertexAttribPointer(3, size, type, (type == GL_FLOAT ? GL_FALSE : GL_TRUE), stride, pointer);
 693                 m_ValidStreams |= STREAM_COLOR;
 694         }
 695
 696         void TexCoordPointer(GLenum texture, const Renderer::Backend::Format format, GLsizei stride, const void* pointer) override
 697         {
 698                 const GLint size = GLSizeFromFormat(format);
 699                 const GLenum type = GLTypeFromFormat(format);
 700                 glVertexAttribPointer(8 + texture - GL_TEXTURE0, size, type, GL_FALSE, stride, pointer);
 701                 m_ValidStreams |= STREAM_UV0 << (texture - GL_TEXTURE0);
 702         }
 703
 704         void VertexAttribPointer(attrib_id_t id, const Renderer::Backend::Format format, GLboolean normalized, GLsizei stride, const void* pointer) override
 705         {
 706                 std::map<CStrIntern, int>::iterator it = m_VertexAttribs.find(id);
 707                 if (it != m_VertexAttribs.end())
 708                 {
 709                         const GLint size = GLSizeFromFormat(format);
 710                         const GLenum type = GLTypeFromFormat(format);
 711                         glVertexAttribPointer(it->second, size, type, normalized, stride, pointer);
 712                 }
 713         }
 714
 715         std::vector<VfsPath> GetFileDependencies() const override
 716         {
 717                 return m_FileDependencies;
 718         }
 719
 720 private:
 721         VfsPath m_VertexFile;
 722         VfsPath m_FragmentFile;
 723         std::vector<VfsPath> m_FileDependencies;
 724         CShaderDefines m_Defines;
 725         std::map<CStrIntern, int> m_VertexAttribs;
 726
 727         GLhandleARB m_Program;
 728         GLhandleARB m_VertexShader;
 729         GLhandleARB m_FragmentShader;
 730
 731         std::map<CStrIntern, std::pair<int, GLenum>> m_Uniforms;
 732         std::map<CStrIntern, std::pair<GLenum, int>> m_Samplers; // texture target & unit chosen for each uniform sampler
 733 };
 734
 735 //////////////////////////////////////////////////////////////////////////
 736
 737 CShaderProgram::CShaderProgram(int streamflags)
 738         : m_StreamFlags(streamflags), m_ValidStreams(0)
 739 {
 740 }
 741
 742 // static
 743 CShaderProgramPtr CShaderProgram::Create(const char* name, const CShaderDefines& baseDefines)
 744 {
 745         PROFILE2("loading shader");
 746         PROFILE2_ATTR("name: %s", name);
 747
 748         VfsPath xmlFilename = L"shaders/" + wstring_from_utf8(name) + L".xml";
 749
 750         CXeromyces XeroFile;
 751         PSRETURN ret = XeroFile.Load(g_VFS, xmlFilename);
 752         if (ret != PSRETURN_OK)
 753                 return nullptr;
 754
 755 #if USE_SHADER_XML_VALIDATION
 756         {
 757                 TIMER_ACCRUE(tc_ShaderValidation);
 758
 759                 // Serialize the XMB data and pass it to the validator
 760                 XMLWriter_File shaderFile;
 761                 shaderFile.SetPrettyPrint(false);
 762                 shaderFile.XMB(XeroFile);
 763                 bool ok = CXeromyces::ValidateEncoded("shader", name, shaderFile.GetOutput());
 764                 if (!ok)
 765                         return nullptr;
 766         }
 767 #endif
 768
 769         // Define all the elements and attributes used in the XML file
 770 #define EL(x) int el_##x = XeroFile.GetElementID(#x)
 771 #define AT(x) int at_##x = XeroFile.GetAttributeID(#x)
 772         EL(attrib);
 773         EL(define);
 774         EL(fragment);
 775         EL(stream);
 776         EL(uniform);
 777         EL(vertex);
 778         AT(file);
 779         AT(if);
 780         AT(loc);
 781         AT(name);
 782         AT(semantics);
 783         AT(type);
 784         AT(value);
 785 #undef AT
 786 #undef EL
 787
 788         CPreprocessorWrapper preprocessor;
 789         preprocessor.AddDefines(baseDefines);
 790
 791         XMBElement root = XeroFile.GetRoot();
 792
 793         VfsPath vertexFile;
 794         VfsPath fragmentFile;
 795         CShaderDefines defines = baseDefines;
 796         std::map<CStrIntern, int> vertexUniforms;
 797         std::map<CStrIntern, CShaderProgram::frag_index_pair_t> fragmentUniforms;
 798         std::map<CStrIntern, int> vertexAttribs;
 799         int streamFlags = 0;
 800
 801         XERO_ITER_EL(root, Child)
 802         {
 803                 if (Child.GetNodeName() == el_define)
 804                 {
 805                         defines.Add(CStrIntern(Child.GetAttributes().GetNamedItem(at_name)), CStrIntern(Child.GetAttributes().GetNamedItem(at_value)));
 806                 }
 807                 else if (Child.GetNodeName() == el_vertex)
 808                 {
 809                         vertexFile = L"shaders/" + Child.GetAttributes().GetNamedItem(at_file).FromUTF8();
 810
 811                         XERO_ITER_EL(Child, Param)
 812                         {
 813                                 XMBAttributeList Attrs = Param.GetAttributes();
 814
 815                                 CStr cond = Attrs.GetNamedItem(at_if);
 816                                 if (!cond.empty() && !preprocessor.TestConditional(cond))
 817                                         continue;
 818
 819                                 if (Param.GetNodeName() == el_uniform)
 820                                 {
 821                                         vertexUniforms[CStrIntern(Attrs.GetNamedItem(at_name))] = Attrs.GetNamedItem(at_loc).ToInt();
 822                                 }
 823                                 else if (Param.GetNodeName() == el_stream)
 824                                 {
 825                                         CStr StreamName = Attrs.GetNamedItem(at_name);
 826                                         if (StreamName == "pos")
 827                                                 streamFlags |= STREAM_POS;
 828                                         else if (StreamName == "normal")
 829                                                 streamFlags |= STREAM_NORMAL;
 830                                         else if (StreamName == "color")
 831                                                 streamFlags |= STREAM_COLOR;
 832                                         else if (StreamName == "uv0")
 833                                                 streamFlags |= STREAM_UV0;
 834                                         else if (StreamName == "uv1")
 835                                                 streamFlags |= STREAM_UV1;
 836                                         else if (StreamName == "uv2")
 837                                                 streamFlags |= STREAM_UV2;
 838                                         else if (StreamName == "uv3")
 839                                                 streamFlags |= STREAM_UV3;
 840                                 }
 841                                 else if (Param.GetNodeName() == el_attrib)
 842                                 {
 843                                         int attribLoc = ParseAttribSemantics(Attrs.GetNamedItem(at_semantics));
 844                                         vertexAttribs[CStrIntern(Attrs.GetNamedItem(at_name))] = attribLoc;
 845                                 }
 846                         }
 847                 }
 848                 else if (Child.GetNodeName() == el_fragment)
 849                 {
 850                         fragmentFile = L"shaders/" + Child.GetAttributes().GetNamedItem(at_file).FromUTF8();
 851
 852                         XERO_ITER_EL(Child, Param)
 853                         {
 854                                 XMBAttributeList Attrs = Param.GetAttributes();
 855
 856                                 CStr cond = Attrs.GetNamedItem(at_if);
 857                                 if (!cond.empty() && !preprocessor.TestConditional(cond))
 858                                         continue;
 859
 860                                 if (Param.GetNodeName() == el_uniform)
 861                                 {
 862                                         // A somewhat incomplete listing, missing "shadow" and "rect" versions
 863                                         // which are interpreted as 2D (NB: our shadowmaps may change
 864                                         // type based on user config).
 865                                         GLenum type = GL_TEXTURE_2D;
 866                                         CStr t = Attrs.GetNamedItem(at_type);
 867                                         if (t == "sampler1D")
 868 #if CONFIG2_GLES
 869                                                 debug_warn(L"sampler1D not implemented on GLES");
 870 #else
 871                                                 type = GL_TEXTURE_1D;
 872 #endif
 873                                         else if (t == "sampler2D")
 874                                                 type = GL_TEXTURE_2D;
 875                                         else if (t == "sampler3D")
 876 #if CONFIG2_GLES
 877                                                 debug_warn(L"sampler3D not implemented on GLES");
 878 #else
 879                                                 type = GL_TEXTURE_3D;
 880 #endif
 881                                         else if (t == "samplerCube")
 882                                                 type = GL_TEXTURE_CUBE_MAP;
 883
 884                                         fragmentUniforms[CStrIntern(Attrs.GetNamedItem(at_name))] =
 885                                                 std::make_pair(Attrs.GetNamedItem(at_loc).ToInt(), type);
 886                                 }
 887                         }
 888                 }
 889         }
 890
 891         if (root.GetAttributes().GetNamedItem(at_type) == "glsl")
 892                 return CShaderProgram::ConstructGLSL(vertexFile, fragmentFile, defines, vertexAttribs, streamFlags);
 893         else
 894                 return CShaderProgram::ConstructARB(vertexFile, fragmentFile, defines, vertexUniforms, fragmentUniforms, streamFlags);
 895 }
 896
 897 #if CONFIG2_GLES
 898 // static
 899 CShaderProgramPtr CShaderProgram::ConstructARB(const VfsPath& vertexFile, const VfsPath& fragmentFile,
 900         const CShaderDefines& UNUSED(defines),
 901         const std::map<CStrIntern, int>& UNUSED(vertexIndexes), const std::map<CStrIntern, frag_index_pair_t>& UNUSED(fragmentIndexes),
 902         int UNUSED(streamflags))
 903 {
 904         LOGERROR("CShaderProgram::ConstructARB: '%s'+'%s': ARB shaders not supported on this device",
 905                 vertexFile.string8(), fragmentFile.string8());
 906         return nullptr;
 907 }
 908 #else
 909 // static
 910 CShaderProgramPtr CShaderProgram::ConstructARB(const VfsPath& vertexFile, const VfsPath& fragmentFile,
 911         const CShaderDefines& defines,
 912         const std::map<CStrIntern, int>& vertexIndexes, const std::map<CStrIntern, frag_index_pair_t>& fragmentIndexes,
 913         int streamflags)
 914 {
 915         return std::make_shared<CShaderProgramARB>(vertexFile, fragmentFile, defines, vertexIndexes, fragmentIndexes, streamflags);
 916 }
 917 #endif
 918
 919 // static
 920 CShaderProgramPtr CShaderProgram::ConstructGLSL(const VfsPath& vertexFile, const VfsPath& fragmentFile,
 921         const CShaderDefines& defines,
 922         const std::map<CStrIntern, int>& vertexAttribs,
 923         int streamflags)
 924 {
 925         return std::make_shared<CShaderProgramGLSL>(vertexFile, fragmentFile, defines, vertexAttribs, streamflags);
 926 }
 927
 928 int CShaderProgram::GetStreamFlags() const
 929 {
 930         return m_StreamFlags;
 931 }
 932
 933 void CShaderProgram::BindTexture(texture_id_t id, const Renderer::Backend::GL::CTexture* tex)
 934 {
 935         BindTexture(id, tex->GetHandle());
 936 }
 937
 938 void CShaderProgram::BindTexture(Binding id, const Renderer::Backend::GL::CTexture* tex)
 939 {
 940         BindTexture(id, tex->GetHandle());
 941 }
 942
 943 void CShaderProgram::Uniform(Binding id, int v)
 944 {
 945         Uniform(id, (float)v, (float)v, (float)v, (float)v);
 946 }
 947
 948 void CShaderProgram::Uniform(Binding id, float v)
 949 {
 950         Uniform(id, v, v, v, v);
 951 }
 952
 953 void CShaderProgram::Uniform(Binding id, float v0, float v1)
 954 {
 955         Uniform(id, v0, v1, 0.0f, 0.0f);
 956 }
 957
 958 void CShaderProgram::Uniform(Binding id, const CVector3D& v)
 959 {
 960         Uniform(id, v.X, v.Y, v.Z, 0.0f);
 961 }
 962
 963 void CShaderProgram::Uniform(Binding id, const CColor& v)
 964 {
 965         Uniform(id, v.r, v.g, v.b, v.a);
 966 }
 967
 968 void CShaderProgram::Uniform(uniform_id_t id, int v)
 969 {
 970         Uniform(GetUniformBinding(id), (float)v, (float)v, (float)v, (float)v);
 971 }
 972
 973 void CShaderProgram::Uniform(uniform_id_t id, float v)
 974 {
 975         Uniform(GetUniformBinding(id), v, v, v, v);
 976 }
 977
 978 void CShaderProgram::Uniform(uniform_id_t id, float v0, float v1)
 979 {
 980         Uniform(GetUniformBinding(id), v0, v1, 0.0f, 0.0f);
 981 }
 982
 983 void CShaderProgram::Uniform(uniform_id_t id, const CVector3D& v)
 984 {
 985         Uniform(GetUniformBinding(id), v.X, v.Y, v.Z, 0.0f);
 986 }
 987
 988 void CShaderProgram::Uniform(uniform_id_t id, const CColor& v)
 989 {
 990         Uniform(GetUniformBinding(id), v.r, v.g, v.b, v.a);
 991 }
 992
 993 void CShaderProgram::Uniform(uniform_id_t id, float v0, float v1, float v2, float v3)
 994 {
 995         Uniform(GetUniformBinding(id), v0, v1, v2, v3);
 996 }
 997
 998 void CShaderProgram::Uniform(uniform_id_t id, const CMatrix3D& v)
 999 {
1000         Uniform(GetUniformBinding(id), v);
1001 }
1002
1003 void CShaderProgram::Uniform(uniform_id_t id, size_t count, const CMatrix3D* v)
1004 {
1005         Uniform(GetUniformBinding(id), count, v);
1006 }
1007
1008 void CShaderProgram::Uniform(uniform_id_t id, size_t count, const float* v)
1009 {
1010         Uniform(GetUniformBinding(id), count, v);
1011 }
1012
1013
1014 // These should all be overridden by CShaderProgramGLSL, and not used
1015 // if a non-GLSL shader was loaded instead:
1016
1017 void CShaderProgram::VertexAttribPointer(attrib_id_t UNUSED(id), const Renderer::Backend::Format UNUSED(format),
1018         GLboolean UNUSED(normalized), GLsizei UNUSED(stride), const void* UNUSED(pointer))
1019 {
1020         debug_warn("Shader type doesn't support VertexAttribPointer");
1021 }
1022
1023 #if CONFIG2_GLES
1024
1025 // These should all be overridden by CShaderProgramGLSL
1026 // (GLES doesn't support any other types of shader program):
1027
1028 void CShaderProgram::VertexPointer(const Renderer::Backend::Format UNUSED(format), GLsizei UNUSED(stride), const void* UNUSED(pointer))
1029 {
1030         debug_warn("CShaderProgram::VertexPointer should be overridden");
1031 }
1032 void CShaderProgram::NormalPointer(const Renderer::Backend::Format UNUSED(format), GLsizei UNUSED(stride), const void* UNUSED(pointer))
1033 {
1034         debug_warn("CShaderProgram::NormalPointer should be overridden");
1035 }
1036 void CShaderProgram::ColorPointer(const Renderer::Backend::Format UNUSED(format), GLsizei UNUSED(stride), const void* UNUSED(pointer))
1037 {
1038         debug_warn("CShaderProgram::ColorPointer should be overridden");
1039 }
1040 void CShaderProgram::TexCoordPointer(GLenum UNUSED(texture), const Renderer::Backend::Format UNUSED(format), GLsizei UNUSED(stride), const void* UNUSED(pointer))
1041 {
1042         debug_warn("CShaderProgram::TexCoordPointer should be overridden");
1043 }
1044
1045 #else
1046
1047 // These are overridden by CShaderProgramGLSL, but fixed-function and ARB shaders
1048 // both use the fixed-function vertex attribute pointers so we'll share their
1049 // definitions here:
1050
1051 void CShaderProgram::VertexPointer(const Renderer::Backend::Format format, GLsizei stride, const void* pointer)
1052 {
1053         const GLint size = GLSizeFromFormat(format);
1054         ENSURE(2 <= size && size <= 4);
1055         const GLenum type = GLTypeFromFormat(format);
1056         glVertexPointer(size, type, stride, pointer);
1057         m_ValidStreams |= STREAM_POS;
1058 }
1059
1060 void CShaderProgram::NormalPointer(const Renderer::Backend::Format format, GLsizei stride, const void* pointer)
1061 {
1062         ENSURE(format == Renderer::Backend::Format::R32G32B32_SFLOAT);
1063         glNormalPointer(GL_FLOAT, stride, pointer);
1064         m_ValidStreams |= STREAM_NORMAL;
1065 }
1066
1067 void CShaderProgram::ColorPointer(const Renderer::Backend::Format format, GLsizei stride, const void* pointer)
1068 {
1069         const GLint size = GLSizeFromFormat(format);
1070         ENSURE(3 <= size && size <= 4);
1071         const GLenum type = GLTypeFromFormat(format);
1072         glColorPointer(size, type, stride, pointer);
1073         m_ValidStreams |= STREAM_COLOR;
1074 }
1075
1076 void CShaderProgram::TexCoordPointer(GLenum texture, const Renderer::Backend::Format format, GLsizei stride, const void* pointer)
1077 {
1078         glClientActiveTextureARB(texture);
1079         const GLint size = GLSizeFromFormat(format);
1080         ENSURE(1 <= size && size <= 4);
1081         const GLenum type = GLTypeFromFormat(format);
1082         glTexCoordPointer(size, type, stride, pointer);
1083         glClientActiveTextureARB(GL_TEXTURE0);
1084         m_ValidStreams |= STREAM_UV0 << (texture - GL_TEXTURE0);
1085 }
1086
1087 void CShaderProgram::BindClientStates()
1088 {
1089         ENSURE(m_StreamFlags == (m_StreamFlags & (STREAM_POS|STREAM_NORMAL|STREAM_COLOR|STREAM_UV0|STREAM_UV1)));
1090
1091         // Enable all the desired client states for non-GLSL rendering
1092
1093         if (m_StreamFlags & STREAM_POS)    glEnableClientState(GL_VERTEX_ARRAY);
1094         if (m_StreamFlags & STREAM_NORMAL) glEnableClientState(GL_NORMAL_ARRAY);
1095         if (m_StreamFlags & STREAM_COLOR)  glEnableClientState(GL_COLOR_ARRAY);
1096
1097         if (m_StreamFlags & STREAM_UV0)
1098         {
1099                 glClientActiveTextureARB(GL_TEXTURE0);
1100                 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
1101         }
1102
1103         if (m_StreamFlags & STREAM_UV1)
1104         {
1105                 glClientActiveTextureARB(GL_TEXTURE1);
1106                 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
1107                 glClientActiveTextureARB(GL_TEXTURE0);
1108         }
1109
1110         // Rendering code must subsequently call VertexPointer etc for all of the streams
1111         // that were activated in this function, else AssertPointersBound will complain
1112         // that some arrays were unspecified
1113         m_ValidStreams = 0;
1114 }
1115
1116 void CShaderProgram::UnbindClientStates()
1117 {
1118         if (m_StreamFlags & STREAM_POS)    glDisableClientState(GL_VERTEX_ARRAY);
1119         if (m_StreamFlags & STREAM_NORMAL) glDisableClientState(GL_NORMAL_ARRAY);
1120         if (m_StreamFlags & STREAM_COLOR)  glDisableClientState(GL_COLOR_ARRAY);
1121
1122         if (m_StreamFlags & STREAM_UV0)
1123         {
1124                 glClientActiveTextureARB(GL_TEXTURE0);
1125                 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
1126         }
1127
1128         if (m_StreamFlags & STREAM_UV1)
1129         {
1130                 glClientActiveTextureARB(GL_TEXTURE1);
1131                 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
1132                 glClientActiveTextureARB(GL_TEXTURE0);
1133         }
1134 }
1135
1136 #endif // !CONFIG2_GLES
1137
1138 void CShaderProgram::AssertPointersBound()
1139 {
1140         ENSURE((m_StreamFlags & ~m_ValidStreams) == 0);
1141 }