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

• Show log

  Commit

• Hash : dd5f27ee
  Author :
  Date : 2017-06-07T10:17:09
  

  Make VertexBinding's member variables private
  
  The patch decorates all members in VertexBinding as private and limits
  access to them only through getters and setters. This makes it easier to
  debug and keep track of any assignments to the class members.
  
  BUG=angleproject:2062
  TEST=angle_end2end_tests
  
  Change-Id: Iddd49063d060f136bc9cf11c313a5af0931d433c
  Reviewed-on: https://chromium-review.googlesource.com/530786
  Commit-Queue: Olli Etuaho <oetuaho@nvidia.com>
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  

Download

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

• //
  // 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.
  //
  
  // BufferD3D.h: Defines the rx::BufferD3D class, an implementation of BufferImpl.
  
  #ifndef LIBANGLE_RENDERER_D3D_BUFFERD3D_H_
  #define LIBANGLE_RENDERER_D3D_BUFFERD3D_H_
  
  #include "libANGLE/angletypes.h"
  #include "libANGLE/renderer/BufferImpl.h"
  
  #include <stdint.h>
  #include <vector>
  
  namespace gl
  {
  struct VertexAttribute;
  class VertexBinding;
  }
  
  namespace rx
  {
  class BufferFactoryD3D;
  class StaticIndexBufferInterface;
  class StaticVertexBufferInterface;
  
  enum class D3DBufferUsage
  {
      STATIC,
      DYNAMIC,
  };
  
  class BufferD3D : public BufferImpl
  {
    public:
      BufferD3D(const gl::BufferState &state, BufferFactoryD3D *factory);
      virtual ~BufferD3D();
  
      unsigned int getSerial() const { return mSerial; }
  
      virtual size_t getSize() const = 0;
      virtual bool supportsDirectBinding() const = 0;
      virtual gl::Error markTransformFeedbackUsage() = 0;
      virtual gl::Error getData(const uint8_t **outData) = 0;
  
      // Warning: you should ensure binding really matches attrib.bindingIndex before using this
      // function.
      StaticVertexBufferInterface *getStaticVertexBuffer(const gl::VertexAttribute &attribute,
                                                         const gl::VertexBinding &binding);
      StaticIndexBufferInterface *getStaticIndexBuffer();
  
      virtual void initializeStaticData();
      virtual void invalidateStaticData();
  
      void promoteStaticUsage(int dataSize);
  
      gl::Error getIndexRange(GLenum type,
                              size_t offset,
                              size_t count,
                              bool primitiveRestartEnabled,
                              gl::IndexRange *outRange) override;
  
      BufferFactoryD3D *getFactory() const { return mFactory; }
      D3DBufferUsage getUsage() const { return mUsage; }
  
    protected:
      void updateSerial();
      void updateD3DBufferUsage(GLenum usage);
      void emptyStaticBufferCache();
  
      BufferFactoryD3D *mFactory;
      unsigned int mSerial;
      static unsigned int mNextSerial;
  
      std::vector<std::unique_ptr<StaticVertexBufferInterface>> mStaticVertexBuffers;
      StaticIndexBufferInterface *mStaticIndexBuffer;
      unsigned int mStaticBufferCacheTotalSize;
      unsigned int mStaticVertexBufferOutOfDate;
      unsigned int mUnmodifiedDataUse;
      D3DBufferUsage mUsage;
  };
  
  }
  
  #endif // LIBANGLE_RENDERER_D3D_BUFFERD3D_H_
  

Download