Show initialize.cpp syntax highlighted
/***************************************************************************
intialize.cpp - Initialize OpenGL
-------------------
begin : Tue Apr 1 2003
copyright : (C) 2003 by Reality Rift Studios
email : mattias@realityrift.com
last modify date : Mon Oct 4 2004
last modify : GLSL manager
l.m. copyright : (C) 2004 by Arcadia Design s.r.l.
email : Dario Deledda (penguindark@hotmail.com)
***************************************************************************
The contents of this file are subject to the Mozilla Public License Version
1.1 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.mozilla.org/MPL/
Software distributed under the License is distributed on an "AS IS" basis,
WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
for the specific language governing rights and limitations under the
License.
The Original Code is the NeoEngine, NeoDevOpenGL, initialize.cpp
The Initial Developer of the Original Code is Mattias Jansson.
Portions created by Mattias Jansson are Copyright (C) 2003
Reality Rift Studios. All Rights Reserved.
Contributors: Dario Deledda (penguindark@hotmail.com)
***************************************************************************/
#define NEEDGDI
#include "device.h"
#include "pixelbuffer.h"
#include "pixelbuffertarget.h"
#include "framebuffertarget.h"
#include "textureunit.h"
#include "extensions.h"
#include "vertexbuffermanager-nobs.h"
#include "vertexbuffermanager-glsl.h"
#include "shader.h"
#include <neoengine/nemath.h>
#include <neoengine/config.h>
#include <neoengine/logstream.h>
#ifdef __APPLE__
# include <mach-o/dyld.h>
#endif
#if defined( WIN32 )
#include "nvidia/NvCpl.h"
#endif
using namespace std;
using namespace NeoEngine;
namespace NeoOGL
{
bool Device::Initialize( const RenderCaps *pkCaps )
{
bool bDisableVBO = false;
//Set active render target
SetRenderTarget( FRAMEBUFFER );
if( !m_pkCurTarget || !m_pkCurTarget->IsActive() )
{
neolog << LogLevel( ERROR ) << "*** unable to initialize render device: unable to activate frame buffer render target" << endl;
return false;
}
m_kExtensions.ResetAll();
string strVendor = (const char*)glGetString( GL_VENDOR );
string strVersion = (const char*)glGetString( GL_VERSION );
string strExt = (const char*)glGetString( GL_EXTENSIONS );
neolog << LogLevel( INFO ) << "Opened device @ <" << GetWidth() << "x" << GetHeight() << "x" << GetBPP() << "> "
<< ( m_kWindow.m_kCaps.IsSet( RenderCaps::FULLSCREEN ) ? "fullscreen" : "windowed mode" ) << endl
<< "Device Information:" << endl
<< "--------------------------" << endl
<< "Vendor: " << strVendor << endl
<< "Renderer: " << glGetString( GL_RENDERER ) << endl
<< "Version: " << strVersion << endl
<< "Extensions: " << strExt << endl;
//Get data
glGetIntegerv( GL_MAX_TEXTURE_SIZE, (GLint*)&m_uiMaxTextureSize );
neolog << "Max texture size: " << m_uiMaxTextureSize << endl;
#if defined( LINUX )
// Selectively disable ARB vertex buffer objects on broken ATI systems
if( strVendor == "ATI Technologies Inc." && strVersion == "1.3 (X4.3.0-3.7.6)" )
bDisableVBO = true;
#endif
#if defined( WIN32 )
if( strExt.find( "WGL_EXT_extensions_string" ) < string::npos )
{
neolog << LogLevel( INFO ) << "WGL_EXT_extensions_string supported" << endl;
//Get WGL extension string proc
if( !( fpneowglGetExtensionsStringEXT = (fpwglGetExtensionsStringEXTProc)GetProcAddress( "wglGetExtensionsStringEXT" ) ) )
neolog << LogLevel( ERROR ) << "WGL_EXT_extensions_string supported, but unable to get \"wglGetExtensionsStringEXT\" proc address" << endl;
}
else if( ( fpneowglGetExtensionsStringEXT = (fpwglGetExtensionsStringEXTProc)GetProcAddress( "wglGetExtensionsStringEXT" ) ) )
neolog << LogLevel( INFO ) << "WGL_EXT_extensions_string NOT supported, but able to get \"wglGetExtensionsStringEXT\" proc address anyway" << endl;
if( fpneowglGetExtensionsStringEXT )
{
string strWGLExt = neowglGetExtensionsStringEXT();
neolog << LogLevel( INFO ) << "WGL Extensions: " << strWGLExt << endl;
strExt += strWGLExt;
}
#endif
m_kWindow.m_kCaps.Set( RenderCaps::PIXELBUFFER );
m_kWindow.m_kCaps.Set( RenderCaps::RENDERTEXTURE );
m_pkPixelBufferTarget = new PixelBufferRenderTarget( this );
//Look for ARB Multisample
#if defined( WIN32 )
if( strExt.find( "WGL_ARB_multisample" ) < std::string::npos )
{
m_kWindow.m_kCaps.Set( RenderCaps::MULTISAMPLE );
neolog << LogLevel( INFO ) << "WGL_ARB_multisample supported" << endl;
}
#else
if( strExt.find( "GL_ARB_multisample" ) < std::string::npos )
{
m_kWindow.m_kCaps.Set( RenderCaps::MULTISAMPLE );
neolog << LogLevel( INFO ) << "GL_ARB_multisample supported" << endl;
}
#endif
//Look for SLI if NVidia and WIN32
#if defined( WIN32 )
HINSTANCE hLib = ::LoadLibrary("NVCPL.dll");
if ( hLib )
{
NvCplGetDataIntType NvCplGetDataInt = (NvCplGetDataIntType)::GetProcAddress(hLib, "NvCplGetDataInt");
if ( NvCplGetDataInt )
{
// Get video memory size
long videoRAMSize;
neolog << LogLevel( INFO ) << "Video memory size: ";
if ( NvCplGetDataInt(NVCPL_API_VIDEO_RAM_SIZE, &videoRAMSize) == FALSE)
neolog << LogLevel( ERROR ) << "Unable to retrieve" << endl;
else
neolog << LogLevel( INFO ) << videoRAMSize << "MBytes" << endl;
// Get number of GPUs and number of SLI GPUs
long numGPUs = 0L;
long numSLIGPUs = 0L;
neolog << LogLevel( INFO ) << "Number of GPUs: ";
if( NvCplGetDataInt( NVCPL_API_NUMBER_OF_GPUS, &numGPUs ) == FALSE )
neolog << LogLevel( ERROR ) << "Unable to retrieve" << endl;
else
neolog << LogLevel( INFO ) << numGPUs << endl;
neolog << LogLevel( INFO ) << "Number of GPUs in SLI mode: ";
if( NvCplGetDataInt( NVCPL_API_NUMBER_OF_SLI_GPUS, &numSLIGPUs) == FALSE )
neolog << LogLevel( ERROR ) << "Unable to retrieve" << endl;
else
neolog << LogLevel( INFO ) << numSLIGPUs << endl;
if( numSLIGPUs > 1L )
{
m_kWindow.m_kCaps.Set( RenderCaps::HWACC_SLI );
long SLIMode = 0L;
if ( NvCplGetDataInt(NVCPL_API_SLI_MULTI_GPU_RENDERING_MODE, &SLIMode ) == FALSE)
neolog << LogLevel( ERROR ) << "Unable to set up SLI!" << endl;
else
{
if( ( SLIMode & NVCPL_API_SLI_ENABLED ) != 0L)
{
neolog << LogLevel( INFO ) << "Setting SLI to AFR mode." << endl;
long newSLIMode = NVCPL_API_SLI_RENDERING_MODE_AFR;
//long newSLIMode = NVCPL_API_SLI_RENDERING_MODE_SFR;
//neolog << LogLevel( INFO ) << "Setting SLI to SFR mode." << endl;
NvCplSetDataIntType NvCplSetDataInt = (NvCplSetDataIntType)::GetProcAddress(hLib, "NvCplSetDataInt");
if( NvCplSetDataInt == 0 )
neolog << LogLevel( ERROR ) << "Unable to get a pointer to NvCplSetDataInt" << endl;
else if( NvCplSetDataInt( NVCPL_API_SLI_MULTI_GPU_RENDERING_MODE, newSLIMode ) == FALSE)
neolog << LogLevel( ERROR ) << "Unable to set up SFR SLI mode" << endl;
else
{
/*
// saving old SLI state for resetting later
newSLIMode = SLIMode & (~NVCPL_API_SLI_ENABLED); // turn off top bit;
// Query current state, should be AFR
if (NvCplGetDataInt(NVCPL_API_SLI_MULTI_GPU_RENDERING_MODE, &SLIMode) == FALSE)
printf("Unable to retrieve\n");
else
{
if ((SLIMode & NVCPL_API_SLI_RENDERING_MODE_AFR) != 0L)
printf("SLI is in AFR mode.\n");
else if ((SLIMode & NVCPL_API_SLI_RENDERING_MODE_SFR) != 0L)
printf("SLI is in SFR mode.\n");
else if ((SLIMode & NVCPL_API_SLI_RENDERING_MODE_SINGLE_GPU) != 0L)
printf("SLI is in single GPU mode.\n");
else
printf("SLI is in auto-select mode.\n");
}
// Reset to initial SLI mode
if (NvCplSetDataInt(NVCPL_API_SLI_MULTI_GPU_RENDERING_MODE, newSLIMode) == FALSE)
printf("Unable to reset SLI mode.\n");
else
printf("Reset SLI mode to initial state.\n");
*/
}
}
}
}
}
}
#endif
//Look for ARB occlusion query
if( strExt.find( "GL_ARB_occlusion_query" ) < std::string::npos )
{
neolog << LogLevel( INFO ) << "GL_ARB_occlusion_query supported" << endl;
m_kExtensions.Set( Extensions::ARB_OCCLUSION_QUERY );
fpneoglGenQueriesARB =(fpglGenQueriesARB ) GetProcAddress( "glGenQueriesARB" );
fpneoglDeleteQueriesARB =(fpglDeleteQueriesARB ) GetProcAddress( "glDeleteQueriesARB" );
fpneoglIsQueryARB =(fpglIsQueryARB ) GetProcAddress( "glIsQueryARB" );
fpneoglBeginQueryARB =(fpglBeginQueryARB ) GetProcAddress( "glBeginQueryARB" );
fpneoglEndQueryARB =(fpglEndQueryARB ) GetProcAddress( "glEndQueryARB" );
fpneoglGetQueryivARB =(fpglGetQueryivARB ) GetProcAddress( "glGetQueryivARB" );
fpneoglGetQueryObjectivARB =(fpglGetQueryObjectivARB ) GetProcAddress( "glGetQueryObjectivARB" );
fpneoglGetQueryObjectuivARB =(fpglGetQueryObjectuivARB ) GetProcAddress( "glGetQueryObjectuivARB" );
}
//Look for frame buffer texture support
if( strExt.find( "GL_EXT_framebuffer_object" ) < std::string::npos )
{
neolog << LogLevel( INFO ) << "GL_EXT_framebuffer_object supported" << endl;
m_kExtensions.Set( Extensions::EXT_FRAME_BUFFER );
m_kWindow.m_kCaps.Set( RenderCaps::FRAMEBUFFEROBJECT );
fpneoglIsRenderbufferEXT =(fpglIsRenderbufferEXT) GetProcAddress( "glIsRenderbufferEXT" );
fpneoglBindRenderbufferEXT =(fpglBindRenderbufferEXT) GetProcAddress( "glBindRenderbufferEXT" );
fpneoglDeleteRenderbuffersEXT =(fpglDeleteRenderbuffersEXT) GetProcAddress( "glDeleteRenderbuffersEXT" );
fpneoglGenRenderbuffersEXT =(fpglGenRenderbuffersEXT) GetProcAddress( "glGenRenderbuffersEXT" );
fpneoglRenderbufferStorageEXT =(fpglRenderbufferStorageEXT) GetProcAddress( "glRenderbufferStorageEXT" );
fpneoglGetRenderbufferParameterivEXT =(fpglGetRenderbufferParameterivEXT) GetProcAddress( "glGetRenderbufferParameterivEXT" );
fpneoglIsFramebufferEXT =(fpglIsFramebufferEXT) GetProcAddress( "glIsFramebufferEXT" );
fpneoglBindFramebufferEXT =(fpglBindFramebufferEXT) GetProcAddress( "glBindFramebufferEXT" );
fpneoglDeleteFramebuffersEXT =(fpglDeleteFramebuffersEXT) GetProcAddress( "glDeleteFramebuffersEXT" );
fpneoglGenFramebuffersEXT =(fpglGenFramebuffersEXT) GetProcAddress( "glGenFramebuffersEXT" );
fpneoglCheckFramebufferStatusEXT =(fpglCheckFramebufferStatusEXT)GetProcAddress( "glCheckFramebufferStatusEXT" );
fpneoglFramebufferTexture1DEXT =(fpglFramebufferTexture1DEXT) GetProcAddress( "glFramebufferTexture1DEXT" );
fpneoglFramebufferTexture2DEXT =(fpglFramebufferTexture2DEXT) GetProcAddress( "glFramebufferTexture2DEXT" );
fpneoglFramebufferTexture3DEXT =(fpglFramebufferTexture3DEXT) GetProcAddress( "glFramebufferTexture3DEXT" );
fpneoglFramebufferRenderbufferEXT =(fpglFramebufferRenderbufferEXT) GetProcAddress( "glFramebufferRenderbufferEXT" );
fpneoglGetFramebufferAttachmentParameterivEXT =(fpglGetFramebufferAttachmentParameterivEXT)GetProcAddress( "glGetFramebufferAttachmentParameterivEXT" );
fpneoglGenerateMipmapEXT =(fpglGenerateMipmapEXT) GetProcAddress( "glGenerateMipmapEXT" );
fpneoglDrawBuffersEXT =(fpglDrawBuffersEXT) GetProcAddress( "glDrawBuffers" );
// FBO multitarget support test
#define MAX_COLOR_ATTACHMENTS_EXT 0x8CDF
GLint maxbuffers=0;
glGetIntegerv(MAX_COLOR_ATTACHMENTS_EXT , &maxbuffers);
neolog << LogLevel( INFO ) << "Max FBO's Texture Targets supported: "<< maxbuffers << endl;
this->m_uiNumFBOTargets = maxbuffers;
}
//Look for depth texture support
if( strExt.find( "GL_ARB_depth_texture" ) < std::string::npos )
{
neolog << LogLevel( INFO ) << "GL_ARB_depth_texture supported" << endl;
m_kExtensions.Set( Extensions::ARB_DEPTH_TEXTURE );
}
//Look for floating point texture support
if( strExt.find( "GL_ARB_texture_float") < std::string::npos )
{
neolog << LogLevel( INFO ) << "GL_ARB_texture_float supported" << endl;
m_kExtensions.Set( Extensions::ARB_FLOAT_TEXTURE );
}
//Look for non power of two texture support
if( strExt.find( "GL_ARB_texture_non_power_of_two") < std::string::npos )
{
neolog << LogLevel( INFO ) << "GL_ARB_texture_non_power_of_two supported" << endl;
m_kExtensions.Set( Extensions::ARB_NP2_TEXTURE );
}
//Look for rectangular texture support
if( strExt.find( "GL_ARB_texture_rectangle") < std::string::npos )
{
neolog << LogLevel( INFO ) << "GL_ARB_texture_rectangle supported" << endl;
m_kExtensions.Set( Extensions::ARB_RECT_TEXTURE );
}
//Look for fog coordinate support
if( strExt.find( "GL_EXT_fog_coord" ) < std::string::npos )
{
neolog << LogLevel( INFO ) << "GL_EXT_fog_coord supported" << endl;
m_kExtensions.Set( Extensions::EXT_FOG_COORD );
fpneoglFogCoordfEXT = (fpglFogCoordfEXTProc) GetProcAddress( "glFogCoordfEXT" );
fpneoglFogCoorddEXT = (fpglFogCoorddEXTProc) GetProcAddress( "glFogCoorddEXT" );
fpneoglFogCoordfvEXT = (fpglFogCoordfvEXTProc) GetProcAddress( "glFogCoordfvEXT" );
fpneoglFogCoorddvEXT = (fpglFogCoorddvEXTProc) GetProcAddress( "glFogCoorddvEXT" );
fpneoglFogCoordPointerEXT = (fpglFogCoordPointerEXTProc)GetProcAddress( "glFogCoordPointerEXT" );
m_kWindow.m_kCaps.Set( RenderCaps::FOGCOORD );
}
//Look for transpose matrix
if( strExt.find( "GL_ARB_transpose_matrix" ) < std::string::npos )
{
neolog << LogLevel( INFO ) << "GL_ARB_transpose_matrix supported" << endl;
m_kExtensions.Set( Extensions::ARB_TRANSPOSE_MATRIX );
fpneoglLoadMatrixfARB = (fpglLoadMatrixfARBProc)GetProcAddress( "glLoadTransposeMatrixfARB" );
fpneoglMultMatrixfARB = (fpglMultMatrixfARBProc)GetProcAddress( "glMultTransposeMatrixfARB" );
}
//Look for cubemap support
if( ( strExt.find( "GL_ARB_texture_cube_map" ) < std::string::npos ) || ( strExt.find( "GL_EXT_texture_cube_map" ) < std::string::npos ) )
{
//Extensions ARB and EXT are identical
neolog << LogLevel( INFO ) << "GL_ARB_texture_cube_map supported" << endl;
m_kExtensions.Set( Extensions::ARB_TEXTURE_CUBE_MAP );
m_kWindow.m_kCaps.Set( RenderCaps::CUBEMAP );
}
//Look for multitexturing
if( strExt.find( "GL_ARB_multitexture" ) < strExt.length() )
{
//multitexture is supported
glGetIntegerv( GL_MAX_TEXTURE_UNITS_ARB, (GLint*)&m_uiNumTMUs );
#if !defined(__APPLE__)
fpneoglActiveTextureARB = (fpglActiveTextureARBProc )GetProcAddress( "glActiveTextureARB" );
fpneoglClientActiveTextureARB = (fpglClientActiveTextureARBProc)GetProcAddress( "glClientActiveTextureARB" );
#else
//Symbols defined as default on OSX
#endif
neolog << LogLevel( INFO ) << "Texture units: " << m_uiNumTMUs << " [arb]" << endl;
m_kWindow.m_kCaps.Set( RenderCaps::MULTITEXTURE );
}
else
{
neolog << LogLevel( INFO ) << "No ARB multitexturing" << endl;
m_uiNumTMUs = 1;
}
m_kWindow.m_kCaps.Set( RenderCaps::MULTITEXTURE_GROUP | ( ( m_uiNumTMUs << RenderCaps::MULTITEXTURE_UNITS_SHIFT ) & RenderCaps::MULTITEXTURE_UNITS_MASK ) );
//Look for ADD texenv support
if( strExt.find( "GL_ARB_texture_env_add" ) < std::string::npos )
{
neolog << LogLevel( INFO ) << "GL_ARB_texture_env_add supported" << endl;
m_kExtensions.Set( Extensions::ARB_TEXENV_ADD );
}
else if( strExt.find( "GL_EXT_texture_env_add" ) < std::string::npos )
{
neolog << LogLevel( INFO ) << "GL_EXT_texture_env_add supported" << endl;
m_kExtensions.Set( Extensions::ARB_TEXENV_ADD );
}
//Look for COMBINE texenv support
if( strExt.find( "GL_ARB_texture_env_combine" ) < std::string::npos )
{
neolog << LogLevel( INFO ) << "GL_ARB_texture_env_combine supported" << endl;
m_kExtensions.Set( Extensions::ARB_TEXENV_COMBINE );
m_kWindow.m_kCaps.Set( RenderCaps::BLENDMODE_FACTOR );
m_kWindow.m_kCaps.Set( RenderCaps::BLENDMODE_INTERPOLATE );
}
m_ppkTMU = new TextureUnit*[ m_uiNumTMUs ];
for( unsigned int uiUnit = 0; uiUnit < m_uiNumTMUs; ++uiUnit )
{
if( m_uiNumTMUs > 1 )
TextureUnit::SetActiveTextureUnit( uiUnit );
glDisableClientState( GL_TEXTURE_COORD_ARRAY );
if( m_kExtensions.IsSupported( Extensions::ARB_TEXENV_COMBINE ) )
m_ppkTMU[ uiUnit ] = new TextureUnitCombine( this, uiUnit );
else
m_ppkTMU[ uiUnit ] = new TextureUnit( this, uiUnit );
}
if( m_uiNumTMUs > 1 )
TextureUnit::SetActiveTextureUnit( 0 );
neolog << LogLevel( INFO ) << " texture units setup" << endl;
neoglCheckError( "*** Error setting up texture units: " );
//Check for automatic mipmap generation
if( strExt.find( "GL_SGIS_generate_mipmap" ) < std::string::npos )
{
neolog << LogLevel( INFO ) << "GL_SGIS_generate_mipmap supported" << endl;
m_kExtensions.Set( Extensions::SGIS_GENERATE_MIPMAP );
glHint( GL_GENERATE_MIPMAP_HINT, GL_NICEST );
}
// Check for anisotropic filtering
if( strExt.find( "GL_EXT_texture_filter_anisotropic" ) < std::string::npos )
{
GLint iMax;
glGetIntegerv( GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &iMax );
neolog << LogLevel( INFO ) << "GL_EXT_texture_filter_anisotropic supported (max: " << iMax << ")" << endl;
m_kExtensions.Set( Extensions::EXT_TEXTURE_FILTER_ANISOTROPIC );
}
// Check for point parameters
if( strExt.find( "GL_ARB_point_parameters" ) < std::string::npos )
{
bool bPointParameters = true;
neolog << LogLevel( INFO ) << "GL_ARB_point_parameters supported" << endl;
if( !( fpneoglPointParameterfARB = (fpglPointParameterfARB) GetProcAddress( "glPointParameterfARB" ) ) )
{
neolog << "GL_ARB_point_parameters supported, but unable to get \"glPointParameterfARB\" address" << endl;
bPointParameters = false;
}
if( !( fpneoglPointParameterfvARB = (fpglPointParameterfvARB) GetProcAddress( "glPointParameterfvARB" ) ) )
{
neolog << "GL_ARB_point_parameters supported, but unable to get \"glPointParameterfvARB\" address" << endl;
bPointParameters = false;
}
if( bPointParameters )
{
m_kExtensions.Set( Extensions::ARB_POINT_PARAMETERS );
}
}
// Check for point sprites
if( strExt.find( "GL_ARB_point_sprite" ) < std::string::npos )
{
neolog << LogLevel( INFO ) << "GL_ARB_point_sprite supported" << endl;
m_kExtensions.Set( Extensions::ARB_POINT_SPRITE );
// Our point sprites feature requires both ARB_point_sprite and ARB_point_parameters
if( m_kExtensions.IsSupported( Extensions::ARB_POINT_PARAMETERS ) )
{
m_kWindow.m_kCaps.Set( RenderCaps::POINTSPRITES );
}
}
if( strExt.find( "GL_ARB_vertex_buffer_object" ) < string::npos && !bDisableVBO )
{
neolog << LogLevel( INFO ) << "GL_ARB_vertex_buffer_object supported" << endl;
fpneoglBindBufferARB = (fpglBindBufferARB )GetProcAddress( "glBindBufferARB" );
fpneoglDeleteBuffersARB = (fpglDeleteBuffersARB )GetProcAddress( "glDeleteBuffersARB" );
fpneoglGenBuffersARB = (fpglGenBuffersARB )GetProcAddress( "glGenBuffersARB" );
fpneoglIsBufferARB = (fpglIsBufferARB )GetProcAddress( "glIsBufferARB" );
fpneoglBufferDataARB = (fpglBufferDataARB )GetProcAddress( "glBufferDataARB" );
fpneoglBufferSubDataARB = (fpglBufferSubDataARB )GetProcAddress( "glBufferSubDataARB" );
fpneoglGetBufferSubDataARB = (fpglGetBufferSubDataARB )GetProcAddress( "glGetBufferSubDataARB" );
fpneoglMapBufferARB = (fpglMapBufferARB )GetProcAddress( "glMapBufferARB" );
fpneoglUnmapBufferARB = (fpglUnmapBufferARB )GetProcAddress( "glUnmapBufferARB" );
fpneoglGetBufferParameterivARB = (fpglGetBufferParameterivARB)GetProcAddress( "glGetBufferParameterivARB" );
fpneoglGetBufferPointervARB = (fpglGetBufferPointervARB )GetProcAddress( "glGetBufferPointervARB" );
m_kExtensions.Set( Extensions::ARB_VERTEX_BUFFER_OBJECT );
if ( strExt.find( "GL_ARB_shading_language_" ) < string::npos){
m_pkVertexBufferManager = new VertexBufferManagerGLSL( this );
}
if( m_pkVertexBufferManager && !m_pkVertexBufferManager->SetSize( m_uiVertexStorageSize ) )
//if( !m_pkVertexBufferManager->SetSize( m_uiVertexStorageSize ) )
delete m_pkVertexBufferManager, m_pkVertexBufferManager = 0;
neoglCheckError( "*** Error setting up ARB vertex buffer extension: " );
}
if( !m_pkVertexBufferManager )
m_pkVertexBufferManager = new VertexBufferManagerNOBS( this );
if( !Shader::s_veVSPriority.size() )
{
//Setup default priority
Shader::s_veVSPriority.push_back( Shader::NEPT_GL_GLSLV );
Shader::s_veVSPriority.push_back( Shader::NEPT_GL_ARBVP_1 );
}
vector< Shader::SHADERTARGET >::iterator peTarget = Shader::s_veVSPriority.begin();
vector< Shader::SHADERTARGET >::iterator peTargetEnd = Shader::s_veVSPriority.end();
for( ; peTarget != peTargetEnd; ++peTarget )
{
if( ( (*peTarget) == Shader::NEPT_GL_GLSLV || (*peTarget) == Shader::NEPT_GL_GLSLF || (*peTarget) == Shader::NEPT_GL_GLSLP)
&& ( strExt.find( "GL_ARB_shader_objects" ) < string::npos )
&& ( strExt.find( "GL_ARB_fragment_shader" ) < string::npos )
&& ( strExt.find( "GL_ARB_vertex_shader" ) < string::npos )
&& ( strExt.find( "GL_ARB_shading_language_100" ) < string::npos )
)
{
neolog << LogLevel( INFO ) << "GL_ARB_shading_language_100 supported" << endl;
//Look for geometry shader support
if ( strExt.find( "GL_EXT_geometry_shader4") < std::string::npos )
{
neolog << LogLevel( INFO ) << "GL_EXT_geometry_shader4 supported" << endl;
m_kExtensions.Set( Extensions::ARB_GEOMETRY_SHADER );
fpneoglProgramParameteriEXT = ( fpglProgramParameteriEXT) GetProcAddress( "glProgramParameteriEXT" );
fpneoglFramebufferTextureEXT = ( fpglFramebufferTextureEXT) GetProcAddress( "glFramebufferTextureEXT" );
fpneoglFramebufferTextureLayerEXT = ( fpglFramebufferTextureLayerEXT) GetProcAddress( "glFramebufferTextureLayerEXT" );
fpneoglFramebufferTextureFaceEXT = ( fpglFramebufferTextureFaceEXT) GetProcAddress( "glFramebufferTextureFaceEXT" );
}
//======================
fpneoglGetObjectParameterivARB = ( fpglGetObjectParameterivARB) GetProcAddress( "glGetObjectParameterivARB" );
fpneoglGetInfoLogARB = ( fpglGetInfoLogARB ) GetProcAddress( "glGetInfoLogARB" );
fpneoglCreateProgramObjectARB = ( fpglCreateProgramObjectARB ) GetProcAddress( "glCreateProgramObjectARB" );
fpneoglCreateShaderObjectARB = ( fpglCreateShaderObjectARB ) GetProcAddress( "glCreateShaderObjectARB" );
fpneoglCreateProgramObjectARB = ( fpglCreateProgramObjectARB ) GetProcAddress( "glCreateProgramObjectARB" );
fpneoglCreateShaderObjectARB = ( fpglCreateShaderObjectARB ) GetProcAddress( "glCreateShaderObjectARB" );
fpneoglDeleteObjectARB = ( fpglDeleteObjectARB ) GetProcAddress( "glDeleteObjectARB" );
fpneoglDetachObjectARB = ( fpglDetachObjectARB ) GetProcAddress( "glDetachObjectARB" );
fpneoglAttachObjectARB = ( fpglAttachObjectARB ) GetProcAddress( "glAttachObjectARB" );
fpneoglShaderSourceARB = ( fpglShaderSourceARB ) GetProcAddress( "glShaderSourceARB" );
fpneoglCompileShaderARB = ( fpglCompileShaderARB ) GetProcAddress( "glCompileShaderARB" );
fpneoglLinkProgramARB = ( fpglLinkProgramARB ) GetProcAddress( "glLinkProgramARB" );
fpneoglGetInfoLogARB = ( fpglGetInfoLogARB ) GetProcAddress( "glGetInfoLogARB" );
fpneoglUseProgramObjectARB = ( fpglUseProgramObjectARB ) GetProcAddress( "glUseProgramObjectARB" );
fpneoglGetObjectParameterivARB = ( fpglGetObjectParameterivARB ) GetProcAddress( "glGetObjectParameterivARB" );
fpneoglGetObjectParameterfvARB = ( fpglGetObjectParameterfvARB ) GetProcAddress( "glGetObjectParameterfvARB" );
fpneoglGetUniformLocationARB = ( fpglGetUniformLocationARB ) GetProcAddress( "glGetUniformLocationARB" );
fpneoglGetAttribLocationARB = ( fpglGetAttribLocationARB ) GetProcAddress( "glGetAttribLocationARB" );
fpneoglBindAttribLocationARB = ( fpglBindAttribLocationARB ) GetProcAddress( "glBindAttribLocationARB" );
fpneoglUniform1fARB = ( fpglUniform1fARB ) GetProcAddress( "glUniform1fARB" );
fpneoglUniform2fARB = ( fpglUniform2fARB ) GetProcAddress( "glUniform2fARB" );
fpneoglUniform3fARB = ( fpglUniform3fARB ) GetProcAddress( "glUniform3fARB" );
fpneoglUniform4fARB = ( fpglUniform4fARB ) GetProcAddress( "glUniform4fARB" );
fpneoglUniform1iARB = ( fpglUniform1iARB ) GetProcAddress( "glUniform1iARB" );
fpneoglUniform2iARB = ( fpglUniform2iARB ) GetProcAddress( "glUniform2iARB" );
fpneoglUniform3iARB = ( fpglUniform3iARB ) GetProcAddress( "glUniform3iARB" );
fpneoglUniform4iARB = ( fpglUniform4iARB ) GetProcAddress( "glUniform4iARB" );
fpneoglUniform1fvARB = ( fpglUniform1fvARB ) GetProcAddress( "glUniform1fvARB" );
fpneoglUniform2fvARB = ( fpglUniform2fvARB ) GetProcAddress( "glUniform2fvARB" );
fpneoglUniform3fvARB = ( fpglUniform3fvARB ) GetProcAddress( "glUniform3fvARB" );
fpneoglUniform4fvARB = ( fpglUniform4fvARB ) GetProcAddress( "glUniform4fvARB" );
fpneoglUniform1ivARB = ( fpglUniform1ivARB ) GetProcAddress( "glUniform1ivARB" );
fpneoglUniform2ivARB = ( fpglUniform2ivARB ) GetProcAddress( "glUniform2ivARB" );
fpneoglUniform3ivARB = ( fpglUniform3ivARB ) GetProcAddress( "glUniform3ivARB" );
fpneoglUniform4ivARB = ( fpglUniform4ivARB ) GetProcAddress( "glUniform4ivARB" );
fpneoglVertexAttrib4fvARB = ( fpglVertexAttrib4fvARB ) GetProcAddress( "glVertexAttrib4fvARB" );
fpneoglVertexAttrib3fvARB = ( fpglVertexAttrib3fvARB ) GetProcAddress( "glVertexAttrib3fvARB" );
fpneoglVertexAttrib2fvARB = ( fpglVertexAttrib2fvARB ) GetProcAddress( "glVertexAttrib2fvARB" );
fpneoglVertexAttrib1fvARB = ( fpglVertexAttrib1fvARB ) GetProcAddress( "glVertexAttrib1fvARB" );
fpneoglVertexAttrib4fARB = ( fpglVertexAttrib4fARB ) GetProcAddress( "glVertexAttrib4fARB" );
fpneoglVertexAttrib3fARB = ( fpglVertexAttrib3fARB ) GetProcAddress( "glVertexAttrib3fARB" );
fpneoglVertexAttrib2fARB = ( fpglVertexAttrib2fARB ) GetProcAddress( "glVertexAttrib2fARB" );
fpneoglVertexAttrib1fARB = ( fpglVertexAttrib1fARB ) GetProcAddress( "glVertexAttrib1fARB" );
fpneoglUniformMatrix2fvARB = ( fpglUniformMatrix2fvARB ) GetProcAddress( "glUniformMatrix2fvARB" );
fpneoglUniformMatrix3fvARB = ( fpglUniformMatrix3fvARB ) GetProcAddress( "glUniformMatrix3fvARB" );
fpneoglUniformMatrix4fvARB = ( fpglUniformMatrix4fvARB ) GetProcAddress( "glUniformMatrix4fvARB" );
//======================
fpneoglVertexAttribPointerARB = (fpglVertexAttribPointerARB )GetProcAddress( "glVertexAttribPointerARB" );
fpneoglEnableVertexAttribArrayARB = (fpglEnableVertexAttribArrayARB )GetProcAddress( "glEnableVertexAttribArrayARB" );
fpneoglDisableVertexAttribArrayARB = (fpglDisableVertexAttribArrayARB)GetProcAddress( "glDisableVertexAttribArrayARB" );
fpneoglProgramStringARB = (fpglProgramStringARB )GetProcAddress( "glProgramStringARB" );
fpneoglBindProgramARB = (fpglBindProgramARB )GetProcAddress( "glBindProgramARB" );
fpneoglDeleteProgramsARB = (fpglDeleteProgramsARB )GetProcAddress( "glDeleteProgramsARB" );
fpneoglGenProgramsARB = (fpglGenProgramsARB )GetProcAddress( "glGenProgramsARB" );
fpneoglProgramEnvParameter4fARB = (fpglProgramEnvParameter4fARB )GetProcAddress( "glProgramEnvParameter4fARB" );
fpneoglProgramEnvParameter4fvARB = (fpglProgramEnvParameter4fvARB )GetProcAddress( "glProgramEnvParameter4fvARB" );
fpneoglProgramLocalParameter4fARB = (fpglProgramLocalParameter4fARB )GetProcAddress( "glProgramLocalParameter4fARB" );
fpneoglProgramLocalParameter4fvARB = (fpglProgramLocalParameter4fvARB)GetProcAddress( "glProgramLocalParameter4fvARB" );
fpneoglGetProgramivARB = (fpglGetProgramivARB )GetProcAddress( "glGetProgramivARB" );
m_kExtensions.Set( Extensions::ARB_SHADING_LANGUAGE_100 );
m_kExtensions.Set( Extensions::ARB_VERTEX_PROGRAM );
m_kExtensions.Set( Extensions::ARB_FRAGMENT_PROGRAM );
m_kExtensions.Set( Extensions::ARB_SHADER_OBJECTS );
Shader::s_eVSTarget = Shader::NEPT_GL_GLSLV;
// add ARB_VERTEX_PROGRAM support
m_kExtensions.Set( Extensions::ARB_VERTEX_PROGRAM );
m_kExtensions.Set( Extensions::ARB_FRAGMENT_PROGRAM );
m_kExtensions.Set( Extensions::ARB_FRAGMENT_PROGRAM );
break;
} else
if( ( (*peTarget) == Shader::NEPT_GL_ARBVP_1 ) && ( strExt.find( "GL_ARB_vertex_program" ) < string::npos ) )
{
neolog << LogLevel( INFO ) << "GL_ARB_vertex_program supported" << endl;
fpneoglVertexAttribPointerARB = (fpglVertexAttribPointerARB )GetProcAddress( "glVertexAttribPointerARB" );
fpneoglEnableVertexAttribArrayARB = (fpglEnableVertexAttribArrayARB )GetProcAddress( "glEnableVertexAttribArrayARB" );
fpneoglDisableVertexAttribArrayARB = (fpglDisableVertexAttribArrayARB)GetProcAddress( "glDisableVertexAttribArrayARB" );
fpneoglProgramStringARB = (fpglProgramStringARB )GetProcAddress( "glProgramStringARB" );
fpneoglBindProgramARB = (fpglBindProgramARB )GetProcAddress( "glBindProgramARB" );
fpneoglDeleteProgramsARB = (fpglDeleteProgramsARB )GetProcAddress( "glDeleteProgramsARB" );
fpneoglGenProgramsARB = (fpglGenProgramsARB )GetProcAddress( "glGenProgramsARB" );
fpneoglProgramEnvParameter4fARB = (fpglProgramEnvParameter4fARB )GetProcAddress( "glProgramEnvParameter4fARB" );
fpneoglProgramEnvParameter4fvARB = (fpglProgramEnvParameter4fvARB )GetProcAddress( "glProgramEnvParameter4fvARB" );
fpneoglProgramLocalParameter4fARB = (fpglProgramLocalParameter4fARB )GetProcAddress( "glProgramLocalParameter4fARB" );
fpneoglProgramLocalParameter4fvARB = (fpglProgramLocalParameter4fvARB)GetProcAddress( "glProgramLocalParameter4fvARB" );
fpneoglGetProgramivARB = (fpglGetProgramivARB )GetProcAddress( "glGetProgramivARB" );
m_kExtensions.Set( Extensions::ARB_VERTEX_PROGRAM );
Shader::s_eVSTarget = Shader::NEPT_GL_ARBVP_1;
break;
}
}
if( Shader::s_eVSTarget != Shader::NOTSUPPORTED )
m_kWindow.m_kCaps.Set( RenderCaps::VERTEXSHADER );
if( !Shader::s_veFSPriority.size() )
{
//Setup default priority
Shader::s_veFSPriority.push_back( Shader::NEPT_GL_GLSLF );
Shader::s_veFSPriority.push_back( Shader::NEPT_GL_ARBFP_1 );
Shader::s_veFSPriority.push_back( Shader::NEPT_GL_NVRC_2 );
Shader::s_veFSPriority.push_back( Shader::NEPT_GL_NVRC );
Shader::s_veFSPriority.push_back( Shader::NEPT_GL_ATIFS );
}
peTarget = Shader::s_veFSPriority.begin();
peTargetEnd = Shader::s_veFSPriority.end();
for( ; peTarget != peTargetEnd; ++peTarget )
{
if( ( (*peTarget) == Shader::NEPT_GL_GLSLF ) && ( strExt.find( "GL_ARB_fragment_shader" ) < string::npos ) )
{
neolog << LogLevel( INFO ) << "GL_ARB_fragment_shader supported" << endl;
fpneoglProgramStringARB = (fpglProgramStringARB )GetProcAddress( "glProgramStringARB" );
fpneoglBindProgramARB = (fpglBindProgramARB )GetProcAddress( "glBindProgramARB" );
fpneoglDeleteProgramsARB = (fpglDeleteProgramsARB )GetProcAddress( "glDeleteProgramsARB" );
fpneoglGenProgramsARB = (fpglGenProgramsARB )GetProcAddress( "glGenProgramsARB" );
fpneoglProgramEnvParameter4fARB = (fpglProgramEnvParameter4fARB )GetProcAddress( "glProgramEnvParameter4fARB" );
fpneoglProgramEnvParameter4fvARB = (fpglProgramEnvParameter4fvARB )GetProcAddress( "glProgramEnvParameter4fvARB" );
fpneoglProgramLocalParameter4fARB = (fpglProgramLocalParameter4fARB )GetProcAddress( "glProgramLocalParameter4fARB" );
fpneoglProgramLocalParameter4fvARB = (fpglProgramLocalParameter4fvARB)GetProcAddress( "glProgramLocalParameter4fvARB" );
fpneoglGetProgramivARB = (fpglGetProgramivARB )GetProcAddress( "glGetProgramivARB" );
m_kExtensions.Set( Extensions::ARB_SHADING_LANGUAGE_100 );
m_kExtensions.Set( Extensions::ARB_VERTEX_PROGRAM );
m_kExtensions.Set( Extensions::ARB_FRAGMENT_PROGRAM );
m_kExtensions.Set( Extensions::ARB_SHADER_OBJECTS );
Shader::s_eFSTarget = Shader::NEPT_GL_GLSLF;
// add ARB_FRAGMENT_PROGRAM support
m_kExtensions.Set( Extensions::ARB_FRAGMENT_PROGRAM );
break;
} else
if( ( (*peTarget) == Shader::NEPT_GL_ARBFP_1 ) && ( strExt.find( "GL_ARB_fragment_program" ) < string::npos ) )
{
neolog << LogLevel( INFO ) << "GL_ARB_fragment_program supported" << endl;
fpneoglProgramStringARB = (fpglProgramStringARB )GetProcAddress( "glProgramStringARB" );
fpneoglBindProgramARB = (fpglBindProgramARB )GetProcAddress( "glBindProgramARB" );
fpneoglDeleteProgramsARB = (fpglDeleteProgramsARB )GetProcAddress( "glDeleteProgramsARB" );
fpneoglGenProgramsARB = (fpglGenProgramsARB )GetProcAddress( "glGenProgramsARB" );
fpneoglProgramEnvParameter4fARB = (fpglProgramEnvParameter4fARB )GetProcAddress( "glProgramEnvParameter4fARB" );
fpneoglProgramEnvParameter4fvARB = (fpglProgramEnvParameter4fvARB )GetProcAddress( "glProgramEnvParameter4fvARB" );
fpneoglProgramLocalParameter4fARB = (fpglProgramLocalParameter4fARB )GetProcAddress( "glProgramLocalParameter4fARB" );
fpneoglProgramLocalParameter4fvARB = (fpglProgramLocalParameter4fvARB)GetProcAddress( "glProgramLocalParameter4fvARB" );
fpneoglGetProgramivARB = (fpglGetProgramivARB )GetProcAddress( "glGetProgramivARB" );
m_kExtensions.Set( Extensions::ARB_FRAGMENT_PROGRAM );
Shader::s_eFSTarget = Shader::NEPT_GL_ARBFP_1;
break;
}
else if( ( ( (*peTarget) == Shader::NEPT_GL_NVRC ) || ( (*peTarget) == Shader::NEPT_GL_NVRC_2 ) ) && ( ( strExt.find( "GL_NV_register_combiners" ) < string::npos ) || ( strExt.find( "GL_NV_register_combiners2" ) < string::npos ) ) )
{
neolog << LogLevel( INFO ) << "GL_NV_register_combiners supported" << endl;
fpneoglCombinerParameterfvNV = (fpglCombinerParameterfvNV)GetProcAddress( "glCombinerParameterfvNV" );
fpneoglCombinerParameterfNV = (fpglCombinerParameterfNV )GetProcAddress( "glCombinerParameterfNV" );
fpneoglCombinerParameterivNV = (fpglCombinerParameterivNV)GetProcAddress( "glCombinerParameterivNV" );
fpneoglCombinerParameteriNV = (fpglCombinerParameteriNV )GetProcAddress( "glCombinerParameteriNV" );
fpneoglCombinerInputNV = (fpglCombinerInputNV )GetProcAddress( "glCombinerInputNV" );
fpneoglCombinerOutputNV = (fpglCombinerOutputNV )GetProcAddress( "glCombinerOutputNV" );
fpneoglFinalCombinerInputNV = (fpglFinalCombinerInputNV )GetProcAddress( "glFinalCombinerInputNV" );
if( strExt.find( "GL_NV_register_combiners2" ) < string::npos )
{
neolog << LogLevel( INFO ) << "GL_NV_register_combiners2 supported" << endl;
fpneoglCombinerStageParameterfvNV = (fpglCombinerStageParameterfvNV)GetProcAddress( "glCombinerStageParameterfvNV" );
m_kExtensions.Set( Extensions::NV_REGISTER_COMBINERS2 );
Shader::s_eFSTarget = Shader::NEPT_GL_NVRC_2;
}
else
{
m_kExtensions.Set( Extensions::NV_REGISTER_COMBINERS );
Shader::s_eFSTarget = Shader::NEPT_GL_NVRC;
}
break;
}
else if( ( (*peTarget) == Shader::NEPT_GL_ATIFS ) && ( ( strExt.find( "GL_ATI_fragment_shader" ) < string::npos ) || ( strExt.find( "GL_ATI_text_fragment_shader" ) < string::npos ) ) )
{
neolog << LogLevel( INFO ) << "GL_ATI_fragment_shader supported" << endl;
fpneoglGenFragmentShadersATI = (fpglGenFragmentShadersATI )GetProcAddress( "glGenFragmentShadersATI" );
fpneoglBindFragmentShaderATI = (fpglBindFragmentShaderATI )GetProcAddress( "glBindFragmentShaderATI" );
fpneoglDeleteFragmentShaderATI = (fpglDeleteFragmentShaderATI )GetProcAddress( "glDeleteFragmentShaderATI" );
fpneoglBeginFragmentShaderATI = (fpglBeginFragmentShaderATI )GetProcAddress( "glBeginFragmentShaderATI" );
fpneoglEndFragmentShaderATI = (fpglEndFragmentShaderATI )GetProcAddress( "glEndFragmentShaderATI" );
fpneoglPassTexCoordATI = (fpglPassTexCoordATI )GetProcAddress( "glPassTexCoordATI" );
fpneoglSampleMapATI = (fpglSampleMapATI )GetProcAddress( "glSampleMapATI" );
fpneoglColorFragmentOp1ATI = (fpglColorFragmentOp1ATI )GetProcAddress( "glColorFragmentOp1ATI" );
fpneoglColorFragmentOp2ATI = (fpglColorFragmentOp2ATI )GetProcAddress( "glColorFragmentOp2ATI" );
fpneoglColorFragmentOp3ATI = (fpglColorFragmentOp3ATI )GetProcAddress( "glColorFragmentOp3ATI" );
fpneoglAlphaFragmentOp1ATI = (fpglAlphaFragmentOp1ATI )GetProcAddress( "glAlphaFragmentOp1ATI" );
fpneoglAlphaFragmentOp2ATI = (fpglAlphaFragmentOp2ATI )GetProcAddress( "glAlphaFragmentOp2ATI" );
fpneoglAlphaFragmentOp3ATI = (fpglAlphaFragmentOp3ATI )GetProcAddress( "glAlphaFragmentOp3ATI" );
fpneoglSetFragmentShaderConstantATI = (fpglSetFragmentShaderConstantATI)GetProcAddress( "glSetFragmentShaderConstantATI" );
m_kExtensions.Set( Extensions::ATI_FRAGMENT_SHADER );
Shader::s_eFSTarget = Shader::NEPT_GL_ATIFS;
break;
}
}
if( Shader::s_eFSTarget != Shader::NOTSUPPORTED )
m_kWindow.m_kCaps.Set( RenderCaps::FRAGMENTSHADER );
neoglCheckError( "*** Error in extension initialization: " );
glEnable(GL_MULTISAMPLE_ARB);
glGetIntegerv( GL_MAX_LIGHTS, (GLint*)&m_uiMaxLights );
neolog << LogLevel( INFO ) << "[" << m_uiMaxLights << "] max lights" << endl;
if( m_kWindow.m_kCaps.IsSet( RenderCaps::DOUBLEBUFFER ) )
glDrawBuffer( GL_BACK );
glShadeModel( GL_SMOOTH );
glLightModeli( GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE );
glLightModeli( GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE );
glLightModeli( GL_LIGHT_MODEL_COLOR_CONTROL, GL_SINGLE_COLOR );
glHint( GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST );
glClearStencil( 0 );
glClearDepth( 1.0f );
glDepthMask( GL_TRUE );
glEnable( GL_CULL_FACE );
glFrontFace( GL_CCW );
glCullFace( GL_BACK );
glBlendFunc( GL_ONE, GL_ZERO );
glEnable( GL_BLEND );
glDisable( GL_LIGHT0 );
glDisable( GL_LIGHTING );
glEnable( GL_DEPTH_TEST );
glDepthFunc( GL_LEQUAL );
glDepthMask( GL_TRUE );
if( m_kWindow.m_kCaps.IsSet( RenderCaps::STENCILBUFFER ) )
glEnable( GL_STENCIL_TEST );
else
glDisable( GL_STENCIL_TEST );
glStencilOp( GL_KEEP, GL_KEEP, GL_KEEP );
//glColorMaterial( GL_FRONT_AND_BACK, GL_DIFFUSE );
glDisable( GL_COLOR_MATERIAL );
glColor3f( 1.0f, 1.0f, 1.0f );
glDisable( GL_TEXTURE_2D );
glEnableClientState( GL_VERTEX_ARRAY );
if( pkCaps && pkCaps->IsSet( RenderCaps::NORMALIZATION ) )
{
glEnable( GL_NORMALIZE );
m_kWindow.m_kCaps.Set( RenderCaps::NORMALIZATION );
}
else
glDisable( GL_NORMALIZE );
//Get default light from config repository
float fAmb = 0.3f;
if( Core::Get()->GetConfig() )
Core::Get()->GetConfig()->GetValue( "ambientlight", &fAmb );
float fDefLight[4] = { fAmb, fAmb, fAmb, 1.0f };
glLightModelfv( GL_LIGHT_MODEL_AMBIENT, fDefLight );
SetViewport( 0, 0, GetWidth(), GetHeight() );
m_kPerspectiveProjection.BuildProjection( m_kViewport );
m_kOrthographicProjection.BuildProjection( m_kViewport );
SetPerspectiveProjection();
m_pkDefaultMaterial = new Material( "__defmat", Core::Get()->GetMaterialManager() );
//Setup modelview transformation matrix
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
neoglCheckError( "*** Error in context state setup: " );
//Clear buffers
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT );
neoglCheckError( "*** Error in clearing buffers: " );
//dario
this->m_kWindow.m_uiFsaa=0;
m_bZbufferRender=false;
m_bSMapRender=false;
m_bSMapGLSL=false;
m_pkShadowMapTxt=0;
SMshaderGLSL=0;
frag_counter=-1;
return true;
}
void *Device::GetProcAddress( const char* pszName )
{
if( !pszName )
return 0;
#if defined (WIN32)
return (void*)wglGetProcAddress( pszName );
#elif defined (POSIX)
// Prepend a '_' for the Unix C symbol mangling convention
string strSymbol = "_"; strSymbol += pszName;
return (void*)neoglXGetProcAddressARB( (GLubyte*)pszName );
#elif defined (__APPLE__)
// Prepend a '_' for the Unix C symbol mangling convention
NSSymbol symbol;
string strSymbolName = "_"; strSymbolName += pszName;
symbol = 0;
if( NSIsSymbolNameDefined( strSymbolName.c_str() ) )
symbol = NSLookupAndBindSymbol( strSymbolName.c_str() );
return( symbol ? NSAddressOfSymbol( symbol ) : 0 );
#else
# error "Platform unimplemented"
#endif
}
}; // namespace NeoOGL
See more files for this project here