/** Try to save the last texture sent to glTexImage2D in a file of the given
* file name. This function should only be used for textures sent to
* glTexImage2D with a compressed internal format as argument.<br>
* \note The following format is used to save the compressed texture:<br>
* <internal-format><width><height><size><data> <br>
* The first four elements are integers and the last one is stored
* on \c size bytes.
* \see loadCompressedTexture
*/
void saveCompressedTexture(const std::string& compressed_tex)
{
int internal_format, width, height, size, compressionSuccessful;
glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_INTERNAL_FORMAT, (GLint *)&internal_format);
glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, (GLint *)&width);
glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, (GLint *)&height);
glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_COMPRESSED, (GLint *)&compressionSuccessful);
if (!compressionSuccessful)
return;
glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_COMPRESSED_IMAGE_SIZE, (GLint *)&size);
char *data = new char[size];
glGetCompressedTexImage(GL_TEXTURE_2D, 0, (GLvoid*)data);
std::ofstream ofs(compressed_tex.c_str(), std::ios::out | std::ios::binary);
if (ofs.is_open())
{
ofs.write((char*)&internal_format, sizeof(int));
ofs.write((char*)&width, sizeof(int));
ofs.write((char*)&height, sizeof(int));
ofs.write((char*)&size, sizeof(int));
ofs.write(data, size);
ofs.close();
}
delete[] data;
}
bool Texture2D::GetData(unsigned level, void* dest) const
{
if (!object_.name_ || !graphics_)
{
URHO3D_LOGERROR("No texture created, can not get data");
return false;
}
#ifndef GL_ES_VERSION_2_0
if (!dest)
{
URHO3D_LOGERROR("Null destination for getting data");
return false;
}
if (level >= levels_)
{
URHO3D_LOGERROR("Illegal mip level for getting data");
return false;
}
if (graphics_->IsDeviceLost())
{
URHO3D_LOGWARNING("Getting texture data while device is lost");
return false;
}
if (multiSample_ > 1 && !autoResolve_)
{
URHO3D_LOGERROR("Can not get data from multisampled texture without autoresolve");
return false;
}
if (resolveDirty_)
graphics_->ResolveToTexture(const_cast<Texture2D*>(this));
graphics_->SetTextureForUpdate(const_cast<Texture2D*>(this));
if (!IsCompressed())
glGetTexImage(target_, level, GetExternalFormat(format_), GetDataType(format_), dest);
else
glGetCompressedTexImage(target_, level, dest);
graphics_->SetTexture(0, 0);
return true;
#else
// Special case on GLES: if the texture is a rendertarget, can make it current and use glReadPixels()
if (usage_ == TEXTURE_RENDERTARGET)
{
graphics_->SetRenderTarget(0, const_cast<Texture2D*>(this));
// Ensure the FBO is current; this viewport is actually never rendered to
graphics_->SetViewport(IntRect(0, 0, width_, height_));
glReadPixels(0, 0, width_, height_, GetExternalFormat(format_), GetDataType(format_), dest);
return true;
}
URHO3D_LOGERROR("Getting texture data not supported");
return false;
#endif
}
void OGLTexture1D::Map1D(uint32_t array_index, uint32_t level, TextureMapAccess tma, uint32_t x_offset, uint32_t /*width*/, void*& data)
{
last_tma_ = tma;
uint32_t const texel_size = NumFormatBytes(format_);
uint8_t* p;
OGLRenderEngine& re = *checked_cast<OGLRenderEngine*>(&Context::Instance().RenderFactoryInstance().RenderEngineInstance());
switch (tma)
{
case TMA_Read_Only:
case TMA_Read_Write:
{
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.BindBuffer(GL_PIXEL_PACK_BUFFER, pbos_[array_index * num_mip_maps_ + level]);
re.BindTexture(0, target_type_, texture_);
if (IsCompressedFormat(format_))
{
glGetCompressedTexImage(target_type_, level, nullptr);
p = static_cast<uint8_t*>(glMapBuffer(GL_PIXEL_PACK_BUFFER, GL_READ_ONLY));
}
else
{
glGetTexImage(target_type_, level, gl_format, gl_type, nullptr);
p = static_cast<uint8_t*>(glMapBuffer(GL_PIXEL_PACK_BUFFER, GL_READ_ONLY));
}
}
break;
case TMA_Write_Only:
re.BindBuffer(GL_PIXEL_PACK_BUFFER, 0);
re.BindBuffer(GL_PIXEL_UNPACK_BUFFER, pbos_[array_index * num_mip_maps_ + level]);
p = static_cast<uint8_t*>(glMapBuffer(GL_PIXEL_UNPACK_BUFFER, GL_WRITE_ONLY));
break;
default:
BOOST_ASSERT(false);
p = nullptr;
break;
}
if (IsCompressedFormat(format_))
{
uint32_t const block_size = NumFormatBytes(format_) * 4;
data = p + (x_offset / 4 * block_size);
}
else
{
data = p + x_offset * texel_size;
}
}
static bool
check_texture(GLuint texture, unsigned level,
const struct texture_format *format, const unsigned char *data)
{
int i, j, k;
bool pass = true;
unsigned char *tex_data;
float passrate;
tex_data = malloc(TEX_SIZE * TEX_SIZE * format->bytes);
glBindTexture(GL_TEXTURE_2D, texture);
if (format->block_width != 1 || format->block_height != 1) {
/* Compressed */
glGetCompressedTexImage(GL_TEXTURE_2D, level, tex_data);
} else {
glGetTexImage(GL_TEXTURE_2D, level, format->format,
format->data_type, tex_data);
}
passrate = 0;
for (j = 0; j < TEX_SIZE; ++j) {
for (i = 0; i < TEX_SIZE; ++i) {
if (memcmp(tex_data + ((j * TEX_SIZE) + i) * format->bytes,
data + ((j * TEX_SIZE) + i) * format->bytes,
format->bytes) == 0) {
passrate += 1;
} else {
fprintf(stdout, "texel mismatch at (%d, %d); expected 0x",
i, j);
for (k = format->bytes - 1; k >= 0; --k)
fprintf(stdout, "%02x", data[((j * TEX_SIZE) + i) * format->bytes + k]);
fprintf(stdout, ", received 0x");
for (k = format->bytes - 1; k >= 0; --k)
fprintf(stdout, "%02x", tex_data[((j * TEX_SIZE) + i) * format->bytes + k]);
fprintf(stdout, ".\n");
pass = false;
}
}
}
passrate /= TEX_SIZE * TEX_SIZE;
printf("%0.1f%% of pixels match\n", passrate * 100);
free(tex_data);
return pass;
}
bool Texture2DArray::GetData(unsigned layer, unsigned level, void* dest) const
{
#ifndef GL_ES_VERSION_2_0
if (!object_.name_ || !graphics_)
{
URHO3D_LOGERROR("Texture array not created, can not get data");
return false;
}
if (!dest)
{
URHO3D_LOGERROR("Null destination for getting data");
return false;
}
if (layer != 0)
{
URHO3D_LOGERROR("Only the full download of the array is supported, set layer=0");
return false;
}
if (level >= levels_)
{
URHO3D_LOGERROR("Illegal mip level for getting data");
return false;
}
if (graphics_->IsDeviceLost())
{
URHO3D_LOGWARNING("Getting texture data while device is lost");
return false;
}
graphics_->SetTextureForUpdate(const_cast<Texture2DArray*>(this));
if (!IsCompressed())
glGetTexImage(target_, level, GetExternalFormat(format_), GetDataType(format_), dest);
else
glGetCompressedTexImage(target_, level, dest);
graphics_->SetTexture(0, 0);
return true;
#else
URHO3D_LOGERROR("Getting texture data not supported");
return false;
#endif
}
bool TextureCube::GetData(CubeMapFace face, unsigned level, void* dest) const
{
if (!object_ || !graphics_)
{
URHO3D_LOGERROR("No texture created, can not get data");
return false;
}
if (!dest)
{
URHO3D_LOGERROR("Null destination for getting data");
return false;
}
if (level >= levels_)
{
URHO3D_LOGERROR("Illegal mip level for getting data");
return false;
}
if (graphics_->IsDeviceLost())
{
URHO3D_LOGWARNING("Getting texture data while device is lost");
return false;
}
if (multiSample_ > 1 && !autoResolve_)
{
URHO3D_LOGERROR("Can not get data from multisampled texture without autoresolve");
return false;
}
if (resolveDirty_)
graphics_->ResolveToTexture(const_cast<TextureCube*>(this));
graphics_->SetTextureForUpdate(const_cast<TextureCube*>(this));
if (!IsCompressed())
glGetTexImage(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, level, GetExternalFormat(format_), GetDataType(format_), dest);
else
glGetCompressedTexImage(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, level, dest);
graphics_->SetTexture(0, nullptr);
return true;
}
static bool
check_texture(GLuint texture, unsigned level,
const struct texture_format *format, const unsigned char *data)
{
int i, j, k;
bool pass = true;
unsigned char *tex_data;
tex_data = malloc(TEX_SIZE * TEX_SIZE * format->bytes);
glBindTexture(GL_TEXTURE_2D, texture);
if (format->block_width != 1 || format->block_height != 1) {
/* Compressed */
glGetCompressedTexImage(GL_TEXTURE_2D, level, tex_data);
} else {
glGetTexImage(GL_TEXTURE_2D, level, format->format,
format->data_type, tex_data);
}
for (j = 0; j < TEX_SIZE; ++j) {
for (i = 0; i < TEX_SIZE; ++i) {
int pos = ((j * TEX_SIZE) + i) * format->bytes;
if (!pixels_equal(tex_data + pos, data + pos, format)) {
fprintf(stdout, "texel mismatch at (%d, %d); expected 0x",
i, j);
for (k = format->bytes - 1; k >= 0; --k)
fprintf(stdout, "%02x", data[pos + k]);
fprintf(stdout, ", received 0x");
for (k = format->bytes - 1; k >= 0; --k)
fprintf(stdout, "%02x", tex_data[pos + k]);
fprintf(stdout, ".\n");
pass = false;
i = j = TEX_SIZE; /* exit loops upon error */
}
}
}
free(tex_data);
return pass;
}
void GLTextureBuffer::download(const PixelData &data)
{
if(data.getWidth() != getWidth() || data.getHeight() != getHeight() || data.getDepth() != getDepth())
BS_EXCEPT(InvalidParametersException, "only download of entire buffer is supported by GL");
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");
// Data must be consecutive and at beginning of buffer as PixelStorei not allowed
// for compressed formate
glGetCompressedTexImage(mFaceTarget, mLevel, data.getData());
}
else
{
if(data.getWidth() != data.getRowPitch())
glPixelStorei(GL_PACK_ROW_LENGTH, data.getRowPitch());
if(data.getHeight()*data.getWidth() != data.getSlicePitch())
glPixelStorei(GL_PACK_IMAGE_HEIGHT, (data.getSlicePitch()/data.getWidth()));
if(data.getLeft() > 0 || data.getTop() > 0 || data.getFront() > 0)
glPixelStorei(GL_PACK_SKIP_PIXELS, data.getLeft() + data.getRowPitch() * data.getTop() + data.getSlicePitch() * data.getFront());
if((data.getWidth()*PixelUtil::getNumElemBytes(data.getFormat())) & 3)
glPixelStorei(GL_PACK_ALIGNMENT, 1);
// We can only get the entire texture
glGetTexImage(mFaceTarget, mLevel, GLPixelUtil::getGLOriginFormat(data.getFormat()),
GLPixelUtil::getGLOriginDataType(data.getFormat()), data.getData());
// Restore defaults
glPixelStorei(GL_PACK_ROW_LENGTH, 0);
glPixelStorei(GL_PACK_IMAGE_HEIGHT, 0);
glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
glPixelStorei(GL_PACK_ALIGNMENT, 4);
}
BS_INC_RENDER_STAT_CAT(ResRead, RenderStatObject_Texture);
}
bool TextureCube::GetData(CubeMapFace face, unsigned level, void* dest) const
{
#ifndef GL_ES_VERSION_2_0
if (!object_ || !graphics_)
{
LOGERROR("No texture created, can not get data");
return false;
}
if (!dest)
{
LOGERROR("Null destination for getting data");
return false;
}
if (level >= levels_)
{
LOGERROR("Illegal mip level for getting data");
return false;
}
if (graphics_->IsDeviceLost())
{
LOGWARNING("Getting texture data while device is lost");
return false;
}
graphics_->SetTextureForUpdate(const_cast<TextureCube*>(this));
if (!IsCompressed())
glGetTexImage(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, level, GetExternalFormat(format_), GetDataType(format_), dest);
else
glGetCompressedTexImage(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, level, dest);
graphics_->SetTexture(0, 0);
return true;
#else
LOGERROR("Getting texture data not supported");
return false;
#endif
}
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 GLtexture::saveToFile(const String& filename) {
glBindTexture(GL_TEXTURE_2D, getObject());
int width, height;
int internal_format;
glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &width);
glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &height);
glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_INTERNAL_FORMAT, &internal_format);
TexFormat texformat = trInternalFormat(internal_format);
Image result;
result.initImage(texformat, width, height);
void* data = Malloc(result.getDataSize(0));
int level = 0;
while (1) {
int imagesize;
glGetTexLevelParameteriv(GL_TEXTURE_2D, level, GL_TEXTURE_WIDTH, &width);
glGetTexLevelParameteriv(GL_TEXTURE_2D, level, GL_TEXTURE_HEIGHT, &height);
if (!width) {
break;
}
if (texformat.isCompressed()) {
glGetTexLevelParameteriv(GL_TEXTURE_2D, level, GL_TEXTURE_COMPRESSED_IMAGE_SIZE, &imagesize);
glGetCompressedTexImage(GL_TEXTURE_2D, level, data);
result.setData(level, data, imagesize);
} else {
glGetTexImage(GL_TEXTURE_2D, level, GL_BGRA, GL_UNSIGNED_BYTE, data);
result.setData(level, data, imagesize);
}
level++;
}
Free(data);
result.saveFile_dds(filename);
}
static bool
test_format(int width, int height, GLfloat *image, GLenum requested_format)
{
GLubyte *compressed_image;
GLenum format2;
int x, y, w, h;
GLuint tex;
bool pass = true;
GLuint expected_size;
GLint is_compressed;
GLint compressed_size;
GLint format;
glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
glPixelStorei(GL_UNPACK_ROW_LENGTH, width);
/* Setup initial texture */
glGenTextures(1, &tex);
glBindTexture(GL_TEXTURE_2D, tex);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexImage2D(GL_TEXTURE_2D, 0, requested_format, width, height, 0,
GL_RGBA, GL_FLOAT, image);
pass = piglit_check_gl_error(GL_NO_ERROR) && pass;
pass = check_rendering(width, height) && pass;
glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_COMPRESSED,
&is_compressed);
glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_INTERNAL_FORMAT,
&format);
glGetTexLevelParameteriv(GL_TEXTURE_2D, 0,
GL_TEXTURE_COMPRESSED_IMAGE_SIZE,
&compressed_size);
pass = piglit_check_gl_error(GL_NO_ERROR) && pass;
if (!is_compressed) {
printf("Image was not compressed\n");
pass = false;
}
if (format != requested_format) {
printf("Internal Format mismatch. Found: 0x%04x Expected: 0x%04x\n",
format, requested_format);
pass = false;
}
expected_size = piglit_compressed_image_size(requested_format, width,
height);
if (compressed_size != expected_size) {
printf("Compressed image size mismatch. Found: %u Expected: %u\n",
compressed_size, expected_size);
pass = false;
}
/* Use GL_TEXTURE_COMPRESSED_IMAGE_SIZE even if it wasn't what we
* expected to avoid corruption due to under-allocated buffer.
*/
compressed_image = malloc(compressed_size);
/* Read back the compressed image data */
glGetCompressedTexImage(GL_TEXTURE_2D, 0, compressed_image);
/* Try texsubimage on 4-texel boundary - should work */
x = 20;
y = 12;
w = 16;
h = 8;
glPixelStorei(GL_UNPACK_SKIP_PIXELS, x);
glPixelStorei(GL_UNPACK_SKIP_ROWS, y);
glTexSubImage2D(GL_TEXTURE_2D, 0,
x, y, w, h,
GL_RGBA, GL_FLOAT, image);
pass = piglit_check_gl_error(GL_NO_ERROR) && pass;
pass = check_rendering(width, height) && pass;
/* Try texsubimage on non 4-texel boundary - should not work */
x = 10;
y = 11;
glPixelStorei(GL_UNPACK_SKIP_PIXELS, x);
glPixelStorei(GL_UNPACK_SKIP_ROWS, y);
glTexSubImage2D(GL_TEXTURE_2D, 0,
x, y, w, h,
GL_RGBA, GL_FLOAT, image);
pass = piglit_check_gl_error(GL_INVALID_OPERATION) && pass;
/* Try compressed subimage on 4-texel boundary - should work */
x = 12;
y = 8;
glPixelStorei(GL_UNPACK_SKIP_PIXELS, x);
glPixelStorei(GL_UNPACK_SKIP_ROWS, y);
glCompressedTexSubImage2D(GL_TEXTURE_2D, 0,
x, y, w, h,
format,
piglit_compressed_image_size(format, w, h),
compressed_image +
piglit_compressed_pixel_offset(format, width, x, y));
pass = piglit_check_gl_error(GL_NO_ERROR) && pass;
pass = check_rendering(width, height) && pass;
/* Try compressed subimage on non 4-texel boundary - should not work */
x = 14;
y = 9;
glPixelStorei(GL_UNPACK_SKIP_PIXELS, x);
glPixelStorei(GL_UNPACK_SKIP_ROWS, y);
glCompressedTexSubImage2D(GL_TEXTURE_2D, 0,
x, y, w, h,
format,
piglit_compressed_image_size(format, w, h),
compressed_image +
piglit_compressed_pixel_offset(format, width, 0, 0));
pass = piglit_check_gl_error(GL_INVALID_OPERATION) && pass;
/* Try compressed subimage with size not a multiple of 4 -
* should not work
*/
x = 8;
y = 8;
w = 14;
h = 10;
glPixelStorei(GL_UNPACK_SKIP_PIXELS, x);
glPixelStorei(GL_UNPACK_SKIP_ROWS, y);
glCompressedTexSubImage2D(GL_TEXTURE_2D, 0,
x, y, w, h,
format,
piglit_compressed_image_size(format, 4, 4),
compressed_image +
piglit_compressed_pixel_offset(format, width, x, y));
/* Note, we can get either of these errors depending on the order
* in which glCompressedTexSubImage parameters are checked.
* INVALID_OPERATION for the bad size or INVALID_VALUE for the
* wrong compressed image size.
*/
pass = check_gl_error2(GL_INVALID_OPERATION, GL_INVALID_VALUE) && pass;
/* Try compressed subimage with invalid offset - should not work */
x = -3;
y = 8;
w = 4;
h = 4;
glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
glCompressedTexSubImage2D(GL_TEXTURE_2D, 0,
x, y, w, h,
format,
piglit_compressed_image_size(format, w, h),
compressed_image +
piglit_compressed_pixel_offset(format, width, 0, 0));
pass = piglit_check_gl_error(GL_INVALID_VALUE) && pass;
/* Try compressed subimage with too large of image - should not work */
x = 16;
y = 8;
w = width * 2;
h = height * 2;
glPixelStorei(GL_UNPACK_SKIP_PIXELS, x);
glPixelStorei(GL_UNPACK_SKIP_ROWS, y);
glCompressedTexSubImage2D(GL_TEXTURE_2D, 0,
x, y, w, h,
format,
piglit_compressed_image_size(format, w, h),
compressed_image +
piglit_compressed_pixel_offset(format, width, x, y));
pass = piglit_check_gl_error(GL_INVALID_VALUE) && pass;
/* Try compressed subimage with different format - should not work */
if (format == GL_COMPRESSED_RGB_S3TC_DXT1_EXT)
format2 = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
else
format2 = GL_COMPRESSED_RGB_S3TC_DXT1_EXT;
x = 4;
y = 4;
w = 4;
h = 4;
glPixelStorei(GL_UNPACK_SKIP_PIXELS, x);
glPixelStorei(GL_UNPACK_SKIP_ROWS, y);
glCompressedTexSubImage2D(GL_TEXTURE_2D, 0,
x, y, w, h,
format2,
piglit_compressed_image_size(format2, w, h),
compressed_image +
piglit_compressed_pixel_offset(format2, width, x, y));
pass = piglit_check_gl_error(GL_INVALID_OPERATION) && pass;
/* Try zero-sized subimage - should not be an error */
x = 4;
y = 4;
w = 0;
h = 0;
glPixelStorei(GL_UNPACK_SKIP_PIXELS, x);
glPixelStorei(GL_UNPACK_SKIP_ROWS, y);
glCompressedTexSubImage2D(GL_TEXTURE_2D, 0,
x, y, w, h,
format,
piglit_compressed_image_size(format, w, h),
compressed_image +
piglit_compressed_pixel_offset(format, width, x, y));
pass = piglit_check_gl_error(GL_NO_ERROR) && pass;
/* Try CompressedTexSubImage into level 1 (which is missing) */
x = 0;
y = 0;
w = 4;
h = 4;
glPixelStorei(GL_UNPACK_SKIP_PIXELS, x);
glPixelStorei(GL_UNPACK_SKIP_ROWS, y);
glCompressedTexSubImage2D(GL_TEXTURE_2D, 1,
x, y, w, h,
format,
piglit_compressed_image_size(format, w, h),
compressed_image +
piglit_compressed_pixel_offset(format, width, x, y));
pass = piglit_check_gl_error(GL_INVALID_OPERATION) && pass;
/* Try CompressedTexImage of size zero - should not be an erorr */
w = 0;
h = 0;
glCompressedTexImage2D(GL_TEXTURE_2D, 0, format, w, h, 0,
piglit_compressed_image_size(format, w, h),
compressed_image);
pass = piglit_check_gl_error(GL_NO_ERROR) && pass;
/* Try CompressedTexImage with size which is a not a multiple of the
* block size - should not be an erorr
*/
w = width - 1;
h = height - 1;
glCompressedTexImage2D(GL_TEXTURE_2D, 0, format, w, h, 0,
piglit_compressed_image_size(format, w, h),
compressed_image);
pass = piglit_check_gl_error(GL_NO_ERROR) && pass;
pass = check_rendering(width, height) && pass;
glDeleteTextures(1, &tex);
free(compressed_image);
return pass;
}
void DxtEncoder::encode(
izanagi::graph::CGraphicsDevice* device,
izanagi::graph::CTexture* texture)
{
izanagi::sys::CTimer timer;
device->SaveRenderState();
device->SetRenderState(
izanagi::graph::E_GRAPH_RS_ZENABLE,
IZ_FALSE);
// For rendering full screen quad without vertex buffer.
device->SetRenderState(
izanagi::graph::E_GRAPH_RS_CULLMODE,
izanagi::graph::E_GRAPH_CULL_NONE);
auto texHandle = m_tex->GetTexHandle();
// Set FBO.
CALL_GL_API(glBindFramebuffer(GL_FRAMEBUFFER, m_fbo));
CALL_GL_API(glFramebufferTexture2D(
GL_FRAMEBUFFER,
GL_COLOR_ATTACHMENT0,
GL_TEXTURE_2D,
texHandle,
0));
GLenum attachedColor[] = {
GL_COLOR_ATTACHMENT0,
};
CALL_GL_API(::glDrawBuffers(1, attachedColor));
CALL_GL_API(glDisable(GL_FRAMEBUFFER_SRGB));
device->SetShaderProgram(m_shd);
{
CALL_GL_API(::glActiveTexture(GL_TEXTURE0));
GLuint handle = texture->GetTexHandle();
CALL_GL_API(::glBindTexture(GL_TEXTURE_2D, handle));
}
auto hImage = m_shd->GetHandleByName("image");
auto hMode = m_shd->GetHandleByName("mode");
CALL_GL_API(glUniform1i(hImage, 0));
CALL_GL_API(glUniform1i(hMode, 3));
device->SetViewport(
izanagi::graph::SViewport(0, 0, m_width/4, m_height/4));
// NOTE
// 頂点バッファを使わず全画面に描画する頂点シェーダ.
CALL_GL_API(glDrawArrays(GL_TRIANGLE_STRIP, 0, 4));
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
#if 1
// Copy to PBO.
{
timer.Begin();
// NOTE
// PBO は STREAM_COPY で作成されている.
CALL_GL_API(glReadBuffer(GL_COLOR_ATTACHMENT0));
CALL_GL_API(glBindBuffer(GL_PIXEL_PACK_BUFFER, m_pbo));
// Copy from GL_COLOR_ATTACHMENT0 to PBO.
CALL_GL_API(glReadPixels(
0, 0,
m_width / 4, m_height / 4,
GL_RGBA_INTEGER,
GL_UNSIGNED_INT,
0));
CALL_GL_API(glBindBuffer(GL_PIXEL_PACK_BUFFER, 0));
auto time = timer.End();
IZ_PRINTF("ReadToPBO [%f]\n", time);
}
CALL_GL_API(glBindFramebuffer(GL_FRAMEBUFFER, 0));
// Copy to texture memory.
{
timer.Begin();
auto texdxt = m_texDxt->GetTexHandle();
CALL_GL_API(glBindTexture(GL_TEXTURE_2D, texdxt));
CALL_GL_API(glBindBuffer(GL_PIXEL_UNPACK_BUFFER, m_pbo));
// Copy from PBO to texture(DXT5) memory.
CALL_GL_API(glCompressedTexSubImage2D(
GL_TEXTURE_2D,
0,
0, 0,
m_width, m_height,
GL_COMPRESSED_RGBA_S3TC_DXT5_EXT,
m_width * m_height,
0));
CALL_GL_API(glBindTexture(GL_TEXTURE_2D, 0));
CALL_GL_API(glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0));
auto time = timer.End();
IZ_PRINTF("CopyToDXT [%f]\n", time);
}
// Readback to memory.
{
timer.Begin();
auto texdxt = m_texDxt->GetTexHandle();
CALL_GL_API(glBindTexture(GL_TEXTURE_2D, texdxt));
CALL_GL_API(glGetCompressedTexImage(
GL_TEXTURE_2D,
0,
m_pixels));
CALL_GL_API(glBindTexture(GL_TEXTURE_2D, 0));
auto time = timer.End();
IZ_PRINTF("ReadToMem [%f]\n", time);
}
#endif
// 元に戻す.
device->SetViewport(
izanagi::graph::SViewport(0, 0, m_width, m_height));
device->LoadRenderState();
}
void GLTextureBuffer::download(const PixelData &data)
{
if (data.getWidth() != getWidth() || data.getHeight() != getHeight() || data.getDepth() != getDepth())
{
LOGERR("Only download of entire buffer is supported by OpenGL.");
return;
}
glBindTexture(mTarget, mTextureID);
BS_CHECK_GL_ERROR();
if(PixelUtil::isCompressed(data.getFormat()))
{
// Block-compressed data cannot be smaller than 4x4, and must be a multiple of 4
const UINT32 actualWidth = Math::divideAndRoundUp(std::max(mWidth, 4U), 4U) * 4U;
const UINT32 actualHeight = Math::divideAndRoundUp(std::max(mHeight, 4U), 4U) * 4U;
const UINT32 expectedRowPitch = actualWidth;
const UINT32 expectedSlicePitch = actualWidth * actualHeight;
const bool isConsecutive = data.getRowPitch() == expectedRowPitch && data.getSlicePitch() == expectedSlicePitch;
if (data.getFormat() != mFormat || !isConsecutive)
{
LOGERR("Compressed images must be consecutive, in the source format");
return;
}
// Data must be consecutive and at beginning of buffer as PixelStorei not allowed
// for compressed formate
glGetCompressedTexImage(mFaceTarget, mLevel, data.getData());
BS_CHECK_GL_ERROR();
}
else
{
if (data.getWidth() != data.getRowPitch())
{
glPixelStorei(GL_PACK_ROW_LENGTH, data.getRowPitch());
BS_CHECK_GL_ERROR();
}
if (data.getHeight()*data.getWidth() != data.getSlicePitch())
{
glPixelStorei(GL_PACK_IMAGE_HEIGHT, (data.getSlicePitch() / data.getWidth()));
BS_CHECK_GL_ERROR();
}
if (data.getLeft() > 0 || data.getTop() > 0 || data.getFront() > 0)
{
glPixelStorei(
GL_PACK_SKIP_PIXELS,
data.getLeft() + data.getRowPitch() * data.getTop() + data.getSlicePitch() * data.getFront());
BS_CHECK_GL_ERROR();
}
if ((data.getWidth()*PixelUtil::getNumElemBytes(data.getFormat())) & 3)
{
glPixelStorei(GL_PACK_ALIGNMENT, 1);
BS_CHECK_GL_ERROR();
}
// We can only get the entire texture
glGetTexImage(mFaceTarget, mLevel, GLPixelUtil::getGLOriginFormat(data.getFormat()),
GLPixelUtil::getGLOriginDataType(data.getFormat()), data.getData());
BS_CHECK_GL_ERROR();
// Restore defaults
glPixelStorei(GL_PACK_ROW_LENGTH, 0);
BS_CHECK_GL_ERROR();
glPixelStorei(GL_PACK_IMAGE_HEIGHT, 0);
BS_CHECK_GL_ERROR();
glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
BS_CHECK_GL_ERROR();
glPixelStorei(GL_PACK_ALIGNMENT, 4);
BS_CHECK_GL_ERROR();
}
BS_INC_RENDER_STAT_CAT(ResRead, RenderStatObject_Texture);
}
void CMapGenerator::GenerateSMT(CVirtualArchive* archive)
{
CVirtualFile* fileSMT = archive->AddFile("maps/generated.smt");
const int tileSize = 32;
//--- Make TileFileHeader ---
TileFileHeader smtHeader;
strcpy(smtHeader.magic, "spring tilefile");
smtHeader.version = 1;
smtHeader.numTiles = 1; //32 * 32 * (generator->GetMapSize().x * 32) * (generator->GetMapSize().y * 32);
smtHeader.tileSize = tileSize;
smtHeader.compressionType = 1;
const int bpp = 3;
int tilePos = 0;
unsigned char tileData[tileSize * tileSize * bpp];
for(int x = 0; x < tileSize; x++)
{
for(int y = 0; y < tileSize; y++)
{
tileData[tilePos] = 0;
tileData[tilePos + 1] = 0xFF;
tileData[tilePos + 2] = 0;
tilePos += bpp;
}
}
glClearErrors();
GLuint tileTex;
glGenTextures(1, &tileTex);
glBindTexture(GL_TEXTURE_2D, tileTex);
glTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGB_S3TC_DXT1_EXT, tileSize, tileSize, 0, GL_RGB, GL_UNSIGNED_BYTE, tileData);
glGenerateMipmapEXT(GL_TEXTURE_2D);
char tileDataDXT[SMALL_TILE_SIZE];
int dxtImageOffset = 0;
int dxtImageSize = 512;
for(int x = 0; x < 4; x++)
{
glGetCompressedTexImage(GL_TEXTURE_2D, x, tileDataDXT + dxtImageOffset);
dxtImageOffset += dxtImageSize;
dxtImageSize /= 4;
}
glDeleteTextures(1, &tileTex);
GLenum errorcode = glGetError();
if(errorcode != GL_NO_ERROR)
{
throw content_error("Error generating map - texture generation not supported");
}
size_t totalSize = sizeof(TileFileHeader);
fileSMT->buffer.resize(totalSize);
int writePosition = 0;
memcpy(&(fileSMT->buffer[writePosition]), &smtHeader, sizeof(smtHeader));
writePosition += sizeof(smtHeader);
fileSMT->buffer.resize(fileSMT->buffer.size() + smtHeader.numTiles * SMALL_TILE_SIZE);
for(int x = 0; x < smtHeader.numTiles; x++)
{
memcpy(&(fileSMT->buffer[writePosition]), tileDataDXT, SMALL_TILE_SIZE);
writePosition += SMALL_TILE_SIZE;
}
}
PIGLIT_GL_TEST_CONFIG_END
static bool
test_getsubimage(GLenum target,
GLsizei width, GLsizei height, GLsizei numSlices,
GLenum intFormat)
{
const GLint bufSize = width * height * 4 * sizeof(GLubyte);
GLubyte *texData;
GLubyte *refData = malloc(6 * bufSize); /* 6 for cubemaps */
GLubyte *testData = malloc(6 * bufSize); /* 6 for cubemaps */
GLuint tex;
int i, slice, compressedSize, compSize;
int blockWidth, blockHeight, blockSize;
bool pass = true;
const int level = 0;
int x0, y0, x1, y1, w0, h0, w1, h1;
printf("Testing %s %s %d x %d\n",
piglit_get_gl_enum_name(target),
piglit_get_gl_enum_name(intFormat),
width, height);
/* For all S3TC formats */
blockWidth = blockHeight = 4;
if (intFormat == GL_COMPRESSED_RGB_S3TC_DXT1_EXT ||
intFormat == GL_COMPRESSED_RGBA_S3TC_DXT1_EXT) {
blockSize = 8;
}
else {
assert(intFormat == GL_COMPRESSED_RGBA_S3TC_DXT3_EXT ||
intFormat == GL_COMPRESSED_RGBA_S3TC_DXT5_EXT);
blockSize = 16;
}
/* Size must be multiple of block dims */
assert(width % blockWidth == 0);
assert(height % blockHeight == 0);
compressedSize = (width / blockWidth) * (height / blockHeight)
* blockSize;
if (0) {
printf("byte per block row: %d\n",
(width / blockWidth) * blockSize);
printf("compressed image size = %d\n", compressedSize);
}
/* initial texture data */
texData = malloc(compressedSize);
for (i = 0; i < compressedSize; i++) {
texData[i] = (i+10) & 0xff;
}
glGenTextures(1, &tex);
glBindTexture(target, tex);
/* Define texture image */
if (target == GL_TEXTURE_CUBE_MAP) {
for (slice = 0; slice < 6; slice++) {
glCompressedTexImage2D(
GL_TEXTURE_CUBE_MAP_POSITIVE_X + slice,
level, intFormat, width, height, 0,
compressedSize, texData);
}
glGetTexLevelParameteriv(GL_TEXTURE_CUBE_MAP_POSITIVE_X, level,
GL_TEXTURE_COMPRESSED_IMAGE_SIZE,
&compSize);
assert(numSlices == 6);
}
else if (target == GL_TEXTURE_CUBE_MAP_ARRAY) {
assert(numSlices % 6 == 0);
glCompressedTexImage3D(target, level, intFormat,
width, height, numSlices, 0,
compressedSize * numSlices, NULL);
for (slice = 0; slice < numSlices; slice++) {
glCompressedTexSubImage3D(target, level,
0, 0, slice,
width, height, 1,
intFormat,
compressedSize, texData);
}
glGetTexLevelParameteriv(target, level,
GL_TEXTURE_COMPRESSED_IMAGE_SIZE,
&compSize);
compSize /= numSlices;
}
else if (target == GL_TEXTURE_2D_ARRAY) {
glCompressedTexImage3D(target, level, intFormat,
width, height, numSlices, 0,
compressedSize * numSlices, NULL);
for (slice = 0; slice < numSlices; slice++) {
glCompressedTexSubImage3D(target, level,
0, 0, slice,
width, height, 1,
intFormat,
compressedSize, texData);
}
glGetTexLevelParameteriv(target, level,
GL_TEXTURE_COMPRESSED_IMAGE_SIZE,
&compSize);
compSize /= numSlices;
}
else {
assert(target == GL_TEXTURE_2D);
glCompressedTexImage2D(target, level, intFormat,
width, height, 0,
compressedSize, texData);
glGetTexLevelParameteriv(target, level,
GL_TEXTURE_COMPRESSED_IMAGE_SIZE,
&compSize);
assert(numSlices == 1);
}
assert(compSize == compressedSize);
/* Should be no GL errors */
if (!piglit_check_gl_error(GL_NO_ERROR)) {
pass = false;
}
refData = calloc(1, numSlices * compressedSize);
testData = calloc(1, numSlices * compressedSize);
/* compute pos/size of sub-regions */
x0 = 0;
y0 = 0;
x1 = width / 4; /* quarter width */
y1 = height / 2; /* half height */
/* Position must be multiple of block dims */
assert(x1 % blockWidth == 0);
assert(y1 % blockHeight == 0);
w0 = x1 - x0;
w1 = width - x1;
h0 = y1 - y0;
h1 = height - y1;
/* Sizes must be multiple of block dims */
assert(w0 % blockWidth == 0);
assert(w1 % blockWidth == 0);
assert(h0 % blockHeight == 0);
assert(h1 % blockHeight == 0);
glPixelStorei(GL_PACK_ALIGNMENT, 1);
glPixelStorei(GL_PACK_ROW_LENGTH, width);
glPixelStorei(GL_PACK_IMAGE_HEIGHT, height);
glPixelStorei(GL_PACK_COMPRESSED_BLOCK_WIDTH, blockWidth);
glPixelStorei(GL_PACK_COMPRESSED_BLOCK_HEIGHT, blockHeight);
glPixelStorei(GL_PACK_COMPRESSED_BLOCK_SIZE, blockSize);
/* Should be no GL errors */
if (!piglit_check_gl_error(GL_NO_ERROR)) {
pass = false;
}
/*
* Get whole compressed image (the reference)
*/
if (target == GL_TEXTURE_CUBE_MAP) {
for (slice = 0; slice < 6; slice++) {
glGetCompressedTexImage(
GL_TEXTURE_CUBE_MAP_POSITIVE_X + slice,
level,
refData + slice * compressedSize);
}
}
else {
glGetCompressedTexImage(target, level, refData);
}
if (!piglit_check_gl_error(GL_NO_ERROR)) {
pass = false;
}
/*
* Now get four sub-regions which should be equivalent
* to the whole reference image.
*/
/* lower-left */
glPixelStorei(GL_PACK_SKIP_PIXELS, x0);
glPixelStorei(GL_PACK_SKIP_ROWS, y0);
glGetCompressedTextureSubImage(tex, level,
x0, y0, 0, w0, h0, numSlices,
numSlices * compressedSize, testData);
/* lower-right */
glPixelStorei(GL_PACK_SKIP_PIXELS, x1);
glPixelStorei(GL_PACK_SKIP_ROWS, y0);
glGetCompressedTextureSubImage(tex, level,
x1, y0, 0, w1, h0, numSlices,
numSlices * compressedSize, testData);
/* upper-left */
glPixelStorei(GL_PACK_SKIP_PIXELS, x0);
glPixelStorei(GL_PACK_SKIP_ROWS, y1);
glGetCompressedTextureSubImage(tex, level,
x0, y1, 0, w0, h1, numSlices,
numSlices * compressedSize, testData);
/* upper-right */
glPixelStorei(GL_PACK_SKIP_PIXELS, x1);
glPixelStorei(GL_PACK_SKIP_ROWS, y1);
glGetCompressedTextureSubImage(tex, level,
x1, y1, 0, w1, h1, numSlices,
numSlices * compressedSize, testData);
/* defaults */
glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
glPixelStorei(GL_PACK_SKIP_ROWS, 0);
/* Should be no GL errors */
if (!piglit_check_gl_error(GL_NO_ERROR)) {
pass = false;
}
/* now compare the images */
for (slice = 0; slice < numSlices; slice++) {
int sliceStart = slice * compressedSize;
if (memcmp(refData + sliceStart,
testData + sliceStart,
compressedSize)) {
int i;
for (i = 0; i < compressedSize; i++) {
if (refData[sliceStart + i] !=
testData[sliceStart + i]) {
printf("fail in slice/face %d at offset %d\n",
slice, i);
printf("expected %d, found %d\n",
refData[sliceStart + i],
testData[sliceStart + i]);
break;
}
}
printf("Failure for %s %s\n",
piglit_get_gl_enum_name(target),
piglit_get_gl_enum_name(intFormat));
pass = false;
}
}
free(texData);
free(refData);
free(testData);
glDeleteTextures(1, &tex);
return pass;
}
// NOTE: Always saves in TGA format
void DGTexture::saveToFile(const char* fileName){
if (_isLoaded) {
FILE* fh;
char fullFileName[DGMaxFileLength - 4];
strncpy(fullFileName, fileName, DGMaxFileLength - 4);
if (_compressionLevel) {
TEXMainHeader header;
TEXSubHeader subheader;
GLint internalformat, size;
// TODO: Must check that the texture is RGB
// NOTE: Let's try to support alpha channel for these textures
glBindTexture(GL_TEXTURE_2D, _ident);
glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_INTERNAL_FORMAT, &internalformat);
glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_COMPRESSED_IMAGE_SIZE, &size);
_bitmap = (GLubyte*)malloc(size * sizeof(GLubyte));
glGetCompressedTexImage(GL_TEXTURE_2D, 0, _bitmap);
header.compressionLevel = 1;
strcpy(header.name, this->name()); // This is the object name
header.width = (short)_width;
header.height = (short)_height;
header.numTextures = 0;
subheader.cubePosition = 0;
subheader.depth = (short)_depth;
subheader.size = (int)size;
subheader.format = (int)internalformat;
strncat(fullFileName, ".tex", 4);
fh = fopen(fullFileName, "wb");
fwrite(&TEXIdent, 1, 8, fh);
fwrite(&header, 1, sizeof(header), fh);
fwrite(&subheader, 1, sizeof(subheader), fh);
fwrite(_bitmap, 1, sizeof(GLubyte) * size, fh);
free(_bitmap);
fclose(fh);
}
else {
unsigned char cGarbage = 0, type, mode;
short int iGarbage = 0;
int i;
GLint size;
strncat(fullFileName, ".tga", 4);
fh = fopen(fullFileName, "wb");
if (fh == NULL)
return;
glBindTexture(GL_TEXTURE_2D, _ident);
// We do this in case the texture wasn't loaded
glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &_width);
glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &_height);
//glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_DEPTH, &texture_data->depth);
_depth = 24; // Hardcoded to 24 bits
mode = _depth / 8;
if ((_depth == 24) || (_depth == 32))
type = 2;
else
type = 3;
fwrite(&cGarbage, sizeof(unsigned char), 1, fh);
fwrite(&cGarbage, sizeof(unsigned char), 1, fh);
fwrite(&type, sizeof(unsigned char), 1, fh);
fwrite(&iGarbage, sizeof(short int), 1, fh);
fwrite(&iGarbage, sizeof(short int), 1, fh);
fwrite(&cGarbage, sizeof(unsigned char), 1, fh);
fwrite(&iGarbage, sizeof(short int), 1, fh);
fwrite(&iGarbage, sizeof(short int), 1, fh);
fwrite(&_width, sizeof(short int), 1, fh);
fwrite(&_height, sizeof(short int), 1, fh);
fwrite(&_depth, sizeof(unsigned char), 1, fh);
fwrite(&cGarbage, sizeof(unsigned char), 1, fh);
_depth = mode;
size = _width * _height * _depth;
_bitmap = (GLubyte*)malloc(size * sizeof(GLubyte));
glGetTexImage(GL_TEXTURE_2D, 0, GL_RGB, GL_UNSIGNED_BYTE, _bitmap);
if (mode >= 3) {
unsigned char aux;
for (i = 0; i < _width * _height * mode ; i+= mode) {
aux = _bitmap[i];
_bitmap[i] = _bitmap[i + 2];
_bitmap[i + 2] = aux;
}
}
fwrite(_bitmap, 1, sizeof(GLubyte) * size, fh);
fclose(fh);
free(_bitmap);
}
}
}
void Texture::getCompressedImage(const GLint lod, GLvoid * image) const
{
bind();
glGetCompressedTexImage(m_target, lod, image);
}
void gl4es_glGetCompressedTextureImage(GLuint texture, GLenum target, GLint level, GLvoid *img) {
text(glGetCompressedTexImage(target, level, img));
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglGetCompressedTexImage(JNIEnv *__env, jclass clazz, jint target, jint lod, jlong imgAddress, jlong __functionAddress) {
GLvoid *img = (GLvoid *)(intptr_t)imgAddress;
glGetCompressedTexImagePROC glGetCompressedTexImage = (glGetCompressedTexImagePROC)(intptr_t)__functionAddress;
UNUSED_PARAMS(__env, clazz)
glGetCompressedTexImage(target, lod, img);
}
//----------------------------------------------------------------------------//
void OpenGL1Texture::blitToMemory(void* targetData)
{
if (OpenGLInfo::getSingleton().isUsingOpenglEs())
{
/* OpenGL ES 3.1 or below doesn't support
"glGetTexImage"/"glGetCompressedTexImage", so we need to emulate it
using "glReadPixels". */
GLint old_pack;
glGetIntegerv(GL_PACK_ALIGNMENT, &old_pack);
GLuint texture_framebuffer(0);
GLint framebuffer_old(0), pack_alignment_old(0);
glGenFramebuffers(1, &texture_framebuffer);
GLenum framebuffer_target(0), framebuffer_param(0);
if (OpenGLInfo::getSingleton()
.isSeperateReadAndDrawFramebufferSupported())
{
framebuffer_param = GL_READ_FRAMEBUFFER_BINDING;
framebuffer_target = GL_READ_FRAMEBUFFER;
}
else
{
framebuffer_param = GL_FRAMEBUFFER_BINDING;
framebuffer_target = GL_FRAMEBUFFER;
}
glGetIntegerv(framebuffer_param, &framebuffer_old);
glBindFramebuffer(framebuffer_target, texture_framebuffer);
glFramebufferTexture2D(framebuffer_target, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, d_ogltexture, 0);
GLint read_buffer_old(0), pixel_pack_buffer_old(0);
if (OpenGLInfo::getSingleton().isReadBufferSupported())
{
glGetIntegerv(GL_READ_BUFFER, &read_buffer_old);
glReadBuffer(GL_COLOR_ATTACHMENT0);
glGetIntegerv(GL_PIXEL_PACK_BUFFER_BINDING, &pixel_pack_buffer_old);
glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
}
glGetIntegerv(GL_PACK_ALIGNMENT, &pack_alignment_old);
glPixelStorei(GL_PACK_ALIGNMENT, 1);
glReadPixels(0, 0, static_cast<GLsizei>(d_dataSize.d_width),
static_cast<GLsizei>(d_dataSize.d_height), GL_RGBA, GL_UNSIGNED_BYTE, targetData);
glPixelStorei(GL_PACK_ALIGNMENT, pack_alignment_old);
if (OpenGLInfo::getSingleton().isReadBufferSupported())
{
glBindBuffer(GL_PIXEL_PACK_BUFFER, pixel_pack_buffer_old);
glReadBuffer(read_buffer_old);
}
glBindFramebuffer(framebuffer_target, framebuffer_old);
glDeleteFramebuffers(1, &texture_framebuffer);
}
else // Desktop OpenGL
{
// save existing config
GLuint old_tex;
glGetIntegerv(GL_TEXTURE_BINDING_2D, reinterpret_cast<GLint*>(&old_tex));
glBindTexture(GL_TEXTURE_2D, d_ogltexture);
if (d_isCompressed)
{
glGetCompressedTexImage(GL_TEXTURE_2D, 0, targetData);
}
else
{
GLint old_pack;
glGetIntegerv(GL_PACK_ALIGNMENT, &old_pack);
glPixelStorei(GL_PACK_ALIGNMENT, 1);
glGetTexImage(GL_TEXTURE_2D, 0, d_format, d_subpixelFormat, targetData);
glPixelStorei(GL_PACK_ALIGNMENT, old_pack);
}
// restore previous config.
glBindTexture(GL_TEXTURE_2D, old_tex);
}
}
void gl4es_glGetCompressedMultiTexImage(GLenum texunit, GLenum target, GLint level, GLvoid *img) {
text(glGetCompressedTexImage(target, level, img));
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglGetCompressedTexImageBO(JNIEnv *env, jclass clazz, jint target, jint lod, jlong img_buffer_offset, jlong function_pointer) {
GLvoid *img_address = (GLvoid *)(intptr_t)offsetToPointer(img_buffer_offset);
glGetCompressedTexImagePROC glGetCompressedTexImage = (glGetCompressedTexImagePROC)((intptr_t)function_pointer);
glGetCompressedTexImage(target, lod, img_address);
}
enum piglit_result
piglit_display(void)
{
GLuint tex, tex_src;
bool pass;
int level;
unsigned bw, bh, bs;
piglit_get_compressed_block_size(format->token, &bw, &bh, &bs);
glClearColor(0.5, 0.5, 0.5, 0.5);
glClear(GL_COLOR_BUFFER_BIT);
tex_src = piglit_rgbw_texture(format->token, SIZE, SIZE,
GL_TRUE, GL_FALSE,
GL_UNSIGNED_NORMALIZED);
glGenTextures(1, &tex);
for (level = 0; (SIZE >> level) > 0; level++) {
int w, h;
int expected_size, size;
void *compressed;
w = SIZE >> level;
h = SIZE >> level;
expected_size = piglit_compressed_image_size(format->token, w, h);
glBindTexture(GL_TEXTURE_2D, tex_src);
glGetTexLevelParameteriv(GL_TEXTURE_2D, level,
GL_TEXTURE_COMPRESSED_IMAGE_SIZE,
&size);
if (size != expected_size) {
fprintf(stderr, "Format %s level %d (%dx%d) size %d "
"doesn't match expected size %d\n",
format->name, level, w, h, size, expected_size);
piglit_report_result(PIGLIT_FAIL);
}
compressed = malloc(size);
glGetCompressedTexImage(GL_TEXTURE_2D, level, compressed);
glBindTexture(GL_TEXTURE_2D, tex);
glCompressedTexImage2D(GL_TEXTURE_2D, level, format->token,
w, h, 0, size, compressed);
if (!piglit_check_gl_error(GL_NO_ERROR))
piglit_report_result(PIGLIT_FAIL);
free(compressed);
}
glDeleteTextures(1, &tex_src);
glBindTexture(GL_TEXTURE_2D, tex);
display_mipmaps(10, 10);
pass = check_resulting_mipmaps(10, 10);
piglit_present_results();
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
