Paranoia2_original/cl_dll/render/gl_framebuffer.cpp

628 lines
21 KiB
C++

/*
gl_framebuffer.cpp - framebuffer implementation class
Copyright (C) 2014 Uncle Mike
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
*/
#include "hud.h"
#include "cl_util.h"
#include "gl_local.h"
#include <mathlib.h>
#include <stringlib.h>
static gl_drawbuffer_t gl_drawbuffers[MAX_FRAMEBUFFERS];
static int gl_num_drawbuffers;
/*
==================
GL_AllocDrawbuffer
==================
*/
gl_drawbuffer_t *GL_AllocDrawbuffer( const char *name, int width, int height, int depth )
{
gl_drawbuffer_t *fbo;
int i;
if( !GL_Support( R_FRAMEBUFFER_OBJECT ))
return NULL;
// find a free FBO slot
for( i = 0, fbo = gl_drawbuffers; i < gl_num_drawbuffers; i++, fbo++ )
if( !fbo->name[0] ) break;
if( i == gl_num_drawbuffers )
{
if( gl_num_drawbuffers == MAX_FRAMEBUFFERS )
HOST_ERROR( "GL_AllocDrawBuffer: MAX_FRAMEBUFFERS limit exceeds\n" );
gl_num_drawbuffers++;
}
if( !GL_Support( R_ARB_TEXTURE_NPOT_EXT ))
{
width = NearestPOW( width, true );
height = NearestPOW( height, true );
}
// fill it in
Q_strncpy( fbo->name, name, sizeof( fbo->name ));
// make sure it's fit in limits
fbo->width = Q_min( glConfig.max_2d_texture_size, width );
fbo->height = Q_min( glConfig.max_2d_texture_size, height );
fbo->depth = depth;
// generate the drawbuffer
pglGenFramebuffers( 1, &fbo->id );
return fbo;
}
/*
==================
GL_ResizeDrawbuffer
==================
*/
void GL_ResizeDrawbuffer( gl_drawbuffer_t *fbo, int width, int height, int depth )
{
ASSERT( fbo != NULL );
// fill it in
fbo->width = width;
fbo->height = height;
fbo->depth = depth;
}
/*
==================
GL_AttachColorTextureToFBO
==================
*/
void GL_AttachColorTextureToFBO( gl_drawbuffer_t *fbo, int texture, int colorIndex, int index )
{
GLuint target = RENDER_GET_PARM( PARM_TEX_TARGET, texture );
GLuint format = RENDER_GET_PARM( PARM_TEX_GLFORMAT, texture );
GLint width = RENDER_GET_PARM( PARM_TEX_WIDTH, texture );
GLint height = RENDER_GET_PARM( PARM_TEX_HEIGHT, texture );
GLint depth = RENDER_GET_PARM( PARM_TEX_DEPTH, texture );
if( target == GL_TEXTURE_2D )
{
// set the texture
fbo->colortarget[colorIndex] = texture;
// if the drawbuffer has been resized
if( width != fbo->width || height != fbo->height )
{
// check the dimensions
if( fbo->width > glConfig.max_2d_texture_size || fbo->height > glConfig.max_2d_texture_size )
HOST_ERROR( "GL_AttachColorTextureToFBO: size exceeds hardware limits (%i > %i or %i > %i)\n",
fbo->width, glConfig.max_2d_texture_size, fbo->height, glConfig.max_2d_texture_size );
// reallocate the texture
GL_UpdateTexSize( texture, fbo->width, fbo->height, fbo->depth );
GL_BindTexture( GL_KEEP_UNIT, texture );
// need to refresh real FBO size with possible hardware limitations
fbo->width = RENDER_GET_PARM( PARM_TEX_WIDTH, texture );
fbo->height = RENDER_GET_PARM( PARM_TEX_HEIGHT, texture );
pglTexImage2D( target, 0, format, fbo->width, fbo->height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL );
}
// Bind the drawbuffer
GL_BindDrawbuffer( fbo );
// Set up the color attachment
pglFramebufferTexture2D( GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT + colorIndex, GL_TEXTURE_2D, texture, 0 );
}
else if( target == GL_TEXTURE_CUBE_MAP_ARB )
{
// set the texture
fbo->colortarget[colorIndex] = texture;
// if the drawbuffer has been resized
if( width != fbo->width || height != fbo->height )
{
// check the dimensions
if( fbo->width > glConfig.max_cubemap_size || fbo->height > glConfig.max_cubemap_size )
HOST_ERROR( "GL_AttachColorTextureToFBO: size exceeds hardware limits (%i > %i or %i > %i)\n",
fbo->width, glConfig.max_cubemap_size, fbo->height, glConfig.max_cubemap_size );
// reallocate the texture
GL_UpdateTexSize( texture, fbo->width, fbo->height, fbo->depth );
GL_BindTexture( GL_KEEP_UNIT, texture );
// need to refresh real FBO size with possible hardware limitations
fbo->width = RENDER_GET_PARM( PARM_TEX_WIDTH, texture );
fbo->height = RENDER_GET_PARM( PARM_TEX_HEIGHT, texture );
pglTexImage2D( GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB, 0, format, fbo->width, fbo->height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL );
pglTexImage2D( GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB, 0, format, fbo->width, fbo->height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL );
pglTexImage2D( GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB, 0, format, fbo->width, fbo->height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL );
pglTexImage2D( GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB, 0, format, fbo->width, fbo->height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL );
pglTexImage2D( GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB, 0, format, fbo->width, fbo->height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL );
pglTexImage2D( GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB, 0, format, fbo->width, fbo->height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL );
}
// bind the drawbuffer
GL_BindDrawbuffer( fbo );
// set up the color attachment
pglFramebufferTexture2D( GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT + colorIndex, GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB + index, texture, 0 );
}
else if( target == GL_TEXTURE_2D_ARRAY_EXT )
{
// Set the texture
fbo->colortarget[colorIndex] = texture;
// if the drawbuffer has been resized
if( width != fbo->width || height != fbo->height || depth != fbo->depth )
{
// check the dimensions
if( fbo->width > glConfig.max_2d_texture_size || fbo->height > glConfig.max_2d_texture_size || fbo->depth > glConfig.max_2d_texture_layers )
HOST_ERROR( "GL_AttachColorTextureToFBO: size exceeds hardware limits (%i > %i or %i > %i or %i > %i)\n",
fbo->width, glConfig.max_2d_texture_size, fbo->height, glConfig.max_2d_texture_size, fbo->depth, glConfig.max_2d_texture_layers );
// reallocate the texture
GL_UpdateTexSize( texture, fbo->width, fbo->height, fbo->depth );
GL_BindTexture( GL_KEEP_UNIT, texture );
// need to refresh real FBO size with possible hardware limitations
fbo->width = RENDER_GET_PARM( PARM_TEX_WIDTH, texture );
fbo->height = RENDER_GET_PARM( PARM_TEX_HEIGHT, texture );
fbo->depth = RENDER_GET_PARM( PARM_TEX_DEPTH, texture );
pglTexImage3D( target, 0, format, fbo->width, fbo->height, fbo->depth, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL );
}
// bind the drawbuffer
GL_BindDrawbuffer( fbo );
// Set up the color attachment
pglFramebufferTextureLayer( GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT + colorIndex, texture, 0, index );
}
else if( target == GL_TEXTURE_3D )
{
// Set the texture
fbo->colortarget[colorIndex] = texture;
// if the drawbuffer has been resized
if( width != fbo->width || height != fbo->height || depth != fbo->depth )
{
// check the dimensions
if( fbo->width > glConfig.max_3d_texture_size || fbo->height > glConfig.max_3d_texture_size || fbo->depth > glConfig.max_3d_texture_size )
HOST_ERROR( "GL_AttachColorTextureToFBO: size exceeds hardware limits (%i > %i or %i > %i or %i > %i)\n",
fbo->width, glConfig.max_3d_texture_size, fbo->height, glConfig.max_3d_texture_size, fbo->depth, glConfig.max_3d_texture_size );
// reallocate the texture
GL_UpdateTexSize( texture, fbo->width, fbo->height, fbo->depth );
GL_BindTexture( GL_KEEP_UNIT, texture );
// need to refresh real FBO size with possible hardware limitations
fbo->width = RENDER_GET_PARM( PARM_TEX_WIDTH, texture );
fbo->height = RENDER_GET_PARM( PARM_TEX_HEIGHT, texture );
fbo->depth = RENDER_GET_PARM( PARM_TEX_DEPTH, texture );
pglTexImage3D( target, 0, format, fbo->width, fbo->height, fbo->depth, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL );
}
// bind the drawbuffer
GL_BindDrawbuffer( fbo );
// Set up the color attachment
pglFramebufferTexture3D( GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT + colorIndex, GL_TEXTURE_3D, texture, 0, index );
}
else
{
HOST_ERROR( "GL_AttachColorTextureToFBO: bad texture target (%i)\n", target );
}
}
/*
==================
GL_AttachDepthTextureToFBO
==================
*/
void GL_AttachDepthTextureToFBO( gl_drawbuffer_t *fbo, int texture, int index )
{
GLuint target = RENDER_GET_PARM( PARM_TEX_TARGET, texture );
GLuint format = RENDER_GET_PARM( PARM_TEX_GLFORMAT, texture );
GLint width = RENDER_GET_PARM( PARM_TEX_WIDTH, texture );
GLint height = RENDER_GET_PARM( PARM_TEX_HEIGHT, texture );
GLint depth = RENDER_GET_PARM( PARM_TEX_DEPTH, texture );
if( target == GL_TEXTURE_2D )
{
// set the texture
fbo->depthtarget = texture;
// if the drawbuffer has been resized
if( width != fbo->width || height != fbo->height )
{
// check the dimensions
if( fbo->width > glConfig.max_2d_texture_size || fbo->height > glConfig.max_2d_texture_size )
HOST_ERROR( "GL_AttachDepthTextureToFBO: size exceeds hardware limits (%i > %i or %i > %i)\n",
fbo->width, glConfig.max_2d_texture_size, fbo->height, glConfig.max_2d_texture_size );
// reallocate the texture
GL_UpdateTexSize( texture, fbo->width, fbo->height, fbo->depth );
GL_BindTexture( GL_KEEP_UNIT, texture );
// need to refresh real FBO size with possible hardware limitations
fbo->width = RENDER_GET_PARM( PARM_TEX_WIDTH, texture );
fbo->height = RENDER_GET_PARM( PARM_TEX_HEIGHT, texture );
pglTexImage2D( target, 0, format, fbo->width, fbo->height, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, NULL );
}
// Bind the drawbuffer
GL_BindDrawbuffer( fbo );
// Set up the color attachment
pglFramebufferTexture2D( GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, texture, 0 );
}
else if( target == GL_TEXTURE_CUBE_MAP_ARB )
{
// set the texture
fbo->depthtarget = texture;
// if the drawbuffer has been resized
if( width != fbo->width || height != fbo->height )
{
// check the dimensions
if( fbo->width > glConfig.max_cubemap_size || fbo->height > glConfig.max_cubemap_size )
HOST_ERROR( "GL_AttachDepthTextureToFBO: size exceeds hardware limits (%i > %i or %i > %i)\n",
fbo->width, glConfig.max_cubemap_size, fbo->height, glConfig.max_cubemap_size );
// reallocate the texture
GL_UpdateTexSize( texture, fbo->width, fbo->height, fbo->depth );
GL_BindTexture( GL_KEEP_UNIT, texture );
// need to refresh real FBO size with possible hardware limitations
fbo->width = RENDER_GET_PARM( PARM_TEX_WIDTH, texture );
fbo->height = RENDER_GET_PARM( PARM_TEX_HEIGHT, texture );
pglTexImage2D( GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB, 0, format, fbo->width, fbo->height, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, NULL );
pglTexImage2D( GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB, 0, format, fbo->width, fbo->height, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, NULL );
pglTexImage2D( GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB, 0, format, fbo->width, fbo->height, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, NULL );
pglTexImage2D( GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB, 0, format, fbo->width, fbo->height, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, NULL );
pglTexImage2D( GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB, 0, format, fbo->width, fbo->height, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, NULL );
pglTexImage2D( GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB, 0, format, fbo->width, fbo->height, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, NULL );
}
// bind the drawbuffer
GL_BindDrawbuffer( fbo );
// set up the color attachment
pglFramebufferTexture2D( GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB + index, texture, 0 );
}
else if( target == GL_TEXTURE_2D_ARRAY_EXT )
{
// Set the texture
fbo->depthtarget = texture;
// if the drawbuffer has been resized
if( width != fbo->width || height != fbo->height || depth != fbo->depth )
{
// check the dimensions
if( fbo->width > glConfig.max_2d_texture_size || fbo->height > glConfig.max_2d_texture_size || fbo->depth > glConfig.max_2d_texture_layers )
HOST_ERROR( "GL_AttachDepthTextureToFBO: size exceeds hardware limits (%i > %i or %i > %i or %i > %i)\n",
fbo->width, glConfig.max_2d_texture_size, fbo->height, glConfig.max_2d_texture_size, fbo->depth, glConfig.max_2d_texture_layers );
// reallocate the texture
GL_UpdateTexSize( texture, fbo->width, fbo->height, fbo->depth );
GL_BindTexture( GL_KEEP_UNIT, texture );
// need to refresh real FBO size with possible hardware limitations
fbo->width = RENDER_GET_PARM( PARM_TEX_WIDTH, texture );
fbo->height = RENDER_GET_PARM( PARM_TEX_HEIGHT, texture );
fbo->depth = RENDER_GET_PARM( PARM_TEX_DEPTH, texture );
pglTexImage3D( target, 0, format, fbo->width, fbo->height, fbo->depth, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, NULL );
}
// bind the drawbuffer
GL_BindDrawbuffer( fbo );
// Set up the color attachment
pglFramebufferTextureLayer( GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, texture, 0, index );
}
else
{
HOST_ERROR( "GL_AttachDepthTextureToFBO: bad texture target (%i)\n", target );
}
}
/*
==================
GL_CheckFBOStatus
==================
*/
void GL_CheckFBOStatus( gl_drawbuffer_t *fbo )
{
const char *string;
int status;
// bind the drawbuffer
GL_BindDrawbuffer( fbo );
// check the framebuffer status
status = pglCheckFramebufferStatus( GL_FRAMEBUFFER_EXT );
if( status == GL_FRAMEBUFFER_COMPLETE_EXT )
return;
switch( status )
{
case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT:
string = "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT";
break;
case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT:
string = "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT";
break;
case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT:
string = "GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER";
break;
case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT:
string = "GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER";
break;
case GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT:
string = "GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE";
break;
case GL_FRAMEBUFFER_UNSUPPORTED_EXT:
string = "GL_FRAMEBUFFER_UNSUPPORTED";
break;
case GL_FRAMEBUFFER_UNDEFINED_EXT:
string = "GL_FRAMEBUFFER_UNDEFINED";
break;
default:
string = "UNKNOWN STATUS";
break;
}
HOST_ERROR( "GL_CheckFBOStatus: %s for '%s'\n", string, fbo->name );
}
/*
==================
GL_FreeDrawbuffers
==================
*/
void GL_FreeDrawbuffers( void )
{
gl_drawbuffer_t *fbo;
// unbind the drawbuffer
GL_BindDrawbuffer( NULL );
// delete all the drawbuffers
for( int i = 0; i < gl_num_drawbuffers; i++ )
{
fbo = &gl_drawbuffers[i];
pglDeleteFramebuffers( 1, &fbo->id );
}
// NOTE: let the engine release attached textures
memset( gl_drawbuffers, 0, sizeof( gl_drawbuffers ));
gl_num_drawbuffers = 0;
}
CFrameBuffer :: CFrameBuffer( void )
{
m_iFrameWidth = m_iFrameHeight = 0;
m_iFrameBuffer = m_iDepthBuffer = 0;
m_iTexture = m_iAttachment = 0;
m_bAllowFBO = false;
}
CFrameBuffer :: ~CFrameBuffer( void )
{
// NOTE: static case will be failed
Free();
}
int CFrameBuffer :: m_iBufferNum = 0;
bool CFrameBuffer :: Init( FBO_TYPE type, GLuint width, GLuint height, GLuint flags )
{
Free(); // release old buffer
m_iFlags = flags;
if( !GL_Support( R_ARB_TEXTURE_NPOT_EXT ))
SetBits( m_iFlags, FBO_MAKEPOW );
if( FBitSet( m_iFlags, FBO_MAKEPOW ))
{
width = NearestPOW( width, true );
height = NearestPOW( height, true );
}
// clamp size to hardware limits
if( type == FBO_CUBE )
{
m_iFrameWidth = bound( 0, width, glConfig.max_cubemap_size );
m_iFrameHeight = bound( 0, height, glConfig.max_cubemap_size );
}
else
{
m_iFrameWidth = bound( 0, width, glConfig.max_2d_texture_size );
m_iFrameHeight = bound( 0, height, glConfig.max_2d_texture_size );
}
if( !m_iFrameWidth || !m_iFrameHeight )
{
ALERT( at_error, "CFrameBuffer( %i x %i ) invalid size\n", m_iFrameWidth, m_iFrameHeight );
return false;
}
// create FBO texture
if( !FBitSet( m_iFlags, FBO_NOTEXTURE ))
{
int texFlags = (TF_NOMIPMAP|TF_CLAMP);
if( type == FBO_CUBE )
SetBits( texFlags, TF_CUBEMAP );
else if( type == FBO_DEPTH )
SetBits( texFlags, TF_DEPTHMAP );
if( !FBitSet( m_iFlags, FBO_LINEAR ))
SetBits( texFlags, TF_NEAREST );
if( FBitSet( m_iFlags, FBO_FLOAT ))
SetBits( texFlags, TF_ARB_FLOAT );
if( FBitSet( m_iFlags, FBO_RECTANGLE ))
SetBits( texFlags, TF_RECTANGLE );
if( FBitSet( m_iFlags, FBO_LUMINANCE ))
SetBits( texFlags, TF_LUMINANCE );
else if( type == FBO_COLOR )
SetBits( texFlags, TF_HAS_ALPHA );
m_iTexture = CREATE_TEXTURE( va( "*framebuffer#%i", m_iBufferNum++ ), m_iFrameWidth, m_iFrameHeight, NULL, texFlags );
}
m_bAllowFBO = (GL_Support( R_FRAMEBUFFER_OBJECT )) ? true : false;
if( m_bAllowFBO )
{
// frame buffer
pglGenFramebuffers( 1, &m_iFrameBuffer );
pglBindFramebuffer( GL_FRAMEBUFFER_EXT, m_iFrameBuffer );
// depth buffer
pglGenRenderbuffers( 1, &m_iDepthBuffer );
pglBindRenderbuffer( GL_RENDERBUFFER_EXT, m_iDepthBuffer );
pglRenderbufferStorage( GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24, m_iFrameWidth, m_iFrameHeight );
// attach depthbuffer to framebuffer
pglFramebufferRenderbuffer( GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_iDepthBuffer );
// attach the framebuffer to our texture, which may be a depth texture
if( type == FBO_DEPTH )
{
m_iAttachment = GL_DEPTH_ATTACHMENT_EXT;
pglDrawBuffer( GL_NONE );
pglReadBuffer( GL_NONE );
}
else
{
m_iAttachment = GL_COLOR_ATTACHMENT0_EXT;
pglDrawBuffer( m_iAttachment );
pglReadBuffer( m_iAttachment );
}
if( m_iTexture != 0 )
{
GLuint target = RENDER_GET_PARM( PARM_TEX_TARGET, m_iTexture );
GLuint texnum = RENDER_GET_PARM( PARM_TEX_TEXNUM, m_iTexture );
if( target == GL_TEXTURE_CUBE_MAP_ARB )
{
target = GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB;
for( int i = 0; i < 6; i++ )
pglFramebufferTexture2D( GL_FRAMEBUFFER_EXT, m_iAttachment, target + i, texnum, 0 );
}
else pglFramebufferTexture2D( GL_FRAMEBUFFER_EXT, m_iAttachment, target, texnum, 0 );
}
m_bAllowFBO = ValidateFBO();
pglBindFramebuffer( GL_FRAMEBUFFER_EXT, 0 );
}
return true;
}
void CFrameBuffer :: Free( void )
{
if( !m_bAllowFBO ) return;
if( !FBitSet( m_iFlags, FBO_NOTEXTURE ) && m_iTexture != 0 )
FREE_TEXTURE( m_iTexture );
pglDeleteRenderbuffers( 1, &m_iDepthBuffer );
pglDeleteFramebuffers( 1, &m_iFrameBuffer );
m_iFrameWidth = m_iFrameHeight = 0;
m_iFrameBuffer = m_iDepthBuffer = 0;
m_iTexture = m_iAttachment = 0;
m_bAllowFBO = false;
}
bool CFrameBuffer :: ValidateFBO( void )
{
if( !GL_Support( R_FRAMEBUFFER_OBJECT ))
return false;
// check FBO status
GLenum status = pglCheckFramebufferStatus( GL_FRAMEBUFFER_EXT );
switch( status )
{
case GL_FRAMEBUFFER_COMPLETE_EXT:
return true;
case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT:
ALERT( at_error, "CFrameBuffer: attachment is NOT complete\n" );
return false;
case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT:
ALERT( at_error, "CFrameBuffer: no image is attached to FBO\n" );
return false;
case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT:
ALERT( at_error, "CFrameBuffer: attached images have different dimensions\n" );
return false;
case GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT:
ALERT( at_error, "CFrameBuffer: color attached images have different internal formats\n" );
return false;
case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT:
ALERT( at_error, "CFrameBuffer: draw buffer incomplete\n" );
return false;
case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT:
ALERT( at_error, "CFrameBuffere: read buffer incomplete\n" );
return false;
case GL_FRAMEBUFFER_UNSUPPORTED_EXT:
ALERT( at_error, "CFrameBuffer: unsupported by current FBO implementation\n" );
return false;
default:
ALERT( at_error, "CFrameBuffer: unknown error\n" );
return false;
}
}
void CFrameBuffer :: Bind( GLuint texture, GLuint side )
{
if( !m_bAllowFBO ) return;
if( glState.frameBuffer != m_iFrameBuffer )
{
pglBindFramebuffer( GL_FRAMEBUFFER_EXT, m_iFrameBuffer );
glState.frameBuffer = m_iFrameBuffer;
}
// change texture if needs
if( FBitSet( m_iFlags, FBO_NOTEXTURE ) && texture != 0 )
{
m_iTexture = texture;
GLuint target = RENDER_GET_PARM( PARM_TEX_TARGET, m_iTexture );
GLuint texnum = RENDER_GET_PARM( PARM_TEX_TEXNUM, m_iTexture );
if( target == GL_TEXTURE_CUBE_MAP_ARB )
target = GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB + side;
pglFramebufferTexture2D( GL_FRAMEBUFFER_EXT, m_iAttachment, target, texnum, 0 );
}
ValidateFBO();
}