tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

TextureStorage9.h (7628B)


      1 //
      2 // Copyright 2012 The ANGLE Project Authors. All rights reserved.
      3 // Use of this source code is governed by a BSD-style license that can be
      4 // found in the LICENSE file.
      5 //
      6 
      7 // TextureStorage9.h: Defines the abstract rx::TextureStorage9 class and its concrete derived
      8 // classes TextureStorage9_2D and TextureStorage9_Cube, which act as the interface to the
      9 // D3D9 texture.
     10 
     11 #ifndef LIBANGLE_RENDERER_D3D_D3D9_TEXTURESTORAGE9_H_
     12 #define LIBANGLE_RENDERER_D3D_D3D9_TEXTURESTORAGE9_H_
     13 
     14 #include "common/debug.h"
     15 #include "libANGLE/renderer/d3d/TextureStorage.h"
     16 
     17 namespace rx
     18 {
     19 class EGLImageD3D;
     20 class Renderer9;
     21 class SwapChain9;
     22 class RenderTargetD3D;
     23 class RenderTarget9;
     24 
     25 class TextureStorage9 : public TextureStorage
     26 {
     27  public:
     28    ~TextureStorage9() override;
     29 
     30    static DWORD GetTextureUsage(GLenum internalformat, bool renderTarget);
     31 
     32    D3DPOOL getPool() const;
     33    DWORD getUsage() const;
     34 
     35    virtual angle::Result getSurfaceLevel(const gl::Context *context,
     36                                          gl::TextureTarget target,
     37                                          int level,
     38                                          bool dirty,
     39                                          IDirect3DSurface9 **outSurface)    = 0;
     40    virtual angle::Result getBaseTexture(const gl::Context *context,
     41                                         IDirect3DBaseTexture9 **outTexture) = 0;
     42 
     43    int getTopLevel() const override;
     44    bool isRenderTarget() const override;
     45    bool isUnorderedAccess() const override { return false; }
     46    bool isManaged() const override;
     47    bool supportsNativeMipmapFunction() const override;
     48    int getLevelCount() const override;
     49 
     50    angle::Result setData(const gl::Context *context,
     51                          const gl::ImageIndex &index,
     52                          ImageD3D *image,
     53                          const gl::Box *destBox,
     54                          GLenum type,
     55                          const gl::PixelUnpackState &unpack,
     56                          const uint8_t *pixelData) override;
     57 
     58  protected:
     59    int mTopLevel;
     60    size_t mMipLevels;
     61    size_t mTextureWidth;
     62    size_t mTextureHeight;
     63    GLenum mInternalFormat;
     64    D3DFORMAT mTextureFormat;
     65 
     66    Renderer9 *mRenderer;
     67 
     68    TextureStorage9(Renderer9 *renderer, DWORD usage, const std::string &label);
     69 
     70  private:
     71    const DWORD mD3DUsage;
     72    const D3DPOOL mD3DPool;
     73 };
     74 
     75 class TextureStorage9_2D : public TextureStorage9
     76 {
     77  public:
     78    TextureStorage9_2D(Renderer9 *renderer, SwapChain9 *swapchain, const std::string &label);
     79    TextureStorage9_2D(Renderer9 *renderer,
     80                       GLenum internalformat,
     81                       bool renderTarget,
     82                       GLsizei width,
     83                       GLsizei height,
     84                       int levels,
     85                       const std::string &label);
     86    ~TextureStorage9_2D() override;
     87 
     88    angle::Result getSurfaceLevel(const gl::Context *context,
     89                                  gl::TextureTarget target,
     90                                  int level,
     91                                  bool dirty,
     92                                  IDirect3DSurface9 **outSurface) override;
     93    angle::Result findRenderTarget(const gl::Context *context,
     94                                   const gl::ImageIndex &index,
     95                                   GLsizei samples,
     96                                   RenderTargetD3D **outRT) const override;
     97    angle::Result getRenderTarget(const gl::Context *context,
     98                                  const gl::ImageIndex &index,
     99                                  GLsizei samples,
    100                                  RenderTargetD3D **outRT) override;
    101    angle::Result getBaseTexture(const gl::Context *context,
    102                                 IDirect3DBaseTexture9 **outTexture) override;
    103    angle::Result generateMipmap(const gl::Context *context,
    104                                 const gl::ImageIndex &sourceIndex,
    105                                 const gl::ImageIndex &destIndex) override;
    106    angle::Result copyToStorage(const gl::Context *context, TextureStorage *destStorage) override;
    107 
    108  private:
    109    IDirect3DTexture9 *mTexture;
    110    std::vector<RenderTarget9 *> mRenderTargets;
    111 };
    112 
    113 class TextureStorage9_EGLImage final : public TextureStorage9
    114 {
    115  public:
    116    TextureStorage9_EGLImage(Renderer9 *renderer,
    117                             EGLImageD3D *image,
    118                             RenderTarget9 *renderTarget9,
    119                             const std::string &label);
    120    ~TextureStorage9_EGLImage() override;
    121 
    122    angle::Result getSurfaceLevel(const gl::Context *context,
    123                                  gl::TextureTarget target,
    124                                  int level,
    125                                  bool dirty,
    126                                  IDirect3DSurface9 **outSurface) override;
    127    angle::Result findRenderTarget(const gl::Context *context,
    128                                   const gl::ImageIndex &index,
    129                                   GLsizei samples,
    130                                   RenderTargetD3D **outRT) const override;
    131    angle::Result getRenderTarget(const gl::Context *context,
    132                                  const gl::ImageIndex &index,
    133                                  GLsizei samples,
    134                                  RenderTargetD3D **outRT) override;
    135    angle::Result getBaseTexture(const gl::Context *context,
    136                                 IDirect3DBaseTexture9 **outTexture) override;
    137    angle::Result generateMipmap(const gl::Context *context,
    138                                 const gl::ImageIndex &sourceIndex,
    139                                 const gl::ImageIndex &destIndex) override;
    140    angle::Result copyToStorage(const gl::Context *context, TextureStorage *destStorage) override;
    141 
    142  private:
    143    EGLImageD3D *mImage;
    144 };
    145 
    146 class TextureStorage9_Cube : public TextureStorage9
    147 {
    148  public:
    149    TextureStorage9_Cube(Renderer9 *renderer,
    150                         GLenum internalformat,
    151                         bool renderTarget,
    152                         int size,
    153                         int levels,
    154                         bool hintLevelZeroOnly,
    155                         const std::string &label);
    156 
    157    ~TextureStorage9_Cube() override;
    158 
    159    angle::Result getSurfaceLevel(const gl::Context *context,
    160                                  gl::TextureTarget target,
    161                                  int level,
    162                                  bool dirty,
    163                                  IDirect3DSurface9 **outSurface) override;
    164    angle::Result findRenderTarget(const gl::Context *context,
    165                                   const gl::ImageIndex &index,
    166                                   GLsizei samples,
    167                                   RenderTargetD3D **outRT) const override;
    168    angle::Result getRenderTarget(const gl::Context *context,
    169                                  const gl::ImageIndex &index,
    170                                  GLsizei samples,
    171                                  RenderTargetD3D **outRT) override;
    172    angle::Result getBaseTexture(const gl::Context *context,
    173                                 IDirect3DBaseTexture9 **outTexture) override;
    174    angle::Result generateMipmap(const gl::Context *context,
    175                                 const gl::ImageIndex &sourceIndex,
    176                                 const gl::ImageIndex &destIndex) override;
    177    angle::Result copyToStorage(const gl::Context *context, TextureStorage *destStorage) override;
    178 
    179  private:
    180    IDirect3DCubeTexture9 *mTexture;
    181    RenderTarget9 *mRenderTarget[gl::kCubeFaceCount];
    182 };
    183 
    184 }  // namespace rx
    185 
    186 #endif  // LIBANGLE_RENDERER_D3D_D3D9_TEXTURESTORAGE9_H_