EffectsGLES30.cpp

#include "EffectsGLES30.h"
#include "ContextGLES30.h"
#include "Foundation/StringView.h"
 
#include <cstring>
#include <memory>
 
#include "../Base/Utilities.h"
#include "../Base/DefaultIOHandler.h"
 
using namespace Cogs;
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("EffectsGLES30");
 
  const char* getGLTypeName(GLenum type)
  {
    switch (type) {
    case GL_FLOAT:                          return "float";
    case GL_FLOAT_VEC2:                     return "vec2";
    case GL_FLOAT_VEC3:                     return "vec3";
    case GL_FLOAT_VEC4:                     return "vec4";
    case GL_INT:                            return "int";
    case GL_INT_VEC2:                       return "ivec2";
    case GL_INT_VEC3:                       return "ivec3";
    case GL_INT_VEC4:                       return "ivec4";
    case GL_UNSIGNED_INT:                   return "uint";
    case GL_UNSIGNED_INT_VEC2:              return "uvec2";
    case GL_UNSIGNED_INT_VEC3:              return "uvec3";
    case GL_UNSIGNED_INT_VEC4:              return "uvec4";
    case GL_BOOL:                           return "bool";
    case GL_BOOL_VEC2:                      return "bvec2";
    case GL_BOOL_VEC3:                      return "bvec3";
    case GL_BOOL_VEC4:                      return "bvec4";
    case GL_FLOAT_MAT2:                     return "mat2";
    case GL_FLOAT_MAT3:                     return "mat3";
    case GL_FLOAT_MAT4:                     return "mat4";
    case GL_FLOAT_MAT2x3:                   return "mat2x3";
    case GL_FLOAT_MAT2x4:                   return "mat2x4";
    case GL_FLOAT_MAT3x2:                   return "mat3x2";
    case GL_FLOAT_MAT3x4:                   return "mat3x4";
    case GL_FLOAT_MAT4x2:                   return "mat4x2";
    case GL_FLOAT_MAT4x3:                   return "mat4x3";
    case GL_SAMPLER_2D:                     return "sampler2D";
    case GL_SAMPLER_3D:                     return "sampler3D";
    case GL_SAMPLER_CUBE:                   return "samplerCube";
    case GL_SAMPLER_2D_SHADOW:              return "sampler2DShadow";
    case GL_SAMPLER_2D_ARRAY:               return "sampler2DArray";
    case GL_SAMPLER_2D_ARRAY_SHADOW:        return "sampler2DArrayShadow";
    case GL_SAMPLER_CUBE_SHADOW:            return "samplerCubeShadow";
    case GL_INT_SAMPLER_2D:                 return "isampler2D";
    case GL_INT_SAMPLER_3D:                 return "isampler3D";
    case GL_INT_SAMPLER_CUBE:               return "isamplerCube";
    case GL_INT_SAMPLER_2D_ARRAY:           return "isampler2DArray";
    case GL_UNSIGNED_INT_SAMPLER_2D:        return "usampler2D";
    case GL_UNSIGNED_INT_SAMPLER_3D:        return "usampler3D";
    case GL_UNSIGNED_INT_SAMPLER_CUBE:      return "usamplerCube";
    case GL_UNSIGNED_INT_SAMPLER_2D_ARRAY:  return "usampler2DArray";
    default: return "???";
    }
  }
 
  void printShaderSource(GLint shaderId)
  {
    GLint sourceLength = 0;
    glGetShaderiv(shaderId, GL_SHADER_SOURCE_LENGTH, &sourceLength);
    if (sourceLength) {
      std::vector<char> source(sourceLength);
      glGetShaderSource(shaderId, sourceLength, &sourceLength, source.data());
 
      char* start = source.data();
      char* stop;
      int line = 1;
      do {
        stop = start;
        while ((*stop != '\0') && (*stop != '\n') && (*stop != '\r')) { stop++; }
 
        LOG_DEBUG(logger, "%3d: %s", line++, std::string(start, stop - start).c_str());
 
        while ((*stop != '\0') && (*stop != '\n')) { stop++; }
        while ((*stop != '\0') && (*stop == '\r')) { stop++; }
 
        start = stop + 1;
      } while (*stop != '\0');
    }
  }
 
  void printShaderError(GLenum shaderType, GLint shaderId, Cogs::EffectFlags::EEffectFlags effectFlags)
  {
    GLint bufferLength = 0;
    glGetShaderiv(shaderId, GL_INFO_LOG_LENGTH, &bufferLength);
 
    if (bufferLength) {
      std::vector<char> buffer(bufferLength);
 
      glGetShaderInfoLog(shaderId, bufferLength, NULL, buffer.data());
 
      if ((effectFlags & EffectFlags::EEffectFlags::LogShaderSource) == EffectFlags::EEffectFlags::LogShaderSource) {
        printShaderSource(shaderId);
      }
      LOG_ERROR(logger, "Could not compile shader %d:\n%s\n", shaderType, buffer.data());
    }
    else if ((effectFlags & (EffectFlags::EEffectFlags::LogShaderInfo | EffectFlags::EEffectFlags::LogShaderSource)) == (EffectFlags::EEffectFlags::LogShaderInfo | EffectFlags::EEffectFlags::LogShaderSource)) {
      printShaderSource(shaderId);
    }
  }
 
  void printProgramError(GLint programId)
  {
    GLint bufferLength = 0;
    glGetProgramiv(programId, GL_INFO_LOG_LENGTH, &bufferLength);
 
    if (bufferLength) {
      std::vector<char> buffer(bufferLength);
 
      glGetProgramInfoLog(programId, bufferLength, NULL, buffer.data());
 
      LOG_ERROR(logger, "Could not link program:\n%s\n", buffer.data());
    }
  }
}
 
void Cogs::EffectsGLES30::releaseEffect(EffectHandle effectHandle)
{
  if (!effectHandle) return;
 
  if (context->getEffect() == effectHandle) {
    LOG_DEBUG_ONCE(logger, "Releasing currently active effect");
    context->setEffect(EffectHandle::NoHandle);
  }
 
  EffectGLES30& effect = effects[effectHandle];
  glDeleteProgram(effect.programId);
  effect.programId = 0;
  effects.removeResource(effectHandle);
}
 
void Cogs::EffectsGLES30::releaseResources()
{
  std::vector<EffectHandle> handles;
  for (auto& resource : effects) {
    handles.push_back(effects.getHandle(resource));
  }
  for (auto& handle : handles) {
    releaseEffect(handle);
  }
}
 
GLint Cogs::EffectsGLES30::loadShader(GLenum shaderType, const char * pSource, PreprocessorDefinitions definitions)
{
  assert(pSource);
 
#if defined(ANDROID) || defined(__APPLE__)
  LOG_INFO(logger, "Loading shader from source:\n(Start source)\n%s", pSource);
  LOG_INFO(logger, "(End source)");
#endif
 
  GLuint shaderId = glCreateShader(shaderType);
  if (shaderId == 0) {
    LOG_ERROR(logger, "loadShader: glCreateShader failed.");
    return 0;
  }
 
  std::vector<std::string> source;
  source.reserve(definitions.size() + 2);
 
  // skip past the version directive
  {
    size_t o = 0;
    // Find first #
    while ((pSource[o] != '\0') && (pSource[o] != '#')) { o++; }
 
    // Check if that is #version
    if ((pSource[o] == '#') && (strncmp("version", pSource + o + 1, 7) == 0)) {
      // Jumpt to end of lines (will consume multiple successive blank lines, but that doesn't matter)
      while (pSource[o] != '\0' && pSource[o] != '\n') { o++; }
      while (pSource[o] != '\0' && (pSource[o] == '\n' || pSource[o] == '\r')) { o++; }
      source.emplace_back(pSource, pSource + o);
      source.emplace_back(pSource + o);
    }
  }
  if (source.empty()) {
    source.push_back(pSource);
  }
 
  if (!definitions.empty()) {
    std::string tail = std::move(source.back());
    source.pop_back();
    for (const PreprocessorDefinition& def : definitions) {
      source.emplace_back("#define " + def.first + " " + def.second + "\n");
    }
    source.emplace_back(std::move(tail));
  }
 
  std::vector<const char*> strings(source.size());
  for (size_t i = 0, n = source.size(); i < n; i++) {
    strings[i] = source[i].c_str();
  }
 
  glShaderSource(shaderId, static_cast<GLsizei>(strings.size()), strings.data(), NULL);
  glCompileShader(shaderId);
 
  return shaderId;
}
 
 
EffectHandle Cogs::EffectsGLES30::loadEffect(const char * pVertexSource, const char * pFragmentSource, const PreprocessorDefinitions & definitions, EffectFlags::EEffectFlags effectFlags)
{
  EffectGLES30 program{};
 
  std::vector<char> buffer;
 
  GLuint programId = glCreateProgram();
  if (programId == 0) {
    LOG_ERROR(logger, "loadEffect: glCreateProgram failed.");
    return EffectHandle::InvalidHandle;
  }
  program.programId = programId;
 
  GLint vertexShader = loadShader(GL_VERTEX_SHADER, pVertexSource, definitions);
  GLint pixelShader = loadShader(GL_FRAGMENT_SHADER, pFragmentSource, definitions);
  glAttachShader(programId, vertexShader);
  glAttachShader(programId, pixelShader);
  glLinkProgram(programId);
 
  GLint linkStatus = GL_FALSE;
  glGetProgramiv(programId, GL_LINK_STATUS, &linkStatus);
  if (linkStatus != GL_TRUE) {
    printShaderError(GL_VERTEX_SHADER, vertexShader, effectFlags);
    printShaderError(GL_FRAGMENT_SHADER, pixelShader, effectFlags);
    printProgramError(programId);
 
    glDeleteShader(vertexShader);
    glDeleteShader(pixelShader);
    glDeleteProgram(programId);
 
    LOG_ERROR(logger, "loadEffect: Failed to link shader program.");
    return EffectHandle::InvalidHandle;
  }
  else {
 
    if ((effectFlags & EffectFlags::EEffectFlags::LogShaderInfo) == EffectFlags::EEffectFlags::LogShaderInfo) {
      printShaderSource(vertexShader);
      printShaderSource(pixelShader);
    }
 
    printShaderError(GL_VERTEX_SHADER, vertexShader, effectFlags);
    printShaderError(GL_FRAGMENT_SHADER, pixelShader, effectFlags);
  }
  glDeleteShader(vertexShader);             // ref kept until program is deleted
  glDeleteShader(pixelShader);              // ref kept until program is deleted
 
 
  GLint activeAttributes = 0;
  glGetProgramiv(programId, GL_ACTIVE_ATTRIBUTES, &activeAttributes);
 
  GLint attributeMaxLength = 0;
  glGetProgramiv(programId, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, &attributeMaxLength);
 
 
  GLint activeUniforms = 0;
  glGetProgramiv(programId, GL_ACTIVE_UNIFORMS, &activeUniforms);
 
  GLint activeUniformBlocks = 0;
  glGetProgramiv(programId, GL_ACTIVE_UNIFORM_BLOCKS, &activeUniformBlocks);
 
  LOG_DEBUG(logger, "Built GLSL program id: %d (active attribs=%d, uniforms=%d, blocks=%d)", programId, activeAttributes, activeUniforms, activeUniformBlocks);
 
  buffer.resize(attributeMaxLength);
  for (int i = 0; i < activeAttributes; ++i) {
    GLsizei length = 0;
    GLint size = 0;
    GLenum type = GL_INVALID_ENUM;
 
    glGetActiveAttrib(programId, static_cast<GLsizei>(i), static_cast<GLsizei>(buffer.size()), &length, &size, &type, buffer.data());
 
    const char* beg = buffer.data();
    const char* end = beg + attributeMaxLength;
 
    // Find end of semantic name
    ElementSemantic semantic = ElementSemantic::Semantic_Size;
    const char* ptr = beg;
    while ((ptr < end) && (*ptr != '\0') && ((*ptr < '0') || ('9' < *ptr))) { ptr++; }
 
    StringView semanticName(beg, ptr - beg);
    switch (Cogs::hash(semanticName)) {
    case Cogs::hash("gl_VertexID"):       semantic = ElementSemantic::Semantic_Size; break;
    case Cogs::hash("gl_InstanceID"):     semantic = ElementSemantic::Semantic_Size; break;
    case Cogs::hash("gl_ViewID_OVR"):     semantic = ElementSemantic::Semantic_Size; break;
    case Cogs::hash("a_POSITION"):        semantic = ElementSemantic::Position; break;
    case Cogs::hash("a_NORMAL"):          semantic = ElementSemantic::Normal; break;
    case Cogs::hash("a_COLOR"):           semantic = ElementSemantic::Color; break;
    case Cogs::hash("a_TEXCOORD"):        semantic = ElementSemantic::TextureCoordinate; break;
    case Cogs::hash("a_TANGENT"):         semantic = ElementSemantic::Tangent; break;
    case Cogs::hash("a_INSTANCEVECTOR"):  semantic = ElementSemantic::InstanceVector; break;
    case Cogs::hash("a_INSTANCEMATRIX"):  semantic = ElementSemantic::InstanceMatrix; break;
    default:
      LOG_ERROR(logger, "Unrecognized attribute name '%.*s'", StringViewFormat(semanticName));
      glDeleteProgram(programId);
      return EffectHandle::InvalidHandle;
    }
    if (semantic == ElementSemantic::Semantic_Size) {
      if ((effectFlags & EffectFlags::EEffectFlags::LogShaderInfo) == EffectFlags::EEffectFlags::LogShaderInfo) {
        LOG_DEBUG(logger, "Attrib -: name=%s type=%s", buffer.data(), getGLTypeName(type));
      }
      // built-in attribute, skip
      continue;
    }
 
    program.attributeSemantic[i].semantic = uint8_t(semantic);
 
    // Find end of slot number
    uint32_t slot = 0;
    while ((ptr < end) && (*ptr != '\0') && ('0' <= *ptr) && (*ptr <= '9')) { slot = 10 * slot + uint32_t(*ptr - '0'); ptr++; }
    if (255 < slot) {
      LOG_ERROR(logger, "Invalid attribute slot index %u in name '%s'", slot, buffer.data());
      glDeleteProgram(programId);
      return EffectHandle::InvalidHandle;
    }
    if (*ptr != '\0') {
      LOG_ERROR(logger, "Unrecognized characters after attribute index in name '%s'", buffer.data());
      glDeleteProgram(programId);
      return EffectHandle::InvalidHandle;
    }
    program.attributeSemantic[i].slot = uint8_t(slot);
 
    const GLint location = glGetAttribLocation(programId, buffer.data());
    if (location < 0 || 0xffff < location) {
      LOG_ERROR(logger, "Invalid attribute location %d, assumptions broken", location);
      glDeleteProgram(programId);
      return EffectHandle::InvalidHandle;
    }
    program.attributeLocation[i] = location;
 
    if ((effectFlags & EffectFlags::EEffectFlags::LogShaderInfo) == EffectFlags::EEffectFlags::LogShaderInfo) {
      LOG_DEBUG(logger, "Attrib %d: name=%s type=%s semantic=%.*s::%u", location, buffer.data(), getGLTypeName(type), StringViewFormat(getElementSemanticName(semantic)), slot);
    }
  }
  program.activeAttributes = static_cast<uint8_t>(std::max(0, activeAttributes));
 
  GLint uniformMaxLength = 0;
  glGetProgramiv(programId, GL_ACTIVE_UNIFORM_MAX_LENGTH, &uniformMaxLength);
 
  // Switch to newly built program so we can use glUniform-calls.
  // But first query currently bound program so we can restore it.
  GLint currentProgram = 0;
  glGetIntegerv(GL_CURRENT_PROGRAM, &currentProgram);
  glUseProgram(program.programId);
 
  size_t allocatedTexUnits = 0;
  buffer.resize(uniformMaxLength);
  for (int i = 0; i < activeUniforms; i++) {
    GLsizei length = 0;
    GLint size = 0;
    GLenum type = GL_INVALID_ENUM;
    glGetActiveUniform(programId, static_cast<GLsizei>(i), static_cast<GLsizei>(buffer.size()), &length, &size, &type, buffer.data());
 
    const GLint location = glGetUniformLocation(programId, buffer.data());
    if (0 <= location) {
      bool isActiveSampler = false;
      switch (type) {
      case GL_SAMPLER_2D: isActiveSampler = true; break;
      case GL_SAMPLER_3D: isActiveSampler = true; break;
      case GL_SAMPLER_CUBE: isActiveSampler = true; break;
      case GL_SAMPLER_2D_SHADOW: isActiveSampler = true; break;
      case GL_SAMPLER_2D_ARRAY: isActiveSampler = true; break;
      case GL_SAMPLER_2D_ARRAY_SHADOW: isActiveSampler = true; break;
      case GL_SAMPLER_CUBE_SHADOW: isActiveSampler = true; break;
      case GL_INT_SAMPLER_2D: isActiveSampler = true; break;
      case GL_INT_SAMPLER_3D: isActiveSampler = true; break;
      case GL_INT_SAMPLER_CUBE: isActiveSampler = true; break;
      case GL_INT_SAMPLER_2D_ARRAY: isActiveSampler = true; break;
      case GL_UNSIGNED_INT_SAMPLER_2D: isActiveSampler = true; break;
      case GL_UNSIGNED_INT_SAMPLER_3D: isActiveSampler = true; break;
      case GL_UNSIGNED_INT_SAMPLER_CUBE: isActiveSampler = true; break;
      case GL_UNSIGNED_INT_SAMPLER_2D_ARRAY: isActiveSampler = true; break;
      default: break;
      }
      if (isActiveSampler) {
 
        size_t unit = 0;
        if (allocatedTexUnits == OpenGLES30::maxTexUnits) {
          LOG_ERROR(logger, "Active texture units exceed OpenGLES30::maxTexUnits");
        }
        else {
          unit = allocatedTexUnits++;
          program.textureSlots[unit].nameHash = Cogs::hash(StringView(buffer.data()));
          glUniform1i(location, GLint(unit));
        }
        if ((effectFlags & EffectFlags::EEffectFlags::LogShaderInfo) == EffectFlags::EEffectFlags::LogShaderInfo) {
          LOG_DEBUG(logger, "Uniform %d: name=%s type=%s sampler unit=%zu", location, buffer.data(), getGLTypeName(type), unit);
        }
        continue;
      }
    }
 
    if ((effectFlags & EffectFlags::EEffectFlags::LogShaderInfo) == EffectFlags::EEffectFlags::LogShaderInfo) {
      LOG_DEBUG(logger, "Uniform %d: name=%s type=%s", location, buffer.data(), getGLTypeName(type));
    }
  }
  assert(allocatedTexUnits <= OpenGLES30::maxTexUnits);
  program.activeTextureUnits = static_cast<uint8_t>(allocatedTexUnits);
 
  // Query uniform block bindings.
  //
  // We currently just use the binding order determined by GL, we could become more clever
  // if we end up with a lot of buffer-switching at runtime.
  //
  {
    GLuint nextBinding = 1; // First binding slot for uniform blocks in use.
    std::memset(&program.uniformBlockBindings[0], 0, sizeof(program.uniformBlockBindings));
    for (GLuint activeBlockIndex = 0; GLint(activeBlockIndex) < activeUniformBlocks; activeBlockIndex++) {
      char uniformBlockNameChars[256] = {};
      GLsizei uniformBlockNameLength = 0;
      glGetActiveUniformBlockName(programId, activeBlockIndex, GLsizei(sizeof(uniformBlockNameChars)), &uniformBlockNameLength, uniformBlockNameChars);
      StringView uniformBlockName(uniformBlockNameChars, uniformBlockNameLength);
 
      GLint vRef = 0;
      glGetActiveUniformBlockiv(programId, activeBlockIndex, GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER, &vRef);
 
      GLint fRef = 0;
      glGetActiveUniformBlockiv(programId, activeBlockIndex, GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER, &fRef);
 
      // Not referenced by VS or FS, bind it to empty uniform buffer at slot 0.
      GLuint binding = 0; // Start at binding 1, 0 is reserved
      if (!uniformBlockName.empty() && (vRef != 0 || fRef != 0)) {
 
        binding = nextBinding++;
 
        size_t nameHash = Cogs::hash(uniformBlockName);
        assert(nameHash);
        program.uniformBlockBindings[binding].nameHash = nameHash;
      }
      glUniformBlockBinding(programId, activeBlockIndex, binding);
 
      if ((effectFlags & EffectFlags::EEffectFlags::LogShaderInfo) == EffectFlags::EEffectFlags::LogShaderInfo) {
        GLint dataSize = 0;
        glGetActiveUniformBlockiv(programId, activeBlockIndex, GL_UNIFORM_BLOCK_DATA_SIZE, &dataSize);
 
        LOG_DEBUG(logger, "block %d: bind=%d size=%5d %c%c name='%.*s'", activeBlockIndex, binding, dataSize, vRef ? 'V' : ' ', fRef ? 'F' : ' ', StringViewFormat(uniformBlockName));
      }
    }
  }
  if ((effectFlags & EffectFlags::EEffectFlags::LogShaderInfo) == EffectFlags::EEffectFlags::LogShaderInfo) {
    LOG_DEBUG(logger, "Loaded GLSL program id: %d", programId);
  }
 
  glUseProgram(currentProgram); // Restore ppreviously bound program
 
  if (delayFrames) {
    program.readyAtFrame = currentFrame + delayFrames;
    if (program.readyAtFrame > allEffectsReadyFrame) allEffectsReadyFrame = program.readyAtFrame;
  }
 
  return effects.addResource(program);
}
 
EffectHandle Cogs::EffectsGLES30::loadComputeEffect(const StringView & /*fileName*/, EffectFlags::EEffectFlags /*effectFlags*/)
{
  LOG_ERROR(logger, "loadComputeEffect: compute shaders not supported");
  return EffectHandle::InvalidHandle;
}
 
EffectHandle Cogs::EffectsGLES30::loadComputeEffect(const StringView & /*fileName*/, const PreprocessorDefinitions& /*definitions*/, EffectFlags::EEffectFlags /*effectFlags*/)
{
  LOG_ERROR(logger, "loadComputeEffect: compute shaders not supported");
  return EffectHandle::InvalidHandle;
}
 
Cogs::TextureBindingHandle Cogs::EffectsGLES30::getTextureBinding(EffectHandle effectHandle, const StringView & name, const unsigned int /*slot*/)
{
  if (!HandleIsValid(effectHandle) || name.empty()) {
    return TextureBindingHandle::NoHandle;  // Invalid effect or empty name.
  }
 
  const size_t nameHash = Cogs::hash(name);
  const EffectGLES30& effect = effects[effectHandle];
  for (size_t i = 0; i < effect.activeTextureUnits; i++) {
    if (effect.textureSlots[i].nameHash == nameHash) {
      return TextureBindingHandle(i + 1);
    }
  }
  return TextureBindingHandle::NoHandle;  // Name not recognized.
}
 
Cogs::SamplerStateBindingHandle Cogs::EffectsGLES30::getSamplerStateBinding(EffectHandle effectHandle, const StringView & name, const unsigned int /*slot*/)
{
  const char suffix[] = "Sampler";
  constexpr size_t suffixLength = sizeof(suffix) - 1;
  if (HandleIsValid(effectHandle)) {
    const EffectGLES30& effect = effects[effectHandle];
 
    // Try with naming scheme
    if ((suffixLength < name.length()) &&
        (std::memcmp(name.data() + name.size() - suffixLength, suffix, suffixLength) == 0))
    {
      const size_t nameHash = Cogs::hash(name.substr(0, name.length() - suffixLength));
      for (size_t i = 0; i < effect.activeTextureUnits; i++) {
        if (effect.textureSlots[i].nameHash == nameHash) {
          return SamplerStateBindingHandle(i + 1);
        }
      }
    }
  }
 
  return SamplerStateBindingHandle::NoHandle; // Name not recognized
}
 
void Cogs::EffectsGLES30::initialize(ContextGLES30* context, uint32_t delayFrames)
{
  this->context = context;
  this->delayFrames = delayFrames;
  EffectsCommon::initialize(buffers);
}
 
Cogs::ResourceStatus Cogs::EffectsGLES30::checkEffect(EffectHandle effectHandle)
{
  if (!HandleIsValid(effectHandle)) return ResourceStatus::Error;
  if (delayFrames == 0) return ResourceStatus::Ready; // Simulation disabled: skip frame comparison and overflow concerns entirely.
 
  return currentFrame < effects[effectHandle].readyAtFrame ? ResourceStatus::Pending : ResourceStatus::Ready;
}
 
Cogs::EffectVariableHandle Cogs::EffectsGLES30::getEffectVariable(EffectHandle effectHandle, const StringView & name)
{
  if (!HandleIsValid(effectHandle)) return EffectVariableHandle::NoHandle;
 
  const GLint programId = effects[effectHandle].programId;
  const GLint location = glGetUniformLocation(programId, name.data());
  if(location == -1) return EffectVariableHandle::NoHandle;
 
  EffectVariableHandle handle(programId << 16 | location);
  return handle;
}
 
Cogs::ConstantBufferBindingHandle Cogs::EffectsGLES30::getConstantBufferBinding(EffectHandle effectHandle, const StringView & name)
{
  if (name.empty()) {
    return Cogs::ConstantBufferBindingHandle::InvalidHandle;
  }
  if (!HandleIsValid(effectHandle)) {
    LOG_ERROR_ONCE(logger, "getConstantBufferBinding: Invalid effect handle");
    return Cogs::ConstantBufferBindingHandle::InvalidHandle;
  }
  EffectGLES30& effect = effects[effectHandle];
 
  size_t nameHash = Cogs::hash(name);
  for (size_t index = 0; index < OpenGLES30::maxUniformBuffers; index++) {
    if (effect.uniformBlockBindings[index].nameHash == nameHash) {
      return ConstantBufferBindingHandle(size_t(index) + 1);
    }
  }
 
  return ConstantBufferBindingHandle::InvalidHandle;
}
 
EffectHandle Cogs::EffectsGLES30::load(const ProcessedContent & vsSource,
                                       const ProcessedContent& hsSource,
                                       const ProcessedContent& dsSource,
                                       const ProcessedContent& gsSource,
                                       const ProcessedContent& psSource,
                                       const StringView& vsEntryPoint,
                                       const StringView& hsEntryPoint,
                                       const StringView& dsEntryPoint,
                                       const StringView& gsEntryPoint,
                                       const StringView& psEntryPoint,
                                       const EffectDescription& desc)
{
  if (!hsSource.content.empty() || !dsSource.content.empty()) {
    LOG_ERROR(logger, "load: Tessellation shaders are not supported.");
    return EffectHandle::InvalidHandle;
  }
  if (!gsSource.content.empty()) {
    LOG_ERROR(logger, "load: Geometry shaders are not supported.");
    return EffectHandle::InvalidHandle;
  }
  if (!(vsEntryPoint.empty() || vsEntryPoint == "main") ||
      !(hsEntryPoint.empty() || hsEntryPoint == "main") ||
      !(dsEntryPoint.empty() || dsEntryPoint == "main") ||
      !(gsEntryPoint.empty() || gsEntryPoint == "main") ||
      !(psEntryPoint.empty() || psEntryPoint == "main"))
  {
    LOG_ERROR(logger, "load: Shader entry points not named main are not supported.");
    return EffectHandle::InvalidHandle;
  }
 
  return loadEffect(vsSource.content.c_str(), psSource.content.c_str(), desc.definitions, desc.flags);
}