• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 // 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
9 // texture.
10 
11 #ifndef LIBANGLE_RENDERER_D3D_D3D11_TEXTURESTORAGE11_H_
12 #define LIBANGLE_RENDERER_D3D_D3D11_TEXTURESTORAGE11_H_
13 
14 #include "libANGLE/Error.h"
15 #include "libANGLE/Texture.h"
16 #include "libANGLE/renderer/d3d/TextureStorage.h"
17 #include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h"
18 #include "libANGLE/renderer/d3d/d3d11/texture_format_table.h"
19 
20 #include <array>
21 #include <map>
22 
23 namespace gl
24 {
25 class ImageIndex;
26 }  // namespace gl
27 
28 namespace rx
29 {
30 class EGLImageD3D;
31 class RenderTargetD3D;
32 class RenderTarget11;
33 class Renderer11;
34 class SwapChain11;
35 class Image11;
36 struct Renderer11DeviceCaps;
37 class TextureStorage11_2DMultisample;
38 
39 template <typename T>
40 using CubeFaceArray = std::array<T, gl::kCubeFaceCount>;
41 
42 struct MultisampledRenderToTextureInfo
43 {
44     MultisampledRenderToTextureInfo(const GLsizei samples,
45                                     const gl::ImageIndex &indexSS,
46                                     const gl::ImageIndex &indexMS);
47     ~MultisampledRenderToTextureInfo();
48 
49     // How many samples the multisampled texture contains
50     GLsizei samples;
51     // This is the image index for the single sampled texture
52     // This will hold the relevant level information
53     gl::ImageIndex indexSS;
54     // This is the image index for the multisampled texture
55     // For multisampled indexes, there is no level Index since they should
56     // account for the entire level.
57     gl::ImageIndex indexMS;
58     // True when multisampled texture has been written to and needs to be
59     // resolved to the single sampled texture
60     bool msTextureNeedsResolve;
61     std::unique_ptr<TextureStorage11_2DMultisample> msTex;
62 };
63 
64 class TextureStorage11 : public TextureStorage
65 {
66   public:
67     ~TextureStorage11() override;
68 
69     static DWORD GetTextureBindFlags(GLenum internalFormat,
70                                      const Renderer11DeviceCaps &renderer11DeviceCaps,
71                                      bool renderTarget);
72     static DWORD GetTextureMiscFlags(GLenum internalFormat,
73                                      const Renderer11DeviceCaps &renderer11DeviceCaps,
74                                      bool renderTarget,
75                                      int levels);
76 
77     UINT getBindFlags() const;
78     UINT getMiscFlags() const;
79     const d3d11::Format &getFormatSet() const;
80     angle::Result getSRVLevels(const gl::Context *context,
81                                GLint baseLevel,
82                                GLint maxLevel,
83                                const d3d11::SharedSRV **outSRV);
84     angle::Result generateSwizzles(const gl::Context *context,
85                                    const gl::SwizzleState &swizzleTarget);
86     void markLevelDirty(int mipLevel);
87     void markDirty();
88 
89     angle::Result updateSubresourceLevel(const gl::Context *context,
90                                          const TextureHelper11 &texture,
91                                          unsigned int sourceSubresource,
92                                          const gl::ImageIndex &index,
93                                          const gl::Box &copyArea);
94 
95     angle::Result copySubresourceLevel(const gl::Context *context,
96                                        const TextureHelper11 &dstTexture,
97                                        unsigned int dstSubresource,
98                                        const gl::ImageIndex &index,
99                                        const gl::Box &region);
100 
101     // TextureStorage virtual functions
102     int getTopLevel() const override;
103     bool isRenderTarget() const override;
104     bool isManaged() const override;
105     bool supportsNativeMipmapFunction() const override;
106     int getLevelCount() const override;
107     angle::Result generateMipmap(const gl::Context *context,
108                                  const gl::ImageIndex &sourceIndex,
109                                  const gl::ImageIndex &destIndex) override;
110     angle::Result copyToStorage(const gl::Context *context, TextureStorage *destStorage) override;
111     angle::Result setData(const gl::Context *context,
112                           const gl::ImageIndex &index,
113                           ImageD3D *image,
114                           const gl::Box *destBox,
115                           GLenum type,
116                           const gl::PixelUnpackState &unpack,
117                           const uint8_t *pixelData) override;
118     void invalidateTextures() override;
119 
120     virtual angle::Result getSRVForSampler(const gl::Context *context,
121                                            const gl::TextureState &textureState,
122                                            const gl::SamplerState &sampler,
123                                            const d3d11::SharedSRV **outSRV);
124     angle::Result getSRVForImage(const gl::Context *context,
125                                  const gl::ImageUnit &imageUnit,
126                                  const d3d11::SharedSRV **outSRV);
127     angle::Result getUAVForImage(const gl::Context *context,
128                                  const gl::ImageUnit &imageUnit,
129                                  const d3d11::SharedUAV **outUAV);
130     virtual angle::Result getSubresourceIndex(const gl::Context *context,
131                                               const gl::ImageIndex &index,
132                                               UINT *outSubresourceIndex) const;
133     virtual angle::Result getResource(const gl::Context *context,
134                                       const TextureHelper11 **outResource)              = 0;
135     virtual void associateImage(Image11 *image, const gl::ImageIndex &index)            = 0;
136     virtual void disassociateImage(const gl::ImageIndex &index, Image11 *expectedImage) = 0;
137     virtual void verifyAssociatedImageValid(const gl::ImageIndex &index,
138                                             Image11 *expectedImage)                     = 0;
139     virtual angle::Result releaseAssociatedImage(const gl::Context *context,
140                                                  const gl::ImageIndex &index,
141                                                  Image11 *incomingImage)                = 0;
142 
143     GLsizei getRenderToTextureSamples() const override;
144 
145   protected:
146     TextureStorage11(Renderer11 *renderer, UINT bindFlags, UINT miscFlags, GLenum internalFormat);
147     int getLevelWidth(int mipLevel) const;
148     int getLevelHeight(int mipLevel) const;
149     int getLevelDepth(int mipLevel) const;
150 
151     // Some classes (e.g. TextureStorage11_2D) will override getMippedResource.
152     virtual angle::Result getMippedResource(const gl::Context *context,
153                                             const TextureHelper11 **outResource);
154 
155     virtual angle::Result getSwizzleTexture(const gl::Context *context,
156                                             const TextureHelper11 **outTexture)          = 0;
157     virtual angle::Result getSwizzleRenderTarget(const gl::Context *context,
158                                                  int mipLevel,
159                                                  const d3d11::RenderTargetView **outRTV) = 0;
160     angle::Result getSRVLevel(const gl::Context *context,
161                               int mipLevel,
162                               bool blitSRV,
163                               const d3d11::SharedSRV **outSRV);
164 
165     // Get a version of a depth texture with only depth information, not stencil.
166     enum DropStencil
167     {
168         CREATED,
169         ALREADY_EXISTS
170     };
171     virtual angle::Result ensureDropStencilTexture(const gl::Context *context,
172                                                    DropStencil *dropStencilOut);
173     angle::Result initDropStencilTexture(const gl::Context *context,
174                                          const gl::ImageIndexIterator &it);
175 
176     // The baseLevel parameter should *not* have mTopLevel applied.
177     virtual angle::Result createSRVForSampler(const gl::Context *context,
178                                               int baseLevel,
179                                               int mipLevels,
180                                               DXGI_FORMAT format,
181                                               const TextureHelper11 &texture,
182                                               d3d11::SharedSRV *outSRV) = 0;
183     virtual angle::Result createSRVForImage(const gl::Context *context,
184                                             int level,
185                                             DXGI_FORMAT format,
186                                             const TextureHelper11 &texture,
187                                             d3d11::SharedSRV *outSRV)   = 0;
188     virtual angle::Result createUAVForImage(const gl::Context *context,
189                                             int level,
190                                             DXGI_FORMAT format,
191                                             const TextureHelper11 &texture,
192                                             d3d11::SharedUAV *outUAV)   = 0;
193 
194     void verifySwizzleExists(const gl::SwizzleState &swizzleState);
195 
196     // Clear all cached non-swizzle SRVs and invalidate the swizzle cache.
197     void clearSRVCache();
198 
199     // Helper for resolving MS shadowed texture
200     angle::Result resolveTextureHelper(const gl::Context *context, const TextureHelper11 &texture);
201     angle::Result releaseMultisampledTexStorageForLevel(size_t level) override;
202     angle::Result findMultisampledRenderTarget(const gl::Context *context,
203                                                const gl::ImageIndex &index,
204                                                GLsizei samples,
205                                                RenderTargetD3D **outRT) const;
206     angle::Result getMultisampledRenderTarget(const gl::Context *context,
207                                               const gl::ImageIndex &index,
208                                               GLsizei samples,
209                                               RenderTargetD3D **outRT);
210 
211     Renderer11 *mRenderer;
212     int mTopLevel;
213     unsigned int mMipLevels;
214 
215     const d3d11::Format &mFormatInfo;
216     unsigned int mTextureWidth;
217     unsigned int mTextureHeight;
218     unsigned int mTextureDepth;
219 
220     gl::TexLevelArray<gl::SwizzleState> mSwizzleCache;
221     TextureHelper11 mDropStencilTexture;
222 
223     std::unique_ptr<MultisampledRenderToTextureInfo> mMSTexInfo;
224 
225   private:
226     const UINT mBindFlags;
227     const UINT mMiscFlags;
228 
229     struct SamplerKey
230     {
231         SamplerKey();
232         SamplerKey(int baseLevel, int mipLevels, bool swizzle, bool dropStencil);
233 
234         bool operator<(const SamplerKey &rhs) const;
235 
236         int baseLevel;
237         int mipLevels;
238         bool swizzle;
239         bool dropStencil;
240     };
241 
242     angle::Result getCachedOrCreateSRVForSampler(const gl::Context *context,
243                                                  const SamplerKey &key,
244                                                  const d3d11::SharedSRV **outSRV);
245 
246     using SRVCacheForSampler = std::map<SamplerKey, d3d11::SharedSRV>;
247     SRVCacheForSampler mSrvCacheForSampler;
248 
249     struct ImageKey
250     {
251         ImageKey();
252         ImageKey(int level, bool layered, int layer, GLenum access, GLenum format);
253         bool operator<(const ImageKey &rhs) const;
254         int level;
255         bool layered;
256         int layer;
257         GLenum access;
258         GLenum format;
259     };
260 
261     angle::Result getCachedOrCreateSRVForImage(const gl::Context *context,
262                                                const ImageKey &key,
263                                                const d3d11::SharedSRV **outSRV);
264     angle::Result getCachedOrCreateUAVForImage(const gl::Context *context,
265                                                const ImageKey &key,
266                                                const d3d11::SharedUAV **outUAV);
267 
268     using SRVCacheForImage = std::map<ImageKey, d3d11::SharedSRV>;
269     SRVCacheForImage mSrvCacheForImage;
270     using UAVCacheForImage = std::map<ImageKey, d3d11::SharedUAV>;
271     UAVCacheForImage mUavCacheForImage;
272 
273     gl::TexLevelArray<d3d11::SharedSRV> mLevelSRVs;
274     gl::TexLevelArray<d3d11::SharedSRV> mLevelBlitSRVs;
275 };
276 
277 class TextureStorage11_2D : public TextureStorage11
278 {
279   public:
280     TextureStorage11_2D(Renderer11 *renderer, SwapChain11 *swapchain);
281     TextureStorage11_2D(Renderer11 *renderer,
282                         GLenum internalformat,
283                         bool renderTarget,
284                         GLsizei width,
285                         GLsizei height,
286                         int levels,
287                         bool hintLevelZeroOnly = false);
288     ~TextureStorage11_2D() override;
289 
290     angle::Result onDestroy(const gl::Context *context) override;
291 
292     angle::Result getResource(const gl::Context *context,
293                               const TextureHelper11 **outResource) override;
294     angle::Result getMippedResource(const gl::Context *context,
295                                     const TextureHelper11 **outResource) override;
296     angle::Result findRenderTarget(const gl::Context *context,
297                                    const gl::ImageIndex &index,
298                                    GLsizei samples,
299                                    RenderTargetD3D **outRT) const override;
300     angle::Result getRenderTarget(const gl::Context *context,
301                                   const gl::ImageIndex &index,
302                                   GLsizei samples,
303                                   RenderTargetD3D **outRT) override;
304 
305     angle::Result copyToStorage(const gl::Context *context, TextureStorage *destStorage) override;
306 
307     void associateImage(Image11 *image, const gl::ImageIndex &index) override;
308     void disassociateImage(const gl::ImageIndex &index, Image11 *expectedImage) override;
309     void verifyAssociatedImageValid(const gl::ImageIndex &index, Image11 *expectedImage) override;
310     angle::Result releaseAssociatedImage(const gl::Context *context,
311                                          const gl::ImageIndex &index,
312                                          Image11 *incomingImage) override;
313 
314     angle::Result useLevelZeroWorkaroundTexture(const gl::Context *context,
315                                                 bool useLevelZeroTexture) override;
316 
317   protected:
318     angle::Result getSwizzleTexture(const gl::Context *context,
319                                     const TextureHelper11 **outTexture) override;
320     angle::Result getSwizzleRenderTarget(const gl::Context *context,
321                                          int mipLevel,
322                                          const d3d11::RenderTargetView **outRTV) override;
323 
324     angle::Result ensureDropStencilTexture(const gl::Context *context,
325                                            DropStencil *dropStencilOut) override;
326 
327     angle::Result ensureTextureExists(const gl::Context *context, int mipLevels);
328 
329     angle::Result resolveTexture(const gl::Context *context) override;
330 
331   private:
332     angle::Result createSRVForSampler(const gl::Context *context,
333                                       int baseLevel,
334                                       int mipLevels,
335                                       DXGI_FORMAT format,
336                                       const TextureHelper11 &texture,
337                                       d3d11::SharedSRV *outSRV) override;
338     angle::Result createSRVForImage(const gl::Context *context,
339                                     int level,
340                                     DXGI_FORMAT format,
341                                     const TextureHelper11 &texture,
342                                     d3d11::SharedSRV *outSRV) override;
343     angle::Result createUAVForImage(const gl::Context *context,
344                                     int level,
345                                     DXGI_FORMAT format,
346                                     const TextureHelper11 &texture,
347                                     d3d11::SharedUAV *outUAV) override;
348 
349     TextureHelper11 mTexture;
350     gl::TexLevelArray<std::unique_ptr<RenderTarget11>> mRenderTarget;
351     bool mHasKeyedMutex;
352 
353     // These are members related to the zero max-LOD workaround.
354     // D3D11 Feature Level 9_3 can't disable mipmaps on a mipmapped texture (i.e. solely sample from
355     // level zero). These members are used to work around this limitation. Usually only mTexture XOR
356     // mLevelZeroTexture will exist. For example, if an app creates a texture with only one level,
357     // then 9_3 will only create mLevelZeroTexture. However, in some scenarios, both textures have
358     // to be created. This incurs additional memory overhead. One example of this is an application
359     // that creates a texture, calls glGenerateMipmap, and then disables mipmaps on the texture. A
360     // more likely example is an app that creates an empty texture, renders to it, and then calls
361     // glGenerateMipmap
362     // TODO: In this rendering scenario, release the mLevelZeroTexture after mTexture has been
363     // created to save memory.
364     TextureHelper11 mLevelZeroTexture;
365     std::unique_ptr<RenderTarget11> mLevelZeroRenderTarget;
366     bool mUseLevelZeroTexture;
367 
368     // Swizzle-related variables
369     TextureHelper11 mSwizzleTexture;
370     gl::TexLevelArray<d3d11::RenderTargetView> mSwizzleRenderTargets;
371 
372     gl::TexLevelArray<Image11 *> mAssociatedImages;
373 };
374 
375 class TextureStorage11_External : public TextureStorage11
376 {
377   public:
378     TextureStorage11_External(Renderer11 *renderer,
379                               egl::Stream *stream,
380                               const egl::Stream::GLTextureDescription &glDesc);
381     ~TextureStorage11_External() override;
382 
383     angle::Result onDestroy(const gl::Context *context) override;
384 
385     angle::Result getResource(const gl::Context *context,
386                               const TextureHelper11 **outResource) override;
387     angle::Result getMippedResource(const gl::Context *context,
388                                     const TextureHelper11 **outResource) override;
389     angle::Result findRenderTarget(const gl::Context *context,
390                                    const gl::ImageIndex &index,
391                                    GLsizei samples,
392                                    RenderTargetD3D **outRT) const override;
393     angle::Result getRenderTarget(const gl::Context *context,
394                                   const gl::ImageIndex &index,
395                                   GLsizei samples,
396                                   RenderTargetD3D **outRT) override;
397 
398     angle::Result copyToStorage(const gl::Context *context, TextureStorage *destStorage) override;
399 
400     void associateImage(Image11 *image, const gl::ImageIndex &index) override;
401     void disassociateImage(const gl::ImageIndex &index, Image11 *expectedImage) override;
402     void verifyAssociatedImageValid(const gl::ImageIndex &index, Image11 *expectedImage) override;
403     angle::Result releaseAssociatedImage(const gl::Context *context,
404                                          const gl::ImageIndex &index,
405                                          Image11 *incomingImage) override;
406 
407   protected:
408     angle::Result getSwizzleTexture(const gl::Context *context,
409                                     const TextureHelper11 **outTexture) override;
410     angle::Result getSwizzleRenderTarget(const gl::Context *context,
411                                          int mipLevel,
412                                          const d3d11::RenderTargetView **outRTV) override;
413 
414   private:
415     angle::Result createSRVForSampler(const gl::Context *context,
416                                       int baseLevel,
417                                       int mipLevels,
418                                       DXGI_FORMAT format,
419                                       const TextureHelper11 &texture,
420                                       d3d11::SharedSRV *outSRV) override;
421     angle::Result createSRVForImage(const gl::Context *context,
422                                     int level,
423                                     DXGI_FORMAT format,
424                                     const TextureHelper11 &texture,
425                                     d3d11::SharedSRV *outSRV) override;
426     angle::Result createUAVForImage(const gl::Context *context,
427                                     int level,
428                                     DXGI_FORMAT format,
429                                     const TextureHelper11 &texture,
430                                     d3d11::SharedUAV *outUAV) override;
431 
432     TextureHelper11 mTexture;
433     int mSubresourceIndex;
434     bool mHasKeyedMutex;
435 
436     Image11 *mAssociatedImage;
437 };
438 
439 // A base class for texture storage classes where the associated images are not changed, nor are
440 // they accessible as images in GLES3.1+ shaders.
441 class TextureStorage11ImmutableBase : public TextureStorage11
442 {
443   public:
444     TextureStorage11ImmutableBase(Renderer11 *renderer,
445                                   UINT bindFlags,
446                                   UINT miscFlags,
447                                   GLenum internalFormat);
448 
449     void associateImage(Image11 *image, const gl::ImageIndex &index) override;
450     void disassociateImage(const gl::ImageIndex &index, Image11 *expectedImage) override;
451     void verifyAssociatedImageValid(const gl::ImageIndex &index, Image11 *expectedImage) override;
452     angle::Result releaseAssociatedImage(const gl::Context *context,
453                                          const gl::ImageIndex &index,
454                                          Image11 *incomingImage) override;
455 
456     angle::Result createSRVForImage(const gl::Context *context,
457                                     int level,
458                                     DXGI_FORMAT format,
459                                     const TextureHelper11 &texture,
460                                     d3d11::SharedSRV *outSRV) override;
461     angle::Result createUAVForImage(const gl::Context *context,
462                                     int level,
463                                     DXGI_FORMAT format,
464                                     const TextureHelper11 &texture,
465                                     d3d11::SharedUAV *outUAV) override;
466 };
467 
468 class TextureStorage11_EGLImage final : public TextureStorage11ImmutableBase
469 {
470   public:
471     TextureStorage11_EGLImage(Renderer11 *renderer,
472                               EGLImageD3D *eglImage,
473                               RenderTarget11 *renderTarget11);
474     ~TextureStorage11_EGLImage() override;
475 
476     angle::Result getSubresourceIndex(const gl::Context *context,
477                                       const gl::ImageIndex &index,
478                                       UINT *outSubresourceIndex) const override;
479     angle::Result getResource(const gl::Context *context,
480                               const TextureHelper11 **outResource) override;
481     angle::Result getSRVForSampler(const gl::Context *context,
482                                    const gl::TextureState &textureState,
483                                    const gl::SamplerState &sampler,
484                                    const d3d11::SharedSRV **outSRV) override;
485     angle::Result getMippedResource(const gl::Context *context,
486                                     const TextureHelper11 **outResource) override;
487     angle::Result findRenderTarget(const gl::Context *context,
488                                    const gl::ImageIndex &index,
489                                    GLsizei samples,
490                                    RenderTargetD3D **outRT) const override;
491     angle::Result getRenderTarget(const gl::Context *context,
492                                   const gl::ImageIndex &index,
493                                   GLsizei samples,
494                                   RenderTargetD3D **outRT) override;
495 
496     angle::Result copyToStorage(const gl::Context *context, TextureStorage *destStorage) override;
497 
498     angle::Result useLevelZeroWorkaroundTexture(const gl::Context *context,
499                                                 bool useLevelZeroTexture) override;
500 
501   protected:
502     angle::Result getSwizzleTexture(const gl::Context *context,
503                                     const TextureHelper11 **outTexture) override;
504     angle::Result getSwizzleRenderTarget(const gl::Context *context,
505                                          int mipLevel,
506                                          const d3d11::RenderTargetView **outRTV) override;
507 
508   private:
509     // Check if the EGL image's render target has been updated due to orphaning and delete
510     // any SRVs and other resources based on the image's old render target.
511     angle::Result checkForUpdatedRenderTarget(const gl::Context *context);
512 
513     angle::Result createSRVForSampler(const gl::Context *context,
514                                       int baseLevel,
515                                       int mipLevels,
516                                       DXGI_FORMAT format,
517                                       const TextureHelper11 &texture,
518                                       d3d11::SharedSRV *outSRV) override;
519 
520     angle::Result getImageRenderTarget(const gl::Context *context, RenderTarget11 **outRT) const;
521 
522     EGLImageD3D *mImage;
523     uintptr_t mCurrentRenderTarget;
524 
525     // Swizzle-related variables
526     TextureHelper11 mSwizzleTexture;
527     std::vector<d3d11::RenderTargetView> mSwizzleRenderTargets;
528 };
529 
530 class TextureStorage11_Cube : public TextureStorage11
531 {
532   public:
533     TextureStorage11_Cube(Renderer11 *renderer,
534                           GLenum internalformat,
535                           bool renderTarget,
536                           int size,
537                           int levels,
538                           bool hintLevelZeroOnly);
539     ~TextureStorage11_Cube() override;
540 
541     angle::Result onDestroy(const gl::Context *context) override;
542 
543     angle::Result getSubresourceIndex(const gl::Context *context,
544                                       const gl::ImageIndex &index,
545                                       UINT *outSubresourceIndex) const override;
546 
547     angle::Result getResource(const gl::Context *context,
548                               const TextureHelper11 **outResource) override;
549     angle::Result getMippedResource(const gl::Context *context,
550                                     const TextureHelper11 **outResource) override;
551     angle::Result findRenderTarget(const gl::Context *context,
552                                    const gl::ImageIndex &index,
553                                    GLsizei samples,
554                                    RenderTargetD3D **outRT) const override;
555     angle::Result getRenderTarget(const gl::Context *context,
556                                   const gl::ImageIndex &index,
557                                   GLsizei samples,
558                                   RenderTargetD3D **outRT) override;
559 
560     angle::Result copyToStorage(const gl::Context *context, TextureStorage *destStorage) override;
561 
562     void associateImage(Image11 *image, const gl::ImageIndex &index) override;
563     void disassociateImage(const gl::ImageIndex &index, Image11 *expectedImage) override;
564     void verifyAssociatedImageValid(const gl::ImageIndex &index, Image11 *expectedImage) override;
565     angle::Result releaseAssociatedImage(const gl::Context *context,
566                                          const gl::ImageIndex &index,
567                                          Image11 *incomingImage) override;
568 
569     angle::Result useLevelZeroWorkaroundTexture(const gl::Context *context,
570                                                 bool useLevelZeroTexture) override;
571 
572   protected:
573     angle::Result getSwizzleTexture(const gl::Context *context,
574                                     const TextureHelper11 **outTexture) override;
575     angle::Result getSwizzleRenderTarget(const gl::Context *context,
576                                          int mipLevel,
577                                          const d3d11::RenderTargetView **outRTV) override;
578 
579     angle::Result ensureDropStencilTexture(const gl::Context *context,
580                                            DropStencil *dropStencilOut) override;
581 
582     angle::Result ensureTextureExists(const gl::Context *context, int mipLevels);
583 
584     angle::Result resolveTexture(const gl::Context *context) override;
585 
586   private:
587     angle::Result createSRVForSampler(const gl::Context *context,
588                                       int baseLevel,
589                                       int mipLevels,
590                                       DXGI_FORMAT format,
591                                       const TextureHelper11 &texture,
592                                       d3d11::SharedSRV *outSRV) override;
593     angle::Result createSRVForImage(const gl::Context *context,
594                                     int level,
595                                     DXGI_FORMAT format,
596                                     const TextureHelper11 &texture,
597                                     d3d11::SharedSRV *outSRV) override;
598     angle::Result createUAVForImage(const gl::Context *context,
599                                     int level,
600                                     DXGI_FORMAT format,
601                                     const TextureHelper11 &texture,
602                                     d3d11::SharedUAV *outUAV) override;
603     angle::Result createRenderTargetSRV(const gl::Context *context,
604                                         const TextureHelper11 &texture,
605                                         const gl::ImageIndex &index,
606                                         DXGI_FORMAT resourceFormat,
607                                         d3d11::SharedSRV *srv) const;
608 
609     TextureHelper11 mTexture;
610     CubeFaceArray<gl::TexLevelArray<std::unique_ptr<RenderTarget11>>> mRenderTarget;
611 
612     // Level-zero workaround members. See TextureStorage11_2D's workaround members for a
613     // description.
614     TextureHelper11 mLevelZeroTexture;
615     CubeFaceArray<std::unique_ptr<RenderTarget11>> mLevelZeroRenderTarget;
616     bool mUseLevelZeroTexture;
617 
618     TextureHelper11 mSwizzleTexture;
619     gl::TexLevelArray<d3d11::RenderTargetView> mSwizzleRenderTargets;
620 
621     CubeFaceArray<gl::TexLevelArray<Image11 *>> mAssociatedImages;
622 };
623 
624 class TextureStorage11_3D : public TextureStorage11
625 {
626   public:
627     TextureStorage11_3D(Renderer11 *renderer,
628                         GLenum internalformat,
629                         bool renderTarget,
630                         GLsizei width,
631                         GLsizei height,
632                         GLsizei depth,
633                         int levels);
634     ~TextureStorage11_3D() override;
635 
636     angle::Result onDestroy(const gl::Context *context) override;
637 
638     angle::Result getResource(const gl::Context *context,
639                               const TextureHelper11 **outResource) override;
640 
641     // Handles both layer and non-layer RTs
642     angle::Result findRenderTarget(const gl::Context *context,
643                                    const gl::ImageIndex &index,
644                                    GLsizei samples,
645                                    RenderTargetD3D **outRT) const override;
646     angle::Result getRenderTarget(const gl::Context *context,
647                                   const gl::ImageIndex &index,
648                                   GLsizei samples,
649                                   RenderTargetD3D **outRT) override;
650 
651     void associateImage(Image11 *image, const gl::ImageIndex &index) override;
652     void disassociateImage(const gl::ImageIndex &index, Image11 *expectedImage) override;
653     void verifyAssociatedImageValid(const gl::ImageIndex &index, Image11 *expectedImage) override;
654     angle::Result releaseAssociatedImage(const gl::Context *context,
655                                          const gl::ImageIndex &index,
656                                          Image11 *incomingImage) override;
657 
658   protected:
659     angle::Result getSwizzleTexture(const gl::Context *context,
660                                     const TextureHelper11 **outTexture) override;
661     angle::Result getSwizzleRenderTarget(const gl::Context *context,
662                                          int mipLevel,
663                                          const d3d11::RenderTargetView **outRTV) override;
664 
665   private:
666     angle::Result createSRVForSampler(const gl::Context *context,
667                                       int baseLevel,
668                                       int mipLevels,
669                                       DXGI_FORMAT format,
670                                       const TextureHelper11 &texture,
671                                       d3d11::SharedSRV *outSRV) override;
672     angle::Result createSRVForImage(const gl::Context *context,
673                                     int level,
674                                     DXGI_FORMAT format,
675                                     const TextureHelper11 &texture,
676                                     d3d11::SharedSRV *outSRV) override;
677     angle::Result createUAVForImage(const gl::Context *context,
678                                     int level,
679                                     DXGI_FORMAT format,
680                                     const TextureHelper11 &texture,
681                                     d3d11::SharedUAV *outUAV) override;
682 
683     typedef std::pair<int, int> LevelLayerKey;
684     std::map<LevelLayerKey, std::unique_ptr<RenderTarget11>> mLevelLayerRenderTargets;
685 
686     gl::TexLevelArray<std::unique_ptr<RenderTarget11>> mLevelRenderTargets;
687 
688     TextureHelper11 mTexture;
689     TextureHelper11 mSwizzleTexture;
690     gl::TexLevelArray<d3d11::RenderTargetView> mSwizzleRenderTargets;
691 
692     gl::TexLevelArray<Image11 *> mAssociatedImages;
693 };
694 
695 class TextureStorage11_2DArray : public TextureStorage11
696 {
697   public:
698     TextureStorage11_2DArray(Renderer11 *renderer,
699                              GLenum internalformat,
700                              bool renderTarget,
701                              GLsizei width,
702                              GLsizei height,
703                              GLsizei depth,
704                              int levels);
705     ~TextureStorage11_2DArray() override;
706 
707     angle::Result onDestroy(const gl::Context *context) override;
708 
709     angle::Result getResource(const gl::Context *context,
710                               const TextureHelper11 **outResource) override;
711     angle::Result findRenderTarget(const gl::Context *context,
712                                    const gl::ImageIndex &index,
713                                    GLsizei samples,
714                                    RenderTargetD3D **outRT) const override;
715     angle::Result getRenderTarget(const gl::Context *context,
716                                   const gl::ImageIndex &index,
717                                   GLsizei samples,
718                                   RenderTargetD3D **outRT) override;
719 
720     void associateImage(Image11 *image, const gl::ImageIndex &index) override;
721     void disassociateImage(const gl::ImageIndex &index, Image11 *expectedImage) override;
722     void verifyAssociatedImageValid(const gl::ImageIndex &index, Image11 *expectedImage) override;
723     angle::Result releaseAssociatedImage(const gl::Context *context,
724                                          const gl::ImageIndex &index,
725                                          Image11 *incomingImage) override;
726 
727     struct LevelLayerRangeKey
728     {
LevelLayerRangeKeyLevelLayerRangeKey729         LevelLayerRangeKey(int mipLevelIn, int layerIn, int numLayersIn)
730             : mipLevel(mipLevelIn), layer(layerIn), numLayers(numLayersIn)
731         {}
732         bool operator<(const LevelLayerRangeKey &other) const
733         {
734             if (mipLevel != other.mipLevel)
735             {
736                 return mipLevel < other.mipLevel;
737             }
738             if (layer != other.layer)
739             {
740                 return layer < other.layer;
741             }
742             return numLayers < other.numLayers;
743         }
744         int mipLevel;
745         int layer;
746         int numLayers;
747     };
748 
749   protected:
750     angle::Result getSwizzleTexture(const gl::Context *context,
751                                     const TextureHelper11 **outTexture) override;
752     angle::Result getSwizzleRenderTarget(const gl::Context *context,
753                                          int mipLevel,
754                                          const d3d11::RenderTargetView **outRTV) override;
755 
756     angle::Result ensureDropStencilTexture(const gl::Context *context,
757                                            DropStencil *dropStencilOut) override;
758 
759   private:
760     angle::Result createSRVForSampler(const gl::Context *context,
761                                       int baseLevel,
762                                       int mipLevels,
763                                       DXGI_FORMAT format,
764                                       const TextureHelper11 &texture,
765                                       d3d11::SharedSRV *outSRV) override;
766     angle::Result createSRVForImage(const gl::Context *context,
767                                     int level,
768                                     DXGI_FORMAT format,
769                                     const TextureHelper11 &texture,
770                                     d3d11::SharedSRV *outSRV) override;
771     angle::Result createUAVForImage(const gl::Context *context,
772                                     int level,
773                                     DXGI_FORMAT format,
774                                     const TextureHelper11 &texture,
775                                     d3d11::SharedUAV *outUAV) override;
776     angle::Result createRenderTargetSRV(const gl::Context *context,
777                                         const TextureHelper11 &texture,
778                                         const gl::ImageIndex &index,
779                                         DXGI_FORMAT resourceFormat,
780                                         d3d11::SharedSRV *srv) const;
781 
782     std::map<LevelLayerRangeKey, std::unique_ptr<RenderTarget11>> mRenderTargets;
783 
784     TextureHelper11 mTexture;
785 
786     TextureHelper11 mSwizzleTexture;
787     gl::TexLevelArray<d3d11::RenderTargetView> mSwizzleRenderTargets;
788 
789     typedef std::map<LevelLayerRangeKey, Image11 *> ImageMap;
790     ImageMap mAssociatedImages;
791 };
792 
793 class TextureStorage11_2DMultisample final : public TextureStorage11ImmutableBase
794 {
795   public:
796     TextureStorage11_2DMultisample(Renderer11 *renderer,
797                                    GLenum internalformat,
798                                    GLsizei width,
799                                    GLsizei height,
800                                    int levels,
801                                    int samples,
802                                    bool fixedSampleLocations);
803     ~TextureStorage11_2DMultisample() override;
804 
805     angle::Result onDestroy(const gl::Context *context) override;
806 
807     angle::Result getResource(const gl::Context *context,
808                               const TextureHelper11 **outResource) override;
809     angle::Result findRenderTarget(const gl::Context *context,
810                                    const gl::ImageIndex &index,
811                                    GLsizei samples,
812                                    RenderTargetD3D **outRT) const override;
813     angle::Result getRenderTarget(const gl::Context *context,
814                                   const gl::ImageIndex &index,
815                                   GLsizei samples,
816                                   RenderTargetD3D **outRT) override;
817 
818     angle::Result copyToStorage(const gl::Context *context, TextureStorage *destStorage) override;
819 
820   protected:
821     angle::Result getSwizzleTexture(const gl::Context *context,
822                                     const TextureHelper11 **outTexture) override;
823     angle::Result getSwizzleRenderTarget(const gl::Context *context,
824                                          int mipLevel,
825                                          const d3d11::RenderTargetView **outRTV) override;
826 
827     angle::Result ensureDropStencilTexture(const gl::Context *context,
828                                            DropStencil *dropStencilOut) override;
829 
830     angle::Result ensureTextureExists(const gl::Context *context, int mipLevels);
831 
832   private:
833     angle::Result createSRVForSampler(const gl::Context *context,
834                                       int baseLevel,
835                                       int mipLevels,
836                                       DXGI_FORMAT format,
837                                       const TextureHelper11 &texture,
838                                       d3d11::SharedSRV *outSRV) override;
839 
840     TextureHelper11 mTexture;
841     std::unique_ptr<RenderTarget11> mRenderTarget;
842 
843     unsigned int mSamples;
844     GLboolean mFixedSampleLocations;
845 };
846 
847 class TextureStorage11_2DMultisampleArray final : public TextureStorage11ImmutableBase
848 {
849   public:
850     TextureStorage11_2DMultisampleArray(Renderer11 *renderer,
851                                         GLenum internalformat,
852                                         GLsizei width,
853                                         GLsizei height,
854                                         GLsizei depth,
855                                         int levels,
856                                         int samples,
857                                         bool fixedSampleLocations);
858     ~TextureStorage11_2DMultisampleArray() override;
859 
860     angle::Result onDestroy(const gl::Context *context) override;
861 
862     angle::Result getResource(const gl::Context *context,
863                               const TextureHelper11 **outResource) override;
864     angle::Result findRenderTarget(const gl::Context *context,
865                                    const gl::ImageIndex &index,
866                                    GLsizei samples,
867                                    RenderTargetD3D **outRT) const override;
868     angle::Result getRenderTarget(const gl::Context *context,
869                                   const gl::ImageIndex &index,
870                                   GLsizei samples,
871                                   RenderTargetD3D **outRT) override;
872 
873     angle::Result copyToStorage(const gl::Context *context, TextureStorage *destStorage) override;
874 
875   protected:
876     angle::Result getSwizzleTexture(const gl::Context *context,
877                                     const TextureHelper11 **outTexture) override;
878     angle::Result getSwizzleRenderTarget(const gl::Context *context,
879                                          int mipLevel,
880                                          const d3d11::RenderTargetView **outRTV) override;
881 
882     angle::Result ensureDropStencilTexture(const gl::Context *context,
883                                            DropStencil *dropStencilOut) override;
884 
885     angle::Result ensureTextureExists(const gl::Context *context, int mipLevels);
886 
887   private:
888     angle::Result createRenderTargetSRV(const gl::Context *context,
889                                         const TextureHelper11 &texture,
890                                         const gl::ImageIndex &index,
891                                         DXGI_FORMAT resourceFormat,
892                                         d3d11::SharedSRV *srv) const;
893 
894     angle::Result createSRVForSampler(const gl::Context *context,
895                                       int baseLevel,
896                                       int mipLevels,
897                                       DXGI_FORMAT format,
898                                       const TextureHelper11 &texture,
899                                       d3d11::SharedSRV *outSRV) override;
900 
901     TextureHelper11 mTexture;
902     std::map<TextureStorage11_2DArray::LevelLayerRangeKey, std::unique_ptr<RenderTarget11>>
903         mRenderTargets;
904 
905     unsigned int mSamples;
906     GLboolean mFixedSampleLocations;
907 };
908 }  // namespace rx
909 
910 #endif  // LIBANGLE_RENDERER_D3D_D3D11_TEXTURESTORAGE11_H_
911