kc3-lang/angle/src/libGLESv2/VertexAttribute.h

• Show log

  Commit

• Hash : 30855b37
  Author :
  Date : 2013-07-02T11:57:06
  

  Support querying if a vertex attribute is an un-normalized integer.
  
  TRAC #23391
  
  Signed-off-by: Shannon Woods
  Signed-off-by: Geoff Lang
  Authored-by: Jamie Madill
  

Download

• src/libGLESv2/VertexAttribute.h

• //
  // Copyright (c) 2013 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.
  //
  // Helper structure describing a single vertex attribute
  //
  
  #ifndef LIBGLESV2_VERTEXATTRIBUTE_H_
  #define LIBGLESV2_VERTEXATTRIBUTE_H_
  
  #include "libGLESv2/Buffer.h"
  
  namespace gl
  {
  
  class VertexAttribute
  {
    public:
      VertexAttribute() : mType(GL_FLOAT), mSize(0), mNormalized(false), mPureInteger(false),
                          mStride(0), mPointer(NULL), mArrayEnabled(false), mDivisor(0)
      {
      }
  
      int typeSize() const
      {
          switch (mType)
          {
            case GL_BYTE:                        return mSize * sizeof(GLbyte);
            case GL_UNSIGNED_BYTE:               return mSize * sizeof(GLubyte);
            case GL_SHORT:                       return mSize * sizeof(GLshort);
            case GL_UNSIGNED_SHORT:              return mSize * sizeof(GLushort);
            case GL_INT:                         return mSize * sizeof(GLint);
            case GL_UNSIGNED_INT:                return mSize * sizeof(GLuint);
            case GL_INT_2_10_10_10_REV:          return 4;
            case GL_UNSIGNED_INT_2_10_10_10_REV: return 4;
            case GL_FIXED:                       return mSize * sizeof(GLfixed);
            case GL_HALF_FLOAT:                  return mSize * sizeof(GLhalf);
            case GL_FLOAT:                       return mSize * sizeof(GLfloat);
            default: UNREACHABLE();              return mSize * sizeof(GLfloat);
          }
      }
  
      GLsizei stride() const
      {
          return mStride ? mStride : typeSize();
      }
  
      void setState(gl::Buffer *boundBuffer, GLint size, GLenum type, bool normalized,
                    bool pureInteger, GLsizei stride, const void *pointer)
      {
          mBoundBuffer.set(boundBuffer);
          mSize = size;
          mType = type;
          mNormalized = normalized;
          mPureInteger = pureInteger;
          mStride = stride;
          mPointer = pointer;
      }
  
      template <typename T>
      T querySingleParameter(GLenum pname) const
      {
          switch (pname)
          {
            case GL_VERTEX_ATTRIB_ARRAY_ENABLED:
              return static_cast<T>(mArrayEnabled ? GL_TRUE : GL_FALSE);
            case GL_VERTEX_ATTRIB_ARRAY_SIZE:
              return static_cast<T>(mSize);
            case GL_VERTEX_ATTRIB_ARRAY_STRIDE:
              return static_cast<T>(mStride);
            case GL_VERTEX_ATTRIB_ARRAY_TYPE:
              return static_cast<T>(mType);
            case GL_VERTEX_ATTRIB_ARRAY_NORMALIZED:
              return static_cast<T>(mNormalized ? GL_TRUE : GL_FALSE);
            case GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING:
              return static_cast<T>(mBoundBuffer.id());
            case GL_VERTEX_ATTRIB_ARRAY_DIVISOR:
              return static_cast<T>(mDivisor);
            case GL_VERTEX_ATTRIB_ARRAY_INTEGER:
              return static_cast<T>(mPureInteger ? GL_TRUE : GL_FALSE);
            default:
              UNREACHABLE();
              return static_cast<T>(0);
          }
      }
  
      // From glVertexAttribPointer
      GLenum mType;
      GLint mSize;
      bool mNormalized;
      bool mPureInteger;
      GLsizei mStride;   // 0 means natural stride
  
      union
      {
          const void *mPointer;
          intptr_t mOffset;
      };
  
      BindingPointer<Buffer> mBoundBuffer;   // Captured when glVertexAttribPointer is called.
      bool mArrayEnabled;   // From glEnable/DisableVertexAttribArray
      unsigned int mDivisor;
  };
  
  struct VertexAttribCurrentValueData
  {
      union
      {
          GLfloat FloatValues[4];
          GLint IntValues[4];
          GLuint UnsignedIntValues[4];
      };
      GLenum Type;
  
      void setFloatValues(const GLfloat floatValues[4])
      {
          for (unsigned int valueIndex = 0; valueIndex < 4; valueIndex++)
          {
              FloatValues[valueIndex] = floatValues[valueIndex];
          }
          Type = GL_FLOAT;
      }
  
      void setIntValues(const GLint intValues[4])
      {
          for (unsigned int valueIndex = 0; valueIndex < 4; valueIndex++)
          {
              IntValues[valueIndex] = intValues[valueIndex];
          }
          Type = GL_INT;
      }
  
      void setUnsignedIntValues(const GLuint unsignedIntValues[4])
      {
          for (unsigned int valueIndex = 0; valueIndex < 4; valueIndex++)
          {
              UnsignedIntValues[valueIndex] = unsignedIntValues[valueIndex];
          }
          Type = GL_UNSIGNED_INT;
      }
  };
  
  }
  
  #endif // LIBGLESV2_VERTEXATTRIBUTE_H_
  

Download