// --------------------------------------------------------------------------------------------------------------------
GLuint NewTex2DFromDetails(const TextureDetails& _texDetails)
{
GLuint retVal = 0;
GLuint texs[2] = { 0 };
glGenTextures(1, &retVal);
if (retVal == 0) {
return retVal;
}
glBindTexture(GL_TEXTURE_2D, retVal);
glTexStorage2D(GL_TEXTURE_2D, _texDetails.szMipMapCount, _texDetails.glFormat,
_texDetails.dwWidth, _texDetails.dwHeight);
size_t offset = 0;
for (int mip = 0; mip < _texDetails.szMipMapCount; ++mip) {
glCompressedTexSubImage2D(GL_TEXTURE_2D, mip, 0, 0, _texDetails.MipMapWidth(mip), _texDetails.MipMapHeight(mip), _texDetails.glFormat, _texDetails.pSizes[mip], (char*)_texDetails.pPixels + offset);
offset += _texDetails.pSizes[mip];
}
assert(GLRenderer::GetApiError() == GL_NO_ERROR);
return retVal;
}
bool initTexture()
{
gli::texture2D Texture(gli::loadStorageDDS(glf::DATA_DIRECTORY + TEXTURE_DIFFUSE));
assert(!Texture.empty());
if(Texture.empty())
return false;
glGenTextures(1, &TextureName);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, TextureName);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, GLint(Texture.levels() - 1));
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, GL_RED);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_G, GL_GREEN);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, GL_BLUE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_A, GL_ALPHA);
glTexStorage2D(GL_TEXTURE_2D, GLint(Texture.levels()), GL_COMPRESSED_RGB_S3TC_DXT1_EXT,
GLsizei(Texture[0].dimensions().x), GLsizei(Texture[0].dimensions().y));
for(std::size_t Level = 0; Level < Texture.levels(); ++Level)
{
glCompressedTexSubImage2D(
GL_TEXTURE_2D,
GLint(Level),
0, 0,
GLsizei(Texture[Level].dimensions().x),
GLsizei(Texture[Level].dimensions().y),
GL_COMPRESSED_RGB_S3TC_DXT1_EXT,
GLsizei(Texture[Level].size()),
Texture[Level].data());
}
return true;
}
void APIENTRY FWGLExtension::initCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)
{
spCompressedTexSubImage2D = (PFNGLCOMPRESSEDTEXSUBIMAGE2D)FW_GETGLPROC("glCompressedTexSubImage2D");
if(!spCompressedTexSubImage2D)
reportError("glCompressedTexSubImage2D");
glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
}
void QOpenGLTextureHelper::qt_CompressedTextureSubImage2D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *bits)
{
GLint oldTexture;
glGetIntegerv(bindingTarget, &oldTexture);
glBindTexture(target, texture);
glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, bits);
glBindTexture(target, oldTexture);
}
void Texture2D::setCompressedSubImage(int level, int x, int y, int w, int h, int s, const Buffer &pixels)
{
bindToTextureUnit();
pixels.bind(GL_PIXEL_UNPACK_BUFFER);
glCompressedTexSubImage2D(textureTarget, level, x, y, w, h, getTextureInternalFormat(internalFormat), s, pixels.data(0));
pixels.unbind(GL_PIXEL_UNPACK_BUFFER);
assert(FrameBuffer::getError() == GL_NO_ERROR);
}
void Texture1DArray::setCompressedSubImage(int level, int x, int l, int w, int d, int s, const Buffer &pixels)
{
bindToTextureUnit();
pixels.bind(GL_PIXEL_UNPACK_BUFFER);
glCompressedTexSubImage2D(GL_TEXTURE_2D, level, x, l, w, d, getTextureInternalFormat(internalFormat), s, pixels.data(0));
pixels.unbind(GL_PIXEL_UNPACK_BUFFER);
assert(FrameBuffer::getError() == GL_NO_ERROR);
}
void OGLESTexture2D::Unmap2D(uint32_t array_index, uint32_t level)
{
switch (last_tma_)
{
case TMA_Read_Only:
break;
case TMA_Write_Only:
case TMA_Read_Write:
{
GLint gl_internalFormat;
GLenum gl_format;
GLenum gl_type;
OGLESMapping::MappingFormat(gl_internalFormat, gl_format, gl_type, format_);
uint32_t const w = this->Width(level);
uint32_t const h = this->Height(level);
OGLESRenderEngine& re = *checked_cast<OGLESRenderEngine*>(&Context::Instance().RenderFactoryInstance().RenderEngineInstance());
re.BindTexture(0, target_type_, texture_);
if (IsCompressedFormat(format_))
{
uint32_t const block_size = NumFormatBytes(format_) * 4;
GLsizei const image_size = ((w + 3) / 4) * ((h + 3) / 4) * block_size;
if (array_size_ > 1)
{
glCompressedTexSubImage3D(target_type_, level, 0, 0, array_index,
w, h, 1, gl_format, image_size, &tex_data_[array_index * num_mip_maps_ + level][0]);
}
else
{
glCompressedTexSubImage2D(target_type_, level, 0, 0,
w, h, gl_format, image_size, &tex_data_[array_index * num_mip_maps_ + level][0]);
}
}
else
{
if (array_size_ > 1)
{
glTexSubImage3D(target_type_, level, 0, 0, array_index, w, h, 1,
gl_format, gl_type, &tex_data_[array_index * num_mip_maps_ + level][0]);
}
else
{
glTexSubImage2D(target_type_, level, 0, 0, w, h,
gl_format, gl_type, &tex_data_[array_index * num_mip_maps_ + level][0]);
}
}
}
break;
default:
BOOST_ASSERT(false);
break;
}
}
//----------------------------------------------------------------------------//
void OpenGLTexture::loadCompressedTextureBuffer(const Rectf& dest_area,
const GLvoid* buffer) const
{
const GLsizei image_size = getCompressedTextureSize(dest_area.getSize());
glCompressedTexSubImage2D(GL_TEXTURE_2D, 0,
static_cast<GLint>(dest_area.left()),
static_cast<GLint>(dest_area.top()),
static_cast<GLsizei>(dest_area.getWidth()),
static_cast<GLsizei>(dest_area.getHeight()),
d_format, image_size, buffer);
}
void OGLESTextureCube::UnmapCube(uint32_t array_index, CubeFaces face, uint32_t level)
{
BOOST_ASSERT(0 == array_index);
UNREF_PARAM(array_index);
switch (last_tma_)
{
case TMA_Read_Only:
break;
case TMA_Write_Only:
case TMA_Read_Write:
{
GLint gl_internalFormat;
GLenum gl_format;
GLenum gl_type;
OGLESMapping::MappingFormat(gl_internalFormat, gl_format, gl_type, format_);
glBindTexture(target_type_, texture_);
if (IsCompressedFormat(format_))
{
int block_size;
if ((EF_BC1 == format_) || (EF_SIGNED_BC1 == format_) || (EF_BC1_SRGB == format_)
|| (EF_BC4 == format_) || (EF_SIGNED_BC4 == format_) || (EF_BC4_SRGB == format_))
{
block_size = 8;
}
else
{
block_size = 16;
}
GLsizei const image_size = ((this->Width(level) + 3) / 4) * ((this->Height(level) + 3) / 4) * block_size;
glCompressedTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, level,
0, 0, widths_[level], widths_[level], gl_format, image_size, &tex_data_[face * num_mip_maps_ + level][0]);
}
else
{
glTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, level,
0, 0, widths_[level], widths_[level],
gl_format, gl_type, &tex_data_[face * num_mip_maps_ + level][0]);
}
}
break;
default:
BOOST_ASSERT(false);
break;
}
}
GLuint Texture::loadDDS(const char * imagepath)
{
GLuint textureID;
glGenTextures(1, &textureID);
gli::texture2D Texture(gli::load_dds(imagepath));
assert(!Texture.empty());
glBindTexture(GL_TEXTURE_2D, textureID);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, GLint(Texture.levels() - 1));
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, GL_RED);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_G, GL_GREEN);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, GL_BLUE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_A, GL_ALPHA);
glTexStorage2D(GL_TEXTURE_2D,
GLint(Texture.levels()),
GLenum(gli::internal_format(Texture.format())),
GLsizei(Texture.dimensions().x),
GLsizei(Texture.dimensions().y));
if (gli::is_compressed(Texture.format()))
{
for (gli::texture2D::size_type Level = 0; Level < Texture.levels(); ++Level)
{
glCompressedTexSubImage2D(GL_TEXTURE_2D,
GLint(Level),
0, 0,
GLsizei(Texture[Level].dimensions().x),
GLsizei(Texture[Level].dimensions().y),
GLenum(gli::internal_format(Texture.format())),
GLsizei(Texture[Level].size()),
Texture[Level].data());
}
}
else
{
for (gli::texture2D::size_type Level = 0; Level < Texture.levels(); ++Level)
{
glTexSubImage2D(GL_TEXTURE_2D,
GLint(Level),
0, 0,
GLsizei(Texture[Level].dimensions().x),
GLsizei(Texture[Level].dimensions().y),
GLenum(gli::external_format(Texture.format())),
GLenum(gli::type_format(Texture.format())),
Texture[Level].data());
}
}
return textureID;
}
bool initTexture()
{
bool Validated(true);
gli::texture2D Texture(gli::load_dds((getDataDirectory() + TEXTURE_DIFFUSE).c_str()));
assert(!Texture.empty());
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glGenTextures(texture::MAX, &TextureName[0]);
glBindTexture(GL_TEXTURE_2D, TextureName[texture::DIFFUSE]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, GLint(Texture.levels() - 1));
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, GL_RED);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_G, GL_GREEN);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, GL_BLUE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_A, GL_ALPHA);
glTexStorage2D(GL_TEXTURE_2D, GLint(Texture.levels()), GL_COMPRESSED_RGB_S3TC_DXT1_EXT, GLsizei(Texture.dimensions().x), GLsizei(Texture.dimensions().y));
for(std::size_t Level = 0; Level < Texture.levels(); ++Level)
{
glCompressedTexSubImage2D(
GL_TEXTURE_2D,
GLint(Level),
0, 0,
GLsizei(Texture[Level].dimensions().x),
GLsizei(Texture[Level].dimensions().y),
GL_COMPRESSED_RGB_S3TC_DXT1_EXT,
GLsizei(Texture[Level].size()),
Texture[Level].data());
}
glm::vec2 WindowSize(this->getWindowSize());
glBindTexture(GL_TEXTURE_2D, TextureName[texture::COLORBUFFER]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
glTexStorage2D(GL_TEXTURE_2D, GLint(1), GL_RGBA8, GLsizei(WindowSize.x), GLsizei(WindowSize.y));
glBindTexture(GL_TEXTURE_2D, TextureName[texture::RENDERBUFFER]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
glTexStorage2D(GL_TEXTURE_2D, GLint(1), GL_DEPTH_COMPONENT24, GLsizei(WindowSize.x), GLsizei(WindowSize.y));
glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
return Validated;
}
void texture_storage_create2D(hUint32 levels, hBool compressed, GLuint internal_fmt, GLuint fmt, GLuint type, hMipDesc* initdata) {
#if 0
glTexStorage2D(GL_TEXTURE_2D, levels, internal_fmt, initdata[0].width, initdata[0].height);
if (compressed) {
for (auto i = 0u; i < levels; ++i) {
glCompressedTexSubImage2D(GL_TEXTURE_2D, i, 0, 0, initdata[i].width, initdata[i].height, fmt, initdata[i].size, initdata[i].data);
}
}
else {
for (auto i = 0u; i < levels; ++i) {
glTexSubImage2D(GL_TEXTURE_2D, i, 0, 0, initdata[i].width, initdata[i].height, fmt, type, initdata[i].data);
}
}
#endif
}
void UploaderTextureRect::uploadImage
(
TextureMipmapFlag texMipMapFlag,
const std::shared_ptr<Image> &image
)
{
PixelFormat format = (*image)[0].getFormat();
uvec2 dim = (*image)[0].getDimensions();
if( !PixelFormatInfos::getInfos(format).isCompressed() )
GLCheck( glTexSubImage2D(GL_TEXTURE_RECTANGLE, 0, 0, 0, dim.x, dim.y, GLEnum::getExternalFormat(format), GLEnum::getType(format), (*image)[0].getPixels() ));
else
GLCheck( glCompressedTexSubImage2D(GL_TEXTURE_RECTANGLE, 0, 0, 0 , dim.x, dim.y, GLEnum::getExternalFormat(format), dim.x * dim.y * PixelFormatInfos::getInfos(format).size(), (*image)[0].getPixels()));
}
void TextureGL::Update(const TextureCubeData &data, const vector2f &dataSize, TextureFormat format, const unsigned int numMips)
{
assert(m_target == GL_TEXTURE_CUBE_MAP);
glBindTexture(m_target, m_texture);
switch (m_target) {
case GL_TEXTURE_CUBE_MAP:
if (!IsCompressed(format)) {
glTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, 0, 0, dataSize.x, dataSize.y, GLImageFormat(format), GLImageType(format), data.posX);
glTexSubImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, 0, 0, dataSize.x, dataSize.y, GLImageFormat(format), GLImageType(format), data.negX);
glTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, 0, 0, dataSize.x, dataSize.y, GLImageFormat(format), GLImageType(format), data.posY);
glTexSubImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, 0, 0, dataSize.x, dataSize.y, GLImageFormat(format), GLImageType(format), data.negY);
glTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, 0, 0, dataSize.x, dataSize.y, GLImageFormat(format), GLImageType(format), data.posZ);
glTexSubImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, 0, 0, dataSize.x, dataSize.y, GLImageFormat(format), GLImageType(format), data.negZ);
} else {
const GLint oglInternalFormat = GLImageFormat(format);
size_t Offset = 0;
size_t Width = dataSize.x;
size_t Height = dataSize.y;
size_t bufSize = ((Width + 3) / 4) * ((Height + 3) / 4) * GetMinSize(format);
const unsigned char *pData_px = static_cast<const unsigned char*>(data.posX);
const unsigned char *pData_nx = static_cast<const unsigned char*>(data.negX);
const unsigned char *pData_py = static_cast<const unsigned char*>(data.posY);
const unsigned char *pData_ny = static_cast<const unsigned char*>(data.negY);
const unsigned char *pData_pz = static_cast<const unsigned char*>(data.posZ);
const unsigned char *pData_nz = static_cast<const unsigned char*>(data.negZ);
for( unsigned int i = 0; i < numMips; ++i ) {
glCompressedTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, i, 0, 0, Width, Height, oglInternalFormat, bufSize, &pData_px[Offset]);
glCompressedTexSubImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, i, 0, 0, Width, Height, oglInternalFormat, bufSize, &pData_nx[Offset]);
glCompressedTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, i, 0, 0, Width, Height, oglInternalFormat, bufSize, &pData_py[Offset]);
glCompressedTexSubImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, i, 0, 0, Width, Height, oglInternalFormat, bufSize, &pData_ny[Offset]);
glCompressedTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, i, 0, 0, Width, Height, oglInternalFormat, bufSize, &pData_pz[Offset]);
glCompressedTexSubImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, i, 0, 0, Width, Height, oglInternalFormat, bufSize, &pData_nz[Offset]);
if( Width<=MIN_COMPRESSED_TEXTURE_DIMENSION || Height<=MIN_COMPRESSED_TEXTURE_DIMENSION ) {
break;
}
Offset += bufSize;
bufSize /= 4;
Width /= 2;
Height /= 2;
}
}
break;
default:
assert(0);
}
if (GetDescriptor().generateMipmaps)
glGenerateMipmap(m_target);
glBindTexture(m_target, 0);
}
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());
assert(!Texture.empty());
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glGenTextures(texture::MAX, &TextureName[0]);
glBindTexture(GL_TEXTURE_2D, TextureName[texture::DIFFUSE]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, GLint(Texture.levels() - 1));
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, GL_RED);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_G, GL_GREEN);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, GL_BLUE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_A, GL_ALPHA);
glTexStorage2D(GL_TEXTURE_2D, static_cast<GLint>(Texture.levels()), Format.Internal, static_cast<GLsizei>(Texture.dimensions().x), static_cast<GLsizei>(Texture.dimensions().y));
for (std::size_t Level = 0; Level < Texture.levels(); ++Level)
{
glCompressedTexSubImage2D(GL_TEXTURE_2D, static_cast<GLint>(Level),
0, 0,
static_cast<GLsizei>(Texture[Level].dimensions().x), static_cast<GLsizei>(Texture[Level].dimensions().y),
Format.External,
static_cast<GLsizei>(Texture[Level].size()),
Texture[Level].data());
}
glm::vec2 WindowSize(this->getWindowSize());
glBindTexture(GL_TEXTURE_2D, TextureName[texture::COLORBUFFER]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexStorage2D(GL_TEXTURE_2D, static_cast<GLint>(1), GL_RGBA8, static_cast<GLsizei>(WindowSize.x), static_cast<GLsizei>(WindowSize.y));
glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
return Validated;
}
enum piglit_result
piglit_display(void)
{
const GLenum format = GL_ETC1_RGB8_OES;
const GLsizei width = 8, height = 8;
struct etc1_rgb8_texture_8x8 tex;
GLuint t;
int pass = GL_TRUE;
glGenTextures(1, &t);
glBindTexture(GL_TEXTURE_2D, t);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
make_etc1_rgb8_texture_8x8(&tex);
glClear(GL_COLOR_BUFFER_BIT);
/* no compression support */
glTexImage2D(GL_TEXTURE_2D, 0, format,
width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, tex.rgb);
pass = piglit_check_gl_error(GL_INVALID_VALUE) && pass;
glCopyTexImage2D(GL_TEXTURE_2D, 0, format, 0, 0, width, height, 0);
pass = piglit_check_gl_error(GL_INVALID_VALUE) && pass;
/* test the texture */
pass = test_etc1_rgb8_texture_8x8(&tex) && pass;
/* no subimage support */
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0,
width, height, GL_RGB, GL_UNSIGNED_BYTE, tex.rgb);
pass = piglit_check_gl_error(GL_INVALID_OPERATION) && pass;
glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, width, height);
pass = piglit_check_gl_error(GL_INVALID_OPERATION) && pass;
glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height, format, sizeof(tex.data), tex.data);
pass = piglit_check_gl_error(GL_INVALID_OPERATION) && pass;
glDeleteTextures(1, &t);
return (pass) ? PIGLIT_PASS : PIGLIT_FAIL;;
}
void OGLTexture1D::UpdateSubresource1D(uint32_t array_index, uint32_t level,
uint32_t x_offset, uint32_t width,
void const * data)
{
OGLRenderEngine& re = *checked_cast<OGLRenderEngine*>(&Context::Instance().RenderFactoryInstance().RenderEngineInstance());
GLint gl_internalFormat;
GLenum gl_format;
GLenum gl_type;
OGLMapping::MappingFormat(gl_internalFormat, gl_format, gl_type, format_);
re.BindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
re.BindTexture(0, target_type_, texture_);
if (IsCompressedFormat(format_))
{
uint32_t const block_size = NumFormatBytes(format_) * 4;
GLsizei const image_size = ((width + 3) / 4) * block_size;
if (array_size_ > 1)
{
glCompressedTexSubImage2D(target_type_, level, x_offset, array_index,
width, 1, gl_format, image_size, data);
}
else
{
glCompressedTexSubImage1D(target_type_, level, x_offset,
width, gl_format, image_size, data);
}
}
else
{
if (array_size_ > 1)
{
glTexSubImage2D(target_type_, level, x_offset, array_index, width, 1,
gl_format, gl_type, data);
}
else
{
glTexSubImage1D(target_type_, level, x_offset, width,
gl_format, gl_type, data);
}
}
}
bool initTexture()
{
bool Validated(true);
gli::texture2d Texture(gli::load_dds((getDataDirectory() + TEXTURE_DIFFUSE).c_str()));
this->FrameBufferSize = Texture.extent();
glGenTextures(texture::MAX, &TextureName[0]);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, TextureName[texture::DIFFUSE]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, GLint(Texture.levels() - 1));
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, GL_RED);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_G, GL_GREEN);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, GL_BLUE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_A, GL_ALPHA);
glTexStorage2D(GL_TEXTURE_2D, GLint(Texture.levels()), GL_COMPRESSED_RGB_S3TC_DXT1_EXT,
GLsizei(Texture.extent().x), GLsizei(Texture.extent().y));
for(std::size_t Level = 0; Level < Texture.levels(); ++Level)
{
glCompressedTexSubImage2D(GL_TEXTURE_2D,
GLint(Level),
0, 0,
GLsizei(Texture[Level].extent().x),
GLsizei(Texture[Level].extent().y),
GL_COMPRESSED_RGB_S3TC_DXT1_EXT,
GLsizei(Texture[Level].size()),
Texture[Level].data());
}
glBindTexture(GL_TEXTURE_2D, TextureName[texture::COLORBUFFER]);
glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, this->FrameBufferSize.x, this->FrameBufferSize.y);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, GL_RED);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_G, GL_GREEN);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, GL_BLUE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_A, GL_ALPHA);
return Validated;
}
/// set texture pixels
void GHL_CALL TextureOpenGL::SetData(UInt32 x,UInt32 y,UInt32 w,UInt32 h,const Data* data,UInt32 level) {
glActiveTexture(GL_TEXTURE0);
//glClientActiveTexture(GL_TEXTURE0);
bind();
glPixelStorei(GL_UNPACK_ALIGNMENT,1);
#ifndef GHL_OPENGLES
glPixelStorei(GL_UNPACK_ROW_LENGTH,w);
#endif
if (format_compressed(m_fmt)) {
glCompressedTexSubImage2D(GL_TEXTURE_2D, level, x, y, w, h, convert_int_format(m_fmt), data->GetSize(), data->GetData());
} else {
glTexSubImage2D(GL_TEXTURE_2D, level, x, y, w, h, convert_format(m_fmt), convert_storage(m_fmt), data->GetData());
}
glPixelStorei(GL_UNPACK_ALIGNMENT,4);
#ifndef GHL_OPENGLES
glPixelStorei(GL_UNPACK_ROW_LENGTH,0);
#endif
m_parent->RestoreTexture();
}
void OGLESTextureCube::UnmapCube(uint32_t array_index, CubeFaces face, uint32_t level)
{
switch (last_tma_)
{
case TMA_Read_Only:
break;
case TMA_Write_Only:
case TMA_Read_Write:
{
GLint gl_internalFormat;
GLenum gl_format;
GLenum gl_type;
OGLESMapping::MappingFormat(gl_internalFormat, gl_format, gl_type, format_);
uint32_t const w = this->Width(level);
OGLESRenderEngine& re = *checked_cast<OGLESRenderEngine*>(&Context::Instance().RenderFactoryInstance().RenderEngineInstance());
re.BindTexture(0, target_type_, texture_);
if (IsCompressedFormat(format_))
{
uint32_t const block_size = NumFormatBytes(format_) * 4;
GLsizei const image_size = ((this->Width(level) + 3) / 4) * ((this->Height(level) + 3) / 4) * block_size;
glCompressedTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, level,
0, 0, w, w, gl_format, image_size, &tex_data_[(array_index * 6 + face) * num_mip_maps_ + level][0]);
}
else
{
glTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, level,
0, 0, w, w, gl_format, gl_type, &tex_data_[(array_index * 6 + face) * num_mip_maps_ + level][0]);
}
}
break;
default:
BOOST_ASSERT(false);
break;
}
}
void TextureGL::Update(const void *data, const vector2f &pos, const vector2f &dataSize, TextureFormat format, const unsigned int numMips)
{
assert(m_target == GL_TEXTURE_2D);
glBindTexture(m_target, m_texture);
switch (m_target) {
case GL_TEXTURE_2D:
if (!IsCompressed(format)) {
glTexSubImage2D(m_target, 0, pos.x, pos.y, dataSize.x, dataSize.y, GLImageFormat(format), GLImageType(format), data);
} else {
const GLint oglInternalFormat = GLImageFormat(format);
size_t Offset = 0;
size_t Width = dataSize.x;
size_t Height = dataSize.y;
size_t bufSize = ((Width + 3) / 4) * ((Height + 3) / 4) * GetMinSize(format);
const unsigned char *pData = static_cast<const unsigned char*>(data);
for( unsigned int i = 0; i < numMips; ++i ) {
glCompressedTexSubImage2D(m_target, i, pos.x, pos.y, Width, Height, oglInternalFormat, bufSize, &pData[Offset]);
if( Width<=MIN_COMPRESSED_TEXTURE_DIMENSION || Height<=MIN_COMPRESSED_TEXTURE_DIMENSION ) {
break;
}
Offset += bufSize;
bufSize /= 4;
Width /= 2;
Height /= 2;
}
}
break;
default:
assert(0);
}
if (GetDescriptor().generateMipmaps)
glGenerateMipmap(m_target);
glBindTexture(m_target, 0);
}
bool initTexture()
{
gli::texture2D Texture(gli::load_dds((getDataDirectory() + TEXTURE_DIFFUSE).c_str()));
assert(!Texture.empty());
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glGenTextures(texture::MAX, &TextureName[0]);
glBindTexture(GL_TEXTURE_2D, TextureName[texture::DIFFUSE]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, GLint(Texture.levels() - 1));
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, GL_RED);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_G, GL_GREEN);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, GL_BLUE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_A, GL_ALPHA);
glTexStorage2D(GL_TEXTURE_2D,
GLint(Texture.levels()),
GL_COMPRESSED_RGB_S3TC_DXT1_EXT,
GLsizei(Texture.dimensions().x),
GLsizei(Texture.dimensions().y));
for(std::size_t Level = 0; Level < Texture.levels(); ++Level)
{
glCompressedTexSubImage2D(
GL_TEXTURE_2D,
GLint(Level),
0, 0,
GLsizei(Texture[Level].dimensions().x),
GLsizei(Texture[Level].dimensions().y),
GL_COMPRESSED_RGB_S3TC_DXT1_EXT,
GLsizei(Texture[Level].size()),
Texture[Level].data());
}
glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
return true;
}
static void GLTexSubImage2DBase(
GLenum target,
std::uint32_t mipLevel,
std::int32_t x,
std::int32_t y,
std::uint32_t width,
std::uint32_t height,
const SrcImageDescriptor& imageDesc)
{
if (IsCompressedFormat(imageDesc.format))
{
glCompressedTexSubImage2D(
target,
static_cast<GLint>(mipLevel),
x,
y,
static_cast<GLsizei>(width),
static_cast<GLsizei>(height),
GLTypes::Map(imageDesc.format),
static_cast<GLsizei>(imageDesc.dataSize),
imageDesc.data
);
}
else
{
glTexSubImage2D(
target,
static_cast<GLint>(mipLevel),
x,
y,
static_cast<GLsizei>(width),
static_cast<GLsizei>(height),
GLTypes::Map(imageDesc.format),
GLTypes::Map(imageDesc.dataType),
imageDesc.data
);
}
}
static enum piglit_result
call_CompressedTexSubImage_when_texture_is_referenced(void *data)
{
void *compressed;
GLuint tex;
GLint size;
tex = piglit_rgbw_texture(GL_COMPRESSED_RGBA_BPTC_UNORM, 16, 16,
GL_FALSE, GL_FALSE, GL_UNSIGNED_NORMALIZED);
glGetTextureHandleARB(tex);
if (!piglit_check_gl_error(GL_NO_ERROR))
return PIGLIT_FAIL;
glGetTexLevelParameteriv(GL_TEXTURE_2D, 0,
GL_TEXTURE_COMPRESSED_IMAGE_SIZE, &size);
compressed = malloc(size);
glGetCompressedTexImage(GL_TEXTURE_2D, 0, compressed);
/* The ARB_bindless_texture spec says:
*
* "The contents of the images in a texture object may still be
* updated via commands such as TexSubImage*, CopyTexSubImage*, and
* CompressedTexSubImage*, and by rendering to a framebuffer object,
* even if the texture object is referenced by one or more texture
* handles."
*/
glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 16, 16,
GL_COMPRESSED_RGBA_BPTC_UNORM, size,
compressed);
free(compressed);
if (!piglit_check_gl_error(GL_NO_ERROR))
return PIGLIT_FAIL;
return PIGLIT_PASS;
}
void UploaderTexture2D::uploadImage
(
TextureMipmapFlag texMipMapFlag,
const std::shared_ptr<Image> &image
)
{
PixelFormat format = (*image)[0].getFormat();
unsigned int levelsCount = (texMipMapFlag == TextureMipmapFlag::FromImage) ? image->levels() : 1;
for(std::size_t i(0); i<levelsCount; ++i)
{
uvec2 dim = (*image)[i].getDimensions();
if( !PixelFormatInfos::getInfos(format).isCompressed() )
GLCheck( glTexSubImage2D(GL_TEXTURE_2D, i, 0, 0, dim.x, dim.y, GLEnum::getExternalFormat(format), GLEnum::getType(format), (*image)[i].getPixels() ));
else
GLCheck( glCompressedTexSubImage2D(GL_TEXTURE_2D, i, 0, 0 , dim.x, dim.y, GLEnum::getExternalFormat(format), dim.x * dim.y * PixelFormatInfos::getInfos(format).size(), (*image)[i].getPixels()));
}
if(texMipMapFlag == TextureMipmapFlag::GenHardware)
GLCheck( glGenerateMipmap(GL_TEXTURE_2D) );
}
void
render_texture_subupdate(struct render *R, RID id, const void *pixels, int x, int y, int w, int h) {
struct texture * tex = (struct texture *)array_ref(&R->texture, id);
if (tex == NULL)
return;
GLenum type;
int target;
bind_texture(R, tex, 0, &type, &target);
glPixelStorei(GL_UNPACK_ALIGNMENT,1);
GLint format = 0;
GLenum itype = 0;
int compressed = texture_format(tex, &format, &itype);
if (compressed) {
glCompressedTexSubImage2D(GL_TEXTURE_2D, 0,
x, y, w, h, format,
calc_texture_size(tex->format, w, h), pixels);
} else {
glTexSubImage2D(GL_TEXTURE_2D, 0, x, y, w, h, format, itype, pixels);
}
CHECK_GL_ERROR
}
void compressed_tex_sub_image_2d(texture_target_t target, gl::int_t level, gl::int_t xoffset, gl::int_t yoffset, gl::sizei_t width, gl::sizei_t height, pixel_format_t format, gl::sizei_t imageSize, const void * data) {
glCompressedTexSubImage2D(static_cast<GLenum>(target), level, xoffset, yoffset, width, height, static_cast<GLenum>(format), imageSize, data);
}
bool Texture2D::SetData(unsigned level, int x, int y, int width, int height, const void* data)
{
URHO3D_PROFILE(SetTextureData);
if (!object_ || !graphics_)
{
URHO3D_LOGERROR("No texture created, can not set data");
return false;
}
if (!data)
{
URHO3D_LOGERROR("Null source for setting data");
return false;
}
if (level >= levels_)
{
URHO3D_LOGERROR("Illegal mip level for setting data");
return false;
}
if (graphics_->IsDeviceLost())
{
URHO3D_LOGWARNING("Texture data assignment while device is lost");
dataPending_ = true;
return true;
}
if (IsCompressed())
{
x &= ~3;
y &= ~3;
}
int levelWidth = GetLevelWidth(level);
int levelHeight = GetLevelHeight(level);
if (x < 0 || x + width > levelWidth || y < 0 || y + height > levelHeight || width <= 0 || height <= 0)
{
URHO3D_LOGERROR("Illegal dimensions for setting data");
return false;
}
graphics_->SetTextureForUpdate(this);
bool wholeLevel = x == 0 && y == 0 && width == levelWidth && height == levelHeight;
unsigned format = GetSRGB() ? GetSRGBFormat(format_) : format_;
if (!IsCompressed())
{
if (wholeLevel)
glTexImage2D(target_, level, format, width, height, 0, GetExternalFormat(format_), GetDataType(format_), data);
else
glTexSubImage2D(target_, level, x, y, width, height, GetExternalFormat(format_), GetDataType(format_), data);
}
else
{
if (wholeLevel)
glCompressedTexImage2D(target_, level, format, width, height, 0, GetDataSize(width, height), data);
else
glCompressedTexSubImage2D(target_, level, x, y, width, height, format, GetDataSize(width, height), data);
}
graphics_->SetTexture(0, 0);
return true;
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglCompressedTexSubImage2DBO(JNIEnv *env, jclass clazz, jint target, jint level, jint xoffset, jint yoffset, jint width, jint height, jint format, jint imageSize, jlong data_buffer_offset, jlong function_pointer) {
const GLvoid *data_address = (const GLvoid *)(intptr_t)offsetToPointer(data_buffer_offset);
glCompressedTexSubImage2DPROC glCompressedTexSubImage2D = (glCompressedTexSubImage2DPROC)((intptr_t)function_pointer);
glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data_address);
}
void GLTextureBuffer::upload(const PixelData &data, const PixelVolume &dest)
{
if((mUsage & TU_RENDERTARGET) != 0)
BS_EXCEPT(NotImplementedException, "Writing to render texture from CPU not supported.");
if ((mUsage & TU_DEPTHSTENCIL) != 0)
BS_EXCEPT(NotImplementedException, "Writing to depth stencil texture from CPU not supported.");
glBindTexture( mTarget, mTextureID );
if(PixelUtil::isCompressed(data.getFormat()))
{
if(data.getFormat() != mFormat || !data.isConsecutive())
BS_EXCEPT(InvalidParametersException,
"Compressed images must be consecutive, in the source format");
GLenum format = GLPixelUtil::getClosestGLInternalFormat(mFormat);
switch(mTarget) {
case GL_TEXTURE_1D:
if (dest.left == 0)
{
glCompressedTexImage1D(GL_TEXTURE_1D, mLevel,
format,
dest.getWidth(),
0,
data.getConsecutiveSize(),
data.getData());
}
else
{
glCompressedTexSubImage1D(GL_TEXTURE_1D, mLevel,
dest.left,
dest.getWidth(),
format, data.getConsecutiveSize(),
data.getData());
}
break;
case GL_TEXTURE_2D:
case GL_TEXTURE_CUBE_MAP:
if (dest.left == 0 && dest.top == 0)
{
glCompressedTexImage2D(mFaceTarget, mLevel,
format,
dest.getWidth(),
dest.getHeight(),
0,
data.getConsecutiveSize(),
data.getData());
}
else
{
glCompressedTexSubImage2D(mFaceTarget, mLevel,
dest.left, dest.top,
dest.getWidth(), dest.getHeight(),
format, data.getConsecutiveSize(),
data.getData());
}
break;
case GL_TEXTURE_3D:
if (dest.left == 0 && dest.top == 0 && dest.front == 0)
{
glCompressedTexImage3D(GL_TEXTURE_3D, mLevel,
format,
dest.getWidth(),
dest.getHeight(),
dest.getDepth(),
0,
data.getConsecutiveSize(),
data.getData());
}
else
{
glCompressedTexSubImage3D(GL_TEXTURE_3D, mLevel,
dest.left, dest.top, dest.front,
dest.getWidth(), dest.getHeight(), dest.getDepth(),
format, data.getConsecutiveSize(),
data.getData());
}
break;
}
}
else
{
if(data.getWidth() != data.getRowPitch())
glPixelStorei(GL_UNPACK_ROW_LENGTH, data.getRowPitch());
if(data.getHeight()*data.getWidth() != data.getSlicePitch())
glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, (data.getSlicePitch()/data.getWidth()));
if(data.getLeft() > 0 || data.getTop() > 0 || data.getFront() > 0)
glPixelStorei(GL_UNPACK_SKIP_PIXELS, data.getLeft() + data.getRowPitch() * data.getTop() + data.getSlicePitch() * data.getFront());
if((data.getWidth()*PixelUtil::getNumElemBytes(data.getFormat())) & 3)
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
switch(mTarget) {
case GL_TEXTURE_1D:
glTexSubImage1D(GL_TEXTURE_1D, mLevel,
dest.left,
dest.getWidth(),
GLPixelUtil::getGLOriginFormat(data.getFormat()), GLPixelUtil::getGLOriginDataType(data.getFormat()),
data.getData());
break;
case GL_TEXTURE_2D:
case GL_TEXTURE_CUBE_MAP:
glTexSubImage2D(mFaceTarget, mLevel,
dest.left, dest.top,
dest.getWidth(), dest.getHeight(),
GLPixelUtil::getGLOriginFormat(data.getFormat()), GLPixelUtil::getGLOriginDataType(data.getFormat()),
data.getData());
break;
case GL_TEXTURE_3D:
glTexSubImage3D(
GL_TEXTURE_3D, mLevel,
dest.left, dest.top, dest.front,
dest.getWidth(), dest.getHeight(), dest.getDepth(),
GLPixelUtil::getGLOriginFormat(data.getFormat()), GLPixelUtil::getGLOriginDataType(data.getFormat()),
data.getData());
break;
}
}
// Restore defaults
glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, 0);
glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
BS_INC_RENDER_STAT_CAT(ResWrite, RenderStatObject_Texture);
}
