Merge gerrit/vulkan-cts-1.0.0 into gerrit/vulkan-cts-1.0.1
[platform/upstream/VK-GL-CTS.git] / framework / opengl / gluTexture.cpp
1 /*-------------------------------------------------------------------------
2  * drawElements Quality Program OpenGL ES Utilities
3  * ------------------------------------------------
4  *
5  * Copyright 2014 The Android Open Source Project
6  *
7  * Licensed under the Apache License, Version 2.0 (the "License");
8  * you may not use this file except in compliance with the License.
9  * You may obtain a copy of the License at
10  *
11  *      http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing, software
14  * distributed under the License is distributed on an "AS IS" BASIS,
15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16  * See the License for the specific language governing permissions and
17  * limitations under the License.
18  *
19  *//*!
20  * \file
21  * \brief Texture classes.
22  *//*--------------------------------------------------------------------*/
23
24 #include "gluTexture.hpp"
25 #include "gluTextureUtil.hpp"
26 #include "deFilePath.hpp"
27 #include "tcuImageIO.hpp"
28 #include "tcuSurface.hpp"
29 #include "tcuTextureUtil.hpp"
30
31 #include "glwFunctions.hpp"
32 #include "glwEnums.hpp"
33
34 #include "deUniquePtr.hpp"
35
36 using std::vector;
37
38 namespace glu
39 {
40
41 static inline int computePixelStore (const tcu::TextureFormat& format)
42 {
43         int pixelSize = format.getPixelSize();
44         if (deIsPowerOfTwo32(pixelSize))
45                 return de::min(pixelSize, 8);
46         else
47                 return 1;
48 }
49
50 // Texture1D
51
52 Texture1D::Texture1D (const RenderContext& context, deUint32 format, deUint32 dataType, int width)
53         : m_context                     (context)
54         , m_format                      (format)
55         , m_refTexture          (mapGLTransferFormat(format, dataType), width)
56         , m_glTexture           (0)
57 {
58         const glw::Functions& gl = context.getFunctions();
59         gl.genTextures(1, &m_glTexture);
60         GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() failed");
61 }
62
63 Texture1D::Texture1D (const RenderContext& context, deUint32 sizedFormat, int width)
64         : m_context                     (context)
65         , m_format                      (sizedFormat)
66         , m_refTexture          (mapGLInternalFormat(sizedFormat), width)
67         , m_glTexture           (0)
68 {
69         const glw::Functions& gl = context.getFunctions();
70         gl.genTextures(1, &m_glTexture);
71         GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() failed");
72 }
73
74 Texture1D::~Texture1D (void)
75 {
76         if (m_glTexture)
77                 m_context.getFunctions().deleteTextures(1, &m_glTexture);
78 }
79
80 void Texture1D::upload (void)
81 {
82         const glw::Functions& gl = m_context.getFunctions();
83
84         TCU_CHECK(m_glTexture);
85         gl.bindTexture(GL_TEXTURE_1D, m_glTexture);
86         gl.pixelStorei(GL_UNPACK_ALIGNMENT, computePixelStore(m_refTexture.getFormat()));
87         GLU_EXPECT_NO_ERROR(gl.getError(), "Texture upload failed");
88
89         TransferFormat transferFormat = getTransferFormat(m_refTexture.getFormat());
90
91         for (int levelNdx = 0; levelNdx < m_refTexture.getNumLevels(); levelNdx++)
92         {
93                 if (m_refTexture.isLevelEmpty(levelNdx))
94                         continue; // Don't upload.
95
96                 tcu::ConstPixelBufferAccess access = m_refTexture.getLevel(levelNdx);
97                 gl.texImage1D(GL_TEXTURE_1D, levelNdx, m_format, access.getWidth(), 0 /* border */, transferFormat.format, transferFormat.dataType, access.getDataPtr());
98         }
99
100         GLU_EXPECT_NO_ERROR(gl.getError(), "Texture upload failed");
101 }
102
103 // Texture2D
104
105 Texture2D::Texture2D (const RenderContext& context, deUint32 format, deUint32 dataType, int width, int height)
106         : m_context                     (context)
107         , m_isCompressed        (false)
108         , m_format                      (format)
109         , m_refTexture          (mapGLTransferFormat(format, dataType), width, height)
110         , m_glTexture           (0)
111 {
112         const glw::Functions& gl = context.getFunctions();
113         gl.genTextures(1, &m_glTexture);
114         GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() failed");
115 }
116
117 Texture2D::Texture2D (const RenderContext& context, deUint32 sizedFormat, int width, int height)
118         : m_context                     (context)
119         , m_isCompressed        (false)
120         , m_format                      (sizedFormat)
121         , m_refTexture          (mapGLInternalFormat(sizedFormat), width, height)
122         , m_glTexture           (0)
123 {
124         const glw::Functions& gl = context.getFunctions();
125         gl.genTextures(1, &m_glTexture);
126         GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() failed");
127 }
128
129 Texture2D::Texture2D (const RenderContext& context, const ContextInfo& contextInfo, int numLevels, const tcu::CompressedTexture* levels, const tcu::TexDecompressionParams& decompressionParams)
130         : m_context                     (context)
131         , m_isCompressed        (true)
132         , m_format                      (getGLFormat(levels[0].getFormat()))
133         , m_refTexture          (getUncompressedFormat(levels[0].getFormat()), levels[0].getWidth(), levels[0].getHeight())
134         , m_glTexture           (0)
135 {
136         const glw::Functions& gl = context.getFunctions();
137
138         if (!contextInfo.isCompressedTextureFormatSupported(m_format))
139                 TCU_THROW(NotSupportedError, "Compressed texture format not supported");
140
141         gl.genTextures(1, &m_glTexture);
142         GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() failed");
143
144         try
145         {
146                 loadCompressed(numLevels, levels, decompressionParams);
147         }
148         catch (const std::exception&)
149         {
150                 gl.deleteTextures(1, &m_glTexture);
151                 throw;
152         }
153 }
154
155 Texture2D::~Texture2D (void)
156 {
157         if (m_glTexture)
158                 m_context.getFunctions().deleteTextures(1, &m_glTexture);
159 }
160
161 void Texture2D::upload (void)
162 {
163         const glw::Functions& gl = m_context.getFunctions();
164
165         DE_ASSERT(!m_isCompressed);
166
167         TCU_CHECK(m_glTexture);
168         gl.bindTexture(GL_TEXTURE_2D, m_glTexture);
169         gl.pixelStorei(GL_UNPACK_ALIGNMENT, computePixelStore(m_refTexture.getFormat()));
170         GLU_EXPECT_NO_ERROR(gl.getError(), "Texture upload failed");
171
172         TransferFormat transferFormat = getTransferFormat(m_refTexture.getFormat());
173
174         for (int levelNdx = 0; levelNdx < m_refTexture.getNumLevels(); levelNdx++)
175         {
176                 if (m_refTexture.isLevelEmpty(levelNdx))
177                         continue; // Don't upload.
178
179                 tcu::ConstPixelBufferAccess access = m_refTexture.getLevel(levelNdx);
180                 DE_ASSERT(access.getRowPitch() == access.getFormat().getPixelSize()*access.getWidth());
181                 gl.texImage2D(GL_TEXTURE_2D, levelNdx, m_format, access.getWidth(), access.getHeight(), 0 /* border */, transferFormat.format, transferFormat.dataType, access.getDataPtr());
182         }
183
184         GLU_EXPECT_NO_ERROR(gl.getError(), "Texture upload failed");
185 }
186
187 void Texture2D::loadCompressed (int numLevels, const tcu::CompressedTexture* levels, const tcu::TexDecompressionParams& decompressionParams)
188 {
189         const glw::Functions&   gl                                      = m_context.getFunctions();
190         deUint32                                compressedFormat        = getGLFormat(levels[0].getFormat());
191
192         TCU_CHECK(m_glTexture);
193         gl.bindTexture(GL_TEXTURE_2D, m_glTexture);
194
195         for (int levelNdx = 0; levelNdx < numLevels; levelNdx++)
196         {
197                 const tcu::CompressedTexture& level = levels[levelNdx];
198
199                 // Decompress to reference texture.
200                 m_refTexture.allocLevel(levelNdx);
201                 tcu::PixelBufferAccess refLevelAccess = m_refTexture.getLevel(levelNdx);
202                 TCU_CHECK(level.getWidth()      == refLevelAccess.getWidth() &&
203                                   level.getHeight()     == refLevelAccess.getHeight());
204                 level.decompress(refLevelAccess, decompressionParams);
205
206                 // Upload to GL texture in compressed form.
207                 gl.compressedTexImage2D(GL_TEXTURE_2D, levelNdx, compressedFormat,
208                                                                 level.getWidth(), level.getHeight(), 0 /* border */, level.getDataSize(), level.getData());
209         }
210
211         GLU_EXPECT_NO_ERROR(gl.getError(), "Texture upload failed");
212 }
213
214 Texture2D* Texture2D::create (const RenderContext& context, const ContextInfo& contextInfo, const tcu::Archive& archive, int numLevels, const char* const* levelFileNames)
215 {
216         DE_ASSERT(numLevels > 0);
217
218         std::string ext = de::FilePath(levelFileNames[0]).getFileExtension();
219
220         if (ext == "png")
221         {
222                 // Uncompressed texture.
223
224                 tcu::TextureLevel level;
225
226                 // Load level 0.
227                 tcu::ImageIO::loadPNG(level, archive, levelFileNames[0]);
228
229                 TCU_CHECK_INTERNAL(level.getFormat() == tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8) ||
230                                                    level.getFormat() == tcu::TextureFormat(tcu::TextureFormat::RGB, tcu::TextureFormat::UNORM_INT8));
231
232                 bool            isRGBA          = level.getFormat() == tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8);
233                 Texture2D*      texture         = new Texture2D(context, isRGBA ? GL_RGBA : GL_RGB, GL_UNSIGNED_BYTE, level.getWidth(), level.getHeight());
234
235                 try
236                 {
237                         // Fill level 0.
238                         texture->getRefTexture().allocLevel(0);
239                         tcu::copy(texture->getRefTexture().getLevel(0), level.getAccess());
240
241                         // Fill remaining levels.
242                         for (int levelNdx = 1; levelNdx < numLevels; levelNdx++)
243                         {
244                                 tcu::ImageIO::loadPNG(level, archive, levelFileNames[levelNdx]);
245
246                                 texture->getRefTexture().allocLevel(levelNdx);
247                                 tcu::copy(texture->getRefTexture().getLevel(levelNdx), level.getAccess());
248                         }
249
250                         // Upload data.
251                         texture->upload();
252                 }
253                 catch (const std::exception&)
254                 {
255                         delete texture;
256                         throw;
257                 }
258
259                 return texture;
260         }
261         else if (ext == "pkm")
262         {
263                 // Compressed texture.
264                 vector<tcu::CompressedTexture> levels(numLevels);
265
266                 for (int ndx = 0; ndx < numLevels; ndx++)
267                         tcu::ImageIO::loadPKM(levels[ndx], archive, levelFileNames[ndx]);
268
269                 return new Texture2D(context, contextInfo, numLevels, &levels[0]);
270         }
271         else
272                 TCU_FAIL("Unsupported file format");
273 }
274
275 Texture2D* Texture2D::create (const RenderContext& context, const ContextInfo& contextInfo, const tcu::Archive& archive, int numLevels, const std::vector<std::string>& filenames)
276 {
277         TCU_CHECK(numLevels == (int)filenames.size());
278
279         std::vector<const char*> charPtrs(filenames.size());
280         for (int ndx = 0; ndx < (int)filenames.size(); ndx++)
281                 charPtrs[ndx] = filenames[ndx].c_str();
282
283         return Texture2D::create(context, contextInfo, archive, numLevels, &charPtrs[0]);
284 }
285
286 // TextureCube
287
288 TextureCube::TextureCube (const RenderContext& context, const ContextInfo& contextInfo, int numLevels, const tcu::CompressedTexture* levels, const tcu::TexDecompressionParams& decompressionParams)
289         : m_context                     (context)
290         , m_isCompressed        (true)
291         , m_format                      (getGLFormat(levels[0].getFormat()))
292         , m_refTexture          (getUncompressedFormat(levels[0].getFormat()), levels[0].getWidth())
293         , m_glTexture           (0)
294 {
295         const glw::Functions& gl = m_context.getFunctions();
296
297         TCU_CHECK_INTERNAL(levels[0].getWidth() == levels[0].getHeight());
298
299         if (!contextInfo.isCompressedTextureFormatSupported(m_format))
300                 throw tcu::NotSupportedError("Compressed texture format not supported", "", __FILE__, __LINE__);
301
302         gl.genTextures(1, &m_glTexture);
303         GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() failed");
304
305         try
306         {
307                 loadCompressed(numLevels, levels, decompressionParams);
308         }
309         catch (const std::exception&)
310         {
311                 gl.deleteTextures(1, &m_glTexture);
312                 throw;
313         }
314 }
315
316 TextureCube::TextureCube (const RenderContext& context, deUint32 format, deUint32 dataType, int size)
317         : m_context                     (context)
318         , m_isCompressed        (false)
319         , m_format                      (format)
320         , m_refTexture          (mapGLTransferFormat(format, dataType), size)
321         , m_glTexture           (0)
322 {
323         const glw::Functions& gl = m_context.getFunctions();
324         gl.genTextures(1, &m_glTexture);
325         GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() failed");
326 }
327
328 TextureCube::TextureCube (const RenderContext& context, deUint32 internalFormat, int size)
329         : m_context                     (context)
330         , m_isCompressed        (false)
331         , m_format                      (internalFormat)
332         , m_refTexture          (mapGLInternalFormat(internalFormat), size)
333         , m_glTexture           (0)
334 {
335         const glw::Functions& gl = m_context.getFunctions();
336         gl.genTextures(1, &m_glTexture);
337         GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() failed");
338 }
339
340 TextureCube::~TextureCube (void)
341 {
342         if (m_glTexture)
343                 m_context.getFunctions().deleteTextures(1, &m_glTexture);
344 }
345
346 void TextureCube::upload (void)
347 {
348         const glw::Functions& gl = m_context.getFunctions();
349
350         DE_ASSERT(!m_isCompressed);
351
352         TCU_CHECK(m_glTexture);
353         gl.bindTexture(GL_TEXTURE_CUBE_MAP, m_glTexture);
354         gl.pixelStorei(GL_UNPACK_ALIGNMENT, computePixelStore(m_refTexture.getFormat()));
355         GLU_EXPECT_NO_ERROR(gl.getError(), "Texture upload failed");
356
357         TransferFormat transferFormat = getTransferFormat(m_refTexture.getFormat());
358
359         for (int face = 0; face < tcu::CUBEFACE_LAST; face++)
360         {
361                 for (int levelNdx = 0; levelNdx < m_refTexture.getNumLevels(); levelNdx++)
362                 {
363                         if (m_refTexture.isLevelEmpty((tcu::CubeFace)face, levelNdx))
364                                 continue; // Don't upload.
365
366                         tcu::ConstPixelBufferAccess access = m_refTexture.getLevelFace(levelNdx, (tcu::CubeFace)face);
367                         DE_ASSERT(access.getRowPitch() == access.getFormat().getPixelSize()*access.getWidth());
368                         gl.texImage2D(getGLCubeFace((tcu::CubeFace)face), levelNdx, m_format, access.getWidth(), access.getHeight(), 0 /* border */, transferFormat.format, transferFormat.dataType, access.getDataPtr());
369                 }
370         }
371
372         GLU_EXPECT_NO_ERROR(gl.getError(), "Texture upload failed");
373 }
374
375 void TextureCube::loadCompressed (int numLevels, const tcu::CompressedTexture* levels, const tcu::TexDecompressionParams& decompressionParams)
376 {
377         const glw::Functions&   gl                                      = m_context.getFunctions();
378         deUint32                                compressedFormat        = getGLFormat(levels[0].getFormat());
379
380         TCU_CHECK(m_glTexture);
381         gl.bindTexture(GL_TEXTURE_CUBE_MAP, m_glTexture);
382
383         for (int levelNdx = 0; levelNdx < numLevels; levelNdx++)
384         {
385                 for (int face = 0; face < tcu::CUBEFACE_LAST; face++)
386                 {
387                         const tcu::CompressedTexture& level = levels[levelNdx*tcu::CUBEFACE_LAST + face];
388
389                         // Decompress to reference texture.
390                         m_refTexture.allocLevel((tcu::CubeFace)face, levelNdx);
391                         tcu::PixelBufferAccess refLevelAccess = m_refTexture.getLevelFace(levelNdx, (tcu::CubeFace)face);
392                         TCU_CHECK(level.getWidth()      == refLevelAccess.getWidth() &&
393                                           level.getHeight()     == refLevelAccess.getHeight());
394                         level.decompress(refLevelAccess, decompressionParams);
395
396                         // Upload to GL texture in compressed form.
397                         gl.compressedTexImage2D(getGLCubeFace((tcu::CubeFace)face), levelNdx, compressedFormat,
398                                                                         level.getWidth(), level.getHeight(), 0 /* border */, level.getDataSize(), level.getData());
399                 }
400         }
401
402         GLU_EXPECT_NO_ERROR(gl.getError(), "Texture upload failed");
403 }
404
405 TextureCube* TextureCube::create (const RenderContext& context, const ContextInfo& contextInfo, const tcu::Archive& archive, int numLevels, const char* const* filenames)
406 {
407         DE_ASSERT(numLevels > 0);
408
409         std::string ext = de::FilePath(filenames[0]).getFileExtension();
410
411         // \todo [2011-11-21 pyry] Support PNG images.
412         if (ext == "pkm")
413         {
414                 // Compressed texture.
415                 int                                                             numImages       = numLevels*tcu::CUBEFACE_LAST;
416                 vector<tcu::CompressedTexture>  levels          (numImages);
417
418                 for (int ndx = 0; ndx < numImages; ndx++)
419                         tcu::ImageIO::loadPKM(levels[ndx], archive, filenames[ndx]);
420
421                 return new TextureCube(context, contextInfo, numLevels, &levels[0]);
422         }
423         else
424                 TCU_FAIL("Unsupported file format");
425 }
426
427 TextureCube* TextureCube::create (const RenderContext& context, const ContextInfo& contextInfo, const tcu::Archive& archive, int numLevels, const std::vector<std::string>& filenames)
428 {
429         DE_STATIC_ASSERT(tcu::CUBEFACE_LAST == 6);
430         TCU_CHECK(numLevels*tcu::CUBEFACE_LAST == (int)filenames.size());
431
432         std::vector<const char*> charPtrs(filenames.size());
433         for (int ndx = 0; ndx < (int)filenames.size(); ndx++)
434                 charPtrs[ndx] = filenames[ndx].c_str();
435
436         return TextureCube::create(context, contextInfo, archive, numLevels, &charPtrs[0]);
437 }
438
439 // Texture1DArray
440
441 Texture1DArray::Texture1DArray (const RenderContext& context, deUint32 format, deUint32 dataType, int width, int numLevels)
442         : m_context                     (context)
443         , m_format                      (format)
444         , m_refTexture          (mapGLTransferFormat(format, dataType), width, numLevels)
445         , m_glTexture           (0)
446 {
447         const glw::Functions& gl = m_context.getFunctions();
448         gl.genTextures(1, &m_glTexture);
449         GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() failed");
450 }
451
452 Texture1DArray::Texture1DArray (const RenderContext& context, deUint32 sizedFormat, int width, int numLevels)
453         : m_context                     (context)
454         , m_format                      (sizedFormat)
455         , m_refTexture          (mapGLInternalFormat(sizedFormat), width, numLevels)
456         , m_glTexture           (0)
457 {
458         const glw::Functions& gl = m_context.getFunctions();
459         gl.genTextures(1, &m_glTexture);
460         GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() failed");
461 }
462
463 Texture1DArray::~Texture1DArray (void)
464 {
465         if (m_glTexture)
466                 m_context.getFunctions().deleteTextures(1, &m_glTexture);
467 }
468
469 void Texture1DArray::upload (void)
470 {
471         const glw::Functions& gl = m_context.getFunctions();
472
473         TCU_CHECK(m_glTexture);
474         gl.bindTexture(GL_TEXTURE_1D_ARRAY, m_glTexture);
475         gl.pixelStorei(GL_UNPACK_ALIGNMENT, computePixelStore(m_refTexture.getFormat()));
476         GLU_EXPECT_NO_ERROR(gl.getError(), "Texture upload failed");
477
478         TransferFormat transferFormat = getTransferFormat(m_refTexture.getFormat());
479
480         for (int levelNdx = 0; levelNdx < m_refTexture.getNumLevels(); levelNdx++)
481         {
482                 if (m_refTexture.isLevelEmpty(levelNdx))
483                         continue; // Don't upload.
484
485                 tcu::ConstPixelBufferAccess access = m_refTexture.getLevel(levelNdx);
486                 DE_ASSERT(access.getRowPitch() == access.getFormat().getPixelSize()*access.getWidth());
487                 gl.texImage2D(GL_TEXTURE_1D_ARRAY, levelNdx, m_format, access.getWidth(), access.getHeight(), 0 /* border */, transferFormat.format, transferFormat.dataType, access.getDataPtr());
488         }
489
490         GLU_EXPECT_NO_ERROR(gl.getError(), "Texture upload failed");
491 }
492
493 // Texture2DArray
494
495 Texture2DArray::Texture2DArray (const RenderContext& context, deUint32 format, deUint32 dataType, int width, int height, int numLevels)
496         : m_context                     (context)
497         , m_isCompressed        (false)
498         , m_format                      (format)
499         , m_refTexture          (mapGLTransferFormat(format, dataType), width, height, numLevels)
500         , m_glTexture           (0)
501 {
502         // \todo [2013-04-08 pyry] Check support here.
503         const glw::Functions& gl = m_context.getFunctions();
504         gl.genTextures(1, &m_glTexture);
505         GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() failed");
506 }
507
508 Texture2DArray::Texture2DArray (const RenderContext& context, deUint32 sizedFormat, int width, int height, int numLevels)
509         : m_context                     (context)
510         , m_isCompressed        (false)
511         , m_format                      (sizedFormat)
512         , m_refTexture          (mapGLInternalFormat(sizedFormat), width, height, numLevels)
513         , m_glTexture           (0)
514 {
515         // \todo [2013-04-08 pyry] Check support here.
516         const glw::Functions& gl = m_context.getFunctions();
517         gl.genTextures(1, &m_glTexture);
518         GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() failed");
519 }
520
521 Texture2DArray::Texture2DArray (const RenderContext& context, const ContextInfo& contextInfo, int numLevels, const tcu::CompressedTexture* levels, const tcu::TexDecompressionParams& decompressionParams)
522         : m_context                     (context)
523         , m_isCompressed        (true)
524         , m_format                      (getGLFormat(levels[0].getFormat()))
525         , m_refTexture          (getUncompressedFormat(levels[0].getFormat()), levels[0].getWidth(), levels[0].getHeight(), levels[0].getDepth())
526         , m_glTexture           (0)
527 {
528         const glw::Functions& gl = context.getFunctions();
529
530         if (!contextInfo.isCompressedTextureFormatSupported(m_format))
531                 throw tcu::NotSupportedError("Compressed texture format not supported", "", __FILE__, __LINE__);
532
533         gl.genTextures(1, &m_glTexture);
534         GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() failed");
535
536         try
537         {
538                 loadCompressed(numLevels, levels, decompressionParams);
539         }
540         catch (const std::exception&)
541         {
542                 gl.deleteTextures(1, &m_glTexture);
543                 throw;
544         }
545 }
546
547 Texture2DArray::~Texture2DArray (void)
548 {
549         if (m_glTexture)
550                 m_context.getFunctions().deleteTextures(1, &m_glTexture);
551 }
552
553 void Texture2DArray::upload (void)
554 {
555         const glw::Functions& gl = m_context.getFunctions();
556
557         if (!gl.texImage3D)
558                 throw tcu::NotSupportedError("glTexImage3D() is not supported");
559
560         TCU_CHECK(m_glTexture);
561         gl.bindTexture(GL_TEXTURE_2D_ARRAY, m_glTexture);
562         gl.pixelStorei(GL_UNPACK_ALIGNMENT, computePixelStore(m_refTexture.getFormat()));
563         GLU_EXPECT_NO_ERROR(gl.getError(), "Texture upload failed");
564
565         TransferFormat transferFormat = getTransferFormat(m_refTexture.getFormat());
566
567         for (int levelNdx = 0; levelNdx < m_refTexture.getNumLevels(); levelNdx++)
568         {
569                 if (m_refTexture.isLevelEmpty(levelNdx))
570                         continue; // Don't upload.
571
572                 tcu::ConstPixelBufferAccess access = m_refTexture.getLevel(levelNdx);
573                 DE_ASSERT(access.getRowPitch() == access.getFormat().getPixelSize()*access.getWidth());
574                 DE_ASSERT(access.getSlicePitch() == access.getFormat().getPixelSize()*access.getWidth()*access.getHeight());
575                 gl.texImage3D(GL_TEXTURE_2D_ARRAY, levelNdx, m_format, access.getWidth(), access.getHeight(), access.getDepth(), 0 /* border */, transferFormat.format, transferFormat.dataType, access.getDataPtr());
576         }
577
578         GLU_EXPECT_NO_ERROR(gl.getError(), "Texture upload failed");
579 }
580
581 void Texture2DArray::loadCompressed (int numLevels, const tcu::CompressedTexture* levels, const tcu::TexDecompressionParams& decompressionParams)
582 {
583         const glw::Functions&   gl                                      = m_context.getFunctions();
584         deUint32                                compressedFormat        = getGLFormat(levels[0].getFormat());
585
586         TCU_CHECK(m_glTexture);
587         gl.bindTexture(GL_TEXTURE_2D_ARRAY, m_glTexture);
588
589         for (int levelNdx = 0; levelNdx < numLevels; levelNdx++)
590         {
591                 const tcu::CompressedTexture& level = levels[levelNdx];
592
593                 // Decompress to reference texture.
594                 m_refTexture.allocLevel(levelNdx);
595                 tcu::PixelBufferAccess refLevelAccess = m_refTexture.getLevel(levelNdx);
596                 TCU_CHECK(level.getWidth()      == refLevelAccess.getWidth() &&
597                                   level.getHeight()     == refLevelAccess.getHeight() &&
598                                   level.getDepth()      == refLevelAccess.getDepth());
599                 level.decompress(refLevelAccess, decompressionParams);
600
601                 // Upload to GL texture in compressed form.
602                 gl.compressedTexImage3D(GL_TEXTURE_2D_ARRAY, levelNdx, compressedFormat,
603                                                                 level.getWidth(), level.getHeight(), m_refTexture.getLevel(levelNdx).getDepth(), 0 /* border */, level.getDataSize(), level.getData());
604         }
605
606         GLU_EXPECT_NO_ERROR(gl.getError(), "Texture upload failed");
607 }
608
609 // Texture3D
610
611 Texture3D::Texture3D (const RenderContext& context, deUint32 format, deUint32 dataType, int width, int height, int depth)
612         : m_context                     (context)
613         , m_isCompressed        (false)
614         , m_format                      (format)
615         , m_refTexture          (mapGLTransferFormat(format, dataType), width, height, depth)
616         , m_glTexture           (0)
617 {
618         // \todo [2013-04-08 pyry] Check support here.
619         const glw::Functions& gl = m_context.getFunctions();
620         gl.genTextures(1, &m_glTexture);
621         GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() failed");
622 }
623
624 Texture3D::Texture3D (const RenderContext& context, deUint32 sizedFormat, int width, int height, int depth)
625         : m_context                     (context)
626         , m_isCompressed        (false)
627         , m_format                      (sizedFormat)
628         , m_refTexture          (mapGLInternalFormat(sizedFormat), width, height, depth)
629         , m_glTexture           (0)
630 {
631         // \todo [2013-04-08 pyry] Check support here.
632         const glw::Functions& gl = m_context.getFunctions();
633         gl.genTextures(1, &m_glTexture);
634         GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() failed");
635 }
636
637 Texture3D::Texture3D (const RenderContext&                                      context,
638                                           const ContextInfo&                                    contextInfo,
639                                           int                                                                   numLevels,
640                                           const tcu::CompressedTexture*                 levels,
641                                           const tcu::TexDecompressionParams&    decompressionParams)
642         : m_context                     (context)
643         , m_isCompressed        (true)
644         , m_format                      (getGLFormat(levels[0].getFormat()))
645         , m_refTexture          (getUncompressedFormat(levels[0].getFormat()), levels[0].getWidth(), levels[0].getHeight(), levels[0].getDepth())
646         , m_glTexture           (0)
647 {
648         const glw::Functions& gl = context.getFunctions();
649
650         if (!contextInfo.isCompressedTextureFormatSupported(m_format))
651                 throw tcu::NotSupportedError("Compressed texture format not supported", "", __FILE__, __LINE__);
652
653         gl.genTextures(1, &m_glTexture);
654         GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() failed");
655
656         try
657         {
658                 loadCompressed(numLevels, levels, decompressionParams);
659         }
660         catch (const std::exception&)
661         {
662                 gl.deleteTextures(1, &m_glTexture);
663                 throw;
664         }
665 }
666
667 Texture3D::~Texture3D (void)
668 {
669         if (m_glTexture)
670                 m_context.getFunctions().deleteTextures(1, &m_glTexture);
671 }
672
673 void Texture3D::upload (void)
674 {
675         const glw::Functions& gl = m_context.getFunctions();
676
677         DE_ASSERT(!m_isCompressed);
678
679         if (!gl.texImage3D)
680                 throw tcu::NotSupportedError("glTexImage3D() is not supported");
681
682         TCU_CHECK(m_glTexture);
683         gl.bindTexture(GL_TEXTURE_3D, m_glTexture);
684         gl.pixelStorei(GL_UNPACK_ALIGNMENT, computePixelStore(m_refTexture.getFormat()));
685         GLU_EXPECT_NO_ERROR(gl.getError(), "Texture upload failed");
686
687         TransferFormat transferFormat = getTransferFormat(m_refTexture.getFormat());
688
689         for (int levelNdx = 0; levelNdx < m_refTexture.getNumLevels(); levelNdx++)
690         {
691                 if (m_refTexture.isLevelEmpty(levelNdx))
692                         continue; // Don't upload.
693
694                 tcu::ConstPixelBufferAccess access = m_refTexture.getLevel(levelNdx);
695                 DE_ASSERT(access.getRowPitch() == access.getFormat().getPixelSize()*access.getWidth());
696                 DE_ASSERT(access.getSlicePitch() == access.getFormat().getPixelSize()*access.getWidth()*access.getHeight());
697                 gl.texImage3D(GL_TEXTURE_3D, levelNdx, m_format, access.getWidth(), access.getHeight(), access.getDepth(), 0 /* border */, transferFormat.format, transferFormat.dataType, access.getDataPtr());
698         }
699
700         GLU_EXPECT_NO_ERROR(gl.getError(), "Texture upload failed");
701 }
702
703 void Texture3D::loadCompressed (int numLevels, const tcu::CompressedTexture* levels, const tcu::TexDecompressionParams& decompressionParams)
704 {
705         const glw::Functions&   gl                                      = m_context.getFunctions();
706         deUint32                                compressedFormat        = getGLFormat(levels[0].getFormat());
707
708         if (!gl.compressedTexImage3D)
709                 throw tcu::NotSupportedError("glCompressedTexImage3D() is not supported");
710
711         TCU_CHECK(m_glTexture);
712         gl.bindTexture(GL_TEXTURE_3D, m_glTexture);
713
714         for (int levelNdx = 0; levelNdx < numLevels; levelNdx++)
715         {
716                 const tcu::CompressedTexture& level = levels[levelNdx];
717
718                 // Decompress to reference texture.
719                 m_refTexture.allocLevel(levelNdx);
720                 tcu::PixelBufferAccess refLevelAccess = m_refTexture.getLevel(levelNdx);
721                 TCU_CHECK(level.getWidth()      == refLevelAccess.getWidth() &&
722                                   level.getHeight()     == refLevelAccess.getHeight() &&
723                                   level.getDepth()      == refLevelAccess.getDepth());
724                 level.decompress(refLevelAccess, decompressionParams);
725
726                 // Upload to GL texture in compressed form.
727                 gl.compressedTexImage3D(GL_TEXTURE_3D, levelNdx, compressedFormat,
728                                                                 level.getWidth(), level.getHeight(), level.getDepth(), 0 /* border */, level.getDataSize(), level.getData());
729         }
730
731         GLU_EXPECT_NO_ERROR(gl.getError(), "Texture upload failed");
732 }
733
734 // TextureCubeArray
735
736 TextureCubeArray::TextureCubeArray (const RenderContext& context, deUint32 format, deUint32 dataType, int size, int numLayers)
737         : m_context                     (context)
738         , m_format                      (format)
739         , m_refTexture          (mapGLTransferFormat(format, dataType), size, numLayers)
740         , m_glTexture           (0)
741 {
742         // \todo [2013-04-08 pyry] Check support here.
743         const glw::Functions& gl = m_context.getFunctions();
744         gl.genTextures(1, &m_glTexture);
745         GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() failed");
746 }
747
748 TextureCubeArray::TextureCubeArray (const RenderContext& context, deUint32 sizedFormat, int size, int numLayers)
749         : m_context                     (context)
750         , m_format                      (sizedFormat)
751         , m_refTexture          (mapGLInternalFormat(sizedFormat), size, numLayers)
752         , m_glTexture           (0)
753 {
754         // \todo [2013-04-08 pyry] Check support here.
755         const glw::Functions& gl = m_context.getFunctions();
756         gl.genTextures(1, &m_glTexture);
757         GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() failed");
758 }
759
760 TextureCubeArray::~TextureCubeArray (void)
761 {
762         if (m_glTexture)
763                 m_context.getFunctions().deleteTextures(1, &m_glTexture);
764 }
765
766 void TextureCubeArray::upload (void)
767 {
768         const glw::Functions& gl = m_context.getFunctions();
769
770         if (!gl.texImage3D)
771                 throw tcu::NotSupportedError("glTexImage3D() is not supported");
772
773         TCU_CHECK(m_glTexture);
774         gl.bindTexture(GL_TEXTURE_CUBE_MAP_ARRAY, m_glTexture);
775         gl.pixelStorei(GL_UNPACK_ALIGNMENT, computePixelStore(m_refTexture.getFormat()));
776         GLU_EXPECT_NO_ERROR(gl.getError(), "Texture upload failed");
777
778         TransferFormat transferFormat = getTransferFormat(m_refTexture.getFormat());
779
780         for (int levelNdx = 0; levelNdx < m_refTexture.getNumLevels(); levelNdx++)
781         {
782                 if (m_refTexture.isLevelEmpty(levelNdx))
783                         continue; // Don't upload.
784
785                 tcu::ConstPixelBufferAccess access = m_refTexture.getLevel(levelNdx);
786                 DE_ASSERT(access.getRowPitch() == access.getFormat().getPixelSize()*access.getWidth());
787                 DE_ASSERT(access.getSlicePitch() == access.getFormat().getPixelSize()*access.getWidth()*access.getHeight());
788                 gl.texImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, levelNdx, m_format, access.getWidth(), access.getHeight(), access.getDepth(), 0 /* border */, transferFormat.format, transferFormat.dataType, access.getDataPtr());
789         }
790
791         GLU_EXPECT_NO_ERROR(gl.getError(), "Texture upload failed");
792 }
793
794 // TextureBuffer
795
796 TextureBuffer::TextureBuffer (const RenderContext& context, deUint32 internalFormat, size_t bufferSize)
797         : m_context                     (context)
798         , m_format                      (0)
799         , m_offset                      (0)
800         , m_size                        (0)
801         , m_glTexture           (0)
802         , m_glBuffer            (0)
803 {
804         init(internalFormat, bufferSize, 0, 0, DE_NULL);
805 }
806
807 TextureBuffer::TextureBuffer (const RenderContext& context, deUint32 internalFormat, size_t bufferSize, size_t offset, size_t size, const void* data)
808         : m_context                     (context)
809         , m_format                      (0)
810         , m_offset                      (0)
811         , m_size                        (0)
812         , m_glTexture           (0)
813         , m_glBuffer            (0)
814 {
815         init(internalFormat, bufferSize, offset, size, data);
816 }
817
818 void TextureBuffer::init (deUint32 internalFormat, size_t bufferSize, size_t offset, size_t size, const void* data)
819 {
820         const glw::Functions&           gl              = m_context.getFunctions();
821         de::UniquePtr<ContextInfo>      info    (ContextInfo::create(m_context));
822
823         if (offset != 0 || size != 0)
824         {
825                 if (!(contextSupports(m_context.getType(), glu::ApiType(3, 3, glu::PROFILE_CORE)) && info->isExtensionSupported("GL_ARB_texture_buffer_range"))
826                         && !(contextSupports(m_context.getType(), glu::ApiType(3, 1, glu::PROFILE_ES))
827                                 && info->isExtensionSupported("GL_EXT_texture_buffer")))
828                 {
829                         throw tcu::NotSupportedError("Ranged texture buffers not supported", "", __FILE__, __LINE__);
830                 }
831         }
832         else
833         {
834                 if (!contextSupports(m_context.getType(), glu::ApiType(3, 3, glu::PROFILE_CORE))
835                         && !(contextSupports(m_context.getType(), glu::ApiType(3, 1, glu::PROFILE_ES))
836                                 && info->isExtensionSupported("GL_EXT_texture_buffer")))
837                 {
838                         throw tcu::NotSupportedError("Texture buffers not supported", "", __FILE__, __LINE__);
839                 }
840         }
841
842         m_refBuffer.setStorage(bufferSize);
843         if (data)
844                 deMemcpy(m_refBuffer.getPtr(), data, (int)bufferSize);
845
846         m_format        = internalFormat;
847         m_offset        = offset;
848         m_size          = size;
849
850         DE_ASSERT(size != 0 || offset == 0);
851
852         {
853                 gl.genTextures(1, &m_glTexture);
854                 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() failed");
855
856                 gl.genBuffers(1, &m_glBuffer);
857                 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers() failed");
858
859                 gl.bindBuffer(GL_TEXTURE_BUFFER, m_glBuffer);
860                 gl.bufferData(GL_TEXTURE_BUFFER, (glw::GLsizei)m_refBuffer.size(), data, GL_STATIC_DRAW);
861                 gl.bindBuffer(GL_TEXTURE_BUFFER, 0);
862                 GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to create buffer");
863
864                 gl.bindTexture(GL_TEXTURE_BUFFER, m_glTexture);
865
866                 if (offset != 0 || size != 0)
867                         gl.texBufferRange(GL_TEXTURE_BUFFER, m_format, m_glBuffer, (glw::GLintptr)m_offset, (glw::GLsizeiptr)m_size);
868                 else
869                         gl.texBuffer(GL_TEXTURE_BUFFER, m_format, m_glBuffer);
870
871                 gl.bindTexture(GL_TEXTURE_BUFFER, 0);
872                 GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to bind buffer to texture");
873         }
874 }
875
876 TextureBuffer::~TextureBuffer (void)
877 {
878         if (m_glTexture)
879                 m_context.getFunctions().deleteTextures(1, &m_glTexture);
880
881         if (m_glBuffer)
882                 m_context.getFunctions().deleteBuffers(1, &m_glBuffer);
883 }
884
885
886 const tcu::PixelBufferAccess TextureBuffer::getFullRefTexture (void)
887 {
888         const tcu::TextureFormat        format                          = mapGLInternalFormat(m_format);
889         const size_t                            bufferLengthBytes       = (m_size != 0) ? (m_size) : (m_refBuffer.size());
890         const int                                       bufferLengthPixels      = (int)bufferLengthBytes / format.getPixelSize();
891
892         return tcu::PixelBufferAccess(format,
893                                                                   tcu::IVec3(bufferLengthPixels, 1, 1),
894                                                                   (deUint8*)m_refBuffer.getPtr() + m_offset);
895 }
896
897 const tcu::ConstPixelBufferAccess TextureBuffer::getFullRefTexture (void) const
898 {
899         return const_cast<TextureBuffer*>(this)->getFullRefTexture();
900 }
901
902 void TextureBuffer::upload (void)
903 {
904         const glw::Functions& gl = m_context.getFunctions();
905
906         gl.bindBuffer(GL_TEXTURE_BUFFER, m_glBuffer);
907         gl.bufferData(GL_TEXTURE_BUFFER, (glw::GLsizei)m_refBuffer.size(), m_refBuffer.getPtr(), GL_STATIC_DRAW);
908         gl.bindBuffer(GL_TEXTURE_BUFFER, 0);
909         GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to upload buffer");
910 }
911
912 } // glu