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

• Show log

  Commit

• Hash : 2597fb64
  Author :
  Date : 2016-12-09T16:38:02
  

  ES31: Refactor VertexArray for Vertex Attrib Binding
  
  OpenGL ES3.1 feature Vertex Attrib Binding requires vertex arrays should
  be split into two arrays:
  1. an array of vertex buffer binding points, each of which specifies:
    - a bound buffer object,
    - a starting offset for vertex attribute data in that buffer object,
    - a stride used by all attributes using that binding point,
    - a frequency divisor used by all attributes using that binding point.
  2. an array of generic vertex attribute format information records, each
  of which specifies:
    - a reference to one of the new buffer binding points above,
    - a component count and format, and a normalization flag for the
      attribute data,
    - the offset of the attribute data relative to the base offset of each
      vertex found at the associated binding point.
  
  Current ANGLE implementation simply uses a struct to represent a vertex
  attribute object, which does not meet the requirements above.
  
  This patch aims to be the the basis of the implementation of all ES3.1
  Vertex Attrib Binding APIs by refactoring the struct VertexAttribute and
  the class VertexArray to fit the new data layout and ensuring all current
  functionality is retained.
  
  BUG=angleproject:1593
  
  TEST=angle_unittests, angle_end2end_tests, gpu_unittests
  
  Change-Id: Ieb41f1bf503f815fd0476d2ea045dcb863465254
  Reviewed-on: https://chromium-review.googlesource.com/418880
  Reviewed-by: Corentin Wallez <cwallez@chromium.org>
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Commit-Queue: Jamie Madill <jmadill@chromium.org>
  

Download

• src/libANGLE/VertexAttribute.cpp

• //
  // Copyright 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.
  //
  // Implementation of the state classes for mananging GLES 3.1 Vertex Array Objects.
  //
  
  #include "libANGLE/VertexAttribute.h"
  
  namespace gl
  {
  
  // [OpenGL ES 3.1] (November 3, 2016) Section 20 Page 361
  // Table 20.2: Vertex Array Object State
  VertexBinding::VertexBinding() : stride(16u), divisor(0), offset(0)
  {
  }
  
  VertexBinding::VertexBinding(VertexBinding &&binding)
  {
      *this = std::move(binding);
  }
  
  VertexBinding &VertexBinding::operator=(VertexBinding &&binding)
  {
      if (this != &binding)
      {
          stride  = binding.stride;
          divisor = binding.divisor;
          offset  = binding.offset;
  
          buffer.set(binding.buffer.get());
          binding.buffer.set(nullptr);
      }
      return *this;
  }
  
  VertexAttribute::VertexAttribute(GLuint bindingIndex)
      : enabled(false),
        type(GL_FLOAT),
        size(4u),
        normalized(false),
        pureInteger(false),
        pointer(nullptr),
        relativeOffset(0),
        vertexAttribArrayStride(0),
        bindingIndex(bindingIndex)
  {
  }
  
  VertexAttribute::VertexAttribute(VertexAttribute &&attrib)
      : enabled(attrib.enabled),
        type(attrib.type),
        size(attrib.size),
        normalized(attrib.normalized),
        pureInteger(attrib.pureInteger),
        pointer(attrib.pointer),
        relativeOffset(attrib.relativeOffset),
        vertexAttribArrayStride(attrib.vertexAttribArrayStride),
        bindingIndex(attrib.bindingIndex)
  {
  }
  
  VertexAttribute &VertexAttribute::operator=(VertexAttribute &&attrib)
  {
      if (this != &attrib)
      {
          enabled                 = attrib.enabled;
          type                    = attrib.type;
          size                    = attrib.size;
          normalized              = attrib.normalized;
          pureInteger             = attrib.pureInteger;
          pointer                 = attrib.pointer;
          relativeOffset          = attrib.relativeOffset;
          vertexAttribArrayStride = attrib.vertexAttribArrayStride;
          bindingIndex            = attrib.bindingIndex;
      }
      return *this;
  }
  
  size_t ComputeVertexAttributeTypeSize(const VertexAttribute& attrib)
  {
      GLuint size = attrib.size;
      switch (attrib.type)
      {
        case GL_BYTE:                        return size * sizeof(GLbyte);
        case GL_UNSIGNED_BYTE:               return size * sizeof(GLubyte);
        case GL_SHORT:                       return size * sizeof(GLshort);
        case GL_UNSIGNED_SHORT:              return size * sizeof(GLushort);
        case GL_INT:                         return size * sizeof(GLint);
        case GL_UNSIGNED_INT:                return size * 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 size * sizeof(GLfixed);
        case GL_HALF_FLOAT:                  return size * sizeof(GLhalf);
        case GL_FLOAT:                       return size * sizeof(GLfloat);
        default: UNREACHABLE();              return size * sizeof(GLfloat);
      }
  }
  
  size_t ComputeVertexAttributeStride(const VertexAttribute &attrib, const VertexBinding &binding)
  {
      // In ES 3.1, VertexAttribPointer will store the type size in the binding stride.
      // Hence, rendering always uses the binding's stride.
      return attrib.enabled ? binding.stride : 16u;
  }
  
  // Warning: you should ensure binding really matches attrib.bindingIndex before using this function.
  GLintptr ComputeVertexAttributeOffset(const VertexAttribute &attrib, const VertexBinding &binding)
  {
      return attrib.relativeOffset + binding.offset;
  }
  
  size_t ComputeVertexBindingElementCount(const VertexBinding &binding,
                                          size_t drawCount,
                                          size_t instanceCount)
  {
      // For instanced rendering, we draw "instanceDrawCount" sets of "vertexDrawCount" vertices.
      //
      // A vertex attribute with a positive divisor loads one instanced vertex for every set of
      // non-instanced vertices, and the instanced vertex index advances once every "mDivisor"
      // instances.
      if (instanceCount > 0 && binding.divisor > 0)
      {
          // When instanceDrawCount is not a multiple attrib.divisor, the division must round up.
          // For instance, with 5 non-instanced vertices and a divisor equal to 3, we need 2 instanced
          // vertices.
          return (instanceCount + binding.divisor - 1u) / binding.divisor;
      }
  
      return drawCount;
  }
  
  }  // namespace gl
  

Download