/* create a new cache entry */
cache_entry*
cache_create_entry(int tname) {
float * new_array;
int sidelength, new_element = cache.len;
if(cache.len >= CACHE_SIZE) { rb_raise(rb_eRuntimeError, "cache is full! increase CACHE_SIZE"); }
/* opengl initialization code */
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, tname);
/* get length of a side, since square texture */
glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &sidelength);
/* initialize texture data array, mult. by 4 because {rgba} */
new_array = malloc(sidelength * sidelength * 4 * sizeof(float));
/* get texture data from video memory */
glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_FLOAT,(void*)(new_array));
/* save texture data in the cache */
cache.entry[new_element].tname = tname;
cache.entry[new_element].sidelength = sidelength;
cache.entry[new_element].tdata = new_array;
/* update size of cache */
cache.len++;
glDisable(GL_TEXTURE_2D);
return &cache.entry[new_element];
}
void glSaveTexture(const GLuint textureID, const char* filename)
{
const GLenum target = GL_TEXTURE_2D;
GLenum format = GL_RGBA8;
int sizeX, sizeY;
int bits = 0;
{
glBindTexture(GL_TEXTURE_2D, textureID);
glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &sizeX);
glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &sizeY);
glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_INTERNAL_FORMAT, (GLint*)&format);
GLint _cbits;
glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_RED_SIZE, &_cbits); bits += _cbits;
glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_GREEN_SIZE, &_cbits); bits += _cbits;
glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_BLUE_SIZE, &_cbits); bits += _cbits;
glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_ALPHA_SIZE, &_cbits); bits += _cbits;
glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_DEPTH_SIZE, &_cbits); bits += _cbits;
}
assert(bits == 32);
assert(format == GL_RGBA8);
CBitmap bmp;
bmp.Alloc(sizeX, sizeY, 4);
glGetTexImage(target, 0, GL_RGBA, GL_UNSIGNED_BYTE, bmp.GetRawMem());
bmp.Save(filename, false);
}
bool Texture :: saveAsTga ( const char * fileName )
{
GLuint boundTex;
glGetIntegerv ( GL_TEXTURE_BINDING_2D, (int *) &boundTex );
int numPixels = width * height;
int numComponents = 4;
if ( getFormat ().getFormat () == GL_RGB || getFormat ().getFormat () == GL_BGR )
numComponents = 3;
byte * buffer = (byte *) calloc ( numPixels * numComponents, 1 );
if ( buffer == NULL )
return NULL;
if ( boundTex != id )
glBindTexture ( target, id );
glGetTexImage ( target, 0, numComponents == 3 ? GL_RGB : GL_RGBA, GL_UNSIGNED_BYTE, buffer );
if ( boundTex != id )
glBindTexture ( target, boundTex );
TgaEncoder encoder;
bool result = encoder.encode ( buffer, width, height, numComponents, fileName );
free ( buffer );
return result;
}
* @param format int
*/
void GLTexture::getBuffer(float *floatArray, int format)
{
int mult;
int glFormat;
if (format == GL_LUMINANCE)
{
mult = 1;
}
else if (format == GL_RGB)
{
mult = 3;
}
else // GL_RGBA, GL_RGBA16F_ARB, GL_RGBA32F_ARB;
{
glFormat = GL_RGBA;
mult = 4;
}
int size = mult * width * height;
glEnable(texTarget);
glBindTexture(texTarget, tex[0]);
glGetTexImage(texTarget, 0, glFormat, type, floatArray);
TBlurText *BT_New (char *texture)
{
TBlurText *self;
self = (TBlurText *) malloc (sizeof (TBlurText));
assert (self != NULL);
self->texture = CACHE_LoadTexture (texture, TEX_BUILD_MIPMAPS);
assert (self->texture != NULL);
TEX_Bind (self->texture);
self->w = self->texture->width;
self->h = self->texture->height;
self->data_src = malloc (self->w * self->h * 4);
self->data_dst = malloc (self->w * self->h * 4);
//self->data_src = malloc (Epopeia_GetResX ( ) * Epopeia_GetResY ( ) * 4);
//self->data_dst = malloc (Epopeia_GetResX ( ) * Epopeia_GetResY ( ) * 4);
assert (self->data_src != NULL);
assert (self->data_dst != NULL);
glGetTexImage (GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, self->data_src);
//glGetTexImage (GL_TEXTURE_RECTANGLE_NV, 0, GL_RGBA, GL_UNSIGNED_BYTE, self->data_src);
//glGetTexImage (GL_TEXTURE_2D, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, self->data_src);
//glGetTexImage (GL_TEXTURE_2D, 0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, self->data_src);
self->step = 0;
self->mode = BLUR_ALL;
self->level = 0.0f;
self->it = INTERP_New ( );
return self;
}
void FrameBufferInterface::saveToFile(const char * _filename, unsigned long int _fbochannel){
// get the channel we're asking for
const FrameBufferChannel & channel = frameBufferChannels.at(_fbochannel);
unsigned long int bytes = width*height*channel.numChannels;
GLubyte * pixels = getPixelData(_fbochannel);
unsigned char * pixelsSOIL = (unsigned char *)malloc(bytes * sizeof(unsigned char));
glBindTexture(GL_TEXTURE_2D, frameBufferChannels.at(_fbochannel).id);
glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
for(unsigned long int i = 0; i < bytes; ++i){
pixelsSOIL[i] = pixels[i];
}
std::stringstream ss;
ss << "data/images/" << _filename;
if(stbi_write_tga(ss.str().c_str(), width, height, channel.numChannels, pixelsSOIL, 1)){
Log::info("FBO \""+ss.str()+"\" saved");
}else{
Log::error("FBO \""+ss.str()+"\" not saved");
}
free(pixels);
free(pixelsSOIL);
}
void OpenGLUtils::getDepthStencilTextureToFile(std::string filename,
int width,int height,
GLuint texturehandle,
bool stencilValue) {
int sizet = width*height;
char* texContent = new char[sizet*4];
char* texContentByte = new char[width*height];
glEnable(GL_TEXTURE_2D);
std::cout << "Texture DepthStencil "<<filename<<", size: (" << width<<", "<<height<<")"<<std::endl;
glBindTexture(GL_TEXTURE_2D,texturehandle);
if(stencilValue)
glTexParameteri(GL_TEXTURE_2D,GL_DEPTH_STENCIL_TEXTURE_MODE,GL_STENCIL_INDEX);
else
glTexParameteri(GL_TEXTURE_2D,GL_DEPTH_STENCIL_TEXTURE_MODE,GL_DEPTH_COMPONENT);
glGetTexImage(GL_TEXTURE_2D,0,GL_DEPTH_STENCIL,GL_UNSIGNED_INT_24_8,texContent);
//glGetTexImage(GL_TEXTURE_2D,0,GL_DEPTH_STENCIL,GL_UNSIGNED_BYTE,texContent);
for(int i = 0; i<sizet; ++i)
texContentByte[i] = texContent[i*4+3];
if(OpenGLUtils::printOpenGLError())
std::cout << "NO HAY ERROR AQUI222"<<std::endl;
std::fstream f(filename.c_str(),std::fstream::out | std::fstream::binary |
std::fstream::trunc);
f.write(texContentByte,sizet);
f.close();
delete[] texContent;
delete[] texContentByte;
}
//Transfers data from a texture
void transferFromTexture(textureParameters tp, GLuint tex, GLenum type, void *data)
{
glBindTexture(tp.texTarget, tex);
glGetTexImage(tp.texTarget, 0, tp.texFormat, type, data);
checkGLErrors("transferFromTexture");
}
void
SaveTextureToImageFile( uint32 aWidth, uint32 aHeight, GLuint aTexture, std::string aPath, bool aOverwrite )
{
//TODO auto_ptr on textures
ILuint imageID; // The image name to return.
DEVIL_CHECKED_CALL( ilGenImages( 1, &imageID ) );
DEVIL_CHECKED_CALL( ilBindImage( imageID ) );
if ( aOverwrite ) {
DEVIL_CHECKED_CALL( ilEnable(IL_FILE_OVERWRITE) );
} else {
DEVIL_CHECKED_CALL( ilDisable(IL_FILE_OVERWRITE) );
}
DEVIL_CHECKED_CALL( ilTexImage( aWidth, aHeight, 1, 3, IL_RGB, IL_UNSIGNED_BYTE, NULL ) );
ILubyte* data = new ILubyte[ 3 * aWidth * aHeight ];
GL_CHECKED_CALL( glBindTexture( GL_TEXTURE_2D, aTexture ) );
GL_CHECKED_CALL( glGetTexImage(
GL_TEXTURE_2D,
0,
GL_RGB,
GL_UNSIGNED_BYTE,
(void*)data
) );
GL_CHECKED_CALL( glBindTexture( GL_TEXTURE_2D, 0 ) );
DEVIL_CHECKED_CALL( ilSetPixels( 0, 0, 0, aWidth, aHeight, 1, IL_RGB, IL_UNSIGNED_BYTE, data ) );
delete [] data;
DEVIL_CHECKED_CALL( ilSaveImage( aPath.data() ) );
DEVIL_CHECKED_CALL( ilDeleteImages( 1, &imageID) );
}
void GLGSRender::WriteDepthBuffer()
{
if(!m_set_context_dma_z)
{
return;
}
u32 address = GetAddress(m_surface_offset_z, m_context_dma_z - 0xfeed0000);
if(!Memory.IsGoodAddr(address))
{
ConLog.Warning("Bad depth address: address=0x%x, offset=0x%x, dma=0x%x", address, m_surface_offset_z, m_context_dma_z);
return;
}
glReadPixels(0, 0, RSXThread::m_width, RSXThread::m_height, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, &Memory[address]);
checkForGlError("glReadPixels");
GLuint depth_tex;
glGenTextures(1, &depth_tex);
glBindTexture(GL_TEXTURE_2D, depth_tex);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, RSXThread::m_width, RSXThread::m_height, 0, GL_ALPHA, GL_UNSIGNED_BYTE, &Memory[address]);
checkForGlError("glTexImage2D");
glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, &Memory[address]);
checkForGlError("glGetTexImage");
glDeleteTextures(1, &depth_tex);
}
static bool
test_mipmap_tree(void)
{
bool pass = true;
int layer, level;
for (level = 0; level < TEX_LEVELS; level++) {
int size = TEX_SIZE >> level;
float *observed;
/* With a compressed texture, skip checking the second and
* third last levels, because one DXTC block cannot contain
* more than 2 colors.
*
* However, always test the last level, which should only
* contain one color, which is the average of all 4.
*/
if (format == GL_COMPRESSED_RGB_S3TC_DXT1_EXT &&
level >= TEX_LEVELS-3 && level <= TEX_LEVELS-2)
continue;
if (test_array) {
observed = malloc(num_layers * size * size * 4 * sizeof(float));
glGetTexImage(target, level, GL_RGBA, GL_FLOAT, observed);
for (layer = 0; layer < num_layers; layer++) {
pass = pass && test_face(layer % 6, level, layer / 6,
observed + layer * size * size * 4);
}
free(observed);
}
else {
for (layer = 0; layer < num_layers; layer++) {
observed = malloc(size * size * 4 * sizeof(float));
glGetTexImage(GL_TEXTURE_CUBE_MAP_POSITIVE_X + layer,
level, GL_RGBA, GL_FLOAT, observed);
pass = pass && test_face(layer, level, 0, observed);
free(observed);
}
}
}
return pass;
}
void GLTools::writePPM(GLuint texId, char* name, int w, int h){
float* buffer = new float[w*h];
glBindTexture(GL_TEXTURE_2D, texId);
glGetTexImage(GL_TEXTURE_2D, 0, GL_RED, GL_FLOAT, buffer);
glBindTexture(GL_TEXTURE_2D, 0);
writePPM(buffer, name, w, h);
delete[] buffer;
}
void GuiMaterial::setThemeMap(Texture *themeMap) {
this->themeMap = themeMap;
themeMap->bind(0);
unsigned char *buff = new unsigned char[themeMap->width()*themeMap->height()*4];
glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, buff);
_tone = (static_cast<int>(buff[0])+buff[1]+buff[2])/3;
delete[] buff;
}
void HostVector::operator=(DeviceVector& fVec)
{
width = fVec.width;
Resize(fVec.size);
glBindTexture(GL_TEXTURE_2D, fVec.texture);
glGetTexImage(GL_TEXTURE_2D, 0, GL_RED, GL_FLOAT, data);
glBindTexture(GL_TEXTURE_2D, 0);
}
//----------------------------------------------------------
void ofTexture::readToPixels(ofFloatPixels & pixels){
#ifndef TARGET_OPENGLES
pixels.allocate(texData.width,texData.height,ofGetImageTypeFromGLType(texData.glTypeInternal));
bind();
glGetTexImage(texData.textureTarget,0,ofGetGlFormat(pixels),GL_FLOAT,pixels.getPixels());
unbind();
#endif
}
U8* GFXGLTextureObject::getTextureData()
{
U8* data = new U8[mTextureSize.x * mTextureSize.y * mBytesPerTexel];
PRESERVE_TEXTURE(mBinding);
glBindTexture(mBinding, mHandle);
glGetTexImage(mBinding, 0, GFXGLTextureFormat[mFormat], GFXGLTextureType[mFormat], data);
return data;
}
// Make a copy of the pixel_cache texture in main memory.
static void cache_texture(PixelCache* pixel_cache)
{
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, pixel_cache->texture_id);
glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixel_cache->data);
pixel_cache->is_cached = true;
}
void COGLTexture2D::GetPixelData(void* pData)
{
COGLBindLock lock(this, COGL_TEXTURE0_SLOT);
glGetTexImage(GL_TEXTURE_2D, 0, m_Format, m_Type, pData);
CheckGLError(m_DebugName, "COGLTexture2D::GetPixelData()");
}
void readback_buffer()
{
printf("first few bytes before readback: 0x%.8X 0x%.8X 0x%.8X \n", *((unsigned int *) &(testtex[0])), *((unsigned int *) &(testtex[4])), *((unsigned int *) &(testtex[8])));
glBindTexture(GL_TEXTURE_2D, textures[1]);
glGetTexImage(GL_TEXTURE_2D, 0, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, (void*) testtex);
glBindTexture(GL_TEXTURE_2D, 0);
printf("first few bytes after readback: 0x%.8X 0x%.8X 0x%.8X\n", *((unsigned int *) &(testtex[0])), *((unsigned int *) &(testtex[4])), *((unsigned int *) &(testtex[8])));
}
CMemoryBuffer CHardwarePixelBuffer::LockSource(size_t offset, size_t length, THardwareBufferLock opt)
{
if(mSize == 0)
throw NOVA_EXP("CHardwarePixelBuffer::LockSource - \
mSize == 0, null pixel box..", BAD_OPERATION);
CMemoryBuffer data;
GLuint face_target = 0;
data.AllocBuffer(mSize);
COpenGLFormats informat;
informat.SetExFormat(mPixelFormat);
glPixelStorei(GL_PACK_ALIGNMENT, 1);
GLenum type = TextureTarget(mTarget);
if(mTarget == USE_CUBEMAP_TEXTURE)
face_target = GL_TEXTURE_CUBE_MAP_POSITIVE_X + mFace;
else
face_target = type;
glBindTexture(type, mTargetId);
glGetTexImage(face_target, mLevel, informat.GetFormat(),
GL_UNSIGNED_BYTE, data.GetBegin());
glPixelStorei(GL_PACK_ALIGNMENT, 4);
int error = glGetError();
if(error != GL_NO_ERROR)
{
nstringstream str;
str << "CHardwarePixelBuffer::LockSource - \
detecting OpenGL error with code " << error;
throw NOVA_EXP(str.str().c_str(), BAD_OPERATION);
}
CMemoryBuffer result;
result.AllocBuffer(mLockActSize);
size_t line = mLockWidth * informat.GetInternalChannels();
nova::byte * source = (nova::byte *)data.GetBegin() + offset;
nova::byte * dest = (nova::byte *)result.GetBegin();
for(nova::uint i = 0; i < mLockDepth; ++i)
{
for(nova::uint j = 0; j < mLockHeight; ++j)
{
memcpy(dest, source, line);
source += mRowPitch * informat.GetInternalChannels();
dest += line;
}
source += mSlicePitch * informat.GetInternalChannels();
}
data.FreeBuffer();
return result;
}
//----------------------------------------------------------
void ofTexture::copyTo(ofBufferObject & buffer) const{
ofSetPixelStoreiAlignment(GL_PACK_ALIGNMENT,getWidth(),ofGetBytesPerChannelFromGLType(ofGetGlTypeFromInternal(texData.glInternalFormat)),ofGetNumChannelsFromGLFormat(ofGetGLFormatFromInternal(texData.glInternalFormat)));
buffer.bind(GL_PIXEL_PACK_BUFFER);
glBindTexture(texData.textureTarget,texData.textureID);
glGetTexImage(texData.textureTarget,0,ofGetGLFormatFromInternal(texData.glInternalFormat),ofGetGlTypeFromInternal(texData.glInternalFormat),0);
glBindTexture(texData.textureTarget,0);
buffer.unbind(GL_PIXEL_PACK_BUFFER);
}
void ofTexture::readToPixels(ofFloatPixels & pixels) const {
#ifndef TARGET_OPENGLES
pixels.allocate(texData.width,texData.height,ofGetImageTypeFromGLType(texData.glInternalFormat));
ofSetPixelStoreiAlignment(GL_PACK_ALIGNMENT,pixels.getWidth(),pixels.getBytesPerChannel(),pixels.getNumChannels());
glBindTexture(texData.textureTarget,texData.textureID);
glGetTexImage(texData.textureTarget,0,ofGetGlFormat(pixels),GL_FLOAT,pixels.getData());
glBindTexture(texData.textureTarget,0);
#endif
}
void TextureCommandsGL33::getPixelData(PixelFormat format, PixelType type, char* buffer, unsigned int level) const
{
glGetError();
glGetTexImage(texType2GL(s_pCurTexture->getType()), level, pixelFormat2GL(format), pixelType2GL(type), buffer);
auto err = glGetError();
if (err != GL_NO_ERROR)
throw std::runtime_error { std::string { "glGetTexImage failed: " }
+ reinterpret_cast<const char*>(glewGetErrorString(err)) };
}
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;
}
}
QImage OpenGLTexture2D::toImage() const {
if (isEmpty())
return QImage();
OpenGLTextureBinder<OGL::Target2D> binder(const_cast<OpenGLTexture2D*>(this));
QImage image(size(), QImage::Format_ARGB32);
image.fill(0x0);
glGetTexImage(target(), 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, image.bits());
return image;
}
//----------------------------------------------------------
void ofTexture::readToPixels(ofShortPixels & pixels) const {
#ifndef TARGET_OPENGLES
pixels.allocate(texData.width,texData.height,ofGetImageTypeFromGLType(texData.glTypeInternal));
ofSetPixelStoreiAlignment(GL_PACK_ALIGNMENT,pixels.getWidth(),pixels.getBytesPerChannel(),pixels.getNumChannels());
bind();
glGetTexImage(texData.textureTarget,0,ofGetGlFormat(pixels),GL_UNSIGNED_SHORT,pixels.getData());
unbind();
#endif
}
bool TextureIO::saveTexture(const string &imgPath, const Texture &texture, bool flip)
{
Mat outMat(texture.getHeight(), texture.getWidth(), CV_8UC4);
texture.bind();
glGetTexImage( GL_TEXTURE_2D, 0, GL_BGRA, GL_UNSIGNED_BYTE, outMat.data );
if(flip){cv::flip(outMat, outMat, 0);}
return imwrite(imgPath, outMat);
}
bool upload(int texture_id, int width, int height) {
if(!writeLock()) return false;
metadata->timestamp = get_precise_time();
glBindTexture(GL_TEXTURE_2D, texture_id);
glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
fprintf(stderr, "upload: %d %d", texture_id, (int)pixels[0]);
writeUnlock();
return true;
}
void say_image_target_update(say_image_target *target) {
if (target->img) {
say_target_update(target->target);
say_image_bind(target->img);
glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE,
say_image_get_buffer(target->img));
}
}
void Render_OpenGL31::getPixelData(const PGE_Texture *tx, unsigned char *pixelData)
{
if(!tx)
return;
setRenderTexture(const_cast<PGE_Texture *>(tx)->texture);
glGetTexImage(GL_TEXTURE_2D, 0, GL_BGRA, GL_UNSIGNED_BYTE, pixelData);
setUnbindTexture();
}
