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