YUV420PGrabber::~YUV420PGrabber() {
deleteShader(frag_y);
deleteShader(vert_yuv);
deleteShader(frag_u);
deleteShader(frag_v);
deleteShader(frag_pt);
deleteProgram(prog_y);
deleteProgram(prog_u);
deleteProgram(prog_v);
deleteProgram(prog_pt);
deleteTexture(yuv_tex);
deleteTexture(scene_tex);
if(scene_fbo) {
glDeleteFramebuffers(1, &scene_fbo);
}
if(scene_depth) {
glDeleteRenderbuffers(1, &scene_depth);
}
if(vao) {
#if YUV420P_USE_APPLE_VAO
glDeleteVertexArraysAPPLE(1, &vao);
#else
glDeleteVertexArrays(1, &vao);
#endif
}
if(outfile_set && ofs.is_open()) {
ofs.close();
}
if(image) {
delete[] image;
}
outfile_set = false;
win_w = 0;
win_h = 0;
vid_w = 0;
vid_h = 0;
uv_w = 0;
uv_h = 0;
yuv_tex = 0;
scene_fbo = 0;
scene_depth = 0;
scene_tex = 0;
vao = 0;
fps = 0;
tex_w = 0;
tex_h = 0;
image = NULL;
frame_timeout = 0;
frame_prev_timeout = 0;
frame_delay = 0;
frame_delay_adjusted = 0;
frame_diff = 0;
frame_diff_avg = 0;
}
GraphicDebugger::~GraphicDebugger()
{
deleteTexture(m_scene.textureNode());
deleteTexture(m_scene.textureGlow());
deleteTexture(m_scene.textureEdge());
// deleteTexture(_helpDialog->texture());
}
CompassWidget::~CompassWidget()
{
makeCurrent();
if (robotTextureFront)
deleteTexture(robotTextureFront);
if (robotTextureBack)
deleteTexture(robotTextureBack);
if (robotTextureLeft)
deleteTexture(robotTextureLeft);
if (robotTextureRight)
deleteTexture(robotTextureRight);
if (zAxisCone)
gluDeleteQuadric (zAxisCone);
if (yAxisCone)
gluDeleteQuadric (yAxisCone);
if (xAxisCone)
gluDeleteQuadric (xAxisCone);
if (zAxisCylinder)
gluDeleteQuadric (zAxisCylinder);
if (yAxisCylinder)
gluDeleteQuadric (yAxisCylinder);
if (xAxisCylinder)
gluDeleteQuadric (xAxisCylinder);
}
BallsAnalyzer::~BallsAnalyzer()
{
deleteTexture( m_ballTexture );
deleteTexture( m_gridTexture );
delete m_leftPaddle;
delete m_rightPaddle;
qDeleteAll( m_balls );
}
void terrainUninit()
{
if(terrain_current->width != 256 || terrain_current->height != 256)
deleteTexture(terrain_resized);
if(terrain_current != &terrain)
deleteTexture(terrain_current);
deleteTexture(terrain_quad);
deleteTexture(glass_big);
}
MediaTexture::~MediaTexture()
{
if (m_contentTexture)
deleteTexture(m_contentTexture, true);
for (unsigned int i = 0; i < m_videoTextures.size(); i++) {
deleteTexture(m_videoTextures[i], true);
}
JNIEnv* env = JSC::Bindings::getJNIEnv();
env->DeleteWeakGlobalRef(m_weakWebViewRef);
env->DeleteWeakGlobalRef(m_weakWebViewCoreRef);
}
void ImageTexture::release()
{
if (m_refCount >= 1)
m_refCount--;
if (!m_refCount)
deleteTexture();
}
CUDARenderer::~CUDARenderer(void)
{
gpuErrchk(cudaFree(d_scene));
deleteTexture();
vao.destroy();
vertices.destroy();
}
void ViewPort::RenderManipulationInterface(){
deleteTexture(m_VideoTexture);
m_VideoTexture = bindTexture(*m_pVideoImage, GL_TEXTURE_2D, GL_RGBA);
glClear(GL_COLOR_BUFFER_BIT);
glLoadIdentity();
glDisable(GL_BLEND);
// Draw main texture
glColor4f(1.0, 1.0, 1.0, 1.0);
glBegin(GL_QUADS);
glTexCoord2f(0, 1);
glVertex2f(0, 960);
glTexCoord2f(1, 1);
glVertex2f(1280, 960);
glTexCoord2f(1, 0);
glVertex2f(1280, 0);
glTexCoord2f(0, 0);
glVertex2f(0, 0);
glEnd();
}
bool doRedo() override
{
if (!created_)
return deleteTexture();
else
return createTexture();
}
void ResourceManager::cleanup()
{
std::cout << "################ ResourceManager::cleanup ################" << std::endl;
// textures
std::cout << "---------- Delete Textures ----------" << std::endl;
std::map<std::string, Texture*>::iterator text_it;
for (text_it=_textures.begin(); text_it!=_textures.end(); ++text_it) {
if (text_it->second != NULL) {
//std::cout << text_it->first << " => " << text_it->second << '\n';
deleteTexture(text_it->first);
}
}
_textures.clear();
// meshes
std::cout << "---------- Delete Meshes ----------" << std::endl;
std::map<std::string, Mesh*>::iterator mesh_it;
for (mesh_it=_meshes.begin(); mesh_it!=_meshes.end(); ++mesh_it) {
if (mesh_it->second != NULL) {
//std::cout << mesh_it->first << " => " << mesh_it->second << '\n';
deleteMesh(mesh_it->first);
}
}
_meshes.clear();
}
ResourceManager::~ResourceManager()
{
while (!mBufferMap.empty())
{
deleteBuffer(mBufferMap.begin()->first);
}
while (!mProgramMap.empty())
{
deleteProgram(mProgramMap.begin()->first);
}
while (!mShaderMap.empty())
{
deleteShader(mShaderMap.begin()->first);
}
while (!mRenderbufferMap.empty())
{
deleteRenderbuffer(mRenderbufferMap.begin()->first);
}
while (!mTextureMap.empty())
{
deleteTexture(mTextureMap.begin()->first);
}
}
void ImagesDisplay::load_texture(image_info *info)
{
QImage *ima_loaded;
qreal width;
qreal height;
ima_loaded = info->ima_loaded;
if (ima_loaded == NULL)
{ return; }
if (info->no_textures)
{ info->no_textures = 0;}
else
{ deleteTexture(texture); }
texture = bindTexture(*(ima_loaded));
//FIXME Assert all pictures have the same dimentions in the future
width = ima_loaded->width();
height = ima_loaded->height();
if (height == 0){height = 1.0;}
image_aspect = width/height;//Aspect ratio of image
// Set nearest filtering mode for texture minification
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
// Set bilinear filtering mode for texture magnification
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
// Make texture coordinates to repeat, not really useful as we will never get out of the vertex coords
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
return;
}
void cleanup(void)
{
cudaGraphicsUnregisterResource(cuda_vbo_resource);
unbindTexture();
deleteTexture();
// Free all host and device resources
free(hvfield);
free(particles);
cudaFree(dvfield);
cudaFree(vxfield);
cudaFree(vyfield);
cufftDestroy(planr2c);
cufftDestroy(planc2r);
glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
glDeleteBuffersARB(1, &vbo);
sdkDeleteTimer(&timer);
if (g_bExitESC)
{
checkCudaErrors(cudaDeviceReset());
}
}
bool doUndo()
{
if (created)
return deleteTexture();
else
return createTexture();
}
bool doRedo()
{
if (!created)
return deleteTexture();
else
return createTexture();
}
//--------------------------------------------------------------------------------------------------
/// Note: Default unpack alignment (GL_UNPACK_ALIGNMENT) is 4 and 4 byte values is preferred, thus
/// we should always use RGBA when having byte textures as GPUs are optimized to 32 bit values
//--------------------------------------------------------------------------------------------------
bool Texture2D_FF::setupTexture(OpenGLContext* oglContext)
{
CVF_ASSERT(oglContext);
CVF_ASSERT(OglRc::safeOglId(m_oglRcTexture.p()) == 0);
CVF_CLEAR_OGL_ERROR(oglContext);
m_oglRcTexture = oglContext->resourceManager()->createOglRcTexture(oglContext);
bind(oglContext);
CVF_CHECK_OGL(oglContext);
CVF_ASSERT(m_image.notNull());
GLsizei width = static_cast<GLsizei>(m_image->width());
GLsizei height = static_cast<GLsizei>(m_image->height());
CVF_ASSERT(height > 0 && width > 0);
//glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, m_image->ptr());
// Note: gluBuild2DMipmaps will scale the image to the closest power of 2 dimension, which is required by the software renderer
gluBuild2DMipmaps(GL_TEXTURE_2D, 4, width, height, GL_RGBA, GL_UNSIGNED_BYTE, m_image->ptr());
if (CVF_TEST_AND_REPORT_OPENGL_ERROR(oglContext, "Setup texture"))
{
deleteTexture(oglContext);
return false;
}
return true;
}
void PointCloudViewer::animate()
{
deleteTexture(texid);
texid = bindTexture(QImage(rgbImg->ptr(), rgbImg->cols, rgbImg->rows, QImage::Format_RGB888), GL_TEXTURE_2D, GL_RGB, QGLContext::LinearFilteringBindOption);
}
void cleanUp(void)
{
/*** delete texture ***/
deleteTexture(&tex);
free(h_g_data);
free_data();
}
////////////////////////////////////////////////////////////////////////////////
//! Keyboard events handler
////////////////////////////////////////////////////////////////////////////////
void
keyboard( unsigned char key, int /*x*/, int /*y*/) {
switch( key) {
case( 27) :
deletePBO( &pbo_source);
deletePBO( &pbo_dest);
deleteFBO( &fbo, &tex_fbo);
deleteTexture( &tex_screen);
exit( 0);
case ' ':
enable_cuda ^= 1;
break;
case 'a':
animate ^= 1;
break;
case '=':
case '+':
if (blur_radius < 16) blur_radius++;
printf("radius = %d\n", blur_radius);
break;
case '-':
if (blur_radius > 1) blur_radius--;
printf("radius = %d\n", blur_radius);
break;
}
}
MainWidget::~MainWidget()
{
delete timer; timer = 0;
delete program; program = 0;
delete geometries; geometries = 0;
deleteTexture(texture);
}
void cleanupCUDA() {
if (m_pbo) {
deletePBO(&m_pbo);
}
if (m_image) {
deleteTexture(&m_image);
}
}
Layer::~Layer() {
if (colorFilter) caches.resourceCache.decrementRefcount(colorFilter);
removeFbo();
deleteTexture();
delete[] mesh;
delete deferredList;
}
void cleanupCuda() {
if (pbo) {
deletePBO(&pbo);
}
if (displayImage) {
deleteTexture(&displayImage);
}
}
void Image::unloadVolatile()
{
// Delete the hardware texture.
if (texture != 0)
{
deleteTexture(texture);
texture = 0;
}
}
void MyGLWidget::cleanUp()
{
obj = 0;
if (texturing)
{
deleteTexture();
}
drawer.cleanUp();
}
Layer::~Layer() {
if (colorFilter) Caches::getInstance().resourceCache.decrementRefcount(colorFilter);
removeFbo();
deleteTexture();
delete[] mesh;
delete[] meshIndices;
delete deferredList;
}
////////////////////////////////////////////////////////////////////////////////
//! Cleanup offscreen render target
////////////////////////////////////////////////////////////////////////////////
void
deleteFBO( GLuint* fbo, GLuint* tex) {
glDeleteFramebuffersEXT( 1, fbo);
CUT_CHECK_ERROR_GL();
deleteTexture( tex);
*fbo = 0;
}
void Image::unloadVolatile()
{
settings.filter = getFilter();
settings.wrap = getWrap();
// Delete the hardware texture.
if (texture != 0)
{
deleteTexture(texture);
texture = 0;
}
}
void cleanup(void)
{
cudaGraphicsUnregisterResource(cuda_pbo_resource);
glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
glDeleteBuffers(1, &pbo_buffer);
glDeleteTextures(1, &texid);
deleteTexture();
sdkDeleteTimer(&timer);
}
