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

• Show log

  Commit

• Hash : 4928b7ca
  Author :
  Date : 2017-06-20T12:57:39
  

  Proliferate gl::Context everywhere.
  
  This gives the D3D back-end access to the GL state almost anywhere.
  This uses the onDestroy hook for Textures to push errors up from
  destructors, although they still don't quite make it to the Context.
  
  There are places, such as in EGL object (Context/Surface) destruction,
  where we end up calling through to GL implementation internals without
  having access to a gl::Context. We handle this via a proxy Context
  to a Display, basically a null context, that has access to impl-side
  state like the Renderer pointer if necessary. It does not have access
  to the normal GL state.
  
  Also Pass gl::Context to RefCountObject::release(). Since we're using
  destroy() methods now, we should not ever call the destructor directly.
  
  BUG=angleproject:1156
  
  Change-Id: Ie4c32ad6bf6caaff0289901f30b5c6bafa2ce259
  Reviewed-on: https://chromium-review.googlesource.com/529707
  Commit-Queue: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Geoff Lang <geofflang@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 Context;
  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::Context *context,
                                 const gl::Box &area,
                                 const gl::PixelUnpackState &unpack,
                                 GLenum type,
                                 const void *input,
                                 bool applySkipImages) = 0;
      virtual gl::Error loadCompressedData(const gl::Context *context,
                                           const gl::Box &area,
                                           const void *input) = 0;
  
      virtual gl::Error setManagedSurface2D(const gl::Context *context,
                                            TextureStorage *storage,
                                            int level)
      {
          return gl::NoError();
      }
      virtual gl::Error setManagedSurfaceCube(const gl::Context *context,
                                              TextureStorage *storage,
                                              int face,
                                              int level)
      {
          return gl::NoError();
      }
      virtual gl::Error setManagedSurface3D(const gl::Context *context,
                                            TextureStorage *storage,
                                            int level)
      {
          return gl::NoError();
      }
      virtual gl::Error setManagedSurface2DArray(const gl::Context *context,
                                                 TextureStorage *storage,
                                                 int layer,
                                                 int level)
      {
          return gl::NoError();
      }
      virtual gl::Error copyToStorage(const gl::Context *context,
                                      TextureStorage *storage,
                                      const gl::ImageIndex &index,
                                      const gl::Box &region) = 0;
  
      virtual gl::Error copyFromTexStorage(const gl::Context *context,
                                           const gl::ImageIndex &imageIndex,
                                           TextureStorage *source) = 0;
      virtual gl::Error copyFromFramebuffer(const gl::Context *context,
                                            const gl::Offset &destOffset,
                                            const gl::Rectangle &sourceArea,
                                            const gl::Framebuffer *source) = 0;
  
    protected:
      GLsizei mWidth;
      GLsizei mHeight;
      GLsizei mDepth;
      GLenum mInternalFormat;
      bool mRenderable;
      GLenum mTarget;
  
      bool mDirty;
  };
  
  }
  
  #endif // LIBANGLE_RENDERER_D3D_IMAGED3D_H_
  

Download