kc3-lang/angle/src/libANGLE/renderer/d3d/IndexDataManager.h

• Show log

  Commit

• Hash : 534bf87b
  Author :
  Date : 2016-02-09T11:33:29
  

  Implemented instanced rendering for emulated point sprites
  
  Non-instanced PointSprite emulation for lower feature levels is
  implemented using D3D DrawIndexedInstanced and an instanced vertex
  buffer containing a pointsprite quad.
  
  GL instanced rendering using glDrawArraysInstanced and
  glDrawElementsInstanced with pointsprite emulation is performed using
  a for-loop.  The loop iterates over each instance to render and adjusts
  the buffer offsets accordingly. This is not performant and is only used
  and required by this chosen pointsprite emulation method.
  
  Indexed instanced (glDrawElementsInstanced), uses the same offset loop
  because the vertex buffer containing the data to be rendered has already
  been expanded using getEmulatedIndexedBuffer().  Expanding the buffer
  makes the two rendering operations similar enough to share code.
  
  BUG=angleproject:1279
  TEST=angle_end2end_tests
  
  Change-Id: If46cc9f158e29f5518c70ad630b3228f474a9f8b
  Reviewed-on: https://chromium-review.googlesource.com/321407
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  Commit-Queue: Geoff Lang <geofflang@chromium.org>
  

Download

• src/libANGLE/renderer/d3d/IndexDataManager.h

• //
  // 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.
  //
  
  // IndexDataManager.h: Defines the IndexDataManager, a class that
  // runs the Buffer translation process for index buffers.
  
  #ifndef LIBANGLE_INDEXDATAMANAGER_H_
  #define LIBANGLE_INDEXDATAMANAGER_H_
  
  #include <GLES2/gl2.h>
  
  #include "common/angleutils.h"
  #include "common/mathutil.h"
  #include "libANGLE/Error.h"
  #include "libANGLE/renderer/d3d/RendererD3D.h"
  
  namespace
  {
      enum { INITIAL_INDEX_BUFFER_SIZE = 4096 * sizeof(GLuint) };
  }
  
  namespace gl
  {
  class Buffer;
  }
  
  namespace rx
  {
  class IndexBufferInterface;
  class StaticIndexBufferInterface;
  class StreamingIndexBufferInterface;
  class IndexBuffer;
  class BufferD3D;
  class RendererD3D;
  
  struct SourceIndexData
  {
      BufferD3D *srcBuffer;
      const GLvoid *srcIndices;
      unsigned int srcCount;
      GLenum srcIndexType;
      bool srcIndicesChanged;
  };
  
  struct TranslatedIndexData
  {
      gl::IndexRange indexRange;
      unsigned int startIndex;
      unsigned int startOffset;   // In bytes
  
      IndexBuffer *indexBuffer;
      BufferD3D *storage;
      GLenum indexType;
      unsigned int serial;
  
      SourceIndexData srcIndexData;
  };
  
  class IndexDataManager : angle::NonCopyable
  {
    public:
      explicit IndexDataManager(BufferFactoryD3D *factory, RendererClass rendererClass);
      virtual ~IndexDataManager();
  
      gl::Error prepareIndexData(GLenum srcType,
                                 GLsizei count,
                                 gl::Buffer *glBuffer,
                                 const GLvoid *indices,
                                 TranslatedIndexData *translated,
                                 bool primitiveRestartFixedIndexEnabled);
  
    private:
      gl::Error streamIndexData(const GLvoid *data,
                                unsigned int count,
                                GLenum srcType,
                                GLenum dstType,
                                bool usePrimitiveRestartFixedIndex,
                                TranslatedIndexData *translated);
      gl::Error getStreamingIndexBuffer(GLenum destinationIndexType,
                                        IndexBufferInterface **outBuffer);
  
      BufferFactoryD3D *const mFactory;
      RendererClass mRendererClass;
      StreamingIndexBufferInterface *mStreamingBufferShort;
      StreamingIndexBufferInterface *mStreamingBufferInt;
  };
  
  }
  
  #endif   // LIBANGLE_INDEXDATAMANAGER_H_
  

Download