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