kc3-lang/angle/src/libANGLE/Program.cpp

Branch : - branch - main - tag -

• Show log

  Commit

• Author : Jamie Madill
  Date : 2015-04-15 10:18:05
  Hash : 56c6e3cb
  Message : Micro-optimize ValidateDrawBase. This speeds up our draw call benchmark. BUG=angleproject:959 Change-Id: I9a916a6c344493cc96873ae5f4ec337c181dc487 Reviewed-on: https://chromium-review.googlesource.com/266026 Reviewed-by: Geoff Lang <geofflang@chromium.org> Reviewed-by: Brandon Jones <bajones@chromium.org> Tested-by: Jamie Madill <jmadill@chromium.org>

• src/libANGLE/Program.cpp

• //
  // Copyright (c) 2002-2014 The ANGLE Project Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  //
  
  // Program.cpp: Implements the gl::Program class. Implements GL program objects
  // and related functionality. [OpenGL ES 2.0.24] section 2.10.3 page 28.
  
  #include "libANGLE/Program.h"
  
  #include <algorithm>
  
  #include "common/debug.h"
  #include "common/platform.h"
  #include "common/utilities.h"
  #include "common/version.h"
  #include "compiler/translator/blocklayout.h"
  #include "libANGLE/Data.h"
  #include "libANGLE/ResourceManager.h"
  #include "libANGLE/features.h"
  #include "libANGLE/renderer/Renderer.h"
  #include "libANGLE/renderer/ProgramImpl.h"
  
  namespace gl
  {
  const char * const g_fakepath = "C:\\fakepath";
  
  namespace
  {
  
  unsigned int ParseAndStripArrayIndex(std::string* name)
  {
      unsigned int subscript = GL_INVALID_INDEX;
  
      // Strip any trailing array operator and retrieve the subscript
      size_t open = name->find_last_of('[');
      size_t close = name->find_last_of(']');
      if (open != std::string::npos && close == name->length() - 1)
      {
          subscript = atoi(name->substr(open + 1).c_str());
          name->erase(open);
      }
  
      return subscript;
  }
  
  }
  
  AttributeBindings::AttributeBindings()
  {
  }
  
  AttributeBindings::~AttributeBindings()
  {
  }
  
  InfoLog::InfoLog() : mInfoLog(NULL)
  {
  }
  
  InfoLog::~InfoLog()
  {
      delete[] mInfoLog;
  }
  
  
  int InfoLog::getLength() const
  {
      if (!mInfoLog)
      {
          return 0;
      }
      else
      {
         return strlen(mInfoLog) + 1;
      }
  }
  
  void InfoLog::getLog(GLsizei bufSize, GLsizei *length, char *infoLog)
  {
      int index = 0;
  
      if (bufSize > 0)
      {
          if (mInfoLog)
          {
              index = std::min(bufSize - 1, (int)strlen(mInfoLog));
              memcpy(infoLog, mInfoLog, index);
          }
  
          infoLog[index] = '\0';
      }
  
      if (length)
      {
          *length = index;
      }
  }
  
  // append a santized message to the program info log.
  // The D3D compiler includes a fake file path in some of the warning or error 
  // messages, so lets remove all occurrences of this fake file path from the log.
  void InfoLog::appendSanitized(const char *message)
  {
      std::string msg(message);
  
      size_t found;
      do
      {
          found = msg.find(g_fakepath);
          if (found != std::string::npos)
          {
              msg.erase(found, strlen(g_fakepath));
          }
      }
      while (found != std::string::npos);
  
      append("%s", msg.c_str());
  }
  
  void InfoLog::append(const char *format, ...)
  {
      if (!format)
      {
          return;
      }
  
      va_list vararg;
      va_start(vararg, format);
      size_t infoLength = vsnprintf(NULL, 0, format, vararg);
      va_end(vararg);
  
      char *logPointer = NULL;
  
      if (!mInfoLog)
      {
          mInfoLog = new char[infoLength + 2];
          logPointer = mInfoLog;
      }
      else
      {
          size_t currentlogLength = strlen(mInfoLog);
          char *newLog = new char[currentlogLength + infoLength + 2];
          strcpy(newLog, mInfoLog);
  
          delete[] mInfoLog;
          mInfoLog = newLog;
  
          logPointer = mInfoLog + currentlogLength;
      }
  
      va_start(vararg, format);
      vsnprintf(logPointer, infoLength, format, vararg);
      va_end(vararg);
  
      logPointer[infoLength] = 0;
      strcpy(logPointer + infoLength, "\n");
  }
  
  void InfoLog::reset()
  {
      if (mInfoLog)
      {
          delete [] mInfoLog;
          mInfoLog = NULL;
      }
  }
  
  VariableLocation::VariableLocation()
      : name(), element(0), index(0)
  {
  }
  
  VariableLocation::VariableLocation(const std::string &name, unsigned int element, unsigned int index)
      : name(name), element(element), index(index)
  {
  }
  
  LinkedVarying::LinkedVarying()
  {
  }
  
  LinkedVarying::LinkedVarying(const std::string &name, GLenum type, GLsizei size, const std::string &semanticName,
                               unsigned int semanticIndex, unsigned int semanticIndexCount)
      : name(name), type(type), size(size), semanticName(semanticName), semanticIndex(semanticIndex), semanticIndexCount(semanticIndexCount)
  {
  }
  
  Program::Program(rx::ProgramImpl *impl, ResourceManager *manager, GLuint handle)
      : mProgram(impl),
        mValidated(false),
        mTransformFeedbackVaryings(),
        mTransformFeedbackBufferMode(GL_NONE),
        mFragmentShader(NULL),
        mVertexShader(NULL),
        mLinked(false),
        mDeleteStatus(false),
        mRefCount(0),
        mResourceManager(manager),
        mHandle(handle)
  {
      ASSERT(mProgram);
  
      resetUniformBlockBindings();
      unlink();
  }
  
  Program::~Program()
  {
      unlink(true);
  
      if (mVertexShader != NULL)
      {
          mVertexShader->release();
      }
  
      if (mFragmentShader != NULL)
      {
          mFragmentShader->release();
      }
  
      SafeDelete(mProgram);
  }
  
  bool Program::attachShader(Shader *shader)
  {
      if (shader->getType() == GL_VERTEX_SHADER)
      {
          if (mVertexShader)
          {
              return false;
          }
  
          mVertexShader = shader;
          mVertexShader->addRef();
      }
      else if (shader->getType() == GL_FRAGMENT_SHADER)
      {
          if (mFragmentShader)
          {
              return false;
          }
  
          mFragmentShader = shader;
          mFragmentShader->addRef();
      }
      else UNREACHABLE();
  
      return true;
  }
  
  bool Program::detachShader(Shader *shader)
  {
      if (shader->getType() == GL_VERTEX_SHADER)
      {
          if (mVertexShader != shader)
          {
              return false;
          }
  
          mVertexShader->release();
          mVertexShader = NULL;
      }
      else if (shader->getType() == GL_FRAGMENT_SHADER)
      {
          if (mFragmentShader != shader)
          {
              return false;
          }
  
          mFragmentShader->release();
          mFragmentShader = NULL;
      }
      else UNREACHABLE();
  
      return true;
  }
  
  int Program::getAttachedShadersCount() const
  {
      return (mVertexShader ? 1 : 0) + (mFragmentShader ? 1 : 0);
  }
  
  void AttributeBindings::bindAttributeLocation(GLuint index, const char *name)
  {
      if (index < MAX_VERTEX_ATTRIBS)
      {
          for (int i = 0; i < MAX_VERTEX_ATTRIBS; i++)
          {
              mAttributeBinding[i].erase(name);
          }
  
          mAttributeBinding[index].insert(name);
      }
  }
  
  void Program::bindAttributeLocation(GLuint index, const char *name)
  {
      mAttributeBindings.bindAttributeLocation(index, name);
  }
  
  // Links the HLSL code of the vertex and pixel shader by matching up their varyings,
  // compiling them into binaries, determining the attribute mappings, and collecting
  // a list of uniforms
  Error Program::link(const Data &data)
  {
      unlink(false);
  
      mInfoLog.reset();
      resetUniformBlockBindings();
  
      if (!mFragmentShader || !mFragmentShader->isCompiled())
      {
          return Error(GL_NO_ERROR);
      }
      ASSERT(mFragmentShader->getType() == GL_FRAGMENT_SHADER);
  
      if (!mVertexShader || !mVertexShader->isCompiled())
      {
          return Error(GL_NO_ERROR);
      }
      ASSERT(mVertexShader->getType() == GL_VERTEX_SHADER);
  
      if (!linkAttributes(mInfoLog, mAttributeBindings, mVertexShader))
      {
          return Error(GL_NO_ERROR);
      }
  
      int registers;
      std::vector<LinkedVarying> linkedVaryings;
      rx::LinkResult result = mProgram->link(data, mInfoLog, mFragmentShader, mVertexShader, mTransformFeedbackVaryings, mTransformFeedbackBufferMode,
                                             &registers, &linkedVaryings, &mOutputVariables);
      if (result.error.isError() || !result.linkSuccess)
      {
          return result.error;
      }
  
      if (!mProgram->linkUniforms(mInfoLog, *mVertexShader, *mFragmentShader, *data.caps))
      {
          return Error(GL_NO_ERROR);
      }
  
      if (!linkUniformBlocks(mInfoLog, *mVertexShader, *mFragmentShader, *data.caps))
      {
          return Error(GL_NO_ERROR);
      }
  
      if (!gatherTransformFeedbackLinkedVaryings(mInfoLog, linkedVaryings, mTransformFeedbackVaryings,
                                                 mTransformFeedbackBufferMode, &mProgram->getTransformFeedbackLinkedVaryings(), *data.caps))
      {
          return Error(GL_NO_ERROR);
      }
  
      // TODO: The concept of "executables" is D3D only, and as such this belongs in ProgramD3D. It must be called,
      // however, last in this function, so it can't simply be moved to ProgramD3D::link without further shuffling.
      result = mProgram->compileProgramExecutables(mInfoLog, mFragmentShader, mVertexShader, registers);
      if (result.error.isError() || !result.linkSuccess)
      {
          mInfoLog.append("Failed to create D3D shaders.");
          unlink(false);
          return result.error;
      }
  
      mLinked = true;
      return gl::Error(GL_NO_ERROR);
  }
  
  int AttributeBindings::getAttributeBinding(const std::string &name) const
  {
      for (int location = 0; location < MAX_VERTEX_ATTRIBS; location++)
      {
          if (mAttributeBinding[location].find(name) != mAttributeBinding[location].end())
          {
              return location;
          }
      }
  
      return -1;
  }
  
  // Returns the program object to an unlinked state, before re-linking, or at destruction
  void Program::unlink(bool destroy)
  {
      if (destroy)   // Object being destructed
      {
          if (mFragmentShader)
          {
              mFragmentShader->release();
              mFragmentShader = NULL;
          }
  
          if (mVertexShader)
          {
              mVertexShader->release();
              mVertexShader = NULL;
          }
      }
  
      std::fill(mLinkedAttribute, mLinkedAttribute + ArraySize(mLinkedAttribute), sh::Attribute());
      mOutputVariables.clear();
  
      mProgram->reset();
  
      mValidated = false;
  
      mLinked = false;
  }
  
  bool Program::isLinked()
  {
      return mLinked;
  }
  
  Error Program::loadBinary(GLenum binaryFormat, const void *binary, GLsizei length)
  {
      unlink(false);
  
  #if ANGLE_PROGRAM_BINARY_LOAD != ANGLE_ENABLED
      return Error(GL_NO_ERROR);
  #else
      ASSERT(binaryFormat == mProgram->getBinaryFormat());
  
      BinaryInputStream stream(binary, length);
  
      GLenum format = stream.readInt<GLenum>();
      if (format != mProgram->getBinaryFormat())
      {
          mInfoLog.append("Invalid program binary format.");
          return Error(GL_NO_ERROR);
      }
  
      int majorVersion = stream.readInt<int>();
      int minorVersion = stream.readInt<int>();
      if (majorVersion != ANGLE_MAJOR_VERSION || minorVersion != ANGLE_MINOR_VERSION)
      {
          mInfoLog.append("Invalid program binary version.");
          return Error(GL_NO_ERROR);
      }
  
      unsigned char commitString[ANGLE_COMMIT_HASH_SIZE];
      stream.readBytes(commitString, ANGLE_COMMIT_HASH_SIZE);
      if (memcmp(commitString, ANGLE_COMMIT_HASH, sizeof(unsigned char) * ANGLE_COMMIT_HASH_SIZE) != 0)
      {
          mInfoLog.append("Invalid program binary version.");
          return Error(GL_NO_ERROR);
      }
  
      for (int i = 0; i < MAX_VERTEX_ATTRIBS; ++i)
      {
          stream.readInt(&mLinkedAttribute[i].type);
          stream.readString(&mLinkedAttribute[i].name);
          stream.readInt(&mProgram->getShaderAttributes()[i].type);
          stream.readString(&mProgram->getShaderAttributes()[i].name);
          stream.readInt(&mProgram->getSemanticIndexes()[i]);
      }
  
      rx::LinkResult result = mProgram->load(mInfoLog, &stream);
      if (result.error.isError() || !result.linkSuccess)
      {
          return result.error;
      }
  
      mLinked = true;
      return Error(GL_NO_ERROR);
  #endif // #if ANGLE_PROGRAM_BINARY_LOAD == ANGLE_ENABLED
  }
  
  Error Program::saveBinary(GLenum *binaryFormat, void *binary, GLsizei bufSize, GLsizei *length) const
  {
      if (binaryFormat)
      {
          *binaryFormat = mProgram->getBinaryFormat();
      }
  
      BinaryOutputStream stream;
  
      stream.writeInt(mProgram->getBinaryFormat());
      stream.writeInt(ANGLE_MAJOR_VERSION);
      stream.writeInt(ANGLE_MINOR_VERSION);
      stream.writeBytes(reinterpret_cast<const unsigned char*>(ANGLE_COMMIT_HASH), ANGLE_COMMIT_HASH_SIZE);
  
      for (unsigned int i = 0; i < MAX_VERTEX_ATTRIBS; ++i)
      {
          stream.writeInt(mLinkedAttribute[i].type);
          stream.writeString(mLinkedAttribute[i].name);
          stream.writeInt(mProgram->getShaderAttributes()[i].type);
          stream.writeString(mProgram->getShaderAttributes()[i].name);
          stream.writeInt(mProgram->getSemanticIndexes()[i]);
      }
  
      gl::Error error = mProgram->save(&stream);
      if (error.isError())
      {
          return error;
      }
  
      GLsizei streamLength = stream.length();
      const void *streamData = stream.data();
  
      if (streamLength > bufSize)
      {
          if (length)
          {
              *length = 0;
          }
  
          // TODO: This should be moved to the validation layer but computing the size of the binary before saving
          // it causes the save to happen twice.  It may be possible to write the binary to a separate buffer, validate
          // sizes and then copy it.
          return Error(GL_INVALID_OPERATION);
      }
  
      if (binary)
      {
          char *ptr = reinterpret_cast<char*>(binary);
  
          memcpy(ptr, streamData, streamLength);
          ptr += streamLength;
  
          ASSERT(ptr - streamLength == binary);
      }
  
      if (length)
      {
          *length = streamLength;
      }
  
      return Error(GL_NO_ERROR);
  }
  
  GLint Program::getBinaryLength() const
  {
      GLint length;
      Error error = saveBinary(NULL, NULL, std::numeric_limits<GLint>::max(), &length);
      if (error.isError())
      {
          return 0;
      }
  
      return length;
  }
  
  void Program::release()
  {
      mRefCount--;
  
      if (mRefCount == 0 && mDeleteStatus)
      {
          mResourceManager->deleteProgram(mHandle);
      }
  }
  
  void Program::addRef()
  {
      mRefCount++;
  }
  
  unsigned int Program::getRefCount() const
  {
      return mRefCount;
  }
  
  int Program::getInfoLogLength() const
  {
      return mInfoLog.getLength();
  }
  
  void Program::getInfoLog(GLsizei bufSize, GLsizei *length, char *infoLog)
  {
      return mInfoLog.getLog(bufSize, length, infoLog);
  }
  
  void Program::getAttachedShaders(GLsizei maxCount, GLsizei *count, GLuint *shaders)
  {
      int total = 0;
  
      if (mVertexShader)
      {
          if (total < maxCount)
          {
              shaders[total] = mVertexShader->getHandle();
          }
  
          total++;
      }
  
      if (mFragmentShader)
      {
          if (total < maxCount)
          {
              shaders[total] = mFragmentShader->getHandle();
          }
  
          total++;
      }
  
      if (count)
      {
          *count = total;
      }
  }
  
  GLuint Program::getAttributeLocation(const std::string &name)
  {
      for (int index = 0; index < MAX_VERTEX_ATTRIBS; index++)
      {
          if (mLinkedAttribute[index].name == name)
          {
              return index;
          }
      }
  
      return static_cast<GLuint>(-1);
  }
  
  const int *Program::getSemanticIndexes() const
  {
      return mProgram->getSemanticIndexes();
  }
  
  int Program::getSemanticIndex(int attributeIndex)
  {
      ASSERT(attributeIndex >= 0 && attributeIndex < MAX_VERTEX_ATTRIBS);
  
      return mProgram->getSemanticIndexes()[attributeIndex];
  }
  
  void Program::getActiveAttribute(GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
  {
      if (mLinked)
      {
          // Skip over inactive attributes
          unsigned int activeAttribute = 0;
          unsigned int attribute;
          for (attribute = 0; attribute < MAX_VERTEX_ATTRIBS; attribute++)
          {
              if (mLinkedAttribute[attribute].name.empty())
              {
                  continue;
              }
  
              if (activeAttribute == index)
              {
                  break;
              }
  
              activeAttribute++;
          }
  
          if (bufsize > 0)
          {
              const char *string = mLinkedAttribute[attribute].name.c_str();
  
              strncpy(name, string, bufsize);
              name[bufsize - 1] = '\0';
  
              if (length)
              {
                  *length = strlen(name);
              }
          }
  
          *size = 1;   // Always a single 'type' instance
  
          *type = mLinkedAttribute[attribute].type;
      }
      else
      {
          if (bufsize > 0)
          {
              name[0] = '\0';
          }
  
          if (length)
          {
              *length = 0;
          }
  
          *type = GL_NONE;
          *size = 1;
      }
  }
  
  GLint Program::getActiveAttributeCount()
  {
      int count = 0;
  
      if (mLinked)
      {
          for (int attributeIndex = 0; attributeIndex < MAX_VERTEX_ATTRIBS; attributeIndex++)
          {
              if (!mLinkedAttribute[attributeIndex].name.empty())
              {
                  count++;
              }
          }
      }
  
      return count;
  }
  
  GLint Program::getActiveAttributeMaxLength()
  {
      int maxLength = 0;
  
      if (mLinked)
      {
          for (int attributeIndex = 0; attributeIndex < MAX_VERTEX_ATTRIBS; attributeIndex++)
          {
              if (!mLinkedAttribute[attributeIndex].name.empty())
              {
                  maxLength = std::max((int)(mLinkedAttribute[attributeIndex].name.length() + 1), maxLength);
              }
          }
      }
  
      return maxLength;
  }
  
  // Returns one more than the highest sampler index used.
  GLint Program::getUsedSamplerRange(SamplerType type)
  {
      return mProgram->getUsedSamplerRange(type);
  }
  
  bool Program::usesPointSize() const
  {
      return mProgram->usesPointSize();
  }
  
  GLint Program::getSamplerMapping(SamplerType type, unsigned int samplerIndex, const Caps &caps)
  {
      return mProgram->getSamplerMapping(type, samplerIndex, caps);
  }
  
  GLenum Program::getSamplerTextureType(SamplerType type, unsigned int samplerIndex)
  {
      return mProgram->getSamplerTextureType(type, samplerIndex);
  }
  
  GLint Program::getFragDataLocation(const std::string &name) const
  {
      std::string baseName(name);
      unsigned int arrayIndex = ParseAndStripArrayIndex(&baseName);
      for (auto locationIt = mOutputVariables.begin(); locationIt != mOutputVariables.end(); locationIt++)
      {
          const VariableLocation &outputVariable = locationIt->second;
          if (outputVariable.name == baseName && (arrayIndex == GL_INVALID_INDEX || arrayIndex == outputVariable.element))
          {
              return static_cast<GLint>(locationIt->first);
          }
      }
      return -1;
  }
  
  void Program::getActiveUniform(GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
  {
      if (mLinked)
      {
          ASSERT(index < mProgram->getUniforms().size());   // index must be smaller than getActiveUniformCount()
          LinkedUniform *uniform = mProgram->getUniforms()[index];
  
          if (bufsize > 0)
          {
              std::string string = uniform->name;
              if (uniform->isArray())
              {
                  string += "[0]";
              }
  
              strncpy(name, string.c_str(), bufsize);
              name[bufsize - 1] = '\0';
  
              if (length)
              {
                  *length = strlen(name);
              }
          }
  
          *size = uniform->elementCount();
          *type = uniform->type;
      }
      else
      {
          if (bufsize > 0)
          {
              name[0] = '\0';
          }
  
          if (length)
          {
              *length = 0;
          }
  
          *size = 0;
          *type = GL_NONE;
      }
  }
  
  GLint Program::getActiveUniformCount()
  {
      if (mLinked)
      {
          return mProgram->getUniforms().size();
      }
      else
      {
          return 0;
      }
  }
  
  GLint Program::getActiveUniformMaxLength()
  {
      int maxLength = 0;
  
      if (mLinked)
      {
          unsigned int numUniforms = mProgram->getUniforms().size();
          for (unsigned int uniformIndex = 0; uniformIndex < numUniforms; uniformIndex++)
          {
              if (!mProgram->getUniforms()[uniformIndex]->name.empty())
              {
                  int length = (int)(mProgram->getUniforms()[uniformIndex]->name.length() + 1);
                  if (mProgram->getUniforms()[uniformIndex]->isArray())
                  {
                      length += 3;  // Counting in "[0]".
                  }
                  maxLength = std::max(length, maxLength);
              }
          }
      }
  
      return maxLength;
  }
  
  GLint Program::getActiveUniformi(GLuint index, GLenum pname) const
  {
      const gl::LinkedUniform& uniform = *mProgram->getUniforms()[index];
      switch (pname)
      {
        case GL_UNIFORM_TYPE:         return static_cast<GLint>(uniform.type);
        case GL_UNIFORM_SIZE:         return static_cast<GLint>(uniform.elementCount());
        case GL_UNIFORM_NAME_LENGTH:  return static_cast<GLint>(uniform.name.size() + 1 + (uniform.isArray() ? 3 : 0));
        case GL_UNIFORM_BLOCK_INDEX:  return uniform.blockIndex;
        case GL_UNIFORM_OFFSET:       return uniform.blockInfo.offset;
        case GL_UNIFORM_ARRAY_STRIDE: return uniform.blockInfo.arrayStride;
        case GL_UNIFORM_MATRIX_STRIDE: return uniform.blockInfo.matrixStride;
        case GL_UNIFORM_IS_ROW_MAJOR: return static_cast<GLint>(uniform.blockInfo.isRowMajorMatrix);
        default:
          UNREACHABLE();
          break;
      }
      return 0;
  }
  
  bool Program::isValidUniformLocation(GLint location) const
  {
      ASSERT(rx::IsIntegerCastSafe<GLint>(mProgram->getUniformIndices().size()));
      return (location >= 0 && location < static_cast<GLint>(mProgram->getUniformIndices().size()));
  }
  
  LinkedUniform *Program::getUniformByLocation(GLint location) const
  {
      return mProgram->getUniformByLocation(location);
  }
  
  LinkedUniform *Program::getUniformByName(const std::string &name) const
  {
      return mProgram->getUniformByName(name);
  }
  
  GLint Program::getUniformLocation(const std::string &name)
  {
      return mProgram->getUniformLocation(name);
  }
  
  GLuint Program::getUniformIndex(const std::string &name)
  {
      return mProgram->getUniformIndex(name);
  }
  
  void Program::setUniform1fv(GLint location, GLsizei count, const GLfloat *v)
  {
      mProgram->setUniform1fv(location, count, v);
  }
  
  void Program::setUniform2fv(GLint location, GLsizei count, const GLfloat *v)
  {
      mProgram->setUniform2fv(location, count, v);
  }
  
  void Program::setUniform3fv(GLint location, GLsizei count, const GLfloat *v)
  {
      mProgram->setUniform3fv(location, count, v);
  }
  
  void Program::setUniform4fv(GLint location, GLsizei count, const GLfloat *v)
  {
      mProgram->setUniform4fv(location, count, v);
  }
  
  void Program::setUniform1iv(GLint location, GLsizei count, const GLint *v)
  {
      mProgram->setUniform1iv(location, count, v);
  }
  
  void Program::setUniform2iv(GLint location, GLsizei count, const GLint *v)
  {
      mProgram->setUniform2iv(location, count, v);
  }
  
  void Program::setUniform3iv(GLint location, GLsizei count, const GLint *v)
  {
      mProgram->setUniform3iv(location, count, v);
  }
  
  void Program::setUniform4iv(GLint location, GLsizei count, const GLint *v)
  {
      mProgram->setUniform4iv(location, count, v);
  }
  
  void Program::setUniform1uiv(GLint location, GLsizei count, const GLuint *v)
  {
      mProgram->setUniform1uiv(location, count, v);
  }
  
  void Program::setUniform2uiv(GLint location, GLsizei count, const GLuint *v)
  {
      mProgram->setUniform2uiv(location, count, v);
  }
  
  void Program::setUniform3uiv(GLint location, GLsizei count, const GLuint *v)
  {
      mProgram->setUniform3uiv(location, count, v);
  }
  
  void Program::setUniform4uiv(GLint location, GLsizei count, const GLuint *v)
  {
      mProgram->setUniform4uiv(location, count, v);
  }
  
  void Program::setUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *v)
  {
      mProgram->setUniformMatrix2fv(location, count, transpose, v);
  }
  
  void Program::setUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *v)
  {
      mProgram->setUniformMatrix3fv(location, count, transpose, v);
  }
  
  void Program::setUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *v)
  {
      mProgram->setUniformMatrix4fv(location, count, transpose, v);
  }
  
  void Program::setUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *v)
  {
      mProgram->setUniformMatrix2x3fv(location, count, transpose, v);
  }
  
  void Program::setUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *v)
  {
      mProgram->setUniformMatrix2x4fv(location, count, transpose, v);
  }
  
  void Program::setUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *v)
  {
      mProgram->setUniformMatrix3x2fv(location, count, transpose, v);
  }
  
  void Program::setUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *v)
  {
      mProgram->setUniformMatrix3x4fv(location, count, transpose, v);
  }
  
  void Program::setUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *v)
  {
      mProgram->setUniformMatrix4x2fv(location, count, transpose, v);
  }
  
  void Program::setUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *v)
  {
      mProgram->setUniformMatrix4x3fv(location, count, transpose, v);
  }
  
  void Program::getUniformfv(GLint location, GLfloat *v)
  {
      mProgram->getUniformfv(location, v);
  }
  
  void Program::getUniformiv(GLint location, GLint *v)
  {
      mProgram->getUniformiv(location, v);
  }
  
  void Program::getUniformuiv(GLint location, GLuint *v)
  {
      mProgram->getUniformuiv(location, v);
  }
  
  // Applies all the uniforms set for this program object to the renderer
  Error Program::applyUniforms()
  {
      return mProgram->applyUniforms();
  }
  
  Error Program::applyUniformBuffers(const gl::Data &data)
  {
      return mProgram->applyUniformBuffers(data, mUniformBlockBindings);
  }
  
  void Program::flagForDeletion()
  {
      mDeleteStatus = true;
  }
  
  bool Program::isFlaggedForDeletion() const
  {
      return mDeleteStatus;
  }
  
  void Program::validate(const Caps &caps)
  {
      mInfoLog.reset();
      mValidated = false;
  
      if (mLinked)
      {
          applyUniforms();
          mValidated = mProgram->validateSamplers(&mInfoLog, caps);
      }
      else
      {
          mInfoLog.append("Program has not been successfully linked.");
      }
  }
  
  bool Program::validateSamplers(InfoLog *infoLog, const Caps &caps)
  {
      return mProgram->validateSamplers(infoLog, caps);
  }
  
  bool Program::isValidated() const
  {
      return mValidated;
  }
  
  void Program::updateSamplerMapping()
  {
      return mProgram->updateSamplerMapping();
  }
  
  GLuint Program::getActiveUniformBlockCount()
  {
      return mProgram->getUniformBlocks().size();
  }
  
  void Program::getActiveUniformBlockName(GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName) const
  {
      ASSERT(uniformBlockIndex < mProgram->getUniformBlocks().size());   // index must be smaller than getActiveUniformBlockCount()
  
      const UniformBlock &uniformBlock = *mProgram->getUniformBlocks()[uniformBlockIndex];
  
      if (bufSize > 0)
      {
          std::string string = uniformBlock.name;
  
          if (uniformBlock.isArrayElement())
          {
              string += ArrayString(uniformBlock.elementIndex);
          }
  
          strncpy(uniformBlockName, string.c_str(), bufSize);
          uniformBlockName[bufSize - 1] = '\0';
  
          if (length)
          {
              *length = strlen(uniformBlockName);
          }
      }
  }
  
  void Program::getActiveUniformBlockiv(GLuint uniformBlockIndex, GLenum pname, GLint *params) const
  {
      ASSERT(uniformBlockIndex < mProgram->getUniformBlocks().size());   // index must be smaller than getActiveUniformBlockCount()
  
      const UniformBlock &uniformBlock = *mProgram->getUniformBlocks()[uniformBlockIndex];
  
      switch (pname)
      {
        case GL_UNIFORM_BLOCK_DATA_SIZE:
          *params = static_cast<GLint>(uniformBlock.dataSize);
          break;
        case GL_UNIFORM_BLOCK_NAME_LENGTH:
          *params = static_cast<GLint>(uniformBlock.name.size() + 1 + (uniformBlock.isArrayElement() ? 3 : 0));
          break;
        case GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS:
          *params = static_cast<GLint>(uniformBlock.memberUniformIndexes.size());
          break;
        case GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES:
          {
              for (unsigned int blockMemberIndex = 0; blockMemberIndex < uniformBlock.memberUniformIndexes.size(); blockMemberIndex++)
              {
                  params[blockMemberIndex] = static_cast<GLint>(uniformBlock.memberUniformIndexes[blockMemberIndex]);
              }
          }
          break;
        case GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER:
          *params = static_cast<GLint>(uniformBlock.isReferencedByVertexShader());
          break;
        case GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER:
          *params = static_cast<GLint>(uniformBlock.isReferencedByFragmentShader());
          break;
        default: UNREACHABLE();
      }
  }
  
  GLint Program::getActiveUniformBlockMaxLength()
  {
      int maxLength = 0;
  
      if (mLinked)
      {
          unsigned int numUniformBlocks = mProgram->getUniformBlocks().size();
          for (unsigned int uniformBlockIndex = 0; uniformBlockIndex < numUniformBlocks; uniformBlockIndex++)
          {
              const UniformBlock &uniformBlock = *mProgram->getUniformBlocks()[uniformBlockIndex];
              if (!uniformBlock.name.empty())
              {
                  const int length = uniformBlock.name.length() + 1;
  
                  // Counting in "[0]".
                  const int arrayLength = (uniformBlock.isArrayElement() ? 3 : 0);
  
                  maxLength = std::max(length + arrayLength, maxLength);
              }
          }
      }
  
      return maxLength;
  }
  
  GLuint Program::getUniformBlockIndex(const std::string &name)
  {
      return mProgram->getUniformBlockIndex(name);
  }
  
  const UniformBlock *Program::getUniformBlockByIndex(GLuint index) const
  {
      return mProgram->getUniformBlockByIndex(index);
  }
  
  void Program::bindUniformBlock(GLuint uniformBlockIndex, GLuint uniformBlockBinding)
  {
      mUniformBlockBindings[uniformBlockIndex] = uniformBlockBinding;
  }
  
  GLuint Program::getUniformBlockBinding(GLuint uniformBlockIndex) const
  {
      return mUniformBlockBindings[uniformBlockIndex];
  }
  
  void Program::resetUniformBlockBindings()
  {
      for (unsigned int blockId = 0; blockId < IMPLEMENTATION_MAX_COMBINED_SHADER_UNIFORM_BUFFERS; blockId++)
      {
          mUniformBlockBindings[blockId] = 0;
      }
  }
  
  void Program::setTransformFeedbackVaryings(GLsizei count, const GLchar *const *varyings, GLenum bufferMode)
  {
      mTransformFeedbackVaryings.resize(count);
      for (GLsizei i = 0; i < count; i++)
      {
          mTransformFeedbackVaryings[i] = varyings[i];
      }
  
      mTransformFeedbackBufferMode = bufferMode;
  }
  
  void Program::getTransformFeedbackVarying(GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name) const
  {
      if (mLinked)
      {
          ASSERT(index < mProgram->getTransformFeedbackLinkedVaryings().size());
          const LinkedVarying &varying = mProgram->getTransformFeedbackLinkedVaryings()[index];
          GLsizei lastNameIdx = std::min(bufSize - 1, static_cast<GLsizei>(varying.name.length()));
          if (length)
          {
              *length = lastNameIdx;
          }
          if (size)
          {
              *size = varying.size;
          }
          if (type)
          {
              *type = varying.type;
          }
          if (name)
          {
              memcpy(name, varying.name.c_str(), lastNameIdx);
              name[lastNameIdx] = '\0';
          }
      }
  }
  
  GLsizei Program::getTransformFeedbackVaryingCount() const
  {
      if (mLinked)
      {
          return static_cast<GLsizei>(mProgram->getTransformFeedbackLinkedVaryings().size());
      }
      else
      {
          return 0;
      }
  }
  
  GLsizei Program::getTransformFeedbackVaryingMaxLength() const
  {
      if (mLinked)
      {
          GLsizei maxSize = 0;
          for (size_t i = 0; i < mProgram->getTransformFeedbackLinkedVaryings().size(); i++)
          {
              const LinkedVarying &varying = mProgram->getTransformFeedbackLinkedVaryings()[i];
              maxSize = std::max(maxSize, static_cast<GLsizei>(varying.name.length() + 1));
          }
  
          return maxSize;
      }
      else
      {
          return 0;
      }
  }
  
  GLenum Program::getTransformFeedbackBufferMode() const
  {
      return mTransformFeedbackBufferMode;
  }
  
  bool Program::linkVaryings(InfoLog &infoLog, Shader *fragmentShader, Shader *vertexShader)
  {
      std::vector<PackedVarying> &fragmentVaryings = fragmentShader->getVaryings();
      std::vector<PackedVarying> &vertexVaryings = vertexShader->getVaryings();
  
      for (size_t fragVaryingIndex = 0; fragVaryingIndex < fragmentVaryings.size(); fragVaryingIndex++)
      {
          PackedVarying *input = &fragmentVaryings[fragVaryingIndex];
          bool matched = false;
  
          // Built-in varyings obey special rules
          if (input->isBuiltIn())
          {
              continue;
          }
  
          for (size_t vertVaryingIndex = 0; vertVaryingIndex < vertexVaryings.size(); vertVaryingIndex++)
          {
              PackedVarying *output = &vertexVaryings[vertVaryingIndex];
              if (output->name == input->name)
              {
                  if (!linkValidateVaryings(infoLog, output->name, *input, *output))
                  {
                      return false;
                  }
  
                  output->registerIndex = input->registerIndex;
                  output->columnIndex = input->columnIndex;
  
                  matched = true;
                  break;
              }
          }
  
          // We permit unmatched, unreferenced varyings
          if (!matched && input->staticUse)
          {
              infoLog.append("Fragment varying %s does not match any vertex varying", input->name.c_str());
              return false;
          }
      }
  
      return true;
  }
  
  bool Program::linkValidateInterfaceBlockFields(InfoLog &infoLog, const std::string &uniformName, const sh::InterfaceBlockField &vertexUniform, const sh::InterfaceBlockField &fragmentUniform)
  {
      if (!linkValidateVariablesBase(infoLog, uniformName, vertexUniform, fragmentUniform, true))
      {
          return false;
      }
  
      if (vertexUniform.isRowMajorLayout != fragmentUniform.isRowMajorLayout)
      {
          infoLog.append("Matrix packings for %s differ between vertex and fragment shaders", uniformName.c_str());
          return false;
      }
  
      return true;
  }
  
  // Determines the mapping between GL attributes and Direct3D 9 vertex stream usage indices
  bool Program::linkAttributes(InfoLog &infoLog, const AttributeBindings &attributeBindings, const Shader *vertexShader)
  {
      unsigned int usedLocations = 0;
      const std::vector<sh::Attribute> &shaderAttributes = vertexShader->getActiveAttributes();
  
      // Link attributes that have a binding location
      for (unsigned int attributeIndex = 0; attributeIndex < shaderAttributes.size(); attributeIndex++)
      {
          const sh::Attribute &attribute = shaderAttributes[attributeIndex];
  
          ASSERT(attribute.staticUse);
  
          const int location = attribute.location == -1 ? attributeBindings.getAttributeBinding(attribute.name) : attribute.location;
  
          mProgram->getShaderAttributes()[attributeIndex] = attribute;
  
          if (location != -1)   // Set by glBindAttribLocation or by location layout qualifier
          {
              const int rows = VariableRegisterCount(attribute.type);
  
              if (rows + location > MAX_VERTEX_ATTRIBS)
              {
                  infoLog.append("Active attribute (%s) at location %d is too big to fit", attribute.name.c_str(), location);
  
                  return false;
              }
  
              for (int row = 0; row < rows; row++)
              {
                  const int rowLocation = location + row;
                  sh::ShaderVariable &linkedAttribute = mLinkedAttribute[rowLocation];
  
                  // In GLSL 3.00, attribute aliasing produces a link error
                  // In GLSL 1.00, attribute aliasing is allowed
                  if (mProgram->getShaderVersion() >= 300)
                  {
                      if (!linkedAttribute.name.empty())
                      {
                          infoLog.append("Attribute '%s' aliases attribute '%s' at location %d", attribute.name.c_str(), linkedAttribute.name.c_str(), rowLocation);
                          return false;
                      }
                  }
  
                  linkedAttribute = attribute;
                  usedLocations |= 1 << rowLocation;
              }
          }
      }
  
      // Link attributes that don't have a binding location
      for (unsigned int attributeIndex = 0; attributeIndex < shaderAttributes.size(); attributeIndex++)
      {
          const sh::Attribute &attribute = shaderAttributes[attributeIndex];
  
          ASSERT(attribute.staticUse);
  
          const int location = attribute.location == -1 ? attributeBindings.getAttributeBinding(attribute.name) : attribute.location;
  
          if (location == -1)   // Not set by glBindAttribLocation or by location layout qualifier
          {
              int rows = VariableRegisterCount(attribute.type);
              int availableIndex = AllocateFirstFreeBits(&usedLocations, rows, MAX_VERTEX_ATTRIBS);
  
              if (availableIndex == -1 || availableIndex + rows > MAX_VERTEX_ATTRIBS)
              {
                  infoLog.append("Too many active attributes (%s)", attribute.name.c_str());
  
                  return false;   // Fail to link
              }
  
              mLinkedAttribute[availableIndex] = attribute;
          }
      }
  
      for (int attributeIndex = 0; attributeIndex < MAX_VERTEX_ATTRIBS; )
      {
          int index = vertexShader->getSemanticIndex(mLinkedAttribute[attributeIndex].name);
          int rows = VariableRegisterCount(mLinkedAttribute[attributeIndex].type);
  
          for (int r = 0; r < rows; r++)
          {
              mProgram->getSemanticIndexes()[attributeIndex++] = index++;
          }
      }
  
      return true;
  }
  
  bool Program::linkUniformBlocks(InfoLog &infoLog, const Shader &vertexShader, const Shader &fragmentShader, const Caps &caps)
  {
      const std::vector<sh::InterfaceBlock> &vertexInterfaceBlocks = vertexShader.getInterfaceBlocks();
      const std::vector<sh::InterfaceBlock> &fragmentInterfaceBlocks = fragmentShader.getInterfaceBlocks();
      // Check that interface blocks defined in the vertex and fragment shaders are identical
      typedef std::map<std::string, const sh::InterfaceBlock*> UniformBlockMap;
      UniformBlockMap linkedUniformBlocks;
      for (unsigned int blockIndex = 0; blockIndex < vertexInterfaceBlocks.size(); blockIndex++)
      {
          const sh::InterfaceBlock &vertexInterfaceBlock = vertexInterfaceBlocks[blockIndex];
          linkedUniformBlocks[vertexInterfaceBlock.name] = &vertexInterfaceBlock;
      }
      for (unsigned int blockIndex = 0; blockIndex < fragmentInterfaceBlocks.size(); blockIndex++)
      {
          const sh::InterfaceBlock &fragmentInterfaceBlock = fragmentInterfaceBlocks[blockIndex];
          UniformBlockMap::const_iterator entry = linkedUniformBlocks.find(fragmentInterfaceBlock.name);
          if (entry != linkedUniformBlocks.end())
          {
              const sh::InterfaceBlock &vertexInterfaceBlock = *entry->second;
              if (!areMatchingInterfaceBlocks(infoLog, vertexInterfaceBlock, fragmentInterfaceBlock))
              {
                  return false;
              }
          }
      }
      for (unsigned int blockIndex = 0; blockIndex < vertexInterfaceBlocks.size(); blockIndex++)
      {
          const sh::InterfaceBlock &interfaceBlock = vertexInterfaceBlocks[blockIndex];
          // Note: shared and std140 layouts are always considered active
          if (interfaceBlock.staticUse || interfaceBlock.layout != sh::BLOCKLAYOUT_PACKED)
          {
              if (!mProgram->defineUniformBlock(infoLog, vertexShader, interfaceBlock, caps))
              {
                  return false;
              }
          }
      }
      for (unsigned int blockIndex = 0; blockIndex < fragmentInterfaceBlocks.size(); blockIndex++)
      {
          const sh::InterfaceBlock &interfaceBlock = fragmentInterfaceBlocks[blockIndex];
          // Note: shared and std140 layouts are always considered active
          if (interfaceBlock.staticUse || interfaceBlock.layout != sh::BLOCKLAYOUT_PACKED)
          {
              if (!mProgram->defineUniformBlock(infoLog, fragmentShader, interfaceBlock, caps))
              {
                  return false;
              }
          }
      }
      return true;
  }
  
  bool Program::areMatchingInterfaceBlocks(gl::InfoLog &infoLog, const sh::InterfaceBlock &vertexInterfaceBlock,
                                           const sh::InterfaceBlock &fragmentInterfaceBlock)
  {
      const char* blockName = vertexInterfaceBlock.name.c_str();
      // validate blocks for the same member types
      if (vertexInterfaceBlock.fields.size() != fragmentInterfaceBlock.fields.size())
      {
          infoLog.append("Types for interface block '%s' differ between vertex and fragment shaders", blockName);
          return false;
      }
      if (vertexInterfaceBlock.arraySize != fragmentInterfaceBlock.arraySize)
      {
          infoLog.append("Array sizes differ for interface block '%s' between vertex and fragment shaders", blockName);
          return false;
      }
      if (vertexInterfaceBlock.layout != fragmentInterfaceBlock.layout || vertexInterfaceBlock.isRowMajorLayout != fragmentInterfaceBlock.isRowMajorLayout)
      {
          infoLog.append("Layout qualifiers differ for interface block '%s' between vertex and fragment shaders", blockName);
          return false;
      }
      const unsigned int numBlockMembers = vertexInterfaceBlock.fields.size();
      for (unsigned int blockMemberIndex = 0; blockMemberIndex < numBlockMembers; blockMemberIndex++)
      {
          const sh::InterfaceBlockField &vertexMember = vertexInterfaceBlock.fields[blockMemberIndex];
          const sh::InterfaceBlockField &fragmentMember = fragmentInterfaceBlock.fields[blockMemberIndex];
          if (vertexMember.name != fragmentMember.name)
          {
              infoLog.append("Name mismatch for field %d of interface block '%s': (in vertex: '%s', in fragment: '%s')",
                             blockMemberIndex, blockName, vertexMember.name.c_str(), fragmentMember.name.c_str());
              return false;
          }
          std::string memberName = "interface block '" + vertexInterfaceBlock.name + "' member '" + vertexMember.name + "'";
          if (!linkValidateInterfaceBlockFields(infoLog, memberName, vertexMember, fragmentMember))
          {
              return false;
          }
      }
      return true;
  }
  
  bool Program::linkValidateVariablesBase(InfoLog &infoLog, const std::string &variableName, const sh::ShaderVariable &vertexVariable,
                                                const sh::ShaderVariable &fragmentVariable, bool validatePrecision)
  {
      if (vertexVariable.type != fragmentVariable.type)
      {
          infoLog.append("Types for %s differ between vertex and fragment shaders", variableName.c_str());
          return false;
      }
      if (vertexVariable.arraySize != fragmentVariable.arraySize)
      {
          infoLog.append("Array sizes for %s differ between vertex and fragment shaders", variableName.c_str());
          return false;
      }
      if (validatePrecision && vertexVariable.precision != fragmentVariable.precision)
      {
          infoLog.append("Precisions for %s differ between vertex and fragment shaders", variableName.c_str());
          return false;
      }
  
      if (vertexVariable.fields.size() != fragmentVariable.fields.size())
      {
          infoLog.append("Structure lengths for %s differ between vertex and fragment shaders", variableName.c_str());
          return false;
      }
      const unsigned int numMembers = vertexVariable.fields.size();
      for (unsigned int memberIndex = 0; memberIndex < numMembers; memberIndex++)
      {
          const sh::ShaderVariable &vertexMember = vertexVariable.fields[memberIndex];
          const sh::ShaderVariable &fragmentMember = fragmentVariable.fields[memberIndex];
  
          if (vertexMember.name != fragmentMember.name)
          {
              infoLog.append("Name mismatch for field '%d' of %s: (in vertex: '%s', in fragment: '%s')",
                             memberIndex, variableName.c_str(),
                             vertexMember.name.c_str(), fragmentMember.name.c_str());
              return false;
          }
  
          const std::string memberName = variableName.substr(0, variableName.length() - 1) + "." +
                                         vertexMember.name + "'";
  
          if (!linkValidateVariablesBase(infoLog, vertexMember.name, vertexMember, fragmentMember, validatePrecision))
          {
              return false;
          }
      }
  
      return true;
  }
  
  bool Program::linkValidateUniforms(InfoLog &infoLog, const std::string &uniformName, const sh::Uniform &vertexUniform, const sh::Uniform &fragmentUniform)
  {
      if (!linkValidateVariablesBase(infoLog, uniformName, vertexUniform, fragmentUniform, true))
      {
          return false;
      }
  
      return true;
  }
  
  bool Program::linkValidateVaryings(InfoLog &infoLog, const std::string &varyingName, const sh::Varying &vertexVarying, const sh::Varying &fragmentVarying)
  {
      if (!linkValidateVariablesBase(infoLog, varyingName, vertexVarying, fragmentVarying, false))
      {
          return false;
      }
  
      if (!sh::InterpolationTypesMatch(vertexVarying.interpolation, fragmentVarying.interpolation))
      {
          infoLog.append("Interpolation types for %s differ between vertex and fragment shaders", varyingName.c_str());
          return false;
      }
  
      return true;
  }
  
  bool Program::gatherTransformFeedbackLinkedVaryings(InfoLog &infoLog, const std::vector<LinkedVarying> &linkedVaryings,
                                                      const std::vector<std::string> &transformFeedbackVaryingNames,
                                                      GLenum transformFeedbackBufferMode,
                                                      std::vector<LinkedVarying> *outTransformFeedbackLinkedVaryings,
                                                      const Caps &caps) const
  {
      size_t totalComponents = 0;
  
      // Gather the linked varyings that are used for transform feedback, they should all exist.
      outTransformFeedbackLinkedVaryings->clear();
      for (size_t i = 0; i < transformFeedbackVaryingNames.size(); i++)
      {
          bool found = false;
          for (size_t j = 0; j < linkedVaryings.size(); j++)
          {
              if (transformFeedbackVaryingNames[i] == linkedVaryings[j].name)
              {
                  for (size_t k = 0; k < outTransformFeedbackLinkedVaryings->size(); k++)
                  {
                      if (outTransformFeedbackLinkedVaryings->at(k).name == linkedVaryings[j].name)
                      {
                          infoLog.append("Two transform feedback varyings specify the same output variable (%s).", linkedVaryings[j].name.c_str());
                          return false;
                      }
                  }
  
                  size_t componentCount = linkedVaryings[j].semanticIndexCount * 4;
                  if (transformFeedbackBufferMode == GL_SEPARATE_ATTRIBS &&
                      componentCount > caps.maxTransformFeedbackSeparateComponents)
                  {
                      infoLog.append("Transform feedback varying's %s components (%u) exceed the maximum separate components (%u).",
                                     linkedVaryings[j].name.c_str(), componentCount, caps.maxTransformFeedbackSeparateComponents);
                      return false;
                  }
  
                  totalComponents += componentCount;
  
                  outTransformFeedbackLinkedVaryings->push_back(linkedVaryings[j]);
                  found = true;
                  break;
              }
          }
  
          // All transform feedback varyings are expected to exist since packVaryings checks for them.
          ASSERT(found);
      }
  
      if (transformFeedbackBufferMode == GL_INTERLEAVED_ATTRIBS && totalComponents > caps.maxTransformFeedbackInterleavedComponents)
      {
          infoLog.append("Transform feedback varying total components (%u) exceed the maximum interleaved components (%u).",
                         totalComponents, caps.maxTransformFeedbackInterleavedComponents);
          return false;
      }
  
      return true;
  }
  
  }