kc3-lang/angle/src/libGLESv2/renderer/VertexDataManager.cpp

• Show log

  Commit

• Hash : 047dc625
  Author :
  Date : 2013-02-28T23:18:08
  

  Only allow direct vertex buffers binding with attribute with 4 byte aligned offsets.
  
  TRAC #22647
  
  Signed-off-by: Geoff Lang
  Signed-off-by: Shannon Woods
  Author: Jamie Madill
  
  git-svn-id: https://angleproject.googlecode.com/svn/branches/dx11proto@1947 736b8ea6-26fd-11df-bfd4-992fa37f6226
  

Download

• src/libGLESv2/renderer/VertexDataManager.cpp

• #include "precompiled.h"
  //
  // Copyright (c) 2002-2012 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.
  //
  
  // VertexDataManager.h: Defines the VertexDataManager, a class that
  // runs the Buffer translation process.
  
  #include "libGLESv2/renderer/VertexDataManager.h"
  #include "libGLESv2/renderer/BufferStorage.h"
  
  #include "libGLESv2/Buffer.h"
  #include "libGLESv2/ProgramBinary.h"
  #include "libGLESv2/Context.h"
  #include "libGLESv2/renderer/VertexBuffer.h"
  
  namespace
  {
      enum { INITIAL_STREAM_BUFFER_SIZE = 1024*1024 };
      // This has to be at least 4k or else it fails on ATI cards.
      enum { CONSTANT_VERTEX_BUFFER_SIZE = 4096 };
  }
  
  namespace rx
  {
  
  static int elementsInBuffer(const gl::VertexAttribute &attribute, int size)
  {
      int stride = attribute.stride();
      return (size - attribute.mOffset % stride + (stride - attribute.typeSize())) / stride;
  }
  
  VertexDataManager::VertexDataManager(Renderer *renderer) : mRenderer(renderer)
  {
      for (int i = 0; i < gl::MAX_VERTEX_ATTRIBS; i++)
      {
          mCurrentValue[i][0] = std::numeric_limits<float>::quiet_NaN();
          mCurrentValue[i][1] = std::numeric_limits<float>::quiet_NaN();
          mCurrentValue[i][2] = std::numeric_limits<float>::quiet_NaN();
          mCurrentValue[i][3] = std::numeric_limits<float>::quiet_NaN();
          mCurrentValueBuffer[i] = NULL;
          mCurrentValueOffsets[i] = 0;
      }
  
      mStreamingBuffer = new StreamingVertexBufferInterface(renderer, INITIAL_STREAM_BUFFER_SIZE);
  
      if (!mStreamingBuffer)
      {
          ERR("Failed to allocate the streaming vertex buffer.");
      }
  }
  
  VertexDataManager::~VertexDataManager()
  {
      delete mStreamingBuffer;
  
      for (int i = 0; i < gl::MAX_VERTEX_ATTRIBS; i++)
      {
          delete mCurrentValueBuffer[i];
      }
  }
  
  static bool directStoragePossible(VertexBufferInterface* vb, const gl::VertexAttribute& attrib)
  {
      gl::Buffer *buffer = attrib.mBoundBuffer.get();
      BufferStorage *storage = buffer ? buffer->getStorage() : NULL;
  
      const bool isAligned = (attrib.stride() % 4 == 0) && (attrib.mOffset % 4 == 0);
  
      return storage && storage->supportsDirectBinding() && !vb->getVertexBuffer()->requiresConversion(attrib) && isAligned;
  }
  
  GLenum VertexDataManager::prepareVertexData(const gl::VertexAttribute attribs[], gl::ProgramBinary *programBinary, GLint start, GLsizei count, TranslatedAttribute *translated, GLsizei instances)
  {
      if (!mStreamingBuffer)
      {
          return GL_OUT_OF_MEMORY;
      }
  
      for (int attributeIndex = 0; attributeIndex < gl::MAX_VERTEX_ATTRIBS; attributeIndex++)
      {
          translated[attributeIndex].active = (programBinary->getSemanticIndex(attributeIndex) != -1);
      }
  
      // Invalidate static buffers that don't contain matching attributes
      for (int i = 0; i < gl::MAX_VERTEX_ATTRIBS; i++)
      {
          if (translated[i].active && attribs[i].mArrayEnabled)
          {
              gl::Buffer *buffer = attribs[i].mBoundBuffer.get();
              StaticVertexBufferInterface *staticBuffer = buffer ? buffer->getStaticVertexBuffer() : NULL;
  
              if (staticBuffer && staticBuffer->getBufferSize() > 0 && staticBuffer->lookupAttribute(attribs[i]) == -1 &&
                  !directStoragePossible(staticBuffer, attribs[i]))
              {
                  buffer->invalidateStaticData();
              }
          }
      }
  
      // Reserve the required space in the buffers
      for (int i = 0; i < gl::MAX_VERTEX_ATTRIBS; i++)
      {
          if (translated[i].active && attribs[i].mArrayEnabled)
          {
              gl::Buffer *buffer = attribs[i].mBoundBuffer.get();
              StaticVertexBufferInterface *staticBuffer = buffer ? buffer->getStaticVertexBuffer() : NULL;
              VertexBufferInterface *vertexBuffer = staticBuffer ? staticBuffer : static_cast<VertexBufferInterface*>(mStreamingBuffer);
  
              if (!directStoragePossible(vertexBuffer, attribs[i]))
              {
                  if (staticBuffer)
                  {
                      if (staticBuffer->getBufferSize() == 0)
                      {
                          int totalCount = elementsInBuffer(attribs[i], buffer->size());
                          staticBuffer->reserveVertexSpace(attribs[i], totalCount, 0);
                      }
                  }
                  else
                  {
                      mStreamingBuffer->reserveVertexSpace(attribs[i], count, instances);
                  }
              }
          }
      }
  
      // Perform the vertex data translations
      for (int i = 0; i < gl::MAX_VERTEX_ATTRIBS; i++)
      {
          if (translated[i].active)
          {
              if (attribs[i].mArrayEnabled)
              {
                  gl::Buffer *buffer = attribs[i].mBoundBuffer.get();
  
                  if (!buffer && attribs[i].mPointer == NULL)
                  {
                      // This is an application error that would normally result in a crash, but we catch it and return an error
                      ERR("An enabled vertex array has no buffer and no pointer.");
                      return GL_INVALID_OPERATION;
                  }
  
                  StaticVertexBufferInterface *staticBuffer = buffer ? buffer->getStaticVertexBuffer() : NULL;
                  VertexBufferInterface *vertexBuffer = staticBuffer ? staticBuffer : static_cast<VertexBufferInterface*>(mStreamingBuffer);
  
                  BufferStorage *storage = buffer ? buffer->getStorage() : NULL;
                  bool directStorage = directStoragePossible(vertexBuffer, attribs[i]);
  
                  std::size_t streamOffset = -1;
                  unsigned int outputElementSize = 0;
  
                  if (directStorage)
                  {
                      outputElementSize = attribs[i].stride();
                      streamOffset = attribs[i].mOffset + outputElementSize * start;
                      storage->markBufferUsage();
                  }
                  else if (staticBuffer)
                  {
                      streamOffset = staticBuffer->lookupAttribute(attribs[i]);
                      outputElementSize = staticBuffer->getVertexBuffer()->getSpaceRequired(attribs[i], 1, 0);
  
                      if (streamOffset == -1)
                      {
                          // Convert the entire buffer
                          int totalCount = elementsInBuffer(attribs[i], storage->getSize());
                          int startIndex = attribs[i].mOffset / attribs[i].stride();
  
                          streamOffset = staticBuffer->storeVertexAttributes(attribs[i], -startIndex, totalCount, 0);
                      }
  
                      if (streamOffset != -1)
                      {
                          streamOffset += (attribs[i].mOffset / attribs[i].stride()) * outputElementSize;
  
                          if (instances == 0 || attribs[i].mDivisor == 0)
                          {
                              streamOffset += start * outputElementSize;
                          }
                      }
                  }
                  else
                  {
                      outputElementSize = mStreamingBuffer->getVertexBuffer()->getSpaceRequired(attribs[i], 1, 0);
                      streamOffset = mStreamingBuffer->storeVertexAttributes(attribs[i], start, count, instances);
                  }
  
                  if (streamOffset == -1)
                  {
                      return GL_OUT_OF_MEMORY;
                  }
  
                  translated[i].storage = directStorage ? storage : NULL;
                  translated[i].vertexBuffer = vertexBuffer->getVertexBuffer();
                  translated[i].serial = directStorage ? storage->getSerial() : vertexBuffer->getSerial();
                  translated[i].divisor = attribs[i].mDivisor;
  
                  translated[i].attribute = &attribs[i];
                  translated[i].stride = outputElementSize;
                  translated[i].offset = streamOffset;
              }
              else
              {
                  if (!mCurrentValueBuffer[i])
                  {
                      mCurrentValueBuffer[i] = new StreamingVertexBufferInterface(mRenderer, CONSTANT_VERTEX_BUFFER_SIZE);
                  }
  
                  StreamingVertexBufferInterface *buffer = mCurrentValueBuffer[i];
  
                  if (mCurrentValue[i][0] != attribs[i].mCurrentValue[0] ||
                      mCurrentValue[i][1] != attribs[i].mCurrentValue[1] ||
                      mCurrentValue[i][2] != attribs[i].mCurrentValue[2] ||
                      mCurrentValue[i][3] != attribs[i].mCurrentValue[3])
                  {
                      unsigned int requiredSpace = sizeof(float) * 4;
                      buffer->reserveRawDataSpace(requiredSpace);
                      int streamOffset = buffer->storeRawData(attribs[i].mCurrentValue, requiredSpace);
                      if (streamOffset == -1)
                      {
                          return GL_OUT_OF_MEMORY;
                      }
  
                      mCurrentValueOffsets[i] = streamOffset;
                  }
  
                  translated[i].storage = NULL;
                  translated[i].vertexBuffer = mCurrentValueBuffer[i]->getVertexBuffer();
                  translated[i].serial = mCurrentValueBuffer[i]->getSerial();
                  translated[i].divisor = 0;
  
                  translated[i].attribute = &attribs[i];
                  translated[i].stride = 0;
                  translated[i].offset = mCurrentValueOffsets[i];
              }
          }
      }
  
      for (int i = 0; i < gl::MAX_VERTEX_ATTRIBS; i++)
      {
          if (translated[i].active && attribs[i].mArrayEnabled)
          {
              gl::Buffer *buffer = attribs[i].mBoundBuffer.get();
  
              if (buffer)
              {
                  buffer->promoteStaticUsage(count * attribs[i].typeSize());
              }
          }
      }
  
      return GL_NO_ERROR;
  }
  
  }
  

Download