src/third_party/angle/src/libGLESv2/renderer/d3d/d3d11/TextureStorage11.h

   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/Error.h"
  15 #include "libGLESv2/renderer/d3d/TextureStorage.h"
  16
  17 #include <map>
  18
  19 namespace gl
  20 {
  21 struct ImageIndex;
  22 }
  23
  24 namespace rx
  25 {
  26 class RenderTarget;
  27 class RenderTarget11;
  28 class Renderer;
  29 class Renderer11;
  30 class SwapChain11;
  31 class Image11;
  32
  33 class TextureStorage11 : public TextureStorage
  34 {
  35   public:
  36     virtual ~TextureStorage11();
  37
  38     static TextureStorage11 *makeTextureStorage11(TextureStorage *storage);
  39
  40     static DWORD GetTextureBindFlags(GLenum internalFormat, bool renderTarget);
  41
  42     UINT getBindFlags() const;
  43
  44     virtual gl::Error getResource(ID3D11Resource **outResource) = 0;
  45     virtual gl::Error getSRV(const gl::SamplerState &samplerState, ID3D11ShaderResourceView **outSRV);
  46     virtual gl::Error getRenderTarget(const gl::ImageIndex &index, RenderTarget **outRT) = 0;
  47
  48     virtual gl::Error generateMipmap(const gl::ImageIndex &sourceIndex, const gl::ImageIndex &destIndex);
  49
  50     virtual int getTopLevel() const;
  51     virtual bool isRenderTarget() const;
  52     virtual bool isManaged() const;
  53     virtual int getLevelCount() const;
  54     UINT getSubresourceIndex(const gl::ImageIndex &index) const;
  55
  56     gl::Error generateSwizzles(GLenum swizzleRed, GLenum swizzleGreen, GLenum swizzleBlue, GLenum swizzleAlpha);
  57     void invalidateSwizzleCacheLevel(int mipLevel);
  58     void invalidateSwizzleCache();
  59
  60     gl::Error updateSubresourceLevel(ID3D11Resource *texture, unsigned int sourceSubresource,
  61                                      const gl::ImageIndex &index, const gl::Box &copyArea);
  62
  63     gl::Error copySubresourceLevel(ID3D11Resource* dstTexture, unsigned int dstSubresource,
  64                                    const gl::ImageIndex &index, const gl::Box &region);
  65
  66     virtual void associateImage(Image11* image, const gl::ImageIndex &index) = 0;
  67     virtual void disassociateImage(const gl::ImageIndex &index, Image11* expectedImage) = 0;
  68     virtual bool isAssociatedImageValid(const gl::ImageIndex &index, Image11* expectedImage) = 0;
  69     virtual gl::Error releaseAssociatedImage(const gl::ImageIndex &index, Image11* incomingImage) = 0;
  70
  71     virtual gl::Error copyToStorage(TextureStorage *destStorage);
  72     virtual gl::Error setData(const gl::ImageIndex &index, Image *image, const gl::Box *destBox, GLenum type,
  73                               const gl::PixelUnpackState &unpack, const uint8_t *pixelData);
  74
  75   protected:
  76     TextureStorage11(Renderer *renderer, UINT bindFlags);
  77     int getLevelWidth(int mipLevel) const;
  78     int getLevelHeight(int mipLevel) const;
  79     int getLevelDepth(int mipLevel) const;
  80
  81     virtual gl::Error getSwizzleTexture(ID3D11Resource **outTexture) = 0;
  82     virtual gl::Error getSwizzleRenderTarget(int mipLevel, ID3D11RenderTargetView **outRTV) = 0;
  83     gl::Error getSRVLevel(int mipLevel, ID3D11ShaderResourceView **outSRV);
  84
  85     virtual gl::Error createSRV(int baseLevel, int mipLevels, DXGI_FORMAT format, ID3D11Resource *texture,
  86                                 ID3D11ShaderResourceView **outSRV) const = 0;
  87
  88     void verifySwizzleExists(GLenum swizzleRed, GLenum swizzleGreen, GLenum swizzleBlue, GLenum swizzleAlpha);
  89
  90     Renderer11 *mRenderer;
  91     int mTopLevel;
  92     unsigned int mMipLevels;
  93
  94     DXGI_FORMAT mTextureFormat;
  95     DXGI_FORMAT mShaderResourceFormat;
  96     DXGI_FORMAT mRenderTargetFormat;
  97     DXGI_FORMAT mDepthStencilFormat;
  98     DXGI_FORMAT mSwizzleTextureFormat;
  99     DXGI_FORMAT mSwizzleShaderResourceFormat;
 100     DXGI_FORMAT mSwizzleRenderTargetFormat;
 101     unsigned int mTextureWidth;
 102     unsigned int mTextureHeight;
 103     unsigned int mTextureDepth;
 104
 105     struct SwizzleCacheValue
 106     {
 107         GLenum swizzleRed;
 108         GLenum swizzleGreen;
 109         GLenum swizzleBlue;
 110         GLenum swizzleAlpha;
 111
 112         SwizzleCacheValue();
 113         SwizzleCacheValue(GLenum red, GLenum green, GLenum blue, GLenum alpha);
 114
 115         bool operator ==(const SwizzleCacheValue &other) const;
 116         bool operator !=(const SwizzleCacheValue &other) const;
 117     };
 118     SwizzleCacheValue mSwizzleCache[gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS];
 119
 120   private:
 121     DISALLOW_COPY_AND_ASSIGN(TextureStorage11);
 122
 123     const UINT mBindFlags;
 124
 125     struct SRVKey
 126     {
 127         SRVKey(int baseLevel = 0, int mipLevels = 0, bool swizzle = false);
 128
 129         bool operator<(const SRVKey &rhs) const;
 130
 131         int baseLevel;
 132         int mipLevels;
 133         bool swizzle;
 134     };
 135     typedef std::map<SRVKey, ID3D11ShaderResourceView *> SRVCache;
 136
 137     SRVCache mSrvCache;
 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 gl::Error getResource(ID3D11Resource **outResource);
 151     virtual gl::Error getRenderTarget(const gl::ImageIndex &index, RenderTarget **outRT);
 152
 153     virtual void associateImage(Image11* image, const gl::ImageIndex &index);
 154     virtual void disassociateImage(const gl::ImageIndex &index, Image11* expectedImage);
 155     virtual bool isAssociatedImageValid(const gl::ImageIndex &index, Image11* expectedImage);
 156     virtual gl::Error releaseAssociatedImage(const gl::ImageIndex &index, Image11* incomingImage);
 157
 158   protected:
 159     virtual gl::Error getSwizzleTexture(ID3D11Resource **outTexture);
 160     virtual gl::Error getSwizzleRenderTarget(int mipLevel, ID3D11RenderTargetView **outRTV);
 161
 162   private:
 163     DISALLOW_COPY_AND_ASSIGN(TextureStorage11_2D);
 164
 165     virtual gl::Error createSRV(int baseLevel, int mipLevels, DXGI_FORMAT format, ID3D11Resource *texture,
 166                                 ID3D11ShaderResourceView **outSRV) const;
 167
 168     ID3D11Texture2D *mTexture;
 169     RenderTarget11 *mRenderTarget[gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS];
 170
 171     ID3D11Texture2D *mSwizzleTexture;
 172     ID3D11RenderTargetView *mSwizzleRenderTargets[gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS];
 173
 174     Image11 *mAssociatedImages[gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS];
 175 };
 176
 177 class TextureStorage11_Cube : public TextureStorage11
 178 {
 179   public:
 180     TextureStorage11_Cube(Renderer *renderer, GLenum internalformat, bool renderTarget, int size, int levels);
 181     virtual ~TextureStorage11_Cube();
 182
 183     static TextureStorage11_Cube *makeTextureStorage11_Cube(TextureStorage *storage);
 184
 185     virtual gl::Error getResource(ID3D11Resource **outResource);
 186     virtual gl::Error getRenderTarget(const gl::ImageIndex &index, RenderTarget **outRT);
 187
 188     virtual void associateImage(Image11* image, const gl::ImageIndex &index);
 189     virtual void disassociateImage(const gl::ImageIndex &index, Image11* expectedImage);
 190     virtual bool isAssociatedImageValid(const gl::ImageIndex &index, Image11* expectedImage);
 191     virtual gl::Error releaseAssociatedImage(const gl::ImageIndex &index, Image11* incomingImage);
 192
 193   protected:
 194     virtual gl::Error getSwizzleTexture(ID3D11Resource **outTexture);
 195     virtual gl::Error getSwizzleRenderTarget(int mipLevel, ID3D11RenderTargetView **outRTV);
 196
 197   private:
 198     DISALLOW_COPY_AND_ASSIGN(TextureStorage11_Cube);
 199
 200     virtual gl::Error createSRV(int baseLevel, int mipLevels, DXGI_FORMAT format, ID3D11Resource *texture,
 201                                 ID3D11ShaderResourceView **outSRV) const;
 202
 203     static const size_t CUBE_FACE_COUNT = 6;
 204
 205     ID3D11Texture2D *mTexture;
 206     RenderTarget11 *mRenderTarget[CUBE_FACE_COUNT][gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS];
 207
 208     ID3D11Texture2D *mSwizzleTexture;
 209     ID3D11RenderTargetView *mSwizzleRenderTargets[gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS];
 210
 211     Image11 *mAssociatedImages[CUBE_FACE_COUNT][gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS];
 212 };
 213
 214 class TextureStorage11_3D : public TextureStorage11
 215 {
 216   public:
 217     TextureStorage11_3D(Renderer *renderer, GLenum internalformat, bool renderTarget,
 218                         GLsizei width, GLsizei height, GLsizei depth, int levels);
 219     virtual ~TextureStorage11_3D();
 220
 221     static TextureStorage11_3D *makeTextureStorage11_3D(TextureStorage *storage);
 222
 223     virtual gl::Error getResource(ID3D11Resource **outResource);
 224
 225     // Handles both layer and non-layer RTs
 226     virtual gl::Error getRenderTarget(const gl::ImageIndex &index, RenderTarget **outRT);
 227
 228     virtual void associateImage(Image11* image, const gl::ImageIndex &index);
 229     virtual void disassociateImage(const gl::ImageIndex &index, Image11* expectedImage);
 230     virtual bool isAssociatedImageValid(const gl::ImageIndex &index, Image11* expectedImage);
 231     virtual gl::Error releaseAssociatedImage(const gl::ImageIndex &index, Image11* incomingImage);
 232
 233   protected:
 234     virtual gl::Error getSwizzleTexture(ID3D11Resource **outTexture);
 235     virtual gl::Error getSwizzleRenderTarget(int mipLevel, ID3D11RenderTargetView **outRTV);
 236
 237   private:
 238     DISALLOW_COPY_AND_ASSIGN(TextureStorage11_3D);
 239
 240     virtual gl::Error createSRV(int baseLevel, int mipLevels, DXGI_FORMAT format, ID3D11Resource *texture,
 241                                 ID3D11ShaderResourceView **outSRV) const;
 242
 243     typedef std::pair<int, int> LevelLayerKey;
 244     typedef std::map<LevelLayerKey, RenderTarget11*> RenderTargetMap;
 245     RenderTargetMap mLevelLayerRenderTargets;
 246
 247     RenderTarget11 *mLevelRenderTargets[gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS];
 248
 249     ID3D11Texture3D *mTexture;
 250     ID3D11Texture3D *mSwizzleTexture;
 251     ID3D11RenderTargetView *mSwizzleRenderTargets[gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS];
 252
 253     Image11 *mAssociatedImages[gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS];
 254 };
 255
 256 class TextureStorage11_2DArray : public TextureStorage11
 257 {
 258   public:
 259     TextureStorage11_2DArray(Renderer *renderer, GLenum internalformat, bool renderTarget,
 260                              GLsizei width, GLsizei height, GLsizei depth, int levels);
 261     virtual ~TextureStorage11_2DArray();
 262
 263     static TextureStorage11_2DArray *makeTextureStorage11_2DArray(TextureStorage *storage);
 264
 265     virtual gl::Error getResource(ID3D11Resource **outResource);
 266     virtual gl::Error getRenderTarget(const gl::ImageIndex &index, RenderTarget **outRT);
 267
 268     virtual void associateImage(Image11* image, const gl::ImageIndex &index);
 269     virtual void disassociateImage(const gl::ImageIndex &index, Image11* expectedImage);
 270     virtual bool isAssociatedImageValid(const gl::ImageIndex &index, Image11* expectedImage);
 271     virtual gl::Error releaseAssociatedImage(const gl::ImageIndex &index, Image11* incomingImage);
 272
 273   protected:
 274     virtual gl::Error getSwizzleTexture(ID3D11Resource **outTexture);
 275     virtual gl::Error getSwizzleRenderTarget(int mipLevel, ID3D11RenderTargetView **outRTV);
 276
 277   private:
 278     DISALLOW_COPY_AND_ASSIGN(TextureStorage11_2DArray);
 279
 280     virtual gl::Error createSRV(int baseLevel, int mipLevels, DXGI_FORMAT format, ID3D11Resource *texture,
 281                                 ID3D11ShaderResourceView **outSRV) const;
 282
 283     typedef std::pair<int, int> LevelLayerKey;
 284     typedef std::map<LevelLayerKey, RenderTarget11*> RenderTargetMap;
 285     RenderTargetMap mRenderTargets;
 286
 287     ID3D11Texture2D *mTexture;
 288
 289     ID3D11Texture2D *mSwizzleTexture;
 290     ID3D11RenderTargetView *mSwizzleRenderTargets[gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS];
 291
 292     typedef std::map<LevelLayerKey, Image11*> ImageMap;
 293     ImageMap mAssociatedImages;
 294 };
 295
 296 }
 297
 298 #endif // LIBGLESV2_RENDERER_TEXTURESTORAGE11_H_