/*
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();
}