kc3-lang/angle/src/libANGLE/renderer/d3d/d3d9/Image9.h

• Show log

  Commit

• Hash : acf2f3ad
  Author :
  Date : 2017-11-21T19:22:44
  

  Apply Chromium style fixes.
  
  This addresses several minor code quality issues that are validated
  in Chromium, but not yet applied to ANGLE:
  
  * constructors and destructors must be defined out-of-line
  * auto is not allowed for simple pointer types
  * use override everywhere instead of virtual
  * virtual functions must also be defined out-of-line
  
  Slightly reduces binary size for me (~2k on Win, 150k on Linux).
  
  Bug: angleproject:1569
  Change-Id: I073ca3365188caf5f29fb28d9eb207903c1843e6
  Reviewed-on: https://chromium-review.googlesource.com/779959
  Commit-Queue: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  

Download

• src/libANGLE/renderer/d3d/d3d9/Image9.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.
  //
  
  // Image9.h: Defines the rx::Image9 class, which acts as the interface to
  // the actual underlying surfaces of a Texture.
  
  #ifndef LIBANGLE_RENDERER_D3D_D3D9_IMAGE9_H_
  #define LIBANGLE_RENDERER_D3D_D3D9_IMAGE9_H_
  
  #include "libANGLE/renderer/d3d/ImageD3D.h"
  #include "common/debug.h"
  
  namespace gl
  {
  class Framebuffer;
  }
  
  namespace rx
  {
  class Renderer9;
  
  class Image9 : public ImageD3D
  {
    public:
      Image9(Renderer9 *renderer);
      ~Image9() override;
  
      static gl::Error generateMipmap(Image9 *dest, Image9 *source);
      static gl::Error generateMip(IDirect3DSurface9 *destSurface, IDirect3DSurface9 *sourceSurface);
      static gl::Error copyLockableSurfaces(IDirect3DSurface9 *dest, IDirect3DSurface9 *source);
      static gl::Error CopyImage(const gl::Context *context,
                                 Image9 *dest,
                                 Image9 *source,
                                 const gl::Rectangle &sourceRect,
                                 const gl::Offset &destOffset,
                                 bool unpackFlipY,
                                 bool unpackPremultiplyAlpha,
                                 bool unpackUnmultiplyAlpha);
  
      bool redefine(GLenum target, GLenum internalformat, const gl::Extents &size, bool forceRelease) override;
  
      D3DFORMAT getD3DFormat() const;
  
      bool isDirty() const override;
  
      gl::Error setManagedSurface2D(const gl::Context *context,
                                    TextureStorage *storage,
                                    int level) override;
      gl::Error setManagedSurfaceCube(const gl::Context *context,
                                      TextureStorage *storage,
                                      int face,
                                      int level) override;
      gl::Error copyToStorage(const gl::Context *context,
                              TextureStorage *storage,
                              const gl::ImageIndex &index,
                              const gl::Box &region) override;
  
      gl::Error loadData(const gl::Context *context,
                         const gl::Box &area,
                         const gl::PixelUnpackState &unpack,
                         GLenum type,
                         const void *input,
                         bool applySkipImages) override;
      gl::Error loadCompressedData(const gl::Context *context,
                                   const gl::Box &area,
                                   const void *input) override;
  
      gl::Error copyFromTexStorage(const gl::Context *context,
                                   const gl::ImageIndex &imageIndex,
                                   TextureStorage *source) override;
      gl::Error copyFromFramebuffer(const gl::Context *context,
                                    const gl::Offset &destOffset,
                                    const gl::Rectangle &sourceArea,
                                    const gl::Framebuffer *source) override;
  
    private:
      gl::Error getSurface(IDirect3DSurface9 **outSurface);
  
      gl::Error createSurface();
      gl::Error setManagedSurface(IDirect3DSurface9 *surface);
      gl::Error copyToSurface(IDirect3DSurface9 *dest, const gl::Box &area);
  
      gl::Error lock(D3DLOCKED_RECT *lockedRect, const RECT &rect);
      void unlock();
  
      gl::Error copyFromRTInternal(const gl::Offset &destOffset,
                                   const gl::Rectangle &sourceArea,
                                   RenderTargetD3D *source);
  
      Renderer9 *mRenderer;
  
      D3DPOOL mD3DPool;   // can only be D3DPOOL_SYSTEMMEM or D3DPOOL_MANAGED since it needs to be lockable.
      D3DFORMAT mD3DFormat;
  
      IDirect3DSurface9 *mSurface;
  };
  }
  
  #endif   // LIBANGLE_RENDERER_D3D_D3D9_IMAGE9_H_
  

Download