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

• Show log

  Commit

• Hash : f0d10f89
  Author :
  Date : 2015-03-31T12:56:52
  

  Replace non-copyable macro with a helper class.
  
  This class provides a simpler scheme for blocking default copy
  and assignment operators. It also reduces the amount of code
  needed since it's inherited to child classes. This also fixes
  the conflict between our macro and the same-named macro in
  Chromium code.
  
  BUG=angleproject:956
  
  Change-Id: If0dc72aa3f63fbc7b8fa34907418821c64c39e2f
  Reviewed-on: https://chromium-review.googlesource.com/263257
  Tested-by: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  Reviewed-by: Brandon Jones <bajones@chromium.org>
  

Download

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

• //
  // Copyright (c) 2002-2015 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.
  //
  
  // ImageD3D.h: Defines the rx::ImageD3D class, an abstract base class for the
  // renderer-specific classes which will define the interface to the underlying
  // surfaces or resources.
  
  #ifndef LIBANGLE_RENDERER_D3D_IMAGED3D_H_
  #define LIBANGLE_RENDERER_D3D_IMAGED3D_H_
  
  #include "common/debug.h"
  
  #include "libANGLE/Error.h"
  
  namespace gl
  {
  class Framebuffer;
  struct ImageIndex;
  struct Box;
  struct Extents;
  struct Offset;
  struct Rectangle;
  struct PixelUnpackState;
  }
  
  namespace rx
  {
  class TextureStorage;
  class RendererD3D;
  class RenderTargetD3D;
  
  class ImageD3D : angle::NonCopyable
  {
    public:
      ImageD3D();
      virtual ~ImageD3D() {};
  
      GLsizei getWidth() const { return mWidth; }
      GLsizei getHeight() const { return mHeight; }
      GLsizei getDepth() const { return mDepth; }
      GLenum getInternalFormat() const { return mInternalFormat; }
      GLenum getTarget() const { return mTarget; }
      bool isRenderableFormat() const { return mRenderable; }
  
      void markDirty() { mDirty = true; }
      void markClean() { mDirty = false; }
      virtual bool isDirty() const = 0;
  
      virtual bool redefine(GLenum target, GLenum internalformat, const gl::Extents &size, bool forceRelease) = 0;
  
      virtual gl::Error loadData(const gl::Box &area, const gl::PixelUnpackState &unpack, GLenum type, const void *input) = 0;
      virtual gl::Error loadCompressedData(const gl::Box &area, const void *input) = 0;
  
      virtual gl::Error setManagedSurface2D(TextureStorage *storage, int level) { return gl::Error(GL_NO_ERROR); };
      virtual gl::Error setManagedSurfaceCube(TextureStorage *storage, int face, int level) { return gl::Error(GL_NO_ERROR); };
      virtual gl::Error setManagedSurface3D(TextureStorage *storage, int level) { return gl::Error(GL_NO_ERROR); };
      virtual gl::Error setManagedSurface2DArray(TextureStorage *storage, int layer, int level) { return gl::Error(GL_NO_ERROR); };
      virtual gl::Error copyToStorage(TextureStorage *storage, const gl::ImageIndex &index, const gl::Box &region) = 0;
  
      virtual gl::Error copy(const gl::Offset &destOffset, const gl::Box &sourceArea,
                             const gl::ImageIndex &sourceIndex, TextureStorage *source) = 0;
  
      gl::Error copy(const gl::Offset &destOffset, const gl::Rectangle &sourceArea, const gl::Framebuffer *source);
  
    protected:
      GLsizei mWidth;
      GLsizei mHeight;
      GLsizei mDepth;
      GLenum mInternalFormat;
      bool mRenderable;
      GLenum mTarget;
  
      bool mDirty;
  
    private:
      virtual gl::Error copy(const gl::Offset &destOffset, const gl::Rectangle &sourceArea, RenderTargetD3D *source) = 0;
  };
  
  }
  
  #endif // LIBANGLE_RENDERER_D3D_IMAGED3D_H_
  

Download