static bool
test_cube_array_texture(void)
{
const GLint width = 16, height = 16;
const GLenum target = GL_TEXTURE_CUBE_MAP_ARRAY;
GLuint tex;
bool pass = true;
/* Test valid cube array dimensions */
glCreateTextures(target, 1, &tex);
glBindTextureUnit(0, tex);
glTextureStorage3D(tex, 1, GL_RGBA8, width, height, 12);
pass = piglit_check_gl_error(GL_NO_ERROR) && pass;
glDeleteTextures(1, &tex);
if (!piglit_khr_no_error) {
/* Test invalid cube array width, height dimensions */
glCreateTextures(target, 1, &tex);
glBindTextureUnit(0, tex);
glTextureStorage3D(tex, 1, GL_RGBA8, width, height+3, 12);
pass = piglit_check_gl_error(GL_INVALID_VALUE) && pass;
glDeleteTextures(1, &tex);
/* Test invalid cube array depth */
glCreateTextures(target, 1, &tex);
glBindTextureUnit(0, tex);
glTextureStorage3D(tex, 1, GL_RGBA8, width, height, 12+2);
pass = piglit_check_gl_error(GL_INVALID_VALUE) && pass;
glDeleteTextures(1, &tex);
}
return pass;
}
void Texture2DArray::pushToGPU(bool deleteAfterPush) {
glTextureStorage3D(name, mipmapLevels, images[0].format.sizedFormat, images[0].width, images[0].height, images.size()); //allocate space for all
for (unsigned int i = 0; i < images.size(); ++i) {
ImageData &imageData = images[i];
if (imageData.data != 0)
glTextureSubImage3D(name,
0,
0, 0, i,
imageData.width, imageData.height, 1,
imageData.format.baseFormat, imageData.format.type, imageData.data);
if (deleteAfterPush) {
delete[] imageData.data;
imageData.data = 0;
}
}
if (mipmapLevels > 1) {
glGenerateTextureMipmap(name); //generate the remaining mipmaps
glTextureParameterf(name, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
}
else
glTextureParameterf(name, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTextureParameterf(name, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTextureParameterf(name, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTextureParameterf(name, GL_TEXTURE_WRAP_T, GL_REPEAT);
}
bool initTexture()
{
bool Validated(true);
gli::gl GL;
gli::texture2d Texture(gli::load_dds((getDataDirectory() + TEXTURE_DIFFUSE).c_str()));
gli::gl::format const Format = GL.translate(Texture.format());
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glCreateTextures(GL_TEXTURE_2D_ARRAY, 1, &TextureName);
glTextureParameteri(TextureName, GL_TEXTURE_SWIZZLE_R, GL_RED);
glTextureParameteri(TextureName, GL_TEXTURE_SWIZZLE_G, GL_GREEN);
glTextureParameteri(TextureName, GL_TEXTURE_SWIZZLE_B, GL_BLUE);
glTextureParameteri(TextureName, GL_TEXTURE_SWIZZLE_A, GL_ALPHA);
glTextureParameteri(TextureName, GL_TEXTURE_BASE_LEVEL, 0);
glTextureParameteri(TextureName, GL_TEXTURE_MAX_LEVEL, static_cast<GLint>(Texture.levels() - 1));
glTextureParameteri(TextureName, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTextureParameteri(TextureName, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTextureStorage3D(TextureName, static_cast<GLint>(Texture.levels()),
Format.Internal,
static_cast<GLsizei>(Texture[0].extent().x), static_cast<GLsizei>(Texture[0].extent().y), static_cast<GLsizei>(1));
for(gli::texture2d::size_type Level = 0; Level < Texture.levels(); ++Level)
{
glTextureSubImage3D(TextureName, static_cast<GLint>(Level),
0, 0, 0,
static_cast<GLsizei>(Texture[Level].extent().x), static_cast<GLsizei>(Texture[Level].extent().y), static_cast<GLsizei>(1),
Format.External, Format.Type,
Texture[Level].data());
}
return Validated;
}
GLuint glCreateTextureGTC(GLenum target, GLsizei layers, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei samples, GLboolean fixedsamplelocations)
{
GLuint texture = 0;
glCreateTextures(target, 1, &texture);
glTextureParameteri(texture, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTextureParameteri(texture, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
switch (target)
{
case GL_TEXTURE_2D:
assert(layers == 1 && width >= 1 && height >= 1 && depth == 1 && samples == 1 && fixedsamplelocations == GL_TRUE);
glTextureStorage2D(texture, levels, internalformat, width, height);
break;
case GL_TEXTURE_2D_ARRAY:
assert(layers >= 1 && width >= 1 && height >= 1 && depth == 1 && samples == 1 && fixedsamplelocations == GL_TRUE);
glTextureStorage3D(texture, levels, internalformat, width, height, layers);
break;
case GL_TEXTURE_2D_MULTISAMPLE:
assert(layers == 1 && width >= 1 && height >= 1 && depth == 1 && samples >= 1);
glTextureStorage2DMultisample(texture, samples, internalformat, width, height, fixedsamplelocations);
break;
case GL_TEXTURE_2D_MULTISAMPLE_ARRAY:
assert(layers >= 1 && width >= 1 && height >= 1 && depth == 1 && samples >= 1);
glTextureStorage3DMultisample(texture, samples, internalformat, width, height, layers, fixedsamplelocations);
break;
case GL_TEXTURE_3D:
assert(layers == 1 && width >= 1 && height >= 1 && depth >= 1 && samples == 1 && fixedsamplelocations == GL_TRUE);
glTextureStorage3D(texture, levels, internalformat, width, height, depth);
break;
case GL_TEXTURE_CUBE_MAP:
assert(layers == 1 && width >= 1 && height >= 1 && depth == 1 && samples == 1 && fixedsamplelocations == GL_TRUE);
glTextureStorage2D(texture, levels, internalformat, width, height);
break;
case GL_TEXTURE_CUBE_MAP_ARRAY:
assert(layers >= 1 && width >= 1 && height >= 1 && depth == 1 && samples == 1 && fixedsamplelocations == GL_TRUE);
glTextureStorage3D(texture, levels, internalformat, width, height, layers * 6);
break;
}
return texture;
}
bool initTexture()
{
gli::texture2d Texture(gli::load_dds((getDataDirectory() + TEXTURE_DIFFUSE).c_str()));
assert(!Texture.empty());
glm::uvec2 FramebufferSize(this->getWindowSize() / 16u);
glCreateTextures(GL_TEXTURE_2D_ARRAY, texture::MAX, &TextureName[0]);
glTextureParameteri(TextureName[0], GL_TEXTURE_BASE_LEVEL, 0);
glTextureParameteri(TextureName[0], GL_TEXTURE_MAX_LEVEL, 0);
glTextureParameteri(TextureName[0], GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTextureParameteri(TextureName[0], GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTextureStorage3D(TextureName[0], GLint(1), GL_RGBA8, GLsizei(FramebufferSize.x), GLsizei(FramebufferSize.y), 1);
return true;
}
kit::Texture::Ptr kit::Texture::create3DFromFile(std::string filename, kit::Texture::InternalFormat format, kit::Texture::EdgeSamplingMode edgemode, kit::Texture::FilteringMode minfilter, kit::Texture::FilteringMode magfilter)
{
kit::Texture::Ptr returner = std::make_shared<kit::Texture>(Texture3D);
returner->m_internalFormat = format;
// Try to load data from file
unsigned char* bufferdata;
int x, y, n;
stbi_set_flip_vertically_on_load(0);
bufferdata = stbi_load(filename.c_str(), &x, &y, &n, 4);
if (bufferdata == nullptr) {
KIT_ERR(stbi_failure_reason());
return nullptr;
}
if (y != x*x || y%y != 0)
{
KIT_ERR("Failed to load 3d texture from file, not perfectly cubical");
}
// Set resolution
returner->m_resolution = glm::uvec3(x, x, x);
// Specify storage and upload data to GPU
KIT_GL(glTextureStorage3D(returner->m_glHandle, 1, returner->m_internalFormat, x, x, x));
KIT_GL(glTextureSubImage3D(returner->m_glHandle, 0, 0, 0, 0, x, x, x, GL_RGBA, GL_UNSIGNED_BYTE, bufferdata));
// Free loaded data
stbi_image_free(bufferdata);
// Set parameters
returner->setEdgeSamplingMode(edgemode);
returner->setMinFilteringMode(minfilter);
returner->setMagFilteringMode(magfilter);
// Generate mipmap
//returner->generateMipmap();
return returner;
}
bool initTexture()
{
bool Validated(true);
gli::gl GL(gli::gl::PROFILE_GL33);
gli::texture2d Texture(gli::load_dds((getDataDirectory() + TEXTURE_DIFFUSE).c_str()));
assert(!Texture.empty());
gli::gl::format const Format = GL.translate(Texture.format(), Texture.swizzles());
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glCreateTextures(GL_TEXTURE_2D_ARRAY, 1, &TextureName);
glTextureParameteri(TextureName, GL_TEXTURE_SWIZZLE_R, Format.Swizzles[0]);
glTextureParameteri(TextureName, GL_TEXTURE_SWIZZLE_G, Format.Swizzles[1]);
glTextureParameteri(TextureName, GL_TEXTURE_SWIZZLE_B, Format.Swizzles[2]);
glTextureParameteri(TextureName, GL_TEXTURE_SWIZZLE_A, Format.Swizzles[3]);
glTextureParameteri(TextureName, GL_TEXTURE_BASE_LEVEL, 0);
glTextureParameteri(TextureName, GL_TEXTURE_MAX_LEVEL, GLint(Texture.levels() - 1));
glTextureParameteri(TextureName, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTextureParameteri(TextureName, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTextureStorage3D(TextureName, static_cast<GLint>(Texture.levels()), Format.Internal,
static_cast<GLsizei>(Texture.extent().x), static_cast<GLsizei>(Texture.extent().y), 1);
for(gli::texture2d::size_type Level(0); Level < Texture.levels(); ++Level)
{
glTextureSubImage3D(TextureName, static_cast<GLint>(Level),
0, 0, 0,
static_cast<GLsizei>(Texture[Level].extent().x), static_cast<GLsizei>(Texture[Level].extent().y), 1,
Format.External, Format.Type,
Texture[Level].data());
}
glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
// Query the texture handle and make the texture resident
TextureHandle = glGetTextureHandleNV(TextureName);
glMakeTextureHandleResidentNV(TextureHandle);
return Validated;
}
bool glPixelBuffer::create(GLushort width, GLushort height, GLushort depth,
GFXImageFormat formatEnum,
GFXDataFormat dataTypeEnum) {
GLenum textureTypeEnum = GLUtil::glTextureTypeTable[to_U32(_textureType)];
_internalFormat = GLUtil::internalFormat(formatEnum, dataTypeEnum, false);
_format = GLUtil::glImageFormatTable[to_U32(formatEnum)];
_dataType = GLUtil::glDataFormat[to_U32(dataTypeEnum)];
Console::printfn(Locale::get(_ID("GL_PB_GEN")), width, height);
_width = width;
_height = height;
_depth = depth;
_bufferSize = _width * 4;
switch (_pbtype) {
case PBType::PB_TEXTURE_2D:
_bufferSize *= _height;
break;
case PBType::PB_TEXTURE_3D:
_bufferSize *= _height * _depth;
break;
};
switch (_dataType) {
case GL_SHORT:
case GL_HALF_FLOAT:
case GL_UNSIGNED_SHORT:
_dataSizeBytes = 2;
break;
case GL_FLOAT:
case GL_INT:
case GL_UNSIGNED_INT:
_dataSizeBytes = 4;
break;
default:
break;
}
_bufferSize *= _dataSizeBytes;
GL_API::deleteTextures(1, &_textureID, _textureType);
glCreateTextures(textureTypeEnum, 1, &_textureID);
glTextureParameteri(_textureID, GL_GENERATE_MIPMAP, 0);
glTextureParameteri(_textureID, GL_TEXTURE_MIN_FILTER, to_I32(GL_NEAREST));
glTextureParameteri(_textureID, GL_TEXTURE_MAG_FILTER, to_I32(GL_NEAREST));
glTextureParameteri(_textureID, GL_TEXTURE_BASE_LEVEL, 0);
glTextureParameteri(_textureID, GL_TEXTURE_MAX_LEVEL, 1000);
glTextureParameteri(_textureID, GL_TEXTURE_WRAP_S, to_I32(GL_REPEAT));
if (_pbtype != PBType::PB_TEXTURE_1D) {
glTextureParameteri(_textureID, GL_TEXTURE_WRAP_T, to_I32(GL_REPEAT));
}
if (_pbtype == PBType::PB_TEXTURE_3D) {
glTextureParameteri(_textureID, GL_TEXTURE_WRAP_R, to_I32(GL_REPEAT));
}
U16 mipLevels = to_U16(std::floor(std::log2(std::max(_width, _height))) + 1);
GL_API::getStateTracker().setPixelPackUnpackAlignment();
switch (_pbtype) {
case PBType::PB_TEXTURE_1D:
glTextureStorage1D(_textureID, mipLevels, _internalFormat, _width);
break;
case PBType::PB_TEXTURE_2D:
glTextureStorage2D(_textureID, mipLevels, _internalFormat, _width, _height);
break;
case PBType::PB_TEXTURE_3D:
glTextureStorage3D(_textureID, mipLevels, _internalFormat, _width, _height, _depth);
break;
};
if (_pixelBufferHandle > 0) {
GLUtil::freeBuffer(_pixelBufferHandle);
}
GLUtil::createAndAllocBuffer(_bufferSize, GL_STREAM_DRAW, _pixelBufferHandle, NULL, _name.empty() ? nullptr : _name.c_str());
return _pixelBufferHandle != 0 && _textureID != 0;
}
void Tex2DArray::reload()
{
double timer = ngn::time();
reset();
// RN_CHECK(glGenTextures(1, &id));
// RN_CHECK(glBindTexture(GL_TEXTURE_2D_ARRAY, id));
RN_CHECK(glCreateTextures(GL_TEXTURE_2D_ARRAY, 1, &id));
// RN_CHECK_PARAM(glTextureParameteri(id, GL_TEXTURE_MIN_FILTER, minFilter), rn::getEnumName(minFilter));
// RN_CHECK_PARAM(glTextureParameteri(id, GL_TEXTURE_MAG_FILTER, magFilter), rn::getEnumName(magFilter));
// RN_CHECK_PARAM(glTextureParameteri(id, GL_TEXTURE_WRAP_S, wrapS), rn::getEnumName(wrapS));
// RN_CHECK_PARAM(glTextureParameteri(id, GL_TEXTURE_WRAP_T, wrapT), rn::getEnumName(wrapT));
setParam(GL_TEXTURE_MIN_FILTER, minFilter);
setParam(GL_TEXTURE_MAG_FILTER, magFilter);
setParam(GL_TEXTURE_WRAP_S, wrapS);
setParam(GL_TEXTURE_WRAP_T, wrapT);
// RN_CHECK(glTextureParameterfv(id, GL_TEXTURE_BORDER_COLOR, glm::value_ptr(borderColor)));
setParam(GL_TEXTURE_BORDER_COLOR, glm::value_ptr(borderColor));
if (mipLevels > 0)
{
// RN_CHECK_PARAM(glTextureParameteri(id, GL_TEXTURE_MAX_LEVEL, mipLevels), mipLevels);
setParam(GL_TEXTURE_MAX_LEVEL, mipLevels);
}
switch (internalFormat)
{
case GL_DEPTH_COMPONENT:
format = GL_DEPTH_COMPONENT;
type = GL_UNSIGNED_INT;
break;
case GL_DEPTH_COMPONENT16:
format = GL_DEPTH_COMPONENT;
type = GL_UNSIGNED_INT;
break;
case GL_DEPTH_COMPONENT24:
format = GL_DEPTH_COMPONENT;
type = GL_UNSIGNED_INT;
break;
case GL_DEPTH_COMPONENT32:
format = GL_DEPTH_COMPONENT;
type = GL_UNSIGNED_INT;
break;
case GL_DEPTH_COMPONENT32F:
format = GL_DEPTH_COMPONENT;
type = GL_FLOAT;
break;
case GL_DEPTH24_STENCIL8:
format = GL_DEPTH_STENCIL;
type = GL_UNSIGNED_INT_24_8;
break;
case GL_DEPTH32F_STENCIL8:
format = GL_DEPTH_STENCIL;
type = GL_FLOAT_32_UNSIGNED_INT_24_8_REV;
break;
default:
format = GL_RED;
type = GL_UNSIGNED_BYTE;
}
if (isDepth() && compareFunc != COMPARE_NONE)
{
// RN_CHECK(glTextureParameteri(id, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE));
// RN_CHECK_PARAM(glTextureParameteri(id, GL_TEXTURE_COMPARE_FUNC, compareFunc), rn::getEnumName(compareFunc));
setParam(GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE);
setParam(GL_TEXTURE_COMPARE_FUNC, compareFunc);
}
RN_CHECK_PARAM(glTextureStorage3D(id, mipLevels + 1, internalFormat, width, height, size), mipLevels << ", " << rn::getEnumName(internalFormat) << ", " << width << ", " << height << ", " << size);
/*
GLsizei mipWidth = width;
GLsizei mipHeight = height;
for (GLint i = 0; i <= mipLevels; i++)
{
RN_CHECK_PARAM(glTexImage3D(GL_TEXTURE_2D_ARRAY, i, internalFormat, mipWidth, mipHeight, size, 0, format, type, nullptr), i << ", " << rn::getEnumName(internalFormat) << ", " << mipWidth << ", " << mipHeight << ", " << rn::getEnumName(format) << ", " << rn::getEnumName(type));
mipWidth = max(1, mipWidth / 2);
mipHeight = max(1, mipHeight / 2);
}
*/
// RN_CHECK(glBindTexture(GL_TEXTURE_2D_ARRAY, 0));
UTIL_DEBUG
{
clog << fixed;
clog << " [Tex2DArray \"" << texName << "\":" << (ngn::time() - timer) << "s]" << endl;
clog.unsetf(ios::floatfield);
}
}
kit::Texture::Texture(const std::string & filename, kit::Texture::InternalFormat format, uint8_t levels, Type t) : kit::Texture(t)
{
std::cout << "Loading texture from file \"" << filename.c_str() << "\"" << std::endl;
m_filename = filename;
if(t == Type::Texture2D)
{
m_internalFormat = format;
// Try to load data from file
unsigned char* bufferdata;
int x, y, n;
stbi_set_flip_vertically_on_load(1);
bufferdata = stbi_load(filename.c_str(), &x, &y, &n, 4);
if (bufferdata == nullptr)
{
KIT_THROW(stbi_failure_reason());
}
// Set resolution
m_resolution = glm::uvec3(x, y, 0);
uint8_t mipLevels = levels > 0 ? levels : calculateMipLevels();
// Specify storage and upload data to GPU
#ifndef KIT_SHITTY_INTEL
glTextureStorage2D(m_glHandle, mipLevels, m_internalFormat, m_resolution.x, m_resolution.y);
glTextureSubImage2D(m_glHandle, 0, 0, 0, x, y, GL_RGBA, GL_UNSIGNED_BYTE, bufferdata);
#else
bind();
glTexStorage2D(m_type, mipLevels, m_internalFormat, m_resolution.x, m_resolution.y);
glTexSubImage2D(m_type, 0, 0, 0, x, y, GL_RGBA, GL_UNSIGNED_BYTE, bufferdata);
#endif
// Free loaded data
stbi_image_free(bufferdata);
// Set parameters
setEdgeSamplingMode(EdgeSamplingMode::Repeat);
setMinFilteringMode(m_minFilteringMode);
setMagFilteringMode(m_magFilteringMode);
setAnisotropicLevel(1.0f);
}
if(t == Type::Texture3D)
{
m_internalFormat = format;
// Try to load data from file
unsigned char* bufferdata;
int x, y, n;
stbi_set_flip_vertically_on_load(0);
bufferdata = stbi_load(filename.c_str(), &x, &y, &n, 4);
if (bufferdata == nullptr) {
KIT_THROW(stbi_failure_reason());
}
if (y != x*x || y%y != 0)
{
KIT_THROW("Failed to load 3d texture from file, not perfectly cubical");
}
// Set resolution
m_resolution = glm::uvec3(x, x, x);
// Specify storage and upload data to GPU
#ifndef KIT_SHITTY_INTEL
glTextureStorage3D(m_glHandle, 1, m_internalFormat, x, x, x);
glTextureSubImage3D(m_glHandle, 0, 0, 0, 0, x, x, x, GL_RGBA, GL_UNSIGNED_BYTE, bufferdata);
#else
returner->bind();
glTexStorage3D(returner->m_type, 1, m_internalFormat, x, x, x);
glTexSubImage3D(returner->m_type, 0, 0, 0, 0, x, x, x, GL_RGBA, GL_UNSIGNED_BYTE, bufferdata);
#endif
// Free loaded data
stbi_image_free(bufferdata);
setEdgeSamplingMode(EdgeSamplingMode::Repeat);
setMinFilteringMode(m_minFilteringMode);
setMagFilteringMode(m_magFilteringMode);
setAnisotropicLevel(1.0f);
}
}
//[-------------------------------------------------------]
//[ Public methods ]
//[-------------------------------------------------------]
Texture2DArrayDsa::Texture2DArrayDsa(OpenGLRenderer &openGLRenderer, uint32_t width, uint32_t height, uint32_t numberOfSlices, Renderer::TextureFormat::Enum textureFormat, const void *data, uint32_t flags) :
Texture2DArray(openGLRenderer, width, height, numberOfSlices)
{
#ifndef OPENGLRENDERER_NO_STATE_CLEANUP
// Backup the currently set alignment
GLint openGLAlignmentBackup = 0;
glGetIntegerv(GL_UNPACK_ALIGNMENT, &openGLAlignmentBackup);
#endif
// Set correct alignment
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
// Create the OpenGL texture instance
const bool isARB_DSA = openGLRenderer.getExtensions().isGL_ARB_direct_state_access();
if (isARB_DSA)
{
glCreateTextures(GL_TEXTURE_2D_ARRAY_EXT, 1, &mOpenGLTexture);
}
else
{
glGenTextures(1, &mOpenGLTexture);
}
// Upload the base map of the texture (mipmaps are automatically created as soon as the base map is changed)
if (isARB_DSA)
{
glTextureStorage3D(mOpenGLTexture, 1, Mapping::getOpenGLInternalFormat(textureFormat), static_cast<GLsizei>(width), static_cast<GLsizei>(height), static_cast<GLsizei>(numberOfSlices));
if (nullptr != data)
{
glTextureSubImage3D(mOpenGLTexture, 0, 0, 0, 0, static_cast<GLsizei>(width), static_cast<GLsizei>(height), static_cast<GLsizei>(numberOfSlices), Mapping::getOpenGLFormat(textureFormat), Mapping::getOpenGLType(textureFormat), data);
}
}
else
{
glTextureImage3DEXT(mOpenGLTexture, GL_TEXTURE_2D_ARRAY_EXT, 0, static_cast<GLint>(Mapping::getOpenGLInternalFormat(textureFormat)), static_cast<GLsizei>(width), static_cast<GLsizei>(height), static_cast<GLsizei>(numberOfSlices), 0, Mapping::getOpenGLFormat(textureFormat), Mapping::getOpenGLType(textureFormat), data);
}
// Build mipmaps automatically on the GPU? (or GPU driver)
if (flags & Renderer::TextureFlag::GENERATE_MIPMAPS)
{
if (isARB_DSA)
{
glGenerateTextureMipmap(mOpenGLTexture);
glTextureParameteri(mOpenGLTexture, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);
}
else
{
glGenerateTextureMipmapEXT(mOpenGLTexture, GL_TEXTURE_2D_ARRAY_EXT);
glTextureParameteriEXT(mOpenGLTexture, GL_TEXTURE_2D_ARRAY_EXT, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);
}
}
else
{
if (isARB_DSA)
{
glTextureParameteri(mOpenGLTexture, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
}
else
{
glTextureParameteriEXT(mOpenGLTexture, GL_TEXTURE_2D_ARRAY_EXT, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
}
}
if (isARB_DSA)
{
glTextureParameteri(mOpenGLTexture, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
}
else
{
glTextureParameteriEXT(mOpenGLTexture, GL_TEXTURE_2D_ARRAY_EXT, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
}
#ifndef OPENGLRENDERER_NO_STATE_CLEANUP
// Restore previous alignment
glPixelStorei(GL_UNPACK_ALIGNMENT, openGLAlignmentBackup);
#endif
}
/**
* Do error-check tests for a non-mipmapped texture.
*/
static bool
test_one_level_errors(GLenum target)
{
const GLint width = 64, height = 4, depth = 8;
GLuint tex;
GLint v;
assert(target == GL_TEXTURE_1D ||
target == GL_TEXTURE_2D ||
target == GL_TEXTURE_3D);
glCreateTextures(target, 1, &tex);
glBindTextureUnit(0, tex);
if (target == GL_TEXTURE_1D) {
glTextureStorage1D(tex, 1, GL_RGBA8, width);
} else if (target == GL_TEXTURE_2D) {
glTextureStorage2D(tex, 1, GL_RGBA8, width, height);
} else if (target == GL_TEXTURE_3D) {
glTextureStorage3D(tex, 1, GL_RGBA8, width, height, depth);
}
piglit_check_gl_error(GL_NO_ERROR);
glGetTextureLevelParameteriv(tex, 0, GL_TEXTURE_WIDTH, &v);
if (v != width) {
printf("%s: bad width: %d, should be %d\n", TestName, v, width);
return false;
}
if (target != GL_TEXTURE_1D) {
glGetTextureLevelParameteriv(tex, 0, GL_TEXTURE_HEIGHT, &v);
if (v != height) {
printf("%s: bad height: %d, should be %d\n", TestName,
v, height);
return false;
}
}
if (target == GL_TEXTURE_3D) {
glGetTextureLevelParameteriv(tex, 0, GL_TEXTURE_DEPTH, &v);
if (v != depth) {
printf("%s: bad depth: %d, should be %d\n", TestName,
v, depth);
return false;
}
}
/* The ARB_texture_storage spec says:
*
* "Using any of the following commands with the same texture will
* result in the error INVALID_OPERATION being generated, even if
* it does not affect the dimensions or format:
*
* - TexImage*
* - CompressedTexImage*
* - CopyTexImage*
* - TexStorage*"
*/
if (!piglit_khr_no_error && target == GL_TEXTURE_2D) {
glTexImage2D(target, 0, GL_RGBA, width, height, 0,
GL_RGBA, GL_UNSIGNED_BYTE, NULL);
if (glGetError() != GL_INVALID_OPERATION) {
printf("%s: glTexImage2D failed to generate error\n",
TestName);
return false;
}
glTextureStorage2D(tex, 1, GL_RGBA8, width, height);
if (glGetError() != GL_INVALID_OPERATION) {
printf("%s: glTextureStorage2D() failed to generate "
"error\n", TestName);
return false;
}
glCopyTexImage2D(target, 0, GL_RGBA, 0, 0, width, height, 0);
if (glGetError() != GL_INVALID_OPERATION) {
printf("%s: glCopyTexImage2D() failed to generate "
"error\n", TestName);
return false;
}
}
glDeleteTextures(1, &tex);
return true;
}
/**
* Do error-check tests for a mipmapped texture.
*/
static bool
test_mipmap_errors(GLenum target)
{
GLint width = 128, height = 64, depth = 4, levels = 8;
const char *targetString = piglit_get_gl_enum_name(target);
GLuint tex;
GLint v, l;
assert(target == GL_TEXTURE_1D ||
target == GL_TEXTURE_2D ||
target == GL_TEXTURE_3D);
glCreateTextures(target, 1, &tex);
glBindTextureUnit(0, tex);
if (target == GL_TEXTURE_1D) {
glTextureStorage1D(tex, levels, GL_RGBA8, width);
} else if (target == GL_TEXTURE_2D) {
glTextureStorage2D(tex, levels, GL_RGBA8, width, height);
} else if (target == GL_TEXTURE_3D) {
glTextureStorage3D(tex, levels, GL_RGBA8, width,
height, depth);
}
piglit_check_gl_error(GL_NO_ERROR);
glGetTextureParameteriv(tex, GL_TEXTURE_IMMUTABLE_FORMAT, &v);
if (!v) {
printf("%s: %s GL_TEXTURE_IMMUTABLE_FORMAT query returned "
"false\n",
TestName, targetString);
return false;
}
for (l = 0; l < levels; l++) {
glGetTextureLevelParameteriv(tex, l, GL_TEXTURE_WIDTH, &v);
if (v != width) {
printf("%s: %s level %d: bad width: %d, should be %d\n",
TestName, targetString, l, v, width);
return false;
}
if (target != GL_TEXTURE_1D) {
glGetTextureLevelParameteriv(tex, l,
GL_TEXTURE_HEIGHT, &v);
if (v != height) {
printf("%s: %s level %d: bad height: %d, "
"should be %d\n",
TestName, targetString, l, v, height);
return false;
}
}
if (target == GL_TEXTURE_3D) {
glGetTextureLevelParameteriv(tex, l,
GL_TEXTURE_DEPTH, &v);
if (v != depth) {
printf("%s: %s level %d: bad depth: %d, "
"should be %d\n",
TestName, targetString, l, v, depth);
return false;
}
}
if (width > 1)
width /= 2;
if (height > 1)
height /= 2;
if (depth > 1)
depth /= 2;
}
glDeleteTextures(1, &tex);
return true;
}