void cFrameBufferFBO::BindRenderBuffer() {
if ( mDepthBuffer ) {
GLint curRB;
glGetIntegerv( GL_RENDERBUFFER_BINDING, &curRB );
mLastRB = (Int32)curRB;
glBindRenderbufferEXT( GL_RENDERBUFFER, mDepthBuffer );
}
}
bool RenderTextureImplFBO::create(unsigned int width, unsigned int height, unsigned int textureId, bool depthBuffer)
{
// Create the context
m_context = new Context;
// Create the framebuffer object
GLuint frameBuffer = 0;
glCheck(glGenFramebuffersEXT(1, &frameBuffer));
m_frameBuffer = static_cast<unsigned int>(frameBuffer);
if (!m_frameBuffer)
{
err() << "Impossible to create render texture (failed to create the frame buffer object)" << std::endl;
return false;
}
glCheck(glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_frameBuffer));
// Create the depth buffer if requested
if (depthBuffer || sfExt::StencilBufferEnabled)
{
GLuint depth = 0;
glCheck(glGenRenderbuffersEXT(1, &depth));
m_depthBuffer = static_cast<unsigned int>(depth);
if (!m_depthBuffer)
{
err() << "Impossible to create render texture (failed to create the attached depth buffer)" << std::endl;
return false;
}
glCheck(glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, m_depthBuffer));
if(sfExt::StencilBufferEnabled)
{
err() << "Creating FBO with stencil" << std::endl;
glCheck(glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH24_STENCIL8_EXT, width, height));
glCheck(glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_depthBuffer));
glCheck(glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_depthBuffer));
}
else
{
glCheck(glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, width, height));
glCheck(glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_depthBuffer));
}
}
// Link the texture to the frame buffer
glCheck(glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, textureId, 0));
// A final check, just to be sure...
if (glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT) != GL_FRAMEBUFFER_COMPLETE_EXT)
{
glCheck(glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0));
err() << "Impossible to create render texture (failed to link the target texture to the frame buffer)" << std::endl;
return false;
}
return true;
}
void HeadlessView::resize(const uint16_t width, const uint16_t height, const float pixelRatio) {
dimensions = { width, height, pixelRatio };
clearBuffers();
const unsigned int w = dimensions.width * dimensions.pixelRatio;
const unsigned int h = dimensions.height * dimensions.pixelRatio;
// Create depth/stencil buffer
MBGL_CHECK_ERROR(glGenRenderbuffersEXT(1, &fboDepthStencil));
MBGL_CHECK_ERROR(glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, fboDepthStencil));
MBGL_CHECK_ERROR(glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH24_STENCIL8_EXT, w, h));
MBGL_CHECK_ERROR(glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0));
MBGL_CHECK_ERROR(glGenRenderbuffersEXT(1, &fboColor));
MBGL_CHECK_ERROR(glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, fboColor));
MBGL_CHECK_ERROR(glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_RGBA8, w, h));
MBGL_CHECK_ERROR(glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0));
MBGL_CHECK_ERROR(glGenFramebuffersEXT(1, &fbo));
MBGL_CHECK_ERROR(glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo));
MBGL_CHECK_ERROR(glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_RENDERBUFFER_EXT, fboColor));
MBGL_CHECK_ERROR(glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER_EXT, fboDepthStencil));
GLenum status = MBGL_CHECK_ERROR(glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT));
if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
std::stringstream error("Couldn't create framebuffer: ");
switch (status) {
case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT: (error << "incomplete attachment.\n"); break;
case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT: error << "incomplete missing attachment.\n"; break;
case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT: error << "incomplete dimensions.\n"; break;
case GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT: error << "incomplete formats.\n"; break;
case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT: error << "incomplete draw buffer.\n"; break;
case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT: error << "incomplete read buffer.\n"; break;
case GL_FRAMEBUFFER_UNSUPPORTED: error << "unsupported.\n"; break;
default: error << "other\n"; break;
}
throw std::runtime_error(error.str());
}
}
void EJCanvasContextScreen::present()
{
glViewport(0, 0, viewportWidth, viewportHeight);
#ifdef _WINDOWS
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0 );
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0 );
#else
glBindFramebufferOES(GL_FRAMEBUFFER_OES, 0 );
glBindRenderbufferOES(GL_RENDERBUFFER_OES, 0 );
#endif
// [self flushBuffers];
EJCanvasContext::flushBuffers();
if( msaaEnabled ) {
#ifdef _WINDOWS
//Bind the MSAA and View frameBuffers and resolve
glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, msaaFrameBuffer);
glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, viewFrameBuffer);
//glResolveMultisampleFramebufferAPPLE();
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, viewRenderBuffer);
// [[EJApp instance].glContext presentRenderbuffer:GL_RENDERBUFFER];
// EJApp::instance()->glContext->presentRenderbuffer(GL_RENDERBUFFER_OES);
// presentRenderbuffer(GL_RENDERBUFFER_OES);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, msaaFrameBuffer);
#else
//Bind the MSAA and View frameBuffers and resolve
glBindFramebufferOES(GL_FRAMEBUFFER_OES, msaaFrameBuffer);
glBindFramebufferOES(GL_FRAMEBUFFER_OES, viewFrameBuffer);
// glResolveMultisampleFramebufferAPPLE();
glBindRenderbufferOES(GL_RENDERBUFFER_OES, viewRenderBuffer);
// [[EJApp instance].glContext presentRenderbuffer:GL_RENDERBUFFER];
// EJApp::instance()->glContext->presentRenderbuffer(GL_RENDERBUFFER_OES);
// presentRenderbuffer(GL_RENDERBUFFER_OES);
glBindFramebufferOES(GL_FRAMEBUFFER_OES, msaaFrameBuffer);
#endif
}
else {
}
}
void RE_InitFBOs()
{
GLenum DrawBuffers[1];
GLenum status;
GLenum buffers[] = { GL_COLOR_ATTACHMENT0_EXT, GL_COLOR_ATTACHMENT1_EXT };
glConfig.oculusFBL = 0;
glConfig.oculusFBR = 0;
glGenFramebuffersEXT(1, &glConfig.oculusFBL);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, glConfig.oculusFBL);
// The depth buffer
glGenRenderbuffers(1, &glConfig.oculusDepthRenderBufferLeft);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, glConfig.oculusDepthRenderBufferLeft);
glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, glConfig.vidWidth, glConfig.vidHeight);
glGenTextures(1, &glConfig.oculusRenderTargetLeft);
glBindTexture(GL_TEXTURE_2D, glConfig.oculusRenderTargetLeft);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, glConfig.vidWidth, glConfig.vidHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, 0); // Empty Image
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glGenerateMipmapEXT(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, 0);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, glConfig.oculusRenderTargetLeft, 0);
glGenTextures(1, &glConfig.oculusRenderTargetRight);
glBindTexture(GL_TEXTURE_2D, glConfig.oculusRenderTargetRight);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, glConfig.vidWidth, glConfig.vidHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, 0); // Empty Image
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glGenerateMipmapEXT(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, 0);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT1_EXT, GL_TEXTURE_2D, glConfig.oculusRenderTargetRight, 0);
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, glConfig.oculusDepthRenderBufferLeft);
//glDrawBuffers(2, (GLenum*)buffers);
status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
if(status != GL_FRAMEBUFFER_COMPLETE_EXT)
exit(1);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); // Unbind the FBO for now
}
void say_rbo_make_current(GLuint rbo) {
say_context *context = say_context_current();
if (context != say_rbo_last_context ||
rbo != say_current_rbo) {
say_current_rbo = rbo;
say_rbo_last_context = context;
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, rbo);
}
}
void R_BindNullFBO(void)
{
Ren_LogComment("--- R_BindNullFBO ---\n");
if (glState.currentFBO && glConfig2.framebufferObjectAvailable)
{
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0);
glState.currentFBO = NULL;
}
}
bool InitResourceOpenGL(void)
{
if ( glGenFramebuffersEXT==NULL )
{
printf("Could not create frame buffer object\n");
return false;
}
// 投影矩陣
g_projection_matrix = GutMatrixPerspectiveRH_OpenGL(g_fFOV, 1.0f, 0.1f, 100.0f);
// 設定視角轉換矩陣
glMatrixMode(GL_PROJECTION);
glLoadMatrixf( (float *) &g_projection_matrix);
glMatrixMode(GL_MODELVIEW);
glEnable(GL_DEPTH_TEST);
glDisable(GL_CULL_FACE);
// 開啟一個framebuffer object
glGenFramebuffersEXT(1, &g_framebuffer);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, g_framebuffer);
// 配罝一塊貼圖空間給framebuffer object繪圖使用
{
glGenTextures(1, &g_texture);
glBindTexture(GL_TEXTURE_2D, g_texture);
// 設定filter
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
// 宣告貼圖大小及格式
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 512, 512, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
// framebuffer的RGBA繪圖
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, g_texture, 0);
}
// 配置zbuffer給framebuffer object使用
{
glGenRenderbuffersEXT(1, &g_depthbuffer);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, g_depthbuffer);
glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, 512, 512);
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, g_depthbuffer);
}
// 檢查framebuffer object有沒有配置成功
GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
if ( status!=GL_FRAMEBUFFER_COMPLETE_EXT )
{
return false;
}
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
return true;
}
void CRenderTarget::addDepthRenderBuffer(void)
{
/** Attachement d'un render buffer pour la profondeur */
m_bDepthRenderBuffer = true;
glGenRenderbuffersEXT( 1, &m_uiDepthRenderBuffer );
glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, m_uiFrameBuffer );
glBindRenderbufferEXT( GL_RENDERBUFFER_EXT, m_uiDepthRenderBuffer );
glRenderbufferStorageEXT( GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24, m_uiWidth, m_uiHeight );
glFramebufferRenderbufferEXT( GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_uiDepthRenderBuffer );
bindDefaultTarget();
}
void EJCanvasContext::create()
{
#ifdef _WINDOWS
if( msaaEnabled ) {
glGenFramebuffersEXT(1, &msaaFrameBuffer);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, msaaFrameBuffer);
glGenRenderbuffersEXT(1, &msaaRenderBuffer);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, msaaRenderBuffer);
//glRenderbufferStorageMultisampleIMG(GL_RENDERBUFFER, msaaSamples, GL_RGBA8, bufferWidth, bufferHeight);
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER_EXT, msaaRenderBuffer);
}
glGenFramebuffersEXT(1, &viewFrameBuffer);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, viewFrameBuffer);
glGenRenderbuffersEXT(1, &viewRenderBuffer);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, viewRenderBuffer);
#else
if( msaaEnabled ) {
glGenFramebuffersOES(1, &msaaFrameBuffer);
glBindFramebufferOES(GL_FRAMEBUFFER_OES, msaaFrameBuffer);
glGenRenderbuffersOES(1, &msaaRenderBuffer);
glBindRenderbufferOES(GL_RENDERBUFFER_OES, msaaRenderBuffer);
//glRenderbufferStorageMultisampleIMG(GL_RENDERBUFFER_OES, msaaSamples, GL_RGBA8_OES, bufferWidth, bufferHeight);
glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES, GL_COLOR_ATTACHMENT0_OES, GL_RENDERBUFFER_OES, msaaRenderBuffer);
}
glGenFramebuffersOES(1, &viewFrameBuffer);
glBindFramebufferOES(GL_FRAMEBUFFER_OES, viewFrameBuffer);
glGenRenderbuffersOES(1, &viewRenderBuffer);
glBindRenderbufferOES(GL_RENDERBUFFER_OES, viewRenderBuffer);
#endif
}
void display_reset(int samples, bool vsync) {
int interval = vsync ? 1 : 0;
if (enigma::is_ext_swapcontrol_supported()) {
wglSwapIntervalEXT(interval);
}
GLint fbo;
glGetIntegerv(GL_FRAMEBUFFER_BINDING_EXT, &fbo);
GLuint ColorBufferID, DepthBufferID;
// Cleanup the multi-sampler fbo if turning off multi-sampling
if (samples == 0) {
if (enigma::msaa_fbo != 0) {
glDeleteFramebuffers(1, &enigma::msaa_fbo);
enigma::msaa_fbo = 0;
}
return;
}
//TODO: Change the code below to fix this to size properly to views
// If we don't already have a multi-sample fbo then create one
if (enigma::msaa_fbo == 0) {
glGenFramebuffersEXT(1, &enigma::msaa_fbo);
}
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, enigma::msaa_fbo);
// Now make a multi-sample color buffer
glGenRenderbuffersEXT(1, &ColorBufferID);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, ColorBufferID);
glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, samples, GL_RGBA8, window_get_region_width_scaled(), window_get_region_height_scaled());
// We also need a depth buffer
glGenRenderbuffersEXT(1, &DepthBufferID);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, DepthBufferID);
glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, samples, GL_DEPTH_COMPONENT24, window_get_region_width_scaled(), window_get_region_height_scaled());
// Attach the render buffers to the multi-sampler fbo
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_RENDERBUFFER_EXT, ColorBufferID);
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, DepthBufferID);
}
void InitFBO()
{
glGenTextures(1, &fb_tex);
glBindTexture(GL_TEXTURE_2D, fb_tex);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
printf("\tframebuffer size: %dx%d\n", g_Width, g_Height);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, g_Width, g_Height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glGenFramebuffersEXT(1, &fb);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, fb_tex, 0);
glGenRenderbuffersEXT(1, &depth_rb);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, depth_rb);
glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24, g_Width, g_Height);
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, depth_rb);
GLenum status;
status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
switch(status)
{
case GL_FRAMEBUFFER_COMPLETE_EXT:
printf("\tInitFBO() status: GL_FRAMEBUFFER_COMPLETE\n");
break;
default:
printf("\tInitFBO() error: status != GL_FRAMEBUFFER_COMPLETE\n");
exit(1);
break;
}
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0);
}
void HeadlessView::resizeFramebuffer() {
const unsigned int w = dimensions[0] * pixelRatio;
const unsigned int h = dimensions[1] * pixelRatio;
// Create depth/stencil buffer
MBGL_CHECK_ERROR(glGenRenderbuffersEXT(1, &fboDepthStencil));
MBGL_CHECK_ERROR(glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, fboDepthStencil));
MBGL_CHECK_ERROR(glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH24_STENCIL8_EXT, w, h));
MBGL_CHECK_ERROR(glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0));
MBGL_CHECK_ERROR(glGenRenderbuffersEXT(1, &fboColor));
MBGL_CHECK_ERROR(glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, fboColor));
MBGL_CHECK_ERROR(glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_RGBA8, w, h));
MBGL_CHECK_ERROR(glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0));
MBGL_CHECK_ERROR(glGenFramebuffersEXT(1, &fbo));
MBGL_CHECK_ERROR(glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo));
MBGL_CHECK_ERROR(glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_RENDERBUFFER_EXT, fboColor));
MBGL_CHECK_ERROR(glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER_EXT, fboDepthStencil));
GLenum status = MBGL_CHECK_ERROR(glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT));
if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
std::string error("Couldn't create framebuffer: ");
switch (status) {
case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT: (error += "incomplete attachment"); break;
case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT: error += "incomplete missing attachment"; break;
case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT: error += "incomplete dimensions"; break;
case GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT: error += "incomplete formats"; break;
case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT: error += "incomplete draw buffer"; break;
case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT: error += "incomplete read buffer"; break;
case GL_FRAMEBUFFER_UNSUPPORTED: error += "unsupported"; break;
default: error += "other"; break;
}
throw std::runtime_error(error);
}
MBGL_CHECK_ERROR(glViewport(0, 0, w, h));
}
void RenderBuffer::init(const QSize& size, uint internal_format, int numSamp)
{
if (m_obj != -1)
destroy();
glGenRenderbuffersEXT(1, &m_obj);
Q_ASSERT(!glIsRenderbufferEXT(m_obj));
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, m_obj);
Q_ASSERT(glIsRenderbufferEXT(m_obj));
glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, numSamp, internal_format, size.width(), size.height());
mglCheckErrors("renderBuf");
}
void LLMultisampleBuffer::allocateDepth()
{
glGenRenderbuffersEXT(1, (GLuint* ) &mDepth);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, mDepth);
if (mStencil)
{
glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, mSamples, GL_DEPTH24_STENCIL8_EXT, mResX, mResY);
}
else
{
glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, mSamples, GL_DEPTH_COMPONENT16_ARB, mResX, mResY);
}
}
void GL_RenderBuffer::createRenderBuffer( RenderBufferType bufferComponents )
{
// Render buffers are just objects which are used to support
// offscreen rendering, often for sections of the framebuffer which
// don’t have a texture format associated with them.
if( !checkSize() ) return;
GLuint renderBuffer;
glGenRenderbuffersEXT(1, &renderBuffer);
CheckLastErrorGL( "Could not generate renderbuffer object" );
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, renderBuffer);
CheckLastErrorGL( "Could not bind renderbuffer object" );
bind();
if( BitwiseAnd(bufferComponents, RenderBufferType::Depth) )
{
createRenderBufferStorage(renderBuffer,
GL_DEPTH_COMPONENT, GL_DEPTH_ATTACHMENT_EXT);
}
if( BitwiseAnd(bufferComponents, RenderBufferType::Color) )
{
createRenderBufferStorage(renderBuffer,
GL_RGBA, GL_COLOR_ATTACHMENT0_EXT);
colorAttach = true;
}
if( BitwiseAnd(bufferComponents, RenderBufferType::Stencil) )
{
createRenderBufferStorage(renderBuffer,
GL_STENCIL_INDEX, GL_STENCIL_ATTACHMENT_EXT);
colorAttach = true;
}
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0);
unbind();
}
void FrameBufferObject::initDepthBuffer()
{
if(depthTexture)
{
glBindTexture(GL_TEXTURE_2D, depthTextureID);
glTexParameteri(GL_TEXTURE_2D, GL_DEPTH_TEXTURE_MODE, GL_INTENSITY);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
glTexImage2D(GL_TEXTURE_2D, 0, _fboParams.depthInternalformat , width, height, 0,GL_DEPTH_COMPONENT, GL_FLOAT, NULL);
glBindTexture(GL_TEXTURE_2D, 0);
}
else
{
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, depthTextureID);
glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, width, height);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0);
}
}
void initfbo(GLvoid)
{
// Setup our FBO
glGenFramebuffersEXT(1, &fbo);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo);
// Create the render buffer for depth
glGenRenderbuffersEXT(1, &depthBuffer);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, depthBuffer);
glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, width, height);
// Now setup a texture to render to
glGenTextures(1, &img);
glBindTexture(GL_TEXTURE_2D, img);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glGenTextures(1, &img2);
glBindTexture(GL_TEXTURE_2D, img2);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
// The following 3 lines enable mipmap filtering and generate the mipmap data so rendering works
// glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
// glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
// glGenerateMipmapEXT(GL_TEXTURE_2D);
// And attach it to the FBO so we can render to it
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, img, 0);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT1_EXT, GL_TEXTURE_2D, img2, 0);
// Attach the depth render buffer to the FBO as it's depth attachment
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, depthBuffer);
GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
if(status != GL_FRAMEBUFFER_COMPLETE_EXT)
exit(1);
GLenum buffers[] = {GL_COLOR_ATTACHMENT0_EXT, GL_COLOR_ATTACHMENT1_EXT};
glDrawBuffers(2, buffers);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); // Unbind the FBO for now
}
void create() {
w = width;
h = height;
r = (float)w / (float)h;
//RGBA8 2D texture, 24 bit depth texture, 256x256
std::cout << "gen tex" << std::endl;
glGenTextures(1, &tex);
glBindTexture(GL_TEXTURE_2D, tex); // in order to set parameters
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
//NULL means reserve texture memory, but texels are undefined
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, w, h, 0, GL_BGRA, GL_UNSIGNED_BYTE, NULL); // allocate data
//-------------------------
std::cout << "gen fbo" << std::endl;
glGenFramebuffersEXT(1, &fb);
std::cout << "fbo = " << fb << std::endl;
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb);
//Attach 2D texture to this FBO
std::cout << "attach tex to fbo" << std::endl;
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, tex, 0);
//-------------------------
std::cout << "gen rbo" << std::endl;
glGenRenderbuffersEXT(1, &depth_rb);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, depth_rb);
glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24, w, h);
//-------------------------
//Attach depth buffer to FBO
std::cout << "attach depth buffer to fbo" << std::endl;
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, depth_rb);
//-------------------------
//Does the GPU support current FBO configuration?
GLenum status;
status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
switch(status)
{
case GL_FRAMEBUFFER_COMPLETE_EXT:
std::cout << "good" << std::endl;
break;
default:
//HANDLE_THE_ERROR;
std::cout << "error" << std::endl;
abort();
}
}
void intro_do( long time )
{
//--- update parameters -----------------------------------------
const float t = 0.001f*(float)time;
// camera position
fparams[ 0] = 2.0f;
fparams[ 1] = 0.0f;
fparams[ 2] = 2.0f;
// camera target
fparams[ 4] = 0.0f;
fparams[ 5] = 0.0f;
fparams[ 6] = 0.0f;
// sphere
fparams[ 8] = 0.0f;
fparams[ 9] = 0.0f;
fparams[10] = 0.0f;
fparams[11] = 1.0f;
/*
// Gen renderbuffer
glGenRenderbuffersEXT(1, &frontb);
// Bind renderbuffer
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, frontb);
// Init as a depth buffer
glRenderbufferStorageEXT( GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24, XRES, YRES);
// Attach to the FBO for depth
glFramebufferRenderbufferEXT( GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, frontb);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0);*/
//--- render -----------------------------------------
static float reso[4];
reso[0] = XRES;
reso[1] = YRES;
reso[2] = XRES;
reso[3] = YRES;
oglUseProgram( pid );
glUniform1fARB( oglGetUniformLocation( pid, "iGlobalTime" ), t );
oglUniform4fv( oglGetUniformLocation( pid, "iResolution" ), 1, reso );
oglUniform4fv( oglGetUniformLocation( pid, "fpar" ), 4, fparams );
glRects( -1, -1, 1, 1 );
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0);
}
/*
============
R_BindNullFBO
============
*/
void R_BindNullFBO( void )
{
if ( r_logFile->integer )
{
GLimp_LogComment( "--- R_BindNullFBO ---\n" );
}
if ( glState.currentFBO )
{
glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, 0 );
glBindRenderbufferEXT( GL_RENDERBUFFER_EXT, 0 );
glState.currentFBO = NULL;
}
}
int FrameBuffer::_new(lua_State *l) {
int width = luaL_checkinteger(l, -2);
int height = luaL_checkinteger(l, -1);
FrameBuffer *self = newuserdata(FrameBuffer);
cout << "creating framebuffer " << $(width) << $(height) << endl;
self->width = width;
self->height = height;
self->tex = Image::from_bytes(NULL, width, height);
glGenFramebuffersEXT(1, &self->fbo);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, self->fbo);
// attach texture to fbo
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,
GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D,
self->tex.texid, 0);
// create depth buffer
glGenRenderbuffersEXT(1, &self->depth);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, self->depth);
glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT,
GL_DEPTH_COMPONENT24, width, height);
// attach depth to fbo
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT,
GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, self->depth);
// see if it worked
GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
cout << "Failed to setup framebuffer" << endl;
}
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
if (luaL_newmetatable(l, "FrameBuffer")) {
lua_newtable(l); // the index table
setfunction("bind", FrameBuffer::_bind);
setfunction("release", FrameBuffer::_release);
setfunction("render", FrameBuffer::_render);
setfunction("bindTex", FrameBuffer::_bindTex);
setfunction("draw", FrameBuffer::_draw);
lua_setfield(l, -2, "__index");
}
lua_setmetatable(l, -2);
return 1;
}
bool RfxRenderTarget::Setup(int pass)
{
if (!GLEW_EXT_framebuffer_object) {
qWarning("FBO not supported!");
return false;
}
if (initOk)
return true;
glGenFramebuffersEXT(1, &fbo);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo);
// if "use viewport dimensions" at this point we have a gl context
if (vportdim) {
GLfloat dims[4];
glGetFloatv(GL_VIEWPORT, dims);
width = (int)dims[2];
height = (int)dims[3];
}
// depth buffer
glGenRenderbuffersEXT(1, &depTex);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, depTex);
glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, width, height);
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, depTex);
// color buffer
glGenTextures(1, &colTex);
glBindTexture(GL_TEXTURE_2D, colTex);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, colTex, 0);
// set texture state based on the first uniform that will use RT
QList<int> k = passStates.keys();
for (int i = 0; i < k.size(); ++i) {
if (k.at(i) > pass) {
foreach (RfxState *s, passStates.value(i))
s->SetEnvironment(GL_TEXTURE_2D);
}
}
initOk = (glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT) == GL_FRAMEBUFFER_COMPLETE_EXT);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
return initOk;
}
void initFramebuffer( void )
{
//renderbuffer
glGenRenderbuffersEXT( 1, &rbName );
glBindRenderbufferEXT( GL_RENDERBUFFER_EXT, rbName );
glRenderbufferStorageEXT( GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, TEX_WIDTH, TEX_HEIGHT );
//framebuffer
glGenFramebuffersEXT( 1, &fbName );
glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, fbName );
glFramebufferRenderbufferEXT( GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT,
GL_RENDERBUFFER_EXT, rbName );
glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, 0 );
}
static void
Reshape( int width, int height )
{
float ar = (float) width / (float) height;
glViewport( 0, 0, width, height );
glMatrixMode( GL_PROJECTION );
glLoadIdentity();
glFrustum( -ar, ar, -1.0, 1.0, 5.0, 25.0 );
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
glTranslatef( 0.0, 0.0, -15.0 );
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, ColorRb);
glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_RGB, width, height);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, DepthRb);
glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT,
width, height);
Width = width;
Height = height;
}
void EJCanvasContext::createStencilBufferOnce()
{
if( stencilBuffer ) { return; }
#ifdef _WINDOWS
glGenRenderbuffersEXT(1, &stencilBuffer);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, stencilBuffer);
if( msaaEnabled ) {
glRenderbufferStorageMultisample(GL_RENDERBUFFER_EXT, msaaSamples, GL_DEPTH24_STENCIL8, bufferWidth, bufferHeight);
}
else {
glRenderbufferStorage(GL_RENDERBUFFER_EXT, GL_DEPTH24_STENCIL8, bufferWidth, bufferHeight);
}
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER_EXT, stencilBuffer);
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER_EXT, stencilBuffer);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, msaaEnabled ? msaaRenderBuffer : viewRenderBuffer );
#else
glGenRenderbuffersOES(1, &stencilBuffer);
glBindRenderbufferOES(GL_RENDERBUFFER_OES, stencilBuffer);
if( msaaEnabled ) {
//glRenderbufferStorageMultisampleAPPLE(GL_RENDERBUFFER, msaaSamples, GL_DEPTH24_STENCIL8_OES, bufferWidth, bufferHeight);
}
else {
glRenderbufferStorageOES(GL_RENDERBUFFER_OES, GL_DEPTH24_STENCIL8_OES, bufferWidth, bufferHeight);
}
glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES, GL_DEPTH_ATTACHMENT_OES, GL_RENDERBUFFER_OES, stencilBuffer);
glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES, GL_STENCIL_ATTACHMENT_OES, GL_RENDERBUFFER_OES, stencilBuffer);
glBindRenderbufferOES(GL_RENDERBUFFER_OES, msaaEnabled ? msaaRenderBuffer : viewRenderBuffer );
#endif
glClear(GL_STENCIL_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
virtual GLenum createFBO(GLuint& framebuffer, GLuint& depth_stencil, GLuint& img, int width, int height)
{
GLint current_fbo;
glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING_EXT, ¤t_fbo);
// create framebuffer
glGenFramebuffersEXT(1, &framebuffer);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, framebuffer);
// create stencil buffer
glGenRenderbuffersEXT(1, &depth_stencil);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, depth_stencil);
glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_STENCIL_EXT, width, height);
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT,
GL_RENDERBUFFER_EXT, depth_stencil);
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT,
GL_RENDERBUFFER_EXT, depth_stencil);
// generate texture save target
glGenTextures(1, &img);
bindTexture(img);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, width, height,
0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
bindTexture(0);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
GL_TEXTURE_2D, img, 0);
// check status
GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
// unbind framebuffer
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, (GLuint)current_fbo);
return status;
}
PIGLIT_GL_TEST_CONFIG_END
void
piglit_init(int argc, char **argv)
{
glGetIntegerv(GL_MAX_SAMPLES_EXT, &numSamples);
glGenFramebuffersEXT(1, &framebuffer);
glGenRenderbuffersEXT(1, &renderbuffer);
glBindFramebufferEXT(GL_FRAMEBUFFER, framebuffer);
glBindRenderbufferEXT(GL_RENDERBUFFER, renderbuffer);
glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER, numSamples, GL_RGBA, WIDTH, HEIGHT);
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, renderbuffer);
glEnable (GL_MULTISAMPLE);
}
framebufferobject::framebufferobject(class texture& attachedtex, bool withdepthbuffer)
: id(0), depthbuf_id(0), mytex(attachedtex), bound(false)
{
if (!supported())
throw std::runtime_error("frame buffer objects are not supported!");
// create and bind depth buffer if requested
if (withdepthbuffer) {
glGenRenderbuffersEXT(1, &depthbuf_id);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, depthbuf_id);
glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT,
mytex.get_gl_width(), mytex.get_gl_height());
}
// create and bind FBO
glGenFramebuffersEXT(1, &id);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, id);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
GL_TEXTURE_2D, mytex.get_opengl_name(), 0);
// attach depth buffer if requested
if (withdepthbuffer) {
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT,
GL_RENDERBUFFER_EXT, depthbuf_id);
}
GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
if(status != GL_FRAMEBUFFER_COMPLETE_EXT) {
destroy();
log_warning( "FBO initialization check failed: " << init_failure_reason( status ) );
throw std::runtime_error("FBO initialization check failed");
}
// unbind for now
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0);
}
void intiFB(int w, int h)
{
////////framebuffer init
if(glIsTexture(tex))
{
glDeleteRenderbuffers(1, &depth_rb);
glDeleteTextures(1,&tex);
glDeleteFramebuffers(1, &fb);
}
glEnable(GL_DEPTH_TEST);
glClearColor(0.0, 0.0, 0.0, 1.0);
glGenFramebuffers(1, &fb);
glGenTextures(1, &tex);
glGenRenderbuffers(1, &depth_rb);
glBindFramebuffer(GL_FRAMEBUFFER, fb);
// init texture
glBindTexture(GL_TEXTURE_2D, tex);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, texWidth, texHeight, 0,
GL_RGBA, GL_FLOAT, NULL);
GET_GLERROR(NULL);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
GL_TEXTURE_2D, tex, 0);
GET_GLERROR(0);
// initialize depth renderbuffer
glBindRenderbufferEXT(GL_RENDERBUFFER, depth_rb);
glRenderbufferStorageEXT(GL_RENDERBUFFER, GL_DEPTH_COMPONENT24, texWidth, texHeight);
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
GL_RENDERBUFFER, depth_rb);
glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, tex, 0);
GET_GLERROR(0);
CheckFramebufferStatus();
glBindFramebufferEXT(GL_FRAMEBUFFER, 0);
}
