Merge gerrit/vulkan-cts-1.0.1 into gerrit/vulkan-cts-1.0-dev
[platform/upstream/VK-GL-CTS.git] / framework / opengl / gluTexture.hpp
1 #ifndef _GLUTEXTURE_HPP
2 #define _GLUTEXTURE_HPP
3 /*-------------------------------------------------------------------------
4  * drawElements Quality Program OpenGL ES Utilities
5  * ------------------------------------------------
6  *
7  * Copyright 2014 The Android Open Source Project
8  *
9  * Licensed under the Apache License, Version 2.0 (the "License");
10  * you may not use this file except in compliance with the License.
11  * You may obtain a copy of the License at
12  *
13  *      http://www.apache.org/licenses/LICENSE-2.0
14  *
15  * Unless required by applicable law or agreed to in writing, software
16  * distributed under the License is distributed on an "AS IS" BASIS,
17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18  * See the License for the specific language governing permissions and
19  * limitations under the License.
20  *
21  *//*!
22  * \file
23  * \brief Texture classes.
24  *//*--------------------------------------------------------------------*/
25
26 #include "gluDefs.hpp"
27 #include "tcuTexture.hpp"
28 #include "tcuCompressedTexture.hpp"
29 #include "tcuResource.hpp"
30 #include "gluRenderContext.hpp"
31 #include "gluContextInfo.hpp"
32 #include "deArrayBuffer.hpp"
33
34 #include <vector>
35 #include <string>
36
37 namespace glu
38 {
39
40 /*--------------------------------------------------------------------*//*!
41  * \brief 1D Texture only supported on OpenGL
42  *//*--------------------------------------------------------------------*/
43 class Texture1D
44 {
45 public:
46                                                         Texture1D                               (const RenderContext& context, deUint32 format, deUint32 dataType, int width);
47                                                         Texture1D                               (const RenderContext& context, deUint32 internalFormat, int width);
48                                                         ~Texture1D                              (void);
49
50         tcu::Texture1D&                 getRefTexture                   (void)                  { return m_refTexture;  }
51         const tcu::Texture1D&   getRefTexture                   (void) const    { return m_refTexture;  }
52         deUint32                                getGLTexture                    (void) const    { return m_glTexture;   }
53
54         void                                    upload                                  (void);
55
56 private:
57                                                         Texture1D                               (const Texture1D& other); // Not allowed!
58         Texture1D&                              operator=                               (const Texture1D& other); // Not allowed!
59
60         const RenderContext&    m_context;
61         deUint32                                m_format;                               //!< Internal format.
62         tcu::Texture1D                  m_refTexture;
63         deUint32                                m_glTexture;
64 } DE_WARN_UNUSED_TYPE;
65
66 /*--------------------------------------------------------------------*//*!
67  * \brief 2D Texture
68  *//*--------------------------------------------------------------------*/
69 class Texture2D
70 {
71 public:
72                                                         Texture2D                               (const RenderContext& context, const ContextInfo& contextInfo, int numLevels, const tcu::CompressedTexture* levels, const tcu::TexDecompressionParams& decompressionParams = tcu::TexDecompressionParams());
73                                                         Texture2D                               (const RenderContext& context, deUint32 format, deUint32 dataType, int width, int height);
74                                                         Texture2D                               (const RenderContext& context, deUint32 internalFormat, int width, int height);
75                                                         ~Texture2D                              (void);
76
77         void                                    upload                                  (void); // Not supported on compressed textures.
78
79         tcu::Texture2D&                 getRefTexture                   (void)                  { return m_refTexture;  }
80         const tcu::Texture2D&   getRefTexture                   (void) const    { return m_refTexture;  }
81         deUint32                                getGLTexture                    (void) const    { return m_glTexture;   }
82
83         static Texture2D*               create                                  (const RenderContext& context, const ContextInfo& contextInfo, const tcu::Archive& archive, int numLevels, const std::vector<std::string>& filenames);
84         static Texture2D*               create                                  (const RenderContext& context, const ContextInfo& contextInfo, const tcu::Archive& archive, int numLevels, const char* const* filenames);
85         static Texture2D*               create                                  (const RenderContext& context, const ContextInfo& contextInfo, const tcu::Archive& archive, const char* filename) { return create(context, contextInfo, archive, 1, &filename); }
86
87 private:
88                                                         Texture2D                               (const Texture2D& other); // Not allowed!
89         Texture2D&                              operator=                               (const Texture2D& other); // Not allowed!
90
91         void                                    loadCompressed                  (int numLevels, const tcu::CompressedTexture* levels, const tcu::TexDecompressionParams& decompressionParams);
92
93         const RenderContext&    m_context;
94
95         bool                                    m_isCompressed;
96         deUint32                                m_format;                               //!< Internal format.
97
98         tcu::Texture2D                  m_refTexture;
99         deUint32                                m_glTexture;
100 } DE_WARN_UNUSED_TYPE;
101
102 /*--------------------------------------------------------------------*//*!
103  * \brief Cube Map Texture
104  *//*--------------------------------------------------------------------*/
105 class TextureCube
106 {
107 public:
108         // For compressed cubemap constructor and create() function input level pointers / filenames are expected
109         // to laid out to array in following order:
110         //   { l0_neg_x, l0_pos_x, l0_neg_y, l0_pos_y, l0_neg_z, l0_pos_z, l1_neg_x, l1_pos_x, ... }
111
112                                                         TextureCube                             (const RenderContext& context, const ContextInfo& contextInfo, int numLevels, const tcu::CompressedTexture* levels, const tcu::TexDecompressionParams& decompressionParams = tcu::TexDecompressionParams());
113                                                         TextureCube                             (const RenderContext& context, deUint32 format, deUint32 dataType, int size);
114                                                         TextureCube                             (const RenderContext& context, deUint32 internalFormat, int size);
115                                                         ~TextureCube                    (void);
116
117         void                                    upload                                  (void); // Not supported on compressed textures.
118
119         tcu::TextureCube&               getRefTexture                   (void)                  { return m_refTexture;  }
120         const tcu::TextureCube& getRefTexture                   (void) const    { return m_refTexture;  }
121         deUint32                                getGLTexture                    (void) const    { return m_glTexture;   }
122
123         static TextureCube*             create                                  (const RenderContext& context, const ContextInfo& contextInfo, const tcu::Archive& archive, int numLevels, const std::vector<std::string>& filenames);
124         static TextureCube*             create                                  (const RenderContext& context, const ContextInfo& contextInfo, const tcu::Archive& archive, int numLevels, const char* const* filenames);
125
126 private:
127                                                         TextureCube                             (const TextureCube& other); // Not allowed!
128         TextureCube&                    operator=                               (const TextureCube& other); // Not allowed!
129
130         void                                    loadCompressed                  (int numLevels, const tcu::CompressedTexture* levels, const tcu::TexDecompressionParams& decompressionParams);
131
132         const RenderContext&    m_context;
133
134         bool                                    m_isCompressed;
135         deUint32                                m_format;                               //!< Internal format.
136
137         tcu::TextureCube                m_refTexture;
138         deUint32                                m_glTexture;
139 } DE_WARN_UNUSED_TYPE;
140
141 /*--------------------------------------------------------------------*//*!
142  * \brief 2D Array Texture
143  * \note Not supported on OpenGL ES 2
144  *//*--------------------------------------------------------------------*/
145 class Texture2DArray
146 {
147 public:
148                                                                 Texture2DArray                  (const RenderContext& context, deUint32 format, deUint32 dataType, int width, int height, int numLayers);
149                                                                 Texture2DArray                  (const RenderContext& context, deUint32 internalFormat, int width, int height, int numLayers);
150                                                                 Texture2DArray                  (const RenderContext& context, const ContextInfo& contextInfo, int numLevels, const tcu::CompressedTexture* levels, const tcu::TexDecompressionParams& decompressionParams = tcu::TexDecompressionParams());
151                                                                 ~Texture2DArray                 (void);
152
153         void                                            upload                                  (void);
154
155         tcu::Texture2DArray&            getRefTexture                   (void)                  { return m_refTexture;  }
156         const tcu::Texture2DArray&      getRefTexture                   (void) const    { return m_refTexture;  }
157         deUint32                                        getGLTexture                    (void) const    { return m_glTexture;   }
158
159 private:
160                                                                 Texture2DArray                  (const Texture2DArray& other); // Not allowed!
161         Texture2DArray&                         operator=                               (const Texture2DArray& other); // Not allowed!
162
163         void                                            loadCompressed                  (int numLevels, const tcu::CompressedTexture* levels, const tcu::TexDecompressionParams& decompressionParams);
164
165
166         const RenderContext&            m_context;
167
168         bool                                            m_isCompressed;
169         deUint32                                        m_format;                               //!< Internal format.
170
171         tcu::Texture2DArray                     m_refTexture;
172         deUint32                                        m_glTexture;
173 } DE_WARN_UNUSED_TYPE;
174
175 /*--------------------------------------------------------------------*//*!
176  * \brief 1D Array Texture
177  * \note Only supported on OpenGL
178  *//*--------------------------------------------------------------------*/
179 class Texture1DArray
180 {
181 public:
182                                                                 Texture1DArray                  (const RenderContext& context, deUint32 format, deUint32 dataType, int width, int numLayers);
183                                                                 Texture1DArray                  (const RenderContext& context, deUint32 internalFormat, int width, int numLayers);
184                                                                 ~Texture1DArray                 (void);
185
186         void                                            upload                                  (void);
187
188         tcu::Texture1DArray&            getRefTexture                   (void)                  { return m_refTexture;  }
189         const tcu::Texture1DArray&      getRefTexture                   (void) const    { return m_refTexture;  }
190         deUint32                                        getGLTexture                    (void) const    { return m_glTexture;   }
191
192 private:
193                                                                 Texture1DArray                  (const Texture1DArray& other); // Not allowed!
194         Texture1DArray&                         operator=                               (const Texture1DArray& other); // Not allowed!
195
196         const RenderContext&            m_context;
197
198         deUint32                                        m_format;                               //!< Internal format.
199
200         tcu::Texture1DArray                     m_refTexture;
201         deUint32                                        m_glTexture;
202 } DE_WARN_UNUSED_TYPE;
203
204 /*--------------------------------------------------------------------*//*!
205  * \brief 3D Texture
206  * \note Not supported on OpenGL ES 2
207  *//*--------------------------------------------------------------------*/
208 class Texture3D
209 {
210 public:
211                                                                 Texture3D                       (const RenderContext& context, deUint32 format, deUint32 dataType, int width, int height, int depth);
212                                                                 Texture3D                       (const RenderContext& context, deUint32 internalFormat, int width, int height, int depth);
213                                                                 Texture3D                       (const RenderContext& context, const ContextInfo& contextInfo, int numLevels, const tcu::CompressedTexture* levels, const tcu::TexDecompressionParams& decompressionParams = tcu::TexDecompressionParams());
214                                                                 ~Texture3D                      (void);
215
216         void                                            upload                          (void);
217
218         tcu::Texture3D&                         getRefTexture           (void)                  { return m_refTexture;  }
219         const tcu::Texture3D&           getRefTexture           (void) const    { return m_refTexture;  }
220         deUint32                                        getGLTexture            (void) const    { return m_glTexture;   }
221
222 private:
223                                                                 Texture3D                       (const Texture3D& other); // Not allowed!
224         Texture3D&                                      operator=                       (const Texture3D& other); // Not allowed!
225
226         void                                            loadCompressed          (int numLevels, const tcu::CompressedTexture* levels, const tcu::TexDecompressionParams& decompressionParams);
227
228         const RenderContext&            m_context;
229
230         bool                                            m_isCompressed;
231         deUint32                                        m_format;                       //!< Internal format.
232
233         tcu::Texture3D                          m_refTexture;
234         deUint32                                        m_glTexture;
235 } DE_WARN_UNUSED_TYPE;
236
237 /*--------------------------------------------------------------------*//*!
238  * \brief Cube Map Array Texture
239  * \note Not supported on OpenGL ES 3.0 or lower
240  *//*--------------------------------------------------------------------*/
241 class TextureCubeArray
242 {
243 public:
244                                                                         TextureCubeArray        (const RenderContext& context, deUint32 format, deUint32 dataType, int size, int numLayers);
245                                                                         TextureCubeArray        (const RenderContext& context, deUint32 internalFormat, int size, int numLayers);
246
247                                                                         ~TextureCubeArray       (void);
248
249         void                                                    upload                          (void);
250
251         tcu::TextureCubeArray&                  getRefTexture           (void)                  { return m_refTexture;  }
252         const tcu::TextureCubeArray&    getRefTexture           (void) const    { return m_refTexture;  }
253         deUint32                                                getGLTexture            (void) const    { return m_glTexture;   }
254
255 private:
256                                                                         TextureCubeArray        (const TextureCubeArray& other); // Not allowed!
257         TextureCubeArray&                               operator=                       (const TextureCubeArray& other); // Not allowed!
258
259         const RenderContext&                    m_context;
260
261         bool                                                    m_isCompressed;
262         deUint32                                                m_format;                       //!< Internal format.
263
264         tcu::TextureCubeArray                   m_refTexture;
265         deUint32                                                m_glTexture;
266 } DE_WARN_UNUSED_TYPE;
267
268 /*--------------------------------------------------------------------*//*!
269  * \brief 1D Texture Buffer only supported on OpenGL
270  *//*--------------------------------------------------------------------*/
271 class TextureBuffer
272 {
273 public:
274                                                                                 TextureBuffer           (const RenderContext& context, deUint32 internalFormat, size_t bufferSize);
275                                                                                 TextureBuffer           (const RenderContext& context, deUint32 internalFormat, size_t bufferSize, size_t offset, size_t size, const void* data = DE_NULL);
276
277                                                                                 ~TextureBuffer          (void);
278
279         // \note Effective pixel buffer access must be limited to w <= GL_MAX_TEXTURE_BUFFER_SIZE
280         const tcu::PixelBufferAccess            getFullRefTexture       (void);
281         const tcu::ConstPixelBufferAccess       getFullRefTexture       (void) const;
282
283         // \note mutating buffer storage will invalidate existing pixel buffer accesses
284         de::ArrayBuffer<deUint8>&                       getRefBuffer            (void)                  { return m_refBuffer;                   }
285         const de::ArrayBuffer<deUint8>&         getRefBuffer            (void) const    { return m_refBuffer;                   }
286
287         size_t                                                          getSize                         (void) const    { return m_size;                                }
288         size_t                                                          getOffset                       (void) const    { return m_offset;                              }
289         size_t                                                          getBufferSize           (void) const    { return m_refBuffer.size();    }
290
291         deUint32                                                        getGLTexture            (void) const    { return m_glTexture;                   }
292         deUint32                                                        getGLBuffer                     (void) const    { return m_glBuffer;                    }
293
294         void                                                            upload                          (void);
295
296 private:
297         void                                                            init                            (deUint32 internalFormat, size_t bufferSize, size_t offset, size_t size, const void* data);
298                                                                                 TextureBuffer           (const TextureBuffer& other); // Not allowed!
299         TextureBuffer&                                          operator=                       (const TextureBuffer& other); // Not allowed!
300
301         const RenderContext&                            m_context;
302         deUint32                                                        m_format;               //!< Internal format.
303         de::ArrayBuffer<deUint8>                        m_refBuffer;
304         size_t                                                          m_offset;
305         size_t                                                          m_size;
306
307         deUint32                                                        m_glTexture;
308         deUint32                                                        m_glBuffer;
309 } DE_WARN_UNUSED_TYPE;
310
311 } // glu
312
313 #endif // _GLUTEXTURE_HPP