Home | History | Annotate | Download | only in d3d11
      1 //
      2 // Copyright (c) 2012-2013 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 // TextureStorage11.h: Defines the abstract rx::TextureStorage11 class and its concrete derived
      8 // classes TextureStorage11_2D and TextureStorage11_Cube, which act as the interface to the D3D11 texture.
      9 
     10 #ifndef LIBGLESV2_RENDERER_TEXTURESTORAGE11_H_
     11 #define LIBGLESV2_RENDERER_TEXTURESTORAGE11_H_
     12 
     13 #include "libGLESv2/Texture.h"
     14 #include "libGLESv2/renderer/TextureStorage.h"
     15 
     16 namespace rx
     17 {
     18 class RenderTarget;
     19 class RenderTarget11;
     20 class Renderer;
     21 class Renderer11;
     22 class SwapChain11;
     23 
     24 class TextureStorage11 : public TextureStorage
     25 {
     26   public:
     27     virtual ~TextureStorage11();
     28 
     29     static TextureStorage11 *makeTextureStorage11(TextureStorage *storage);
     30 
     31     static DWORD GetTextureBindFlags(GLenum internalFormat, GLuint clientVersion, bool renderTarget);
     32 
     33     UINT getBindFlags() const;
     34 
     35     virtual ID3D11Resource *getResource() const = 0;
     36     virtual ID3D11ShaderResourceView *getSRV(const gl::SamplerState &samplerState);
     37     virtual RenderTarget *getRenderTarget(int level) { return NULL; }
     38     virtual RenderTarget *getRenderTargetFace(GLenum faceTarget, int level) { return NULL; }
     39     virtual RenderTarget *getRenderTargetLayer(int mipLevel, int layer) { return NULL; }
     40 
     41     virtual void generateMipmap(int level) {};
     42     virtual void generateMipmap(int face, int level) {};
     43 
     44     virtual int getTopLevel() const;
     45     virtual bool isRenderTarget() const;
     46     virtual bool isManaged() const;
     47     virtual int getLevelCount() const;
     48     UINT getSubresourceIndex(int mipLevel, int layerTarget) const;
     49 
     50     void generateSwizzles(GLenum swizzleRed, GLenum swizzleGreen, GLenum swizzleBlue, GLenum swizzleAlpha);
     51     void invalidateSwizzleCacheLevel(int mipLevel);
     52     void invalidateSwizzleCache();
     53 
     54     bool updateSubresourceLevel(ID3D11Resource *texture, unsigned int sourceSubresource, int level,
     55                                 int layerTarget, GLint xoffset, GLint yoffset, GLint zoffset,
     56                                 GLsizei width, GLsizei height, GLsizei depth);
     57 
     58   protected:
     59     TextureStorage11(Renderer *renderer, UINT bindFlags);
     60     void generateMipmapLayer(RenderTarget11 *source, RenderTarget11 *dest);
     61     int getLevelWidth(int mipLevel) const;
     62     int getLevelHeight(int mipLevel) const;
     63     int getLevelDepth(int mipLevel) const;
     64 
     65     virtual ID3D11Resource *getSwizzleTexture() = 0;
     66     virtual ID3D11RenderTargetView *getSwizzleRenderTarget(int mipLevel) = 0;
     67     ID3D11ShaderResourceView *getSRVLevel(int mipLevel);
     68 
     69     virtual ID3D11ShaderResourceView *createSRV(int baseLevel, int mipLevels, DXGI_FORMAT format, ID3D11Resource *texture) = 0;
     70 
     71     void verifySwizzleExists(GLenum swizzleRed, GLenum swizzleGreen, GLenum swizzleBlue, GLenum swizzleAlpha);
     72 
     73     virtual unsigned int getTextureLevelDepth(int mipLevel) const = 0;
     74 
     75     Renderer11 *mRenderer;
     76     int mTopLevel;
     77     unsigned int mMipLevels;
     78 
     79     DXGI_FORMAT mTextureFormat;
     80     DXGI_FORMAT mShaderResourceFormat;
     81     DXGI_FORMAT mRenderTargetFormat;
     82     DXGI_FORMAT mDepthStencilFormat;
     83     DXGI_FORMAT mSwizzleTextureFormat;
     84     DXGI_FORMAT mSwizzleShaderResourceFormat;
     85     DXGI_FORMAT mSwizzleRenderTargetFormat;
     86     unsigned int mTextureWidth;
     87     unsigned int mTextureHeight;
     88     unsigned int mTextureDepth;
     89 
     90     struct SwizzleCacheValue
     91     {
     92         GLenum swizzleRed;
     93         GLenum swizzleGreen;
     94         GLenum swizzleBlue;
     95         GLenum swizzleAlpha;
     96 
     97         SwizzleCacheValue();
     98         SwizzleCacheValue(GLenum red, GLenum green, GLenum blue, GLenum alpha);
     99 
    100         bool operator ==(const SwizzleCacheValue &other) const;
    101         bool operator !=(const SwizzleCacheValue &other) const;
    102     };
    103     SwizzleCacheValue mSwizzleCache[gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS];
    104 
    105     struct SRVKey
    106     {
    107         SRVKey(int baseLevel = 0, int mipLevels = 0, bool swizzle = false);
    108 
    109         bool operator==(const SRVKey &rhs) const;
    110 
    111         int baseLevel;
    112         int mipLevels;
    113         bool swizzle;
    114     };
    115 
    116     struct SRVPair
    117     {
    118         SRVKey key;
    119         ID3D11ShaderResourceView *srv;
    120     };
    121 
    122     struct SRVCache
    123     {
    124         ~SRVCache();
    125 
    126         ID3D11ShaderResourceView *find(const SRVKey &key) const;
    127         ID3D11ShaderResourceView *add(const SRVKey &key, ID3D11ShaderResourceView *srv);
    128 
    129         std::vector<SRVPair> cache;
    130     };
    131 
    132   private:
    133     DISALLOW_COPY_AND_ASSIGN(TextureStorage11);
    134 
    135     const UINT mBindFlags;
    136 
    137     SRVCache srvCache;
    138     ID3D11ShaderResourceView *mLevelSRVs[gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS];
    139 };
    140 
    141 class TextureStorage11_2D : public TextureStorage11
    142 {
    143   public:
    144     TextureStorage11_2D(Renderer *renderer, SwapChain11 *swapchain);
    145     TextureStorage11_2D(Renderer *renderer, GLenum internalformat, bool renderTarget, GLsizei width, GLsizei height, int levels);
    146     virtual ~TextureStorage11_2D();
    147 
    148     static TextureStorage11_2D *makeTextureStorage11_2D(TextureStorage *storage);
    149 
    150     virtual ID3D11Resource *getResource() const;
    151     virtual RenderTarget *getRenderTarget(int level);
    152 
    153     virtual void generateMipmap(int level);
    154 
    155   protected:
    156     virtual ID3D11Resource *getSwizzleTexture();
    157     virtual ID3D11RenderTargetView *getSwizzleRenderTarget(int mipLevel);
    158 
    159     virtual unsigned int getTextureLevelDepth(int mipLevel) const;
    160 
    161   private:
    162     DISALLOW_COPY_AND_ASSIGN(TextureStorage11_2D);
    163 
    164     virtual ID3D11ShaderResourceView *createSRV(int baseLevel, int mipLevels, DXGI_FORMAT format, ID3D11Resource *texture);
    165 
    166     ID3D11Texture2D *mTexture;
    167     RenderTarget11 *mRenderTarget[gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS];
    168 
    169     ID3D11Texture2D *mSwizzleTexture;
    170     ID3D11RenderTargetView *mSwizzleRenderTargets[gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS];
    171 };
    172 
    173 class TextureStorage11_Cube : public TextureStorage11
    174 {
    175   public:
    176     TextureStorage11_Cube(Renderer *renderer, GLenum internalformat, bool renderTarget, int size, int levels);
    177     virtual ~TextureStorage11_Cube();
    178 
    179     static TextureStorage11_Cube *makeTextureStorage11_Cube(TextureStorage *storage);
    180 
    181     virtual ID3D11Resource *getResource() const;
    182     virtual RenderTarget *getRenderTargetFace(GLenum faceTarget, int level);
    183 
    184     virtual void generateMipmap(int faceIndex, int level);
    185 
    186   protected:
    187     virtual ID3D11Resource *getSwizzleTexture();
    188     virtual ID3D11RenderTargetView *getSwizzleRenderTarget(int mipLevel);
    189 
    190     virtual unsigned int getTextureLevelDepth(int mipLevel) const;
    191 
    192   private:
    193     DISALLOW_COPY_AND_ASSIGN(TextureStorage11_Cube);
    194 
    195     virtual ID3D11ShaderResourceView *createSRV(int baseLevel, int mipLevels, DXGI_FORMAT format, ID3D11Resource *texture);
    196 
    197     ID3D11Texture2D *mTexture;
    198     RenderTarget11 *mRenderTarget[6][gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS];
    199 
    200     ID3D11Texture2D *mSwizzleTexture;
    201     ID3D11RenderTargetView *mSwizzleRenderTargets[gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS];
    202 };
    203 
    204 class TextureStorage11_3D : public TextureStorage11
    205 {
    206   public:
    207     TextureStorage11_3D(Renderer *renderer, GLenum internalformat, bool renderTarget,
    208                         GLsizei width, GLsizei height, GLsizei depth, int levels);
    209     virtual ~TextureStorage11_3D();
    210 
    211     static TextureStorage11_3D *makeTextureStorage11_3D(TextureStorage *storage);
    212 
    213     virtual ID3D11Resource *getResource() const;
    214     virtual RenderTarget *getRenderTarget(int mipLevel);
    215     virtual RenderTarget *getRenderTargetLayer(int mipLevel, int layer);
    216 
    217     virtual void generateMipmap(int level);
    218 
    219   protected:
    220     virtual ID3D11Resource *getSwizzleTexture();
    221     virtual ID3D11RenderTargetView *getSwizzleRenderTarget(int mipLevel);
    222 
    223     virtual unsigned int getTextureLevelDepth(int mipLevel) const;
    224 
    225   private:
    226     DISALLOW_COPY_AND_ASSIGN(TextureStorage11_3D);
    227 
    228     virtual ID3D11ShaderResourceView *createSRV(int baseLevel, int mipLevels, DXGI_FORMAT format, ID3D11Resource *texture);
    229 
    230     typedef std::pair<int, int> LevelLayerKey;
    231     typedef std::map<LevelLayerKey, RenderTarget11*> RenderTargetMap;
    232     RenderTargetMap mLevelLayerRenderTargets;
    233 
    234     RenderTarget11 *mLevelRenderTargets[gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS];
    235 
    236     ID3D11Texture3D *mTexture;
    237     ID3D11Texture3D *mSwizzleTexture;
    238     ID3D11RenderTargetView *mSwizzleRenderTargets[gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS];
    239 };
    240 
    241 class TextureStorage11_2DArray : public TextureStorage11
    242 {
    243   public:
    244     TextureStorage11_2DArray(Renderer *renderer, GLenum internalformat, bool renderTarget,
    245                              GLsizei width, GLsizei height, GLsizei depth, int levels);
    246     virtual ~TextureStorage11_2DArray();
    247 
    248     static TextureStorage11_2DArray *makeTextureStorage11_2DArray(TextureStorage *storage);
    249 
    250     virtual ID3D11Resource *getResource() const;
    251     virtual RenderTarget *getRenderTargetLayer(int mipLevel, int layer);
    252 
    253     virtual void generateMipmap(int level);
    254 
    255   protected:
    256     virtual ID3D11Resource *getSwizzleTexture();
    257     virtual ID3D11RenderTargetView *getSwizzleRenderTarget(int mipLevel);
    258 
    259     virtual unsigned int getTextureLevelDepth(int mipLevel) const;
    260 
    261   private:
    262     DISALLOW_COPY_AND_ASSIGN(TextureStorage11_2DArray);
    263 
    264     virtual ID3D11ShaderResourceView *createSRV(int baseLevel, int mipLevels, DXGI_FORMAT format, ID3D11Resource *texture);
    265 
    266     typedef std::pair<int, int> LevelLayerKey;
    267     typedef std::map<LevelLayerKey, RenderTarget11*> RenderTargetMap;
    268     RenderTargetMap mRenderTargets;
    269 
    270     ID3D11Texture2D *mTexture;
    271 
    272     ID3D11Texture2D *mSwizzleTexture;
    273     ID3D11RenderTargetView *mSwizzleRenderTargets[gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS];
    274 };
    275 
    276 }
    277 
    278 #endif // LIBGLESV2_RENDERER_TEXTURESTORAGE11_H_
    279