Exemple #1
0
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;
}
Exemple #2
0
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);
}
Exemple #5
0
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);
}
Exemple #6
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;
    }
Exemple #8
0
/*
============
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);
}
Exemple #10
0
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;
}
Exemple #11
0
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();
	}
Exemple #13
0
/**
 * 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();
	}
}
Exemple #14
0
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);
}
Exemple #15
0
/**
 * 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);
	}
}
Exemple #16
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;
    }
}
Exemple #17
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 ) );
}
Exemple #18
0
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);
}
Exemple #20
0
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;
}
Exemple #21
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;
}
Exemple #22
0
void ShutDown()
{
   glDeleteFramebuffersEXT(1, &fbo);
   glDeleteRenderbuffersEXT(1, &depthBuffer);
   glDeleteTextures(1, &img);
   glDeleteTextures(1, &img2);
}
Exemple #23
0
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;
}
Exemple #26
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);
	}
}
Exemple #30
0
    //----------------------------------------------------------------------
    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]);
        }
        //}
    }