blob: 6444c6bc52eb0af8839ea829c73617bd2b1d89ea [file] [log] [blame]
/*-------------------------------------------------------------------------
* drawElements Quality Program OpenGL ES Utilities
* ------------------------------------------------
*
* Copyright 2014 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*//*!
* \file
* \brief Texture classes.
*//*--------------------------------------------------------------------*/
#include "gluTexture.hpp"
#include "gluTextureUtil.hpp"
#include "deFilePath.hpp"
#include "tcuImageIO.hpp"
#include "tcuSurface.hpp"
#include "tcuTextureUtil.hpp"
#include "glwFunctions.hpp"
#include "glwEnums.hpp"
#include "deUniquePtr.hpp"
using std::vector;
namespace glu
{
static inline int computePixelStore(const tcu::TextureFormat &format)
{
int pixelSize = format.getPixelSize();
if (deIsPowerOfTwo32(pixelSize))
return de::min(pixelSize, 8);
else
return 1;
}
// Texture1D
Texture1D::Texture1D(const RenderContext &context, uint32_t format, uint32_t dataType, int width)
: m_context(context)
, m_format(format)
, m_refTexture(mapGLTransferFormat(format, dataType), width)
, m_glTexture(0)
{
const glw::Functions &gl = context.getFunctions();
gl.genTextures(1, &m_glTexture);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() failed");
}
Texture1D::Texture1D(const RenderContext &context, uint32_t sizedFormat, int width)
: m_context(context)
, m_format(sizedFormat)
, m_refTexture(mapGLInternalFormat(sizedFormat), width)
, m_glTexture(0)
{
const glw::Functions &gl = context.getFunctions();
gl.genTextures(1, &m_glTexture);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() failed");
}
Texture1D::~Texture1D(void)
{
if (m_glTexture)
m_context.getFunctions().deleteTextures(1, &m_glTexture);
}
void Texture1D::upload(void)
{
const glw::Functions &gl = m_context.getFunctions();
TCU_CHECK(m_glTexture);
gl.bindTexture(GL_TEXTURE_1D, m_glTexture);
gl.pixelStorei(GL_UNPACK_ALIGNMENT, computePixelStore(m_refTexture.getFormat()));
GLU_EXPECT_NO_ERROR(gl.getError(), "Texture upload failed");
TransferFormat transferFormat = getTransferFormat(m_refTexture.getFormat());
for (int levelNdx = 0; levelNdx < m_refTexture.getNumLevels(); levelNdx++)
{
if (m_refTexture.isLevelEmpty(levelNdx))
continue; // Don't upload.
tcu::ConstPixelBufferAccess access = m_refTexture.getLevel(levelNdx);
gl.texImage1D(GL_TEXTURE_1D, levelNdx, m_format, access.getWidth(), 0 /* border */, transferFormat.format,
transferFormat.dataType, access.getDataPtr());
}
GLU_EXPECT_NO_ERROR(gl.getError(), "Texture upload failed");
}
// Texture2D
Texture2D::Texture2D(const RenderContext &context, uint32_t format, uint32_t dataType, int width, int height)
: m_context(context)
, m_isCompressed(false)
, m_format(format)
, m_refTexture(mapGLTransferFormat(format, dataType), width, height, isES2Context(context.getType()))
, m_glTexture(0)
{
const glw::Functions &gl = context.getFunctions();
gl.genTextures(1, &m_glTexture);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() failed");
}
Texture2D::Texture2D(const RenderContext &context, uint32_t sizedFormat, int width, int height)
: m_context(context)
, m_isCompressed(false)
, m_format(sizedFormat)
, m_refTexture(mapGLInternalFormat(sizedFormat), width, height, isES2Context(context.getType()))
, m_glTexture(0)
{
const glw::Functions &gl = context.getFunctions();
gl.genTextures(1, &m_glTexture);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() failed");
}
Texture2D::Texture2D(const RenderContext &context, const ContextInfo &contextInfo, int numLevels,
const tcu::CompressedTexture *levels, const tcu::TexDecompressionParams &decompressionParams)
: m_context(context)
, m_isCompressed(true)
, m_format(getGLFormat(levels[0].getFormat()))
, m_refTexture(getUncompressedFormat(levels[0].getFormat()), levels[0].getWidth(), levels[0].getHeight(),
isES2Context(context.getType()))
, m_glTexture(0)
{
const glw::Functions &gl = context.getFunctions();
if (!contextInfo.isCompressedTextureFormatSupported(m_format))
TCU_THROW(NotSupportedError, "Compressed texture format not supported");
gl.genTextures(1, &m_glTexture);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() failed");
try
{
loadCompressed(numLevels, levels, decompressionParams);
}
catch (const std::exception &)
{
gl.deleteTextures(1, &m_glTexture);
throw;
}
}
Texture2D::~Texture2D(void)
{
if (m_glTexture)
m_context.getFunctions().deleteTextures(1, &m_glTexture);
}
void Texture2D::upload(void)
{
const glw::Functions &gl = m_context.getFunctions();
DE_ASSERT(!m_isCompressed);
TCU_CHECK(m_glTexture);
gl.bindTexture(GL_TEXTURE_2D, m_glTexture);
gl.pixelStorei(GL_UNPACK_ALIGNMENT, computePixelStore(m_refTexture.getFormat()));
GLU_EXPECT_NO_ERROR(gl.getError(), "Texture upload failed");
TransferFormat transferFormat = getTransferFormat(m_refTexture.getFormat());
for (int levelNdx = 0; levelNdx < m_refTexture.getNumLevels(); levelNdx++)
{
if (m_refTexture.isLevelEmpty(levelNdx))
continue; // Don't upload.
tcu::ConstPixelBufferAccess access = m_refTexture.getLevel(levelNdx);
DE_ASSERT(access.getRowPitch() == access.getFormat().getPixelSize() * access.getWidth());
gl.texImage2D(GL_TEXTURE_2D, levelNdx, m_format, access.getWidth(), access.getHeight(), 0 /* border */,
transferFormat.format, transferFormat.dataType, access.getDataPtr());
}
GLU_EXPECT_NO_ERROR(gl.getError(), "Texture upload failed");
}
void Texture2D::loadCompressed(int numLevels, const tcu::CompressedTexture *levels,
const tcu::TexDecompressionParams &decompressionParams)
{
const glw::Functions &gl = m_context.getFunctions();
uint32_t compressedFormat = getGLFormat(levels[0].getFormat());
TCU_CHECK(m_glTexture);
gl.bindTexture(GL_TEXTURE_2D, m_glTexture);
for (int levelNdx = 0; levelNdx < numLevels; levelNdx++)
{
const tcu::CompressedTexture &level = levels[levelNdx];
// Decompress to reference texture.
m_refTexture.allocLevel(levelNdx);
tcu::PixelBufferAccess refLevelAccess = m_refTexture.getLevel(levelNdx);
TCU_CHECK(level.getWidth() == refLevelAccess.getWidth() && level.getHeight() == refLevelAccess.getHeight());
level.decompress(refLevelAccess, decompressionParams);
// Upload to GL texture in compressed form.
gl.compressedTexImage2D(GL_TEXTURE_2D, levelNdx, compressedFormat, level.getWidth(), level.getHeight(),
0 /* border */, level.getDataSize(), level.getData());
}
GLU_EXPECT_NO_ERROR(gl.getError(), "Texture upload failed");
}
Texture2D *Texture2D::create(const RenderContext &context, const ContextInfo &contextInfo, const tcu::Archive &archive,
int numLevels, const char *const *levelFileNames)
{
DE_ASSERT(numLevels > 0);
std::string ext = de::FilePath(levelFileNames[0]).getFileExtension();
if (ext == "png")
{
// Uncompressed texture.
tcu::TextureLevel level;
// Load level 0.
tcu::ImageIO::loadPNG(level, archive, levelFileNames[0]);
TCU_CHECK_INTERNAL(
level.getFormat() == tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8) ||
level.getFormat() == tcu::TextureFormat(tcu::TextureFormat::RGB, tcu::TextureFormat::UNORM_INT8));
bool isRGBA = level.getFormat() == tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8);
Texture2D *texture =
new Texture2D(context, isRGBA ? GL_RGBA : GL_RGB, GL_UNSIGNED_BYTE, level.getWidth(), level.getHeight());
try
{
// Fill level 0.
texture->getRefTexture().allocLevel(0);
tcu::copy(texture->getRefTexture().getLevel(0), level.getAccess());
// Fill remaining levels.
for (int levelNdx = 1; levelNdx < numLevels; levelNdx++)
{
tcu::ImageIO::loadPNG(level, archive, levelFileNames[levelNdx]);
texture->getRefTexture().allocLevel(levelNdx);
tcu::copy(texture->getRefTexture().getLevel(levelNdx), level.getAccess());
}
// Upload data.
texture->upload();
}
catch (const std::exception &)
{
delete texture;
throw;
}
return texture;
}
else if (ext == "pkm")
{
// Compressed texture.
vector<tcu::CompressedTexture> levels(numLevels);
for (int ndx = 0; ndx < numLevels; ndx++)
tcu::ImageIO::loadPKM(levels[ndx], archive, levelFileNames[ndx]);
return new Texture2D(context, contextInfo, numLevels, &levels[0]);
}
else
TCU_FAIL("Unsupported file format");
}
Texture2D *Texture2D::create(const RenderContext &context, const ContextInfo &contextInfo, const tcu::Archive &archive,
int numLevels, const std::vector<std::string> &filenames)
{
TCU_CHECK(numLevels == (int)filenames.size());
std::vector<const char *> charPtrs(filenames.size());
for (int ndx = 0; ndx < (int)filenames.size(); ndx++)
charPtrs[ndx] = filenames[ndx].c_str();
return Texture2D::create(context, contextInfo, archive, numLevels, &charPtrs[0]);
}
// ImmutableTexture2D
ImmutableTexture2D::ImmutableTexture2D(const RenderContext &context, uint32_t sizedFormat, int width, int height)
: Texture2D(context, sizedFormat, width, height)
{
}
void ImmutableTexture2D::upload(void)
{
const glw::Functions &gl = m_context.getFunctions();
DE_ASSERT(!m_isCompressed);
TCU_CHECK(m_glTexture);
gl.bindTexture(GL_TEXTURE_2D, m_glTexture);
gl.pixelStorei(GL_UNPACK_ALIGNMENT, computePixelStore(m_refTexture.getFormat()));
GLU_EXPECT_NO_ERROR(gl.getError(), "Texture upload failed");
TransferFormat transferFormat = getTransferFormat(m_refTexture.getFormat());
gl.texStorage2D(GL_TEXTURE_2D, m_refTexture.getNumLevels(), m_format, m_refTexture.getWidth(),
m_refTexture.getHeight());
for (int levelNdx = 0; levelNdx < m_refTexture.getNumLevels(); levelNdx++)
{
if (m_refTexture.isLevelEmpty(levelNdx))
continue; // Don't upload.
tcu::ConstPixelBufferAccess access = m_refTexture.getLevel(levelNdx);
DE_ASSERT(access.getRowPitch() == access.getFormat().getPixelSize() * access.getWidth());
gl.texSubImage2D(GL_TEXTURE_2D, levelNdx, 0, 0, access.getWidth(), access.getHeight(), transferFormat.format,
transferFormat.dataType, access.getDataPtr());
}
GLU_EXPECT_NO_ERROR(gl.getError(), "Texture upload failed");
}
// TextureCube
TextureCube::TextureCube(const RenderContext &context, const ContextInfo &contextInfo, int numLevels,
const tcu::CompressedTexture *levels, const tcu::TexDecompressionParams &decompressionParams)
: m_context(context)
, m_isCompressed(true)
, m_format(getGLFormat(levels[0].getFormat()))
, m_refTexture(getUncompressedFormat(levels[0].getFormat()), levels[0].getWidth(), isES2Context(context.getType()))
, m_glTexture(0)
{
const glw::Functions &gl = m_context.getFunctions();
TCU_CHECK_INTERNAL(levels[0].getWidth() == levels[0].getHeight());
if (!contextInfo.isCompressedTextureFormatSupported(m_format))
throw tcu::NotSupportedError("Compressed texture format not supported", "", __FILE__, __LINE__);
gl.genTextures(1, &m_glTexture);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() failed");
try
{
loadCompressed(numLevels, levels, decompressionParams);
}
catch (const std::exception &)
{
gl.deleteTextures(1, &m_glTexture);
throw;
}
}
TextureCube::TextureCube(const RenderContext &context, uint32_t format, uint32_t dataType, int size)
: m_context(context)
, m_isCompressed(false)
, m_format(format)
, m_refTexture(mapGLTransferFormat(format, dataType), size, isES2Context(context.getType()))
, m_glTexture(0)
{
const glw::Functions &gl = m_context.getFunctions();
gl.genTextures(1, &m_glTexture);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() failed");
}
TextureCube::TextureCube(const RenderContext &context, uint32_t internalFormat, int size)
: m_context(context)
, m_isCompressed(false)
, m_format(internalFormat)
, m_refTexture(mapGLInternalFormat(internalFormat), size, isES2Context(context.getType()))
, m_glTexture(0)
{
const glw::Functions &gl = m_context.getFunctions();
gl.genTextures(1, &m_glTexture);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() failed");
}
TextureCube::~TextureCube(void)
{
if (m_glTexture)
m_context.getFunctions().deleteTextures(1, &m_glTexture);
}
void TextureCube::upload(void)
{
const glw::Functions &gl = m_context.getFunctions();
DE_ASSERT(!m_isCompressed);
TCU_CHECK(m_glTexture);
gl.bindTexture(GL_TEXTURE_CUBE_MAP, m_glTexture);
gl.pixelStorei(GL_UNPACK_ALIGNMENT, computePixelStore(m_refTexture.getFormat()));
GLU_EXPECT_NO_ERROR(gl.getError(), "Texture upload failed");
TransferFormat transferFormat = getTransferFormat(m_refTexture.getFormat());
for (int face = 0; face < tcu::CUBEFACE_LAST; face++)
{
for (int levelNdx = 0; levelNdx < m_refTexture.getNumLevels(); levelNdx++)
{
if (m_refTexture.isLevelEmpty((tcu::CubeFace)face, levelNdx))
continue; // Don't upload.
tcu::ConstPixelBufferAccess access = m_refTexture.getLevelFace(levelNdx, (tcu::CubeFace)face);
DE_ASSERT(access.getRowPitch() == access.getFormat().getPixelSize() * access.getWidth());
gl.texImage2D(getGLCubeFace((tcu::CubeFace)face), levelNdx, m_format, access.getWidth(), access.getHeight(),
0 /* border */, transferFormat.format, transferFormat.dataType, access.getDataPtr());
}
}
GLU_EXPECT_NO_ERROR(gl.getError(), "Texture upload failed");
}
void TextureCube::loadCompressed(int numLevels, const tcu::CompressedTexture *levels,
const tcu::TexDecompressionParams &decompressionParams)
{
const glw::Functions &gl = m_context.getFunctions();
uint32_t compressedFormat = getGLFormat(levels[0].getFormat());
TCU_CHECK(m_glTexture);
gl.bindTexture(GL_TEXTURE_CUBE_MAP, m_glTexture);
for (int levelNdx = 0; levelNdx < numLevels; levelNdx++)
{
for (int face = 0; face < tcu::CUBEFACE_LAST; face++)
{
const tcu::CompressedTexture &level = levels[levelNdx * tcu::CUBEFACE_LAST + face];
// Decompress to reference texture.
m_refTexture.allocLevel((tcu::CubeFace)face, levelNdx);
tcu::PixelBufferAccess refLevelAccess = m_refTexture.getLevelFace(levelNdx, (tcu::CubeFace)face);
TCU_CHECK(level.getWidth() == refLevelAccess.getWidth() && level.getHeight() == refLevelAccess.getHeight());
level.decompress(refLevelAccess, decompressionParams);
// Upload to GL texture in compressed form.
gl.compressedTexImage2D(getGLCubeFace((tcu::CubeFace)face), levelNdx, compressedFormat, level.getWidth(),
level.getHeight(), 0 /* border */, level.getDataSize(), level.getData());
}
}
GLU_EXPECT_NO_ERROR(gl.getError(), "Texture upload failed");
}
TextureCube *TextureCube::create(const RenderContext &context, const ContextInfo &contextInfo,
const tcu::Archive &archive, int numLevels, const char *const *filenames)
{
DE_ASSERT(numLevels > 0);
std::string ext = de::FilePath(filenames[0]).getFileExtension();
// \todo [2011-11-21 pyry] Support PNG images.
if (ext == "pkm")
{
// Compressed texture.
int numImages = numLevels * tcu::CUBEFACE_LAST;
vector<tcu::CompressedTexture> levels(numImages);
for (int ndx = 0; ndx < numImages; ndx++)
tcu::ImageIO::loadPKM(levels[ndx], archive, filenames[ndx]);
return new TextureCube(context, contextInfo, numLevels, &levels[0]);
}
else
TCU_FAIL("Unsupported file format");
}
TextureCube *TextureCube::create(const RenderContext &context, const ContextInfo &contextInfo,
const tcu::Archive &archive, int numLevels, const std::vector<std::string> &filenames)
{
DE_STATIC_ASSERT(tcu::CUBEFACE_LAST == 6);
TCU_CHECK(numLevels * tcu::CUBEFACE_LAST == (int)filenames.size());
std::vector<const char *> charPtrs(filenames.size());
for (int ndx = 0; ndx < (int)filenames.size(); ndx++)
charPtrs[ndx] = filenames[ndx].c_str();
return TextureCube::create(context, contextInfo, archive, numLevels, &charPtrs[0]);
}
// Texture1DArray
Texture1DArray::Texture1DArray(const RenderContext &context, uint32_t format, uint32_t dataType, int width,
int numLevels)
: m_context(context)
, m_format(format)
, m_refTexture(mapGLTransferFormat(format, dataType), width, numLevels)
, m_glTexture(0)
{
const glw::Functions &gl = m_context.getFunctions();
gl.genTextures(1, &m_glTexture);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() failed");
}
Texture1DArray::Texture1DArray(const RenderContext &context, uint32_t sizedFormat, int width, int numLevels)
: m_context(context)
, m_format(sizedFormat)
, m_refTexture(mapGLInternalFormat(sizedFormat), width, numLevels)
, m_glTexture(0)
{
const glw::Functions &gl = m_context.getFunctions();
gl.genTextures(1, &m_glTexture);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() failed");
}
Texture1DArray::~Texture1DArray(void)
{
if (m_glTexture)
m_context.getFunctions().deleteTextures(1, &m_glTexture);
}
void Texture1DArray::upload(void)
{
const glw::Functions &gl = m_context.getFunctions();
TCU_CHECK(m_glTexture);
gl.bindTexture(GL_TEXTURE_1D_ARRAY, m_glTexture);
gl.pixelStorei(GL_UNPACK_ALIGNMENT, computePixelStore(m_refTexture.getFormat()));
GLU_EXPECT_NO_ERROR(gl.getError(), "Texture upload failed");
TransferFormat transferFormat = getTransferFormat(m_refTexture.getFormat());
for (int levelNdx = 0; levelNdx < m_refTexture.getNumLevels(); levelNdx++)
{
if (m_refTexture.isLevelEmpty(levelNdx))
continue; // Don't upload.
tcu::ConstPixelBufferAccess access = m_refTexture.getLevel(levelNdx);
DE_ASSERT(access.getRowPitch() == access.getFormat().getPixelSize() * access.getWidth());
gl.texImage2D(GL_TEXTURE_1D_ARRAY, levelNdx, m_format, access.getWidth(), access.getHeight(), 0 /* border */,
transferFormat.format, transferFormat.dataType, access.getDataPtr());
}
GLU_EXPECT_NO_ERROR(gl.getError(), "Texture upload failed");
}
// Texture2DArray
Texture2DArray::Texture2DArray(const RenderContext &context, uint32_t format, uint32_t dataType, int width, int height,
int numLevels)
: m_context(context)
, m_isCompressed(false)
, m_format(format)
, m_refTexture(mapGLTransferFormat(format, dataType), width, height, numLevels)
, m_glTexture(0)
{
// \todo [2013-04-08 pyry] Check support here.
const glw::Functions &gl = m_context.getFunctions();
gl.genTextures(1, &m_glTexture);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() failed");
}
Texture2DArray::Texture2DArray(const RenderContext &context, uint32_t sizedFormat, int width, int height, int numLevels)
: m_context(context)
, m_isCompressed(false)
, m_format(sizedFormat)
, m_refTexture(mapGLInternalFormat(sizedFormat), width, height, numLevels)
, m_glTexture(0)
{
// \todo [2013-04-08 pyry] Check support here.
const glw::Functions &gl = m_context.getFunctions();
gl.genTextures(1, &m_glTexture);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() failed");
}
Texture2DArray::Texture2DArray(const RenderContext &context, const ContextInfo &contextInfo, int numLevels,
const tcu::CompressedTexture *levels,
const tcu::TexDecompressionParams &decompressionParams)
: m_context(context)
, m_isCompressed(true)
, m_format(getGLFormat(levels[0].getFormat()))
, m_refTexture(getUncompressedFormat(levels[0].getFormat()), levels[0].getWidth(), levels[0].getHeight(),
levels[0].getDepth())
, m_glTexture(0)
{
const glw::Functions &gl = context.getFunctions();
if (!contextInfo.isCompressedTextureFormatSupported(m_format))
throw tcu::NotSupportedError("Compressed texture format not supported", "", __FILE__, __LINE__);
gl.genTextures(1, &m_glTexture);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() failed");
try
{
loadCompressed(numLevels, levels, decompressionParams);
}
catch (const std::exception &)
{
gl.deleteTextures(1, &m_glTexture);
throw;
}
}
Texture2DArray::~Texture2DArray(void)
{
if (m_glTexture)
m_context.getFunctions().deleteTextures(1, &m_glTexture);
}
void Texture2DArray::upload(void)
{
const glw::Functions &gl = m_context.getFunctions();
if (!gl.texImage3D)
throw tcu::NotSupportedError("glTexImage3D() is not supported");
TCU_CHECK(m_glTexture);
gl.bindTexture(GL_TEXTURE_2D_ARRAY, m_glTexture);
gl.pixelStorei(GL_UNPACK_ALIGNMENT, computePixelStore(m_refTexture.getFormat()));
GLU_EXPECT_NO_ERROR(gl.getError(), "Texture upload failed");
TransferFormat transferFormat = getTransferFormat(m_refTexture.getFormat());
for (int levelNdx = 0; levelNdx < m_refTexture.getNumLevels(); levelNdx++)
{
if (m_refTexture.isLevelEmpty(levelNdx))
continue; // Don't upload.
tcu::ConstPixelBufferAccess access = m_refTexture.getLevel(levelNdx);
DE_ASSERT(access.getRowPitch() == access.getFormat().getPixelSize() * access.getWidth());
DE_ASSERT(access.getSlicePitch() == access.getFormat().getPixelSize() * access.getWidth() * access.getHeight());
gl.texImage3D(GL_TEXTURE_2D_ARRAY, levelNdx, m_format, access.getWidth(), access.getHeight(), access.getDepth(),
0 /* border */, transferFormat.format, transferFormat.dataType, access.getDataPtr());
}
GLU_EXPECT_NO_ERROR(gl.getError(), "Texture upload failed");
}
void Texture2DArray::loadCompressed(int numLevels, const tcu::CompressedTexture *levels,
const tcu::TexDecompressionParams &decompressionParams)
{
const glw::Functions &gl = m_context.getFunctions();
uint32_t compressedFormat = getGLFormat(levels[0].getFormat());
TCU_CHECK(m_glTexture);
gl.bindTexture(GL_TEXTURE_2D_ARRAY, m_glTexture);
for (int levelNdx = 0; levelNdx < numLevels; levelNdx++)
{
const tcu::CompressedTexture &level = levels[levelNdx];
// Decompress to reference texture.
m_refTexture.allocLevel(levelNdx);
tcu::PixelBufferAccess refLevelAccess = m_refTexture.getLevel(levelNdx);
TCU_CHECK(level.getWidth() == refLevelAccess.getWidth() && level.getHeight() == refLevelAccess.getHeight() &&
level.getDepth() == refLevelAccess.getDepth());
level.decompress(refLevelAccess, decompressionParams);
// Upload to GL texture in compressed form.
gl.compressedTexImage3D(GL_TEXTURE_2D_ARRAY, levelNdx, compressedFormat, level.getWidth(), level.getHeight(),
m_refTexture.getLevel(levelNdx).getDepth(), 0 /* border */, level.getDataSize(),
level.getData());
}
GLU_EXPECT_NO_ERROR(gl.getError(), "Texture upload failed");
}
// Texture3D
Texture3D::Texture3D(const RenderContext &context, uint32_t format, uint32_t dataType, int width, int height, int depth)
: m_context(context)
, m_isCompressed(false)
, m_format(format)
, m_refTexture(mapGLTransferFormat(format, dataType), width, height, depth)
, m_glTexture(0)
{
// \todo [2013-04-08 pyry] Check support here.
const glw::Functions &gl = m_context.getFunctions();
gl.genTextures(1, &m_glTexture);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() failed");
}
Texture3D::Texture3D(const RenderContext &context, uint32_t sizedFormat, int width, int height, int depth)
: m_context(context)
, m_isCompressed(false)
, m_format(sizedFormat)
, m_refTexture(mapGLInternalFormat(sizedFormat), width, height, depth)
, m_glTexture(0)
{
// \todo [2013-04-08 pyry] Check support here.
const glw::Functions &gl = m_context.getFunctions();
gl.genTextures(1, &m_glTexture);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() failed");
}
Texture3D::Texture3D(const RenderContext &context, const ContextInfo &contextInfo, int numLevels,
const tcu::CompressedTexture *levels, const tcu::TexDecompressionParams &decompressionParams)
: m_context(context)
, m_isCompressed(true)
, m_format(getGLFormat(levels[0].getFormat()))
, m_refTexture(getUncompressedFormat(levels[0].getFormat()), levels[0].getWidth(), levels[0].getHeight(),
levels[0].getDepth())
, m_glTexture(0)
{
const glw::Functions &gl = context.getFunctions();
if (!contextInfo.isCompressedTextureFormatSupported(m_format))
throw tcu::NotSupportedError("Compressed texture format not supported", "", __FILE__, __LINE__);
gl.genTextures(1, &m_glTexture);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() failed");
try
{
loadCompressed(numLevels, levels, decompressionParams);
}
catch (const std::exception &)
{
gl.deleteTextures(1, &m_glTexture);
throw;
}
}
Texture3D::~Texture3D(void)
{
if (m_glTexture)
m_context.getFunctions().deleteTextures(1, &m_glTexture);
}
void Texture3D::upload(void)
{
const glw::Functions &gl = m_context.getFunctions();
DE_ASSERT(!m_isCompressed);
if (!gl.texImage3D)
throw tcu::NotSupportedError("glTexImage3D() is not supported");
TCU_CHECK(m_glTexture);
gl.bindTexture(GL_TEXTURE_3D, m_glTexture);
gl.pixelStorei(GL_UNPACK_ALIGNMENT, computePixelStore(m_refTexture.getFormat()));
GLU_EXPECT_NO_ERROR(gl.getError(), "Texture upload failed");
TransferFormat transferFormat = getTransferFormat(m_refTexture.getFormat());
for (int levelNdx = 0; levelNdx < m_refTexture.getNumLevels(); levelNdx++)
{
if (m_refTexture.isLevelEmpty(levelNdx))
continue; // Don't upload.
tcu::ConstPixelBufferAccess access = m_refTexture.getLevel(levelNdx);
DE_ASSERT(access.getRowPitch() == access.getFormat().getPixelSize() * access.getWidth());
DE_ASSERT(access.getSlicePitch() == access.getFormat().getPixelSize() * access.getWidth() * access.getHeight());
gl.texImage3D(GL_TEXTURE_3D, levelNdx, m_format, access.getWidth(), access.getHeight(), access.getDepth(),
0 /* border */, transferFormat.format, transferFormat.dataType, access.getDataPtr());
}
GLU_EXPECT_NO_ERROR(gl.getError(), "Texture upload failed");
}
void Texture3D::loadCompressed(int numLevels, const tcu::CompressedTexture *levels,
const tcu::TexDecompressionParams &decompressionParams)
{
const glw::Functions &gl = m_context.getFunctions();
uint32_t compressedFormat = getGLFormat(levels[0].getFormat());
if (!gl.compressedTexImage3D)
throw tcu::NotSupportedError("glCompressedTexImage3D() is not supported");
TCU_CHECK(m_glTexture);
gl.bindTexture(GL_TEXTURE_3D, m_glTexture);
for (int levelNdx = 0; levelNdx < numLevels; levelNdx++)
{
const tcu::CompressedTexture &level = levels[levelNdx];
// Decompress to reference texture.
m_refTexture.allocLevel(levelNdx);
tcu::PixelBufferAccess refLevelAccess = m_refTexture.getLevel(levelNdx);
TCU_CHECK(level.getWidth() == refLevelAccess.getWidth() && level.getHeight() == refLevelAccess.getHeight() &&
level.getDepth() == refLevelAccess.getDepth());
level.decompress(refLevelAccess, decompressionParams);
// Upload to GL texture in compressed form.
gl.compressedTexImage3D(GL_TEXTURE_3D, levelNdx, compressedFormat, level.getWidth(), level.getHeight(),
level.getDepth(), 0 /* border */, level.getDataSize(), level.getData());
}
GLU_EXPECT_NO_ERROR(gl.getError(), "Texture upload failed");
}
// TextureCubeArray
TextureCubeArray::TextureCubeArray(const RenderContext &context, uint32_t format, uint32_t dataType, int size,
int numLayers)
: m_context(context)
, m_format(format)
, m_refTexture(mapGLTransferFormat(format, dataType), size, numLayers)
, m_glTexture(0)
{
// \todo [2013-04-08 pyry] Check support here.
const glw::Functions &gl = m_context.getFunctions();
gl.genTextures(1, &m_glTexture);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() failed");
}
TextureCubeArray::TextureCubeArray(const RenderContext &context, uint32_t sizedFormat, int size, int numLayers)
: m_context(context)
, m_format(sizedFormat)
, m_refTexture(mapGLInternalFormat(sizedFormat), size, numLayers)
, m_glTexture(0)
{
// \todo [2013-04-08 pyry] Check support here.
const glw::Functions &gl = m_context.getFunctions();
gl.genTextures(1, &m_glTexture);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() failed");
}
TextureCubeArray::~TextureCubeArray(void)
{
if (m_glTexture)
m_context.getFunctions().deleteTextures(1, &m_glTexture);
}
void TextureCubeArray::upload(void)
{
const glw::Functions &gl = m_context.getFunctions();
if (!gl.texImage3D)
throw tcu::NotSupportedError("glTexImage3D() is not supported");
TCU_CHECK(m_glTexture);
gl.bindTexture(GL_TEXTURE_CUBE_MAP_ARRAY, m_glTexture);
gl.pixelStorei(GL_UNPACK_ALIGNMENT, computePixelStore(m_refTexture.getFormat()));
GLU_EXPECT_NO_ERROR(gl.getError(), "Texture upload failed");
TransferFormat transferFormat = getTransferFormat(m_refTexture.getFormat());
for (int levelNdx = 0; levelNdx < m_refTexture.getNumLevels(); levelNdx++)
{
if (m_refTexture.isLevelEmpty(levelNdx))
continue; // Don't upload.
tcu::ConstPixelBufferAccess access = m_refTexture.getLevel(levelNdx);
DE_ASSERT(access.getRowPitch() == access.getFormat().getPixelSize() * access.getWidth());
DE_ASSERT(access.getSlicePitch() == access.getFormat().getPixelSize() * access.getWidth() * access.getHeight());
gl.texImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, levelNdx, m_format, access.getWidth(), access.getHeight(),
access.getDepth(), 0 /* border */, transferFormat.format, transferFormat.dataType,
access.getDataPtr());
}
GLU_EXPECT_NO_ERROR(gl.getError(), "Texture upload failed");
}
// TextureBuffer
TextureBuffer::TextureBuffer(const RenderContext &context, uint32_t internalFormat, size_t bufferSize)
: m_context(context)
, m_format(0)
, m_offset(0)
, m_size(0)
, m_glTexture(0)
, m_glBuffer(0)
{
init(internalFormat, bufferSize, 0, 0, DE_NULL);
}
TextureBuffer::TextureBuffer(const RenderContext &context, uint32_t internalFormat, size_t bufferSize, size_t offset,
size_t size, const void *data)
: m_context(context)
, m_format(0)
, m_offset(0)
, m_size(0)
, m_glTexture(0)
, m_glBuffer(0)
{
init(internalFormat, bufferSize, offset, size, data);
}
void TextureBuffer::init(uint32_t internalFormat, size_t bufferSize, size_t offset, size_t size, const void *data)
{
const glw::Functions &gl = m_context.getFunctions();
de::UniquePtr<ContextInfo> info(ContextInfo::create(m_context));
if (offset != 0 || size != 0)
{
if (!(contextSupports(m_context.getType(), glu::ApiType(3, 3, glu::PROFILE_CORE)) &&
info->isExtensionSupported("GL_ARB_texture_buffer_range")) &&
!(contextSupports(m_context.getType(), glu::ApiType(3, 1, glu::PROFILE_ES)) &&
info->isExtensionSupported("GL_EXT_texture_buffer")))
{
throw tcu::NotSupportedError("Ranged texture buffers not supported", "", __FILE__, __LINE__);
}
}
else
{
if (!contextSupports(m_context.getType(), glu::ApiType(3, 3, glu::PROFILE_CORE)) &&
!(contextSupports(m_context.getType(), glu::ApiType(3, 1, glu::PROFILE_ES)) &&
info->isExtensionSupported("GL_EXT_texture_buffer")))
{
throw tcu::NotSupportedError("Texture buffers not supported", "", __FILE__, __LINE__);
}
}
m_refBuffer.setStorage(bufferSize);
if (data)
deMemcpy(m_refBuffer.getPtr(), data, (int)bufferSize);
m_format = internalFormat;
m_offset = offset;
m_size = size;
DE_ASSERT(size != 0 || offset == 0);
{
gl.genTextures(1, &m_glTexture);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() failed");
gl.genBuffers(1, &m_glBuffer);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers() failed");
gl.bindBuffer(GL_TEXTURE_BUFFER, m_glBuffer);
gl.bufferData(GL_TEXTURE_BUFFER, (glw::GLsizei)m_refBuffer.size(), data, GL_STATIC_DRAW);
gl.bindBuffer(GL_TEXTURE_BUFFER, 0);
GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to create buffer");
gl.bindTexture(GL_TEXTURE_BUFFER, m_glTexture);
if (offset != 0 || size != 0)
gl.texBufferRange(GL_TEXTURE_BUFFER, m_format, m_glBuffer, (glw::GLintptr)m_offset,
(glw::GLsizeiptr)m_size);
else
gl.texBuffer(GL_TEXTURE_BUFFER, m_format, m_glBuffer);
gl.bindTexture(GL_TEXTURE_BUFFER, 0);
GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to bind buffer to texture");
}
}
TextureBuffer::~TextureBuffer(void)
{
if (m_glTexture)
m_context.getFunctions().deleteTextures(1, &m_glTexture);
if (m_glBuffer)
m_context.getFunctions().deleteBuffers(1, &m_glBuffer);
}
const tcu::PixelBufferAccess TextureBuffer::getFullRefTexture(void)
{
const tcu::TextureFormat format = mapGLInternalFormat(m_format);
const size_t bufferLengthBytes = (m_size != 0) ? (m_size) : (m_refBuffer.size());
const int bufferLengthPixels = (int)bufferLengthBytes / format.getPixelSize();
return tcu::PixelBufferAccess(format, tcu::IVec3(bufferLengthPixels, 1, 1),
(uint8_t *)m_refBuffer.getPtr() + m_offset);
}
const tcu::ConstPixelBufferAccess TextureBuffer::getFullRefTexture(void) const
{
return const_cast<TextureBuffer *>(this)->getFullRefTexture();
}
void TextureBuffer::upload(void)
{
const glw::Functions &gl = m_context.getFunctions();
gl.bindBuffer(GL_TEXTURE_BUFFER, m_glBuffer);
gl.bufferData(GL_TEXTURE_BUFFER, (glw::GLsizei)m_refBuffer.size(), m_refBuffer.getPtr(), GL_STATIC_DRAW);
gl.bindBuffer(GL_TEXTURE_BUFFER, 0);
GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to upload buffer");
}
} // namespace glu