slop::Framebuffer::~Framebuffer() { if ( GLEW_VERSION_3_0 ) { glDeleteFramebuffers( 1, &m_frame ); if ( m_flags & color ) { glDeleteTextures( 1, &m_texture ); } if ( m_flags & depth && !( m_flags & stencil ) ) { glDeleteRenderbuffers( 1, &m_depth ); } if ( m_flags & stencil ) { glDeleteRenderbuffers( 1, &m_stencil ); } } else if ( GLEW_EXT_framebuffer_object ) { glDeleteFramebuffersEXT( 1, &m_frame ); if ( m_flags & color ) { glDeleteTextures( 1, &m_texture ); } if ( m_flags & depth && !( m_flags & stencil ) ) { glDeleteRenderbuffersEXT( 1, &m_depth ); } if ( m_flags & stencil ) { glDeleteRenderbuffersEXT( 1, &m_stencil ); } } if ( generatedBuffers ) { glDeleteBuffers( 2, m_buffers ); } delete m_shader; }
GLOffscreen::~GLOffscreen() { delete[] _pixels; delete[] _pixels_inv; glDeleteRenderbuffersEXT(1, &_depth_renderbuffer); glDeleteRenderbuffersEXT(1, &_color_renderbuffer); glDeleteFramebuffersEXT(1, &_framebuffer); }
bool GLframebuffermanager::checkFormat(TexFormat format) { GLenum dataformat, datatype, iformat; trTexFormat(format, dataformat, datatype, iformat); if (!format) { return false; } GLuint rbuf; glGenRenderbuffersEXT(1, &rbuf); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, rbuf); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, iformat, 32, 32); if (glGetError() != GL_NO_ERROR) { glDeleteRenderbuffersEXT(1, &rbuf); Printf("FBO DON'T SUPPORT %s\n", format.getStringName()); return false; } int realf, r, g, b, a, d, s; glGetRenderbufferParameterivEXT(GL_RENDERBUFFER_EXT, GL_RENDERBUFFER_INTERNAL_FORMAT_EXT, &realf); glGetRenderbufferParameterivEXT(GL_RENDERBUFFER_EXT, GL_RENDERBUFFER_RED_SIZE_EXT, &r); glGetRenderbufferParameterivEXT(GL_RENDERBUFFER_EXT, GL_RENDERBUFFER_GREEN_SIZE_EXT, &g); glGetRenderbufferParameterivEXT(GL_RENDERBUFFER_EXT, GL_RENDERBUFFER_BLUE_SIZE_EXT, &b); glGetRenderbufferParameterivEXT(GL_RENDERBUFFER_EXT, GL_RENDERBUFFER_ALPHA_SIZE_EXT, &a); glGetRenderbufferParameterivEXT(GL_RENDERBUFFER_EXT, GL_RENDERBUFFER_DEPTH_SIZE_EXT, &d); glGetRenderbufferParameterivEXT(GL_RENDERBUFFER_EXT, GL_RENDERBUFFER_STENCIL_SIZE_EXT, &s); if (format.isColor()) { glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_RENDERBUFFER_EXT, rbuf); } else if (format.isDepth()) { glDrawBuffer(GL_NONE); glReadBuffer(GL_NONE); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, rbuf); } else if (format.isStencil()) { glDrawBuffer(GL_NONE); glReadBuffer(GL_NONE); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, rbuf); } GLenum status = glCheckFramebufferStatusEXT(GL_DRAW_FRAMEBUFFER_EXT); if (status == GL_NO_ERROR || status == GL_FRAMEBUFFER_COMPLETE_EXT) { Printf("FBO SUPPORT %s, R%dG%dB%dA%dD%dS%d\n", format.getStringName(), r, g, b, a, d, s); } else { Printf("FBO DON'T SUPPORT %s\n", format.getStringName()); } glDeleteRenderbuffersEXT(1, &rbuf); glGetError(); return true; }
/** * Destructor */ FBORenderTexture::~FBORenderTexture() { glDeleteTextures(1, &m_normalsTexture); glDeleteTextures(1, &m_positionTexture); glDeleteTextures(1, &m_diffuseTexture); glDeleteFramebuffersEXT(1, &m_fbo); glDeleteRenderbuffersEXT(1, &m_diffuseRT); glDeleteRenderbuffersEXT(1, &m_positionRT); glDeleteRenderbuffersEXT(1, &m_normalsRT); glDeleteRenderbuffersEXT(1, &m_depthBuffer); }
static void CleanUp(void) { glDeleteFramebuffersEXT(1, &MyFB); glDeleteRenderbuffersEXT(1, &ColorRb); glDeleteRenderbuffersEXT(1, &DepthRb); assert(!glIsFramebufferEXT(MyFB)); assert(!glIsRenderbufferEXT(ColorRb)); assert(!glIsRenderbufferEXT(DepthRb)); glutDestroyWindow(Win); exit(0); }
void RenderToFrameBuffer::Clean() { if (m_depthBuffer) glDeleteRenderbuffersEXT(1, &m_depthBuffer); if (m_colorMS) glDeleteRenderbuffersEXT(1, &m_colorMS); if (m_fbo) glDeleteFramebuffersEXT(1, &m_fbo); if (m_fboMS) glDeleteFramebuffersEXT(1, &m_fboMS); m_bInitialized = false; }
/** Try a certain FBO format, and return the status. Also sets mDepthRB and mStencilRB. @returns true if this combo is supported false if this combo is not supported */ GLuint GLFBOManager::_tryFormat(GLenum depthFormat, GLenum stencilFormat) { GLuint status, depthRB = 0, stencilRB = 0; bool failed = false; // flag on GL errors if(depthFormat != GL_NONE) { /// Generate depth renderbuffer glGenRenderbuffersEXT(1, &depthRB); /// Bind it to FBO glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, depthRB); /// Allocate storage for depth buffer glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, depthFormat, PROBE_SIZE, PROBE_SIZE); /// Attach depth glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, depthRB); } if(stencilFormat != GL_NONE) { /// Generate stencil renderbuffer glGenRenderbuffersEXT(1, &stencilRB); /// Bind it to FBO glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, stencilRB); glGetError(); // NV hack /// Allocate storage for stencil buffer glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, stencilFormat, PROBE_SIZE, PROBE_SIZE); if(glGetError() != GL_NO_ERROR) // NV hack failed = true; /// Attach stencil glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, stencilRB); if(glGetError() != GL_NO_ERROR) // NV hack failed = true; } status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); /// If status is negative, clean up // Detach and destroy glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, 0); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, 0); if (depthRB) glDeleteRenderbuffersEXT(1, &depthRB); if (stencilRB) glDeleteRenderbuffersEXT(1, &stencilRB); return status == GL_FRAMEBUFFER_COMPLETE_EXT && !failed; }
/* ============ R_ShutdownFBOs ============ */ void R_ShutdownFBOs( void ) { int i, j; FBO_t *fbo; ri.Printf( PRINT_DEVELOPER, "------- R_ShutdownFBOs -------\n" ); #if !defined( USE_D3D10 ) if ( !glConfig2.framebufferObjectAvailable ) { return; } #endif R_BindNullFBO(); for ( i = 0; i < tr.numFBOs; i++ ) { fbo = tr.fbos[ i ]; #if defined( USE_D3D10 ) // TODO #else for ( j = 0; j < glConfig2.maxColorAttachments; j++ ) { if ( fbo->colorBuffers[ j ] ) { glDeleteRenderbuffersEXT( 1, &fbo->colorBuffers[ j ] ); } } if ( fbo->depthBuffer ) { glDeleteRenderbuffersEXT( 1, &fbo->depthBuffer ); } if ( fbo->stencilBuffer ) { glDeleteRenderbuffersEXT( 1, &fbo->stencilBuffer ); } if ( fbo->frameBuffer ) { glDeleteFramebuffersEXT( 1, &fbo->frameBuffer ); } #endif } }
void CFrameBufferObject::freeResources() { if (m_fboData.fb) glDeleteFramebuffersEXT( 1, &m_fboData.fb); if (m_fboData.resolveFB) glDeleteFramebuffersEXT( 1, &m_fboData.resolveFB); if (m_fboData.colorRB) glDeleteRenderbuffersEXT( 1, &m_fboData.colorRB); if (m_fboData.depthRB) glDeleteRenderbuffersEXT( 1, &m_fboData.depthRB); if (m_fboData.colorTex) glDeleteTextures( 1, &m_fboData.colorTex); if (m_fboData.depthTex) glDeleteTextures( 1, &m_fboData.depthTex); glDeleteProgramsARB(1, &m_textureProgram); glDeleteProgramsARB(1, &m_overlayProgram); }
void FBO::destroy() { glDeleteFramebuffersEXT(1, &m_iId); if (m_iType == 0 || m_iType == 2) glDeleteTextures(1,&m_iTexId); if(m_iType == 0) glDeleteRenderbuffersEXT(1, &m_iRenderId); else glDeleteRenderbuffersEXT(1, &m_iTexDepthId); m_bIsActivated = false; }
void RenderSurface::Release() { Graphics* graphics = parentTexture_->GetGraphics(); if (!graphics) return; if (!graphics->IsDeviceLost()) { for (unsigned i = 0; i < MAX_RENDERTARGETS; ++i) { if (graphics->GetRenderTarget(i) == this) graphics->ResetRenderTarget(i); } if (graphics->GetDepthStencil() == this) graphics->ResetDepthStencil(); // Clean up also from non-active FBOs graphics->CleanupRenderSurface(this); if (renderBuffer_) glDeleteRenderbuffersEXT(1, &renderBuffer_); } renderBuffer_ = 0; }
virtual void onDestroy() { glDeleteRenderbuffersEXT(1, &mRboId); glDeleteFramebuffersEXT(1, &mFboId); mRboId = mFboId = 0; CubeMapTexture::onDestroy(); }
/** * Unbinds the framebuffer and deletes it */ FBO::~FBO() { if (!IsSupported()) return; glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0); for (std::vector<GLuint>::iterator ri=myRBOs.begin(); ri!=myRBOs.end(); ++ri) { glDeleteRenderbuffersEXT(1, &(*ri)); } glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); if (fboId) glDeleteFramebuffersEXT(1, &fboId); for (std::vector<FBO*>::iterator fi=fboList.begin(); fi!=fboList.end(); ++fi) { if (*fi==this) { fboList.erase(fi); break; } } // seems the application exits and we are the last fbo left // so we delete the remaining alloc'ed stuff if (fboList.empty()) { for (std::map<GLuint,FBO::TexData*>::iterator ti=texBuf.begin(); ti!=texBuf.end(); ++ti) { FBO::TexData* tex = ti->second; delete[] tex->pixels; delete tex; } texBuf.clear(); } }
void piglit_init(int argc, char **argv) { GLint max_samples, rb_samples; GLuint rb, list; GLint width; bool pass = true; piglit_require_extension("GL_EXT_framebuffer_multisample"); glGetIntegerv(GL_MAX_SAMPLES, &max_samples); if (!piglit_check_gl_error(0)) piglit_report_result(PIGLIT_FAIL); glGenRenderbuffersEXT(1, &rb); glBindRenderbufferEXT(GL_RENDERBUFFER, rb); /* Make the list. The Storage should be called during compile. */ list = glGenLists(1); glNewList(list, GL_COMPILE); glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER, max_samples, GL_RGBA, 1, 1); glEndList(); /* Make sure that the command occurred during the compile. */ glGetRenderbufferParameterivEXT(GL_RENDERBUFFER, GL_RENDERBUFFER_SAMPLES, &rb_samples); if (rb_samples != max_samples) { fprintf(stderr, "glRenderbufferStorageMultisampleEXT not called during " "display list compile\n"); pass = false; } /* Now, make sure that it doesn't occur at execute. Start * with storage of a different size so we can distinguish. */ glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER, max_samples, GL_RGBA, 2, 2); glCallList(list); glGetRenderbufferParameterivEXT(GL_RENDERBUFFER, GL_RENDERBUFFER_WIDTH, &width); if (width != 2) { fprintf(stderr, "glRenderbufferStorageMultisampleEXT called " "during display list execute"); pass = false; } glDeleteRenderbuffersEXT(1, &rb); piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL); }
/** * Deattaches an attachment from the framebuffer */ void FBO::Unattach(const GLenum attachment) { GLuint target; glGetFramebufferAttachmentParameterivEXT(GL_FRAMEBUFFER_EXT, attachment, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT, (GLint*)&target); if (target==GL_RENDERBUFFER_EXT) { //! check if the RBO was created via FBO::CreateRenderBuffer() GLuint id; glGetFramebufferAttachmentParameterivEXT(GL_FRAMEBUFFER_EXT, attachment, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT, (GLint*)&id); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, attachment, GL_RENDERBUFFER_EXT, 0); for (std::vector<GLuint>::iterator ri=myRBOs.begin(); ri!=myRBOs.end(); ++ri) { if (*ri == id) { glDeleteRenderbuffersEXT(1, &(*ri)); myRBOs.erase(ri); break; } } } else { glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, attachment, GL_TEXTURE_2D, 0, 0); } }
void FrameBuffer::destroy() { if (m_colorTex != 0) { glDeleteTextures(1, (GLuint*)&m_colorTex); m_colorTex = 0; } if (m_colorTex1 != 0) { glDeleteTextures(1, (GLuint*)&m_colorTex1); m_colorTex1 = 0; } if (m_shadowTex != 0) { glDeleteTextures(1, (GLuint*)&m_shadowTex); m_shadowTex = 0; } if (m_shadowRBuf != 0) { glDeleteRenderbuffersEXT(1, (GLuint*)&m_shadowRBuf); m_shadowRBuf = 0; } if (m_frameBuffer != 0) { glDeleteFramebuffersEXT(1, (GLuint*)&m_frameBuffer); m_frameBuffer = 0; } }
void R_EXT_FramebufferCleanup ( void ) { int i = 0; framebuffer_t *fbo = framebuffers; texture_t *texture = textures; for ( i=0; i<numFramebuffers; i++, fbo++ ) { if ( !fbo->id ) continue; glDeleteFramebuffersEXT( 1, &fbo->id ); CheckGLErrors( __FILE__, __LINE__ ); } for ( i=0; i<numTextures; i++, texture++ ) { if ( !texture->id ) continue; glDeleteTextures( 1, &texture->id ); CheckGLErrors( __FILE__, __LINE__ ); } glDeleteRenderbuffersEXT( numRenderbuffers, renderbuffers ); currentReadFramebuffer = currentWriteFramebuffer = NULL; numFramebuffers = numTextures = numRenderbuffers = 0; memset( framebuffers, 0, sizeof( framebuffers ) ); memset( textures, 0, sizeof( textures ) ); memset( renderbuffers, 0, sizeof( renderbuffers ) ); }
Map::~Map() { CloseMutex(mMutex); CloseMutex(mCollidableMutex); LightSource * s = 0; foreach(LightSourceList, s, mLightSources) { delete s; } MapObject * o = 0; foreach(MapObjectList, o, mMapObjects) { delete o; } if(mSpot) { delete mSpot; } if(mMinimapParticle) { delete mMinimapParticle; } if(mGaussShader) { delete mGaussShader; } glDeleteLists(mFramebufferList, 1); glDeleteRenderbuffersEXT(1, &mRenderbuffer); glDeleteFramebuffersEXT(1, &mFramebuffer); glDeleteTextures(1, &mFramebufferTexture); }
FBO::~FBO() { for (int i = 0; i < 4; ++i) { Texture* t = color_textures[i]; if (!t) continue; delete t; } if(fbo_id) glDeleteFramebuffers(1, &fbo_id); if (renderbuffer_color) glDeleteRenderbuffersEXT(1, &renderbuffer_color); if (renderbuffer_depth) glDeleteRenderbuffersEXT(1, &renderbuffer_depth); }
void Canvas::Impl::shutdown() { if (width == 0 && height == 0) return; if (GLEW_ARB_framebuffer_object) { glDeleteFramebuffers(1, &frameBuffer); glDeleteRenderbuffers(1, &renderBuffer); } else { glDeleteFramebuffersEXT(1, &frameBuffer); glDeleteRenderbuffersEXT(1, &renderBuffer); } if (texture) { glDeleteTextures(1, &texture); texture = 0; } while (!translucents.empty()) { GLuint tex = translucents.back(); glDeleteTextures(1, &tex); translucents.pop_back(); } frameBuffer = 0; renderBuffer = 0; width = height = 0; }
void fbo_destroy(FBO *fbo) { if (fbo->native_fbo) { delete fbo; return; } if (gl_extensions.ARB_framebuffer_object || gl_extensions.IsGLES) { glBindFramebuffer(GL_FRAMEBUFFER, fbo->handle); glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0); glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, 0); glBindFramebuffer(GL_FRAMEBUFFER, 0); glDeleteFramebuffers(1, &fbo->handle); glDeleteRenderbuffers(1, &fbo->z_stencil_buffer); glDeleteRenderbuffers(1, &fbo->z_buffer); glDeleteRenderbuffers(1, &fbo->stencil_buffer); } else if (gl_extensions.EXT_framebuffer_object) { #ifndef USING_GLES2 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo->handle); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER_EXT, 0); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); glDeleteFramebuffersEXT(1, &fbo->handle); glDeleteRenderbuffersEXT(1, &fbo->z_stencil_buffer); #endif } currentDrawHandle_ = 0; currentReadHandle_ = 0; glDeleteTextures(1, &fbo->color_texture); delete fbo; }
void ShutDown() { glDeleteFramebuffersEXT(1, &fbo); glDeleteRenderbuffersEXT(1, &depthBuffer); glDeleteTextures(1, &img); glDeleteTextures(1, &img2); }
GL2RenderTarget::~GL2RenderTarget() { // Don't clean up m_ColorTextureObject; deleting the texture does that. SafeDelete(m_ColorTexture); if (m_DepthStencilRenderBufferObject != 0) { #ifdef HAVE_GLES glDeleteRenderbuffers(1, &m_DepthStencilRenderBufferObject); #else if (GLEW_ARB_framebuffer_object) { glDeleteRenderbuffers(1, &m_DepthStencilRenderBufferObject); } else if (GLEW_EXT_framebuffer_object) { glDeleteRenderbuffersEXT(1, &m_DepthStencilRenderBufferObject); } #endif } if (m_FrameBufferObject != 0) { #ifdef HAVE_GLES glDeleteFramebuffers(1, &m_FrameBufferObject); #else if (GLEW_ARB_framebuffer_object) { glDeleteFramebuffers(1, &m_FrameBufferObject); } else if (GLEW_EXT_framebuffer_object) { glDeleteFramebuffersEXT(1, &m_FrameBufferObject); } #endif } }
bool OffscreenRenderer::initFrameBuffer(int width, int height, Buffer& buffer) { mainGlWidget->makeCurrent(); #ifndef OSX if(!GLEW_EXT_framebuffer_object) return false; #endif glGenFramebuffersEXT(1, &buffer.frameBufferId); glGenRenderbuffersEXT(2, buffer.renderBufferIds); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, buffer.frameBufferId); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, buffer.renderBufferIds[0]); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, width, height); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, buffer.renderBufferIds[1]); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_RGB, width, height); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, buffer.renderBufferIds[0]); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_RENDERBUFFER_EXT, buffer.renderBufferIds[1]); GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); if(status != GL_FRAMEBUFFER_COMPLETE_EXT) { glDeleteFramebuffersEXT(1, &buffer.frameBufferId); glDeleteRenderbuffersEXT(2, buffer.renderBufferIds); buffer.frameBufferId = 0; return false; } return true; }
FramebufferManager::~FramebufferManager() { glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); GLuint glObj[3]; // Note: OpenGL deletion functions silently ignore parameters of "0". glObj[0] = m_efbFramebuffer; glObj[1] = m_resolvedFramebuffer; glObj[2] = m_xfbFramebuffer; glDeleteFramebuffersEXT(3, glObj); m_efbFramebuffer = 0; m_xfbFramebuffer = 0; glObj[0] = m_resolvedColorTexture; glObj[1] = m_resolvedDepthTexture; glDeleteTextures(2, glObj); m_resolvedColorTexture = 0; m_resolvedDepthTexture = 0; glObj[0] = m_efbColor; glObj[1] = m_efbDepth; if (m_msaaSamples <= 1) glDeleteTextures(2, glObj); else glDeleteRenderbuffersEXT(2, glObj); m_efbColor = 0; m_efbDepth = 0; }
FrameBufferObject::~FrameBufferObject() { glDeleteFramebuffersEXT(1,&fbo); glDeleteTextures(1,&texture); if(depthbuffer) glDeleteRenderbuffersEXT(1, &depthbuffer); }
void piglit_init(int argc, char **argv) { GLint max_samples; GLuint rb; piglit_require_extension("GL_EXT_framebuffer_multisample"); if (piglit_is_extension_supported("GL_ARB_internalformat_query")) { printf("ARB_internalformat_query is supported and " "redefines this behavior; skipping\n"); piglit_report_result(PIGLIT_SKIP); } if (piglit_is_extension_supported("GL_ARB_texture_multisample")) { printf("ARB_texture_multisample is supposed and " "redefines this behavior; skipping\n"); piglit_report_result(PIGLIT_SKIP); } glGetIntegerv(GL_MAX_SAMPLES, &max_samples); glGenRenderbuffersEXT(1, &rb); glBindRenderbufferEXT(GL_RENDERBUFFER, rb); glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER, max_samples + 1, GL_RGBA, 1, 1); if (!piglit_check_gl_error(GL_INVALID_VALUE)) piglit_report_result(PIGLIT_FAIL); glDeleteRenderbuffersEXT(1, &rb); piglit_report_result(PIGLIT_PASS); }
void piglit_init(int argc, char **argv) { GLint rb_samples; GLuint rb; bool pass = true; piglit_require_extension("GL_EXT_framebuffer_multisample"); glGenRenderbuffersEXT(1, &rb); glBindRenderbufferEXT(GL_RENDERBUFFER, rb); glRenderbufferStorageEXT(GL_RENDERBUFFER, GL_RGBA, 1, 1); glGetRenderbufferParameterivEXT(GL_RENDERBUFFER, GL_RENDERBUFFER_SAMPLES, &rb_samples); if (rb_samples != 0) { fprintf(stderr, "glRenderbufferStorageEXT() produced %d samples\n", rb_samples); pass = false; } glDeleteRenderbuffersEXT(1, &rb); piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL); }
void RenderTexture::Shutdown() { if (m_texID) { glDeleteTextures( 1, &m_texID ); m_texID = 0; } if (m_FBO) { glDeleteFramebuffersEXT(1, &m_frameBuffer); glDeleteRenderbuffersEXT(1, &m_depthRenderBuffer); } else { wglMakeCurrent(m_hDC, m_hRC); // Don't forget to clean up after our pixelbuffer... wglReleasePbufferDCARB(m_hPBuffer, m_hDC); wglDestroyPbufferARB(m_hPBuffer); if(m_hRC) { wglDeleteContext(m_hRC); m_hRC = NULL; } wglMakeCurrent(canvas_hDC, canvas_hRC); } }
//---------------------------------------------------------------------- Render::~Render() { printf("Render destructor\n"); for (map<ShaderType,GLuint>::iterator i = glsl_program.begin();i!=glsl_program.end();i++) { glDeleteProgram(i->second); } for (map<string,GLuint>::iterator i = gl_framebuffer_texs.begin();i!=gl_framebuffer_texs.end();i++) { glDeleteTextures(1,&(i->second)); } //for(vector<GLuint>::iterator i=rbos.begin(); i!=rbos.end();i++) //{ if (rbos.size()) { glDeleteRenderbuffersEXT(rbos.size() ,&rbos[0]); } //} //for(vector<GLuint>::iterator i=fbos.begin(); i!=fbos.end();i++) //{ if (fbos.size()) { glDeleteFramebuffersEXT(fbos.size(),&fbos[0]); } //} }