• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 //
2 // Copyright 2014 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 // TextureD3D.h: Implementations of the Texture interfaces shared betweeen the D3D backends.
8 
9 #ifndef LIBANGLE_RENDERER_D3D_TEXTURED3D_H_
10 #define LIBANGLE_RENDERER_D3D_TEXTURED3D_H_
11 
12 #include "common/Color.h"
13 #include "libANGLE/Constants.h"
14 #include "libANGLE/Stream.h"
15 #include "libANGLE/angletypes.h"
16 #include "libANGLE/renderer/TextureImpl.h"
17 #include "libANGLE/renderer/d3d/TextureStorage.h"
18 
19 namespace gl
20 {
21 class Framebuffer;
22 }
23 
24 namespace rx
25 {
26 class EGLImageD3D;
27 class ImageD3D;
28 class RendererD3D;
29 class RenderTargetD3D;
30 class TextureStorage;
31 
32 class TextureD3D : public TextureImpl, public angle::ObserverInterface
33 {
34   public:
35     TextureD3D(const gl::TextureState &data, RendererD3D *renderer);
36     ~TextureD3D() override;
37 
38     void onDestroy(const gl::Context *context) override;
39 
40     angle::Result getNativeTexture(const gl::Context *context, TextureStorage **outStorage);
41 
hasDirtyImages()42     bool hasDirtyImages() const { return mDirtyImages; }
resetDirty()43     void resetDirty() { mDirtyImages = false; }
44 
45     virtual ImageD3D *getImage(const gl::ImageIndex &index) const = 0;
46     virtual GLsizei getLayerCount(int level) const                = 0;
47 
48     angle::Result getImageAndSyncFromStorage(const gl::Context *context,
49                                              const gl::ImageIndex &index,
50                                              ImageD3D **outImage);
51 
52     GLint getBaseLevelWidth() const;
53     GLint getBaseLevelHeight() const;
54     GLenum getBaseLevelInternalFormat() const;
55 
56     angle::Result setStorage(const gl::Context *context,
57                              gl::TextureType type,
58                              size_t levels,
59                              GLenum internalFormat,
60                              const gl::Extents &size) override;
61 
62     angle::Result setStorageMultisample(const gl::Context *context,
63                                         gl::TextureType type,
64                                         GLsizei samples,
65                                         GLint internalformat,
66                                         const gl::Extents &size,
67                                         bool fixedSampleLocations) override;
68 
69     angle::Result setStorageExternalMemory(const gl::Context *context,
70                                            gl::TextureType type,
71                                            size_t levels,
72                                            GLenum internalFormat,
73                                            const gl::Extents &size,
74                                            gl::MemoryObject *memoryObject,
75                                            GLuint64 offset,
76                                            GLbitfield createFlags,
77                                            GLbitfield usageFlags,
78                                            const void *imageCreateInfoPNext) override;
79 
isImmutable()80     bool isImmutable() const { return mImmutable; }
81 
82     virtual angle::Result getRenderTarget(const gl::Context *context,
83                                           const gl::ImageIndex &index,
84                                           GLsizei samples,
85                                           RenderTargetD3D **outRT) = 0;
86 
87     // Returns an iterator over all "Images" for this particular Texture.
88     virtual gl::ImageIndexIterator imageIterator() const = 0;
89 
90     // Returns an ImageIndex for a particular "Image". 3D Textures do not have images for
91     // slices of their depth texures, so 3D textures ignore the layer parameter.
92     virtual gl::ImageIndex getImageIndex(GLint mip, GLint layer) const = 0;
93     virtual bool isValidIndex(const gl::ImageIndex &index) const       = 0;
94 
95     angle::Result setImageExternal(const gl::Context *context,
96                                    gl::TextureType type,
97                                    egl::Stream *stream,
98                                    const egl::Stream::GLTextureDescription &desc) override;
99     angle::Result generateMipmap(const gl::Context *context) override;
hasStorage()100     bool hasStorage() const { return mTexStorage != nullptr; }
101     TextureStorage *getStorage();
102     ImageD3D *getBaseLevelImage() const;
103 
104     angle::Result getAttachmentRenderTarget(const gl::Context *context,
105                                             GLenum binding,
106                                             const gl::ImageIndex &imageIndex,
107                                             GLsizei samples,
108                                             FramebufferAttachmentRenderTarget **rtOut) override;
109 
110     angle::Result setBaseLevel(const gl::Context *context, GLuint baseLevel) override;
111 
112     angle::Result syncState(const gl::Context *context,
113                             const gl::Texture::DirtyBits &dirtyBits,
114                             gl::Command source) override;
115 
116     angle::Result initializeContents(const gl::Context *context,
117                                      const gl::ImageIndex &imageIndex) override;
118 
119     GLsizei getRenderToTextureSamples();
120 
121     void onLabelUpdate() override;
122 
123     // ObserverInterface implementation.
124     void onSubjectStateChange(angle::SubjectIndex index, angle::SubjectMessage message) override;
125 
126   protected:
127     angle::Result setImageImpl(const gl::Context *context,
128                                const gl::ImageIndex &index,
129                                GLenum type,
130                                const gl::PixelUnpackState &unpack,
131                                gl::Buffer *unpackBuffer,
132                                const uint8_t *pixels,
133                                ptrdiff_t layerOffset);
134     angle::Result subImage(const gl::Context *context,
135                            const gl::ImageIndex &index,
136                            const gl::Box &area,
137                            GLenum format,
138                            GLenum type,
139                            const gl::PixelUnpackState &unpack,
140                            gl::Buffer *unpackBuffer,
141                            const uint8_t *pixels,
142                            ptrdiff_t layerOffset);
143     angle::Result setCompressedImageImpl(const gl::Context *context,
144                                          const gl::ImageIndex &index,
145                                          const gl::PixelUnpackState &unpack,
146                                          const uint8_t *pixels,
147                                          ptrdiff_t layerOffset);
148     angle::Result subImageCompressed(const gl::Context *context,
149                                      const gl::ImageIndex &index,
150                                      const gl::Box &area,
151                                      GLenum format,
152                                      const gl::PixelUnpackState &unpack,
153                                      const uint8_t *pixels,
154                                      ptrdiff_t layerOffset);
155     bool isFastUnpackable(const gl::Buffer *unpackBuffer,
156                           const gl::PixelUnpackState &unpack,
157                           GLenum sizedInternalFormat);
158     angle::Result fastUnpackPixels(const gl::Context *context,
159                                    const gl::PixelUnpackState &unpack,
160                                    gl::Buffer *unpackBuffer,
161                                    const uint8_t *pixels,
162                                    const gl::Box &destArea,
163                                    GLenum sizedInternalFormat,
164                                    GLenum type,
165                                    RenderTargetD3D *destRenderTarget);
166 
167     GLint getLevelZeroWidth() const;
168     GLint getLevelZeroHeight() const;
169     virtual GLint getLevelZeroDepth() const;
170 
171     GLint creationLevels(GLsizei width, GLsizei height, GLsizei depth) const;
172     virtual angle::Result initMipmapImages(const gl::Context *context) = 0;
173     bool isBaseImageZeroSize() const;
174     virtual bool isImageComplete(const gl::ImageIndex &index) const = 0;
175 
176     bool canCreateRenderTargetForImage(const gl::ImageIndex &index) const;
177     angle::Result ensureRenderTarget(const gl::Context *context);
178 
179     virtual angle::Result createCompleteStorage(bool renderTarget,
180                                                 TexStoragePointer *outTexStorage) const = 0;
181     virtual angle::Result setCompleteTexStorage(const gl::Context *context,
182                                                 TextureStorage *newCompleteTexStorage)  = 0;
183     angle::Result commitRegion(const gl::Context *context,
184                                const gl::ImageIndex &index,
185                                const gl::Box &region);
186 
187     angle::Result releaseTexStorage(const gl::Context *context);
188 
getBaseLevel()189     GLuint getBaseLevel() const { return mBaseLevel; }
190 
191     virtual void markAllImagesDirty() = 0;
192 
193     GLint getBaseLevelDepth() const;
194 
195     RendererD3D *mRenderer;
196 
197     bool mDirtyImages;
198 
199     bool mImmutable;
200     TextureStorage *mTexStorage;
201     angle::ObserverBinding mTexStorageObserverBinding;
202 
203   private:
204     virtual angle::Result initializeStorage(const gl::Context *context, bool renderTarget) = 0;
205 
206     virtual angle::Result updateStorage(const gl::Context *context) = 0;
207 
208     bool shouldUseSetData(const ImageD3D *image) const;
209 
210     angle::Result generateMipmapUsingImages(const gl::Context *context, const GLuint maxLevel);
211 
212     GLuint mBaseLevel;
213 };
214 
215 class TextureD3D_2D : public TextureD3D
216 {
217   public:
218     TextureD3D_2D(const gl::TextureState &data, RendererD3D *renderer);
219     ~TextureD3D_2D() override;
220 
221     void onDestroy(const gl::Context *context) override;
222 
223     ImageD3D *getImage(int level, int layer) const;
224     ImageD3D *getImage(const gl::ImageIndex &index) const override;
225     GLsizei getLayerCount(int level) const override;
226 
227     GLsizei getWidth(GLint level) const;
228     GLsizei getHeight(GLint level) const;
229     GLenum getInternalFormat(GLint level) const;
230     bool isDepth(GLint level) const;
231     bool isSRGB(GLint level) const;
232 
233     angle::Result setImage(const gl::Context *context,
234                            const gl::ImageIndex &index,
235                            GLenum internalFormat,
236                            const gl::Extents &size,
237                            GLenum format,
238                            GLenum type,
239                            const gl::PixelUnpackState &unpack,
240                            gl::Buffer *unpackBuffer,
241                            const uint8_t *pixels) override;
242     angle::Result setSubImage(const gl::Context *context,
243                               const gl::ImageIndex &index,
244                               const gl::Box &area,
245                               GLenum format,
246                               GLenum type,
247                               const gl::PixelUnpackState &unpack,
248                               gl::Buffer *unpackBuffer,
249                               const uint8_t *pixels) override;
250 
251     angle::Result setCompressedImage(const gl::Context *context,
252                                      const gl::ImageIndex &index,
253                                      GLenum internalFormat,
254                                      const gl::Extents &size,
255                                      const gl::PixelUnpackState &unpack,
256                                      size_t imageSize,
257                                      const uint8_t *pixels) override;
258     angle::Result setCompressedSubImage(const gl::Context *context,
259                                         const gl::ImageIndex &index,
260                                         const gl::Box &area,
261                                         GLenum format,
262                                         const gl::PixelUnpackState &unpack,
263                                         size_t imageSize,
264                                         const uint8_t *pixels) override;
265 
266     angle::Result copyImage(const gl::Context *context,
267                             const gl::ImageIndex &index,
268                             const gl::Rectangle &sourceArea,
269                             GLenum internalFormat,
270                             gl::Framebuffer *source) override;
271     angle::Result copySubImage(const gl::Context *context,
272                                const gl::ImageIndex &index,
273                                const gl::Offset &destOffset,
274                                const gl::Rectangle &sourceArea,
275                                gl::Framebuffer *source) override;
276 
277     angle::Result copyTexture(const gl::Context *context,
278                               const gl::ImageIndex &index,
279                               GLenum internalFormat,
280                               GLenum type,
281                               GLint sourceLevel,
282                               bool unpackFlipY,
283                               bool unpackPremultiplyAlpha,
284                               bool unpackUnmultiplyAlpha,
285                               const gl::Texture *source) override;
286     angle::Result copySubTexture(const gl::Context *context,
287                                  const gl::ImageIndex &index,
288                                  const gl::Offset &destOffset,
289                                  GLint sourceLevel,
290                                  const gl::Box &sourceBox,
291                                  bool unpackFlipY,
292                                  bool unpackPremultiplyAlpha,
293                                  bool unpackUnmultiplyAlpha,
294                                  const gl::Texture *source) override;
295     angle::Result copyCompressedTexture(const gl::Context *context,
296                                         const gl::Texture *source) override;
297 
298     angle::Result setStorage(const gl::Context *context,
299                              gl::TextureType type,
300                              size_t levels,
301                              GLenum internalFormat,
302                              const gl::Extents &size) override;
303 
304     angle::Result bindTexImage(const gl::Context *context, egl::Surface *surface) override;
305     angle::Result releaseTexImage(const gl::Context *context) override;
306 
307     angle::Result setEGLImageTarget(const gl::Context *context,
308                                     gl::TextureType type,
309                                     egl::Image *image) override;
310 
311     angle::Result getRenderTarget(const gl::Context *context,
312                                   const gl::ImageIndex &index,
313                                   GLsizei samples,
314                                   RenderTargetD3D **outRT) override;
315 
316     gl::ImageIndexIterator imageIterator() const override;
317     gl::ImageIndex getImageIndex(GLint mip, GLint layer) const override;
318     bool isValidIndex(const gl::ImageIndex &index) const override;
319 
320   protected:
321     void markAllImagesDirty() override;
322 
323   private:
324     angle::Result initializeStorage(const gl::Context *context, bool renderTarget) override;
325     angle::Result createCompleteStorage(bool renderTarget,
326                                         TexStoragePointer *outTexStorage) const override;
327     angle::Result setCompleteTexStorage(const gl::Context *context,
328                                         TextureStorage *newCompleteTexStorage) override;
329 
330     angle::Result updateStorage(const gl::Context *context) override;
331     angle::Result initMipmapImages(const gl::Context *context) override;
332 
333     bool isValidLevel(int level) const;
334     bool isLevelComplete(int level) const;
335     bool isImageComplete(const gl::ImageIndex &index) const override;
336 
337     angle::Result updateStorageLevel(const gl::Context *context, int level);
338 
339     angle::Result redefineImage(const gl::Context *context,
340                                 size_t level,
341                                 GLenum internalformat,
342                                 const gl::Extents &size,
343                                 bool forceRelease);
344 
345     bool mEGLImageTarget;
346     gl::TexLevelArray<std::unique_ptr<ImageD3D>> mImageArray;
347 };
348 
349 class TextureD3D_Cube : public TextureD3D
350 {
351   public:
352     TextureD3D_Cube(const gl::TextureState &data, RendererD3D *renderer);
353     ~TextureD3D_Cube() override;
354 
355     void onDestroy(const gl::Context *context) override;
356 
357     ImageD3D *getImage(int level, int layer) const;
358     ImageD3D *getImage(const gl::ImageIndex &index) const override;
359     GLsizei getLayerCount(int level) const override;
360 
361     GLenum getInternalFormat(GLint level, GLint layer) const;
362     bool isDepth(GLint level, GLint layer) const;
363     bool isSRGB(GLint level, GLint layer) const;
364 
365     angle::Result setImage(const gl::Context *context,
366                            const gl::ImageIndex &index,
367                            GLenum internalFormat,
368                            const gl::Extents &size,
369                            GLenum format,
370                            GLenum type,
371                            const gl::PixelUnpackState &unpack,
372                            gl::Buffer *unpackBuffer,
373                            const uint8_t *pixels) override;
374     angle::Result setSubImage(const gl::Context *context,
375                               const gl::ImageIndex &index,
376                               const gl::Box &area,
377                               GLenum format,
378                               GLenum type,
379                               const gl::PixelUnpackState &unpack,
380                               gl::Buffer *unpackBuffer,
381                               const uint8_t *pixels) override;
382 
383     angle::Result setCompressedImage(const gl::Context *context,
384                                      const gl::ImageIndex &index,
385                                      GLenum internalFormat,
386                                      const gl::Extents &size,
387                                      const gl::PixelUnpackState &unpack,
388                                      size_t imageSize,
389                                      const uint8_t *pixels) override;
390     angle::Result setCompressedSubImage(const gl::Context *context,
391                                         const gl::ImageIndex &index,
392                                         const gl::Box &area,
393                                         GLenum format,
394                                         const gl::PixelUnpackState &unpack,
395                                         size_t imageSize,
396                                         const uint8_t *pixels) override;
397 
398     angle::Result copyImage(const gl::Context *context,
399                             const gl::ImageIndex &index,
400                             const gl::Rectangle &sourceArea,
401                             GLenum internalFormat,
402                             gl::Framebuffer *source) override;
403     angle::Result copySubImage(const gl::Context *context,
404                                const gl::ImageIndex &index,
405                                const gl::Offset &destOffset,
406                                const gl::Rectangle &sourceArea,
407                                gl::Framebuffer *source) override;
408 
409     angle::Result copyTexture(const gl::Context *context,
410                               const gl::ImageIndex &index,
411                               GLenum internalFormat,
412                               GLenum type,
413                               GLint sourceLevel,
414                               bool unpackFlipY,
415                               bool unpackPremultiplyAlpha,
416                               bool unpackUnmultiplyAlpha,
417                               const gl::Texture *source) override;
418     angle::Result copySubTexture(const gl::Context *context,
419                                  const gl::ImageIndex &index,
420                                  const gl::Offset &destOffset,
421                                  GLint sourceLevel,
422                                  const gl::Box &sourceBox,
423                                  bool unpackFlipY,
424                                  bool unpackPremultiplyAlpha,
425                                  bool unpackUnmultiplyAlpha,
426                                  const gl::Texture *source) override;
427 
428     angle::Result setStorage(const gl::Context *context,
429                              gl::TextureType type,
430                              size_t levels,
431                              GLenum internalFormat,
432                              const gl::Extents &size) override;
433 
434     angle::Result bindTexImage(const gl::Context *context, egl::Surface *surface) override;
435     angle::Result releaseTexImage(const gl::Context *context) override;
436 
437     angle::Result setEGLImageTarget(const gl::Context *context,
438                                     gl::TextureType type,
439                                     egl::Image *image) override;
440 
441     angle::Result getRenderTarget(const gl::Context *context,
442                                   const gl::ImageIndex &index,
443                                   GLsizei samples,
444                                   RenderTargetD3D **outRT) override;
445 
446     gl::ImageIndexIterator imageIterator() const override;
447     gl::ImageIndex getImageIndex(GLint mip, GLint layer) const override;
448     bool isValidIndex(const gl::ImageIndex &index) const override;
449 
450   protected:
451     void markAllImagesDirty() override;
452 
453   private:
454     angle::Result initializeStorage(const gl::Context *context, bool renderTarget) override;
455     angle::Result createCompleteStorage(bool renderTarget,
456                                         TexStoragePointer *outTexStorage) const override;
457     angle::Result setCompleteTexStorage(const gl::Context *context,
458                                         TextureStorage *newCompleteTexStorage) override;
459 
460     angle::Result updateStorage(const gl::Context *context) override;
461     angle::Result initMipmapImages(const gl::Context *context) override;
462 
463     bool isValidFaceLevel(int faceIndex, int level) const;
464     bool isFaceLevelComplete(int faceIndex, int level) const;
465     bool isCubeComplete() const;
466     bool isImageComplete(const gl::ImageIndex &index) const override;
467     angle::Result updateStorageFaceLevel(const gl::Context *context, int faceIndex, int level);
468 
469     angle::Result redefineImage(const gl::Context *context,
470                                 int faceIndex,
471                                 GLint level,
472                                 GLenum internalformat,
473                                 const gl::Extents &size,
474                                 bool forceRelease);
475 
476     std::array<gl::TexLevelArray<std::unique_ptr<ImageD3D>>, 6> mImageArray;
477 };
478 
479 class TextureD3D_3D : public TextureD3D
480 {
481   public:
482     TextureD3D_3D(const gl::TextureState &data, RendererD3D *renderer);
483     ~TextureD3D_3D() override;
484 
485     void onDestroy(const gl::Context *context) override;
486 
487     ImageD3D *getImage(int level, int layer) const;
488     ImageD3D *getImage(const gl::ImageIndex &index) const override;
489     GLsizei getLayerCount(int level) const override;
490 
491     GLsizei getWidth(GLint level) const;
492     GLsizei getHeight(GLint level) const;
493     GLsizei getDepth(GLint level) const;
494     GLenum getInternalFormat(GLint level) const;
495     bool isDepth(GLint level) const;
496     bool isSRGB(GLint level) const;
497 
498     angle::Result setImage(const gl::Context *context,
499                            const gl::ImageIndex &index,
500                            GLenum internalFormat,
501                            const gl::Extents &size,
502                            GLenum format,
503                            GLenum type,
504                            const gl::PixelUnpackState &unpack,
505                            gl::Buffer *unpackBuffer,
506                            const uint8_t *pixels) override;
507     angle::Result setSubImage(const gl::Context *context,
508                               const gl::ImageIndex &index,
509                               const gl::Box &area,
510                               GLenum format,
511                               GLenum type,
512                               const gl::PixelUnpackState &unpack,
513                               gl::Buffer *unpackBuffer,
514                               const uint8_t *pixels) override;
515 
516     angle::Result setCompressedImage(const gl::Context *context,
517                                      const gl::ImageIndex &index,
518                                      GLenum internalFormat,
519                                      const gl::Extents &size,
520                                      const gl::PixelUnpackState &unpack,
521                                      size_t imageSize,
522                                      const uint8_t *pixels) override;
523     angle::Result setCompressedSubImage(const gl::Context *context,
524                                         const gl::ImageIndex &index,
525                                         const gl::Box &area,
526                                         GLenum format,
527                                         const gl::PixelUnpackState &unpack,
528                                         size_t imageSize,
529                                         const uint8_t *pixels) override;
530 
531     angle::Result copyImage(const gl::Context *context,
532                             const gl::ImageIndex &index,
533                             const gl::Rectangle &sourceArea,
534                             GLenum internalFormat,
535                             gl::Framebuffer *source) override;
536     angle::Result copySubImage(const gl::Context *context,
537                                const gl::ImageIndex &index,
538                                const gl::Offset &destOffset,
539                                const gl::Rectangle &sourceArea,
540                                gl::Framebuffer *source) override;
541 
542     angle::Result copyTexture(const gl::Context *context,
543                               const gl::ImageIndex &index,
544                               GLenum internalFormat,
545                               GLenum type,
546                               GLint sourceLevel,
547                               bool unpackFlipY,
548                               bool unpackPremultiplyAlpha,
549                               bool unpackUnmultiplyAlpha,
550                               const gl::Texture *source) override;
551     angle::Result copySubTexture(const gl::Context *context,
552                                  const gl::ImageIndex &index,
553                                  const gl::Offset &destOffset,
554                                  GLint sourceLevel,
555                                  const gl::Box &sourceBox,
556                                  bool unpackFlipY,
557                                  bool unpackPremultiplyAlpha,
558                                  bool unpackUnmultiplyAlpha,
559                                  const gl::Texture *source) override;
560 
561     angle::Result setStorage(const gl::Context *context,
562                              gl::TextureType type,
563                              size_t levels,
564                              GLenum internalFormat,
565                              const gl::Extents &size) override;
566 
567     angle::Result bindTexImage(const gl::Context *context, egl::Surface *surface) override;
568     angle::Result releaseTexImage(const gl::Context *context) override;
569 
570     angle::Result setEGLImageTarget(const gl::Context *context,
571                                     gl::TextureType type,
572                                     egl::Image *image) override;
573 
574     angle::Result getRenderTarget(const gl::Context *context,
575                                   const gl::ImageIndex &index,
576                                   GLsizei samples,
577                                   RenderTargetD3D **outRT) override;
578 
579     gl::ImageIndexIterator imageIterator() const override;
580     gl::ImageIndex getImageIndex(GLint mip, GLint layer) const override;
581     bool isValidIndex(const gl::ImageIndex &index) const override;
582 
583   protected:
584     void markAllImagesDirty() override;
585     GLint getLevelZeroDepth() const override;
586 
587   private:
588     angle::Result initializeStorage(const gl::Context *context, bool renderTarget) override;
589     angle::Result createCompleteStorage(bool renderTarget,
590                                         TexStoragePointer *outStorage) const override;
591     angle::Result setCompleteTexStorage(const gl::Context *context,
592                                         TextureStorage *newCompleteTexStorage) override;
593 
594     angle::Result updateStorage(const gl::Context *context) override;
595     angle::Result initMipmapImages(const gl::Context *context) override;
596 
597     bool isValidLevel(int level) const;
598     bool isLevelComplete(int level) const;
599     bool isImageComplete(const gl::ImageIndex &index) const override;
600     angle::Result updateStorageLevel(const gl::Context *context, int level);
601 
602     angle::Result redefineImage(const gl::Context *context,
603                                 GLint level,
604                                 GLenum internalformat,
605                                 const gl::Extents &size,
606                                 bool forceRelease);
607 
608     gl::TexLevelArray<std::unique_ptr<ImageD3D>> mImageArray;
609 };
610 
611 class TextureD3D_2DArray : public TextureD3D
612 {
613   public:
614     TextureD3D_2DArray(const gl::TextureState &data, RendererD3D *renderer);
615     ~TextureD3D_2DArray() override;
616 
617     void onDestroy(const gl::Context *context) override;
618 
619     virtual ImageD3D *getImage(int level, int layer) const;
620     ImageD3D *getImage(const gl::ImageIndex &index) const override;
621     GLsizei getLayerCount(int level) const override;
622 
623     GLsizei getWidth(GLint level) const;
624     GLsizei getHeight(GLint level) const;
625     GLenum getInternalFormat(GLint level) const;
626     bool isDepth(GLint level) const;
627 
628     angle::Result setImage(const gl::Context *context,
629                            const gl::ImageIndex &index,
630                            GLenum internalFormat,
631                            const gl::Extents &size,
632                            GLenum format,
633                            GLenum type,
634                            const gl::PixelUnpackState &unpack,
635                            gl::Buffer *unpackBuffer,
636                            const uint8_t *pixels) override;
637     angle::Result setSubImage(const gl::Context *context,
638                               const gl::ImageIndex &index,
639                               const gl::Box &area,
640                               GLenum format,
641                               GLenum type,
642                               const gl::PixelUnpackState &unpack,
643                               gl::Buffer *unpackBuffer,
644                               const uint8_t *pixels) override;
645 
646     angle::Result setCompressedImage(const gl::Context *context,
647                                      const gl::ImageIndex &index,
648                                      GLenum internalFormat,
649                                      const gl::Extents &size,
650                                      const gl::PixelUnpackState &unpack,
651                                      size_t imageSize,
652                                      const uint8_t *pixels) override;
653     angle::Result setCompressedSubImage(const gl::Context *context,
654                                         const gl::ImageIndex &index,
655                                         const gl::Box &area,
656                                         GLenum format,
657                                         const gl::PixelUnpackState &unpack,
658                                         size_t imageSize,
659                                         const uint8_t *pixels) override;
660 
661     angle::Result copyImage(const gl::Context *context,
662                             const gl::ImageIndex &index,
663                             const gl::Rectangle &sourceArea,
664                             GLenum internalFormat,
665                             gl::Framebuffer *source) override;
666     angle::Result copySubImage(const gl::Context *context,
667                                const gl::ImageIndex &index,
668                                const gl::Offset &destOffset,
669                                const gl::Rectangle &sourceArea,
670                                gl::Framebuffer *source) override;
671 
672     angle::Result copyTexture(const gl::Context *context,
673                               const gl::ImageIndex &index,
674                               GLenum internalFormat,
675                               GLenum type,
676                               GLint sourceLevel,
677                               bool unpackFlipY,
678                               bool unpackPremultiplyAlpha,
679                               bool unpackUnmultiplyAlpha,
680                               const gl::Texture *source) override;
681     angle::Result copySubTexture(const gl::Context *context,
682                                  const gl::ImageIndex &index,
683                                  const gl::Offset &destOffset,
684                                  GLint sourceLevel,
685                                  const gl::Box &sourceBox,
686                                  bool unpackFlipY,
687                                  bool unpackPremultiplyAlpha,
688                                  bool unpackUnmultiplyAlpha,
689                                  const gl::Texture *source) override;
690 
691     angle::Result setStorage(const gl::Context *context,
692                              gl::TextureType type,
693                              size_t levels,
694                              GLenum internalFormat,
695                              const gl::Extents &size) override;
696 
697     angle::Result bindTexImage(const gl::Context *context, egl::Surface *surface) override;
698     angle::Result releaseTexImage(const gl::Context *context) override;
699 
700     angle::Result setEGLImageTarget(const gl::Context *context,
701                                     gl::TextureType type,
702                                     egl::Image *image) override;
703 
704     angle::Result getRenderTarget(const gl::Context *context,
705                                   const gl::ImageIndex &index,
706                                   GLsizei samples,
707                                   RenderTargetD3D **outRT) override;
708 
709     gl::ImageIndexIterator imageIterator() const override;
710     gl::ImageIndex getImageIndex(GLint mip, GLint layer) const override;
711     bool isValidIndex(const gl::ImageIndex &index) const override;
712 
713   protected:
714     void markAllImagesDirty() override;
715 
716   private:
717     angle::Result initializeStorage(const gl::Context *context, bool renderTarget) override;
718     angle::Result createCompleteStorage(bool renderTarget,
719                                         TexStoragePointer *outStorage) const override;
720     angle::Result setCompleteTexStorage(const gl::Context *context,
721                                         TextureStorage *newCompleteTexStorage) override;
722 
723     angle::Result updateStorage(const gl::Context *context) override;
724     angle::Result initMipmapImages(const gl::Context *context) override;
725 
726     bool isValidLevel(int level) const;
727     bool isLevelComplete(int level) const;
728     bool isImageComplete(const gl::ImageIndex &index) const override;
729     bool isSRGB(GLint level) const;
730     angle::Result updateStorageLevel(const gl::Context *context, int level);
731 
732     void deleteImages();
733     angle::Result redefineImage(const gl::Context *context,
734                                 GLint level,
735                                 GLenum internalformat,
736                                 const gl::Extents &size,
737                                 bool forceRelease);
738 
739     // Storing images as an array of single depth textures since D3D11 treats each array level of a
740     // Texture2D object as a separate subresource.  Each layer would have to be looped over
741     // to update all the texture layers since they cannot all be updated at once and it makes the
742     // most sense for the Image class to not have to worry about layer subresource as well as mip
743     // subresources.
744     GLsizei mLayerCounts[gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS];
745     ImageD3D **mImageArray[gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS];
746 };
747 
748 // Base class for immutable textures. These don't support manipulation of individual texture images.
749 class TextureD3DImmutableBase : public TextureD3D
750 {
751   public:
752     TextureD3DImmutableBase(const gl::TextureState &data, RendererD3D *renderer);
753     ~TextureD3DImmutableBase() override;
754 
755     ImageD3D *getImage(const gl::ImageIndex &index) const override;
756     angle::Result setImage(const gl::Context *context,
757                            const gl::ImageIndex &index,
758                            GLenum internalFormat,
759                            const gl::Extents &size,
760                            GLenum format,
761                            GLenum type,
762                            const gl::PixelUnpackState &unpack,
763                            gl::Buffer *unpackBuffer,
764                            const uint8_t *pixels) override;
765     angle::Result setSubImage(const gl::Context *context,
766                               const gl::ImageIndex &index,
767                               const gl::Box &area,
768                               GLenum format,
769                               GLenum type,
770                               const gl::PixelUnpackState &unpack,
771                               gl::Buffer *unpackBuffer,
772                               const uint8_t *pixels) override;
773 
774     angle::Result setCompressedImage(const gl::Context *context,
775                                      const gl::ImageIndex &index,
776                                      GLenum internalFormat,
777                                      const gl::Extents &size,
778                                      const gl::PixelUnpackState &unpack,
779                                      size_t imageSize,
780                                      const uint8_t *pixels) override;
781     angle::Result setCompressedSubImage(const gl::Context *context,
782                                         const gl::ImageIndex &index,
783                                         const gl::Box &area,
784                                         GLenum format,
785                                         const gl::PixelUnpackState &unpack,
786                                         size_t imageSize,
787                                         const uint8_t *pixels) override;
788 
789     angle::Result copyImage(const gl::Context *context,
790                             const gl::ImageIndex &index,
791                             const gl::Rectangle &sourceArea,
792                             GLenum internalFormat,
793                             gl::Framebuffer *source) override;
794     angle::Result copySubImage(const gl::Context *context,
795                                const gl::ImageIndex &index,
796                                const gl::Offset &destOffset,
797                                const gl::Rectangle &sourceArea,
798                                gl::Framebuffer *source) override;
799 
800     angle::Result bindTexImage(const gl::Context *context, egl::Surface *surface) override;
801     angle::Result releaseTexImage(const gl::Context *context) override;
802 };
803 
804 class TextureD3D_External : public TextureD3DImmutableBase
805 {
806   public:
807     TextureD3D_External(const gl::TextureState &data, RendererD3D *renderer);
808     ~TextureD3D_External() override;
809 
810     GLsizei getLayerCount(int level) const override;
811 
812     angle::Result setImageExternal(const gl::Context *context,
813                                    gl::TextureType type,
814                                    egl::Stream *stream,
815                                    const egl::Stream::GLTextureDescription &desc) override;
816 
817     angle::Result setEGLImageTarget(const gl::Context *context,
818                                     gl::TextureType type,
819                                     egl::Image *image) override;
820 
821     angle::Result getRenderTarget(const gl::Context *context,
822                                   const gl::ImageIndex &index,
823                                   GLsizei samples,
824                                   RenderTargetD3D **outRT) override;
825 
826     gl::ImageIndexIterator imageIterator() const override;
827     gl::ImageIndex getImageIndex(GLint mip, GLint layer) const override;
828     bool isValidIndex(const gl::ImageIndex &index) const override;
829 
830   protected:
831     void markAllImagesDirty() override;
832 
833   private:
834     angle::Result initializeStorage(const gl::Context *context, bool renderTarget) override;
835     angle::Result createCompleteStorage(bool renderTarget,
836                                         TexStoragePointer *outTexStorage) const override;
837     angle::Result setCompleteTexStorage(const gl::Context *context,
838                                         TextureStorage *newCompleteTexStorage) override;
839 
840     angle::Result updateStorage(const gl::Context *context) override;
841     angle::Result initMipmapImages(const gl::Context *context) override;
842 
843     bool isImageComplete(const gl::ImageIndex &index) const override;
844 };
845 
846 class TextureD3D_2DMultisample : public TextureD3DImmutableBase
847 {
848   public:
849     TextureD3D_2DMultisample(const gl::TextureState &data, RendererD3D *renderer);
850     ~TextureD3D_2DMultisample() override;
851 
852     angle::Result setStorageMultisample(const gl::Context *context,
853                                         gl::TextureType type,
854                                         GLsizei samples,
855                                         GLint internalformat,
856                                         const gl::Extents &size,
857                                         bool fixedSampleLocations) override;
858 
859     angle::Result setEGLImageTarget(const gl::Context *context,
860                                     gl::TextureType type,
861                                     egl::Image *image) override;
862 
863     angle::Result getRenderTarget(const gl::Context *context,
864                                   const gl::ImageIndex &index,
865                                   GLsizei samples,
866                                   RenderTargetD3D **outRT) override;
867 
868     gl::ImageIndexIterator imageIterator() const override;
869     gl::ImageIndex getImageIndex(GLint mip, GLint layer) const override;
870     bool isValidIndex(const gl::ImageIndex &index) const override;
871 
872     GLsizei getLayerCount(int level) const override;
873 
874   protected:
875     void markAllImagesDirty() override;
876 
877     angle::Result setCompleteTexStorage(const gl::Context *context,
878                                         TextureStorage *newCompleteTexStorage) override;
879 
880     angle::Result updateStorage(const gl::Context *context) override;
881 
882   private:
883     angle::Result initializeStorage(const gl::Context *context, bool renderTarget) override;
884     angle::Result createCompleteStorage(bool renderTarget,
885                                         TexStoragePointer *outTexStorage) const override;
886     angle::Result initMipmapImages(const gl::Context *context) override;
887 
888     bool isImageComplete(const gl::ImageIndex &index) const override;
889 };
890 
891 class TextureD3D_2DMultisampleArray : public TextureD3DImmutableBase
892 {
893   public:
894     TextureD3D_2DMultisampleArray(const gl::TextureState &data, RendererD3D *renderer);
895     ~TextureD3D_2DMultisampleArray() override;
896 
897     angle::Result setStorageMultisample(const gl::Context *context,
898                                         gl::TextureType type,
899                                         GLsizei samples,
900                                         GLint internalformat,
901                                         const gl::Extents &size,
902                                         bool fixedSampleLocations) override;
903 
904     angle::Result setEGLImageTarget(const gl::Context *context,
905                                     gl::TextureType type,
906                                     egl::Image *image) override;
907 
908     angle::Result getRenderTarget(const gl::Context *context,
909                                   const gl::ImageIndex &index,
910                                   GLsizei samples,
911                                   RenderTargetD3D **outRT) override;
912 
913     gl::ImageIndexIterator imageIterator() const override;
914     gl::ImageIndex getImageIndex(GLint mip, GLint layer) const override;
915     bool isValidIndex(const gl::ImageIndex &index) const override;
916 
917     GLsizei getLayerCount(int level) const override;
918 
919   protected:
920     void markAllImagesDirty() override;
921 
922     angle::Result setCompleteTexStorage(const gl::Context *context,
923                                         TextureStorage *newCompleteTexStorage) override;
924 
925     angle::Result updateStorage(const gl::Context *context) override;
926 
927   private:
928     angle::Result initializeStorage(const gl::Context *context, bool renderTarget) override;
929     angle::Result createCompleteStorage(bool renderTarget,
930                                         TexStoragePointer *outTexStorage) const override;
931     angle::Result initMipmapImages(const gl::Context *context) override;
932 
933     bool isImageComplete(const gl::ImageIndex &index) const override;
934 
935     GLsizei mLayerCount;
936 };
937 }  // namespace rx
938 
939 #endif  // LIBANGLE_RENDERER_D3D_TEXTURED3D_H_
940