kc3-lang/angle/src/libGLESv2/VertexArray.cpp

• Show log

  Commit

• Hash : 0b7eef7c
  Author :
  Date : 2014-06-12T14:10:47
  

  Removed common_includes.h reordered includes.
  
  Since we are not using precompiled headers anymore, remove common_includes.h
  so that fewer files are included in cpp files.
  
  Reordered includes to be in the following order:
   1) Local ANGLE project headers, ordered by directory in descending depth
   2) GL headers
   3) STL headers
  This helps enforce the include-what-you-use principal by reducing the
  number of STL headers unexpectedly shared between files.
  
  This include order conflicts with some of the Google c++ style guide
  which states that STL includes should be first but this helps us catch
  more issues.
  
  Change-Id: I8f7785f4ad574e253dd3c7b4fb1e54d3ce3b99fc
  Reviewed-on: https://chromium-review.googlesource.com/214850
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Tested-by: Geoff Lang <geofflang@chromium.org>
  

Download

• src/libGLESv2/VertexArray.cpp

• //
  // 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.
  //
  // Implementation of the state class for mananging GLES 3 Vertex Array Objects.
  //
  
  #include "libGLESv2/VertexArray.h"
  #include "libGLESv2/Buffer.h"
  #include "libGLESv2/renderer/VertexArrayImpl.h"
  
  namespace gl
  {
  
  VertexArray::VertexArray(rx::VertexArrayImpl *impl, GLuint id, size_t maxAttribs)
      : mId(id),
        mVertexArray(impl),
        mVertexAttributes(maxAttribs)
  {
      ASSERT(impl != NULL);
  }
  
  VertexArray::~VertexArray()
  {
      SafeDelete(mVertexArray);
  
      for (size_t i = 0; i < getMaxAttribs(); i++)
      {
          mVertexAttributes[i].buffer.set(NULL);
      }
      mElementArrayBuffer.set(NULL);
  }
  
  GLuint VertexArray::id() const
  {
      return mId;
  }
  
  void VertexArray::detachBuffer(GLuint bufferName)
  {
      for (size_t attribute = 0; attribute < getMaxAttribs(); attribute++)
      {
          if (mVertexAttributes[attribute].buffer.id() == bufferName)
          {
              mVertexAttributes[attribute].buffer.set(NULL);
          }
      }
  
      if (mElementArrayBuffer.id() == bufferName)
      {
          mElementArrayBuffer.set(NULL);
      }
  }
  
  const VertexAttribute& VertexArray::getVertexAttribute(size_t attributeIndex) const
  {
      ASSERT(attributeIndex < getMaxAttribs());
      return mVertexAttributes[attributeIndex];
  }
  
  void VertexArray::setVertexAttribDivisor(GLuint index, GLuint divisor)
  {
      ASSERT(index < getMaxAttribs());
      mVertexAttributes[index].divisor = divisor;
      mVertexArray->setAttributeDivisor(index, divisor);
  }
  
  void VertexArray::enableAttribute(unsigned int attributeIndex, bool enabledState)
  {
      ASSERT(attributeIndex < getMaxAttribs());
      mVertexAttributes[attributeIndex].enabled = enabledState;
      mVertexArray->enableAttribute(attributeIndex, enabledState);
  }
  
  void VertexArray::setAttributeState(unsigned int attributeIndex, gl::Buffer *boundBuffer, GLint size, GLenum type,
                                      bool normalized, bool pureInteger, GLsizei stride, const void *pointer)
  {
      ASSERT(attributeIndex < getMaxAttribs());
      mVertexAttributes[attributeIndex].buffer.set(boundBuffer);
      mVertexAttributes[attributeIndex].size = size;
      mVertexAttributes[attributeIndex].type = type;
      mVertexAttributes[attributeIndex].normalized = normalized;
      mVertexAttributes[attributeIndex].pureInteger = pureInteger;
      mVertexAttributes[attributeIndex].stride = stride;
      mVertexAttributes[attributeIndex].pointer = pointer;
      mVertexArray->setAttribute(attributeIndex, mVertexAttributes[attributeIndex]);
  }
  
  void VertexArray::setElementArrayBuffer(Buffer *buffer)
  {
      mElementArrayBuffer.set(buffer);
      mVertexArray->setElementArrayBuffer(buffer);
  }
  
  }

Download