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

• Show log

  Commit

• Hash : 99d492c2
  Author :
  Date : 2018-02-27T15:17:10
  

  Use packed enums for the texture types and targets, part 2
  
  This completes the refactor by using the packed enums in the gl:: layer
  and in the backends.
  
  The packed enum code generation is modified to support explicitly
  assigning values to the packed enums so that the TextureTarget cube map
  faces are in the correct order and easy to iterate over.
  
  BUG=angleproject:2169
  
  Change-Id: I5903235e684ccf382e92a8a1e10c5c85b4b16a04
  Reviewed-on: https://chromium-review.googlesource.com/939994
  Commit-Queue: Corentin Wallez <cwallez@chromium.org>
  Reviewed-by: Geoff Lang <geofflang@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(gl::TextureType type,
                    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