void CGLContextGLX::QueryExtensions()
{
m_extensions = " ";
m_extensions += (const char*)glXQueryExtensionsString(m_dpy, m_nScreen);
m_extensions += " ";
CLog::Log(LOGDEBUG, "GLX_EXTENSIONS:%s", m_extensions.c_str());
if (IsExtSupported("GLX_SGI_video_sync"))
m_glXWaitVideoSyncSGI = (int (*)(int, int, unsigned int*))glXGetProcAddress((const GLubyte*)"glXWaitVideoSyncSGI");
else
m_glXWaitVideoSyncSGI = NULL;
if (IsExtSupported("GLX_SGI_video_sync"))
m_glXGetVideoSyncSGI = (int (*)(unsigned int*))glXGetProcAddress((const GLubyte*)"glXGetVideoSyncSGI");
else
m_glXGetVideoSyncSGI = NULL;
if (IsExtSupported("GLX_MESA_swap_control"))
m_glXSwapIntervalMESA = (int (*)(int))glXGetProcAddress((const GLubyte*)"glXSwapIntervalMESA");
else
m_glXSwapIntervalMESA = NULL;
if (IsExtSupported("GLX_EXT_swap_control"))
m_glXSwapIntervalEXT = (PFNGLXSWAPINTERVALEXTPROC)glXGetProcAddress((const GLubyte*)"glXSwapIntervalEXT");
else
m_glXSwapIntervalEXT = NULL;
}
bool CWinSystemX11GL::CreateNewWindow(const CStdString& name, bool fullScreen, RESOLUTION_INFO& res, PHANDLE_EVENT_FUNC userFunction)
{
if(!CWinSystemX11::CreateNewWindow(name, fullScreen, res, userFunction))
return false;
m_glxext = " ";
m_glxext += (const char*)glXQueryExtensionsString(m_dpy, DefaultScreen(m_dpy));
m_glxext += " ";
CLog::Log(LOGDEBUG, "GLX_EXTENSIONS:%s", m_glxext.c_str());
if (IsExtSupported("GLX_SGI_video_sync"))
m_glXWaitVideoSyncSGI = (int (*)(int, int, unsigned int*))glXGetProcAddress((const GLubyte*)"glXWaitVideoSyncSGI");
else
m_glXWaitVideoSyncSGI = NULL;
if (IsExtSupported("GLX_SGI_video_sync"))
m_glXGetVideoSyncSGI = (int (*)(unsigned int*))glXGetProcAddress((const GLubyte*)"glXGetVideoSyncSGI");
else
m_glXGetVideoSyncSGI = NULL;
if (IsExtSupported("GLX_MESA_swap_control"))
m_glXSwapIntervalMESA = (int (*)(int))glXGetProcAddress((const GLubyte*)"glXSwapIntervalMESA");
else
m_glXSwapIntervalMESA = NULL;
if (IsExtSupported("GLX_EXT_swap_control"))
m_glXSwapIntervalEXT = (PFNGLXSWAPINTERVALEXTPROC)glXGetProcAddress((const GLubyte*)"glXSwapIntervalEXT");
else
m_glXSwapIntervalEXT = NULL;
return true;
}
bool CWinSystemX11GL::CreateNewWindow(const CStdString& name, bool fullScreen, RESOLUTION_INFO& res, PHANDLE_EVENT_FUNC userFunction)
{
if(!CWinSystemX11::CreateNewWindow(name, fullScreen, res, userFunction))
return false;
m_glxext = " ";
m_glxext += (const char*)glXQueryExtensionsString(m_dpy, DefaultScreen(m_dpy));
m_glxext += " ";
CLog::Log(LOGDEBUG, "GLX_EXTENSIONS:%s", m_glxext.c_str());
/* any time window is recreated we need new pointers */
if (IsExtSupported("GLX_OML_sync_control"))
m_glXGetSyncValuesOML = (Bool (*)(Display*, GLXDrawable, int64_t*, int64_t*, int64_t*))glXGetProcAddress((const GLubyte*)"glXGetSyncValuesOML");
else
m_glXGetSyncValuesOML = NULL;
if (IsExtSupported("GLX_OML_sync_control"))
m_glXSwapBuffersMscOML = (int64_t (*)(Display*, GLXDrawable, int64_t, int64_t, int64_t))glXGetProcAddress((const GLubyte*)"glXSwapBuffersMscOML");
else
m_glXSwapBuffersMscOML = NULL;
if (IsExtSupported("GLX_SGI_video_sync"))
m_glXWaitVideoSyncSGI = (int (*)(int, int, unsigned int*))glXGetProcAddress((const GLubyte*)"glXWaitVideoSyncSGI");
else
m_glXWaitVideoSyncSGI = NULL;
if (IsExtSupported("GLX_SGI_video_sync"))
m_glXGetVideoSyncSGI = (int (*)(unsigned int*))glXGetProcAddress((const GLubyte*)"glXGetVideoSyncSGI");
else
m_glXGetVideoSyncSGI = NULL;
if (IsExtSupported("GLX_SGI_swap_control") )
m_glXSwapIntervalSGI = (int (*)(int))glXGetProcAddress((const GLubyte*)"glXSwapIntervalSGI");
else
m_glXSwapIntervalSGI = NULL;
if (IsExtSupported("GLX_MESA_swap_control"))
m_glXSwapIntervalMESA = (int (*)(int))glXGetProcAddress((const GLubyte*)"glXSwapIntervalMESA");
else
m_glXSwapIntervalMESA = NULL;
return true;
}
bool CRenderSystemGLES::InitRenderSystem()
{
m_bVSync = false;
m_iVSyncMode = 0;
m_iSwapStamp = 0;
m_iSwapTime = 0;
m_iSwapRate = 0;
m_bVsyncInit = false;
m_maxTextureSize = 2048;
m_renderCaps = 0;
// Get the GLES version number
m_RenderVersionMajor = 0;
m_RenderVersionMinor = 0;
const char* ver = (const char*)glGetString(GL_VERSION);
if (ver != 0)
{
sscanf(ver, "%d.%d", &m_RenderVersionMajor, &m_RenderVersionMinor);
if (!m_RenderVersionMajor)
sscanf(ver, "%*s %*s %d.%d", &m_RenderVersionMajor, &m_RenderVersionMinor);
m_RenderVersion = ver;
}
// Get our driver vendor and renderer
m_RenderVendor = (const char*) glGetString(GL_VENDOR);
m_RenderRenderer = (const char*) glGetString(GL_RENDERER);
m_RenderExtensions = " ";
m_RenderExtensions += (const char*) glGetString(GL_EXTENSIONS);
m_RenderExtensions += " ";
LogGraphicsInfo();
if (IsExtSupported("GL_TEXTURE_NPOT"))
{
m_renderCaps |= RENDER_CAPS_NPOT;
}
if (IsExtSupported("GL_EXT_texture_format_BGRA8888"))
{
m_renderCaps |= RENDER_CAPS_BGRA;
}
if (IsExtSupported("GL_IMG_texture_format_BGRA8888"))
{
m_renderCaps |= RENDER_CAPS_BGRA;
}
if (IsExtSupported("GL_APPLE_texture_format_BGRA8888"))
{
m_renderCaps |= RENDER_CAPS_BGRA_APPLE;
}
m_bRenderCreated = true;
InitialiseGUIShader();
return true;
}
int setup(void)
{
GLuint major, minor;
GLint success;
GLuint model_id;
srand( (unsigned)time( NULL ) );
// Make sure required functionality is available!
if (!getGLversion( &major, &minor))
return -1;
if (major < 2)
{
printf("<!> OpenGL 2.0 or higher is required\n");
return -1;
}
windowpos = IsExtSupported("GL_ARB_window_pos");
// Make sure required functionality is available!
if (!(IsExtSupported("GL_ARB_vertex_program")))
{
printf("<!> ARB vertex program extension not supported\n");
return -1;
}
if (!(IsExtSupported("GL_ARB_fragment_program")))
{
printf("<!> ARB fragment program extension not supported\n");
return -1;
}
if (!(IsExtSupported("GL_ARB_vertex_shader")))
{
printf("<!> ARB vertex shader extension not supported\n");
return -1;
}
if (!(IsExtSupported("GL_ARB_fragment_shader")))
{
printf("<!> ARB fragment shader extension not supported\n");
return -1;
}
if (!(IsExtSupported("GL_EXT_framebuffer_object")))
{
printf("<!> Framebuffer object extension not supported\n");
return -1;
}
//Define extension prointers
glGenFramebuffersEXT = (PFNGLGENFRAMEBUFFERSEXTPROC)glXGetProcAddressARB("glGenFramebuffersEXT");
glBindFramebufferEXT = (PFNGLBINDFRAMEBUFFEREXTPROC)glXGetProcAddressARB("glBindFramebufferEXT");
glFramebufferTexture2DEXT = (PFNGLFRAMEBUFFERTEXTURE2DEXTPROC)glXGetProcAddressARB("glFramebufferTexture2DEXT");
glGenRenderbuffersEXT = (PFNGLGENRENDERBUFFERSEXTPROC)glXGetProcAddressARB("glGenRenderbuffersEXT");
glBindRenderbufferEXT = (PFNGLBINDRENDERBUFFEREXTPROC)glXGetProcAddressARB("glBindRenderbufferEXT");
glRenderbufferStorageEXT = (PFNGLRENDERBUFFERSTORAGEEXTPROC)glXGetProcAddressARB("glRenderbufferStorageEXT");
glFramebufferRenderbufferEXT = (PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC)glXGetProcAddressARB("glFramebufferRenderbufferEXT");
glDeleteFramebuffersEXT = (PFNGLDELETEFRAMEBUFFERSEXTPROC)glXGetProcAddressARB("glDeleteFramebuffersEXT");
glDeleteRenderbuffersEXT = (PFNGLDELETERENDERBUFFERSEXTPROC)glXGetProcAddressARB("glDeleteRenderbuffersEXT");
glCheckFramebufferStatusEXT = (PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC)glXGetProcAddressARB("glCheckFramebufferStatusEXT");
if ( !glGenFramebuffersEXT || !glBindFramebufferEXT ||
!glFramebufferTexture2DEXT || !glGenRenderbuffersEXT ||
!glBindRenderbufferEXT || !glRenderbufferStorageEXT ||
!glFramebufferRenderbufferEXT || !glDeleteFramebuffersEXT ||
!glDeleteRenderbuffersEXT || !glCheckFramebufferStatusEXT )
{
printf("<!> Required extension not supported\n");
return -1;
}
//Enable smooth shading
glShadeModel(GL_SMOOTH);
//Enable depth testing
glEnable(GL_DEPTH_TEST);
glPolygonOffset( scalePoly, biasPoly );
//Enable backface culling
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
glFrontFace( GL_CW );
//Background color (Ligth blue)
glClearColor(0.0f, 0.4f, 0.8f, 1.0f);
//Generate texture objects
texture_id = (GLuint *)malloc( NUM_TEXTURES * sizeof(GLuint) );
glGenTextures( NUM_TEXTURES, texture_id );
// Enable Anisotropic filtering (for 2D textures only)
if( enable_anisotropic )
{
glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &MaxAnisoLevel);
if( AnisoLevel > MaxAnisoLevel)
AnisoLevel = MaxAnisoLevel;
if( print_info )
printf("<-> %.0fX anisotropic filtering enabled\n", AnisoLevel);
}
else
AnisoLevel = 0.0f;
// Enable FSAA
if (enable_fsaa)
glEnable(GL_MULTISAMPLE);
//Load MD2 models and textures
for (model_id = 0; model_id < NUM_MODELS; ++model_id)
{
// Load the .md2 model
if ( (md2_model[model_id] = (MD2_MODEL_PTR)malloc(sizeof(MD2_MODEL))) == NULL)
{
printf("<!> Unable to allocate memory for MD2 model in %s\n", filename[3*model_id]);
return -1;
}
if ( !LoadMD2(md2_model[model_id], filename[3*model_id]) )
{
printf("<!> Unable to load MD2 model from %s\n", filename[3*model_id]);
return -1;
}
if( print_info )
printf("<-> Loaded MD2 model from \"%s\" for model #%d\n", filename[3*model_id], model_id);
// Load texture from disk
if ( !LoadImageFromDisk(md2_model[model_id]->skin, filename[3*model_id+1]) )
{
printf("<!> Unable to load texture from %s \n", filename[3*model_id+1]);
return -1;
}
if( print_info )
printf("<-> Loaded texture from \"%s\" for model #%d\n", filename[3*model_id+1], model_id);
//Set up model texture parameters
glBindTexture(GL_TEXTURE_2D, texture_id[2*model_id]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
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, md2_model[model_id]->skin->components,
md2_model[model_id]->skin->width, md2_model[model_id]->skin->height,
0, md2_model[model_id]->skin->format, GL_UNSIGNED_BYTE,
md2_model[model_id]->skin->data);
// Load normal from disk
if ( !LoadImageFromDisk(md2_model[model_id]->normal, filename[3*model_id+2]) )
{
printf("<!> Unable to load texture from %s \n", filename[3*model_id+2]);
return -1;
}
if( print_info )
printf("<-> Loaded texture from \"%s\" for model #%d\n", filename[3*model_id+2], model_id);
//Set up model texture parameters
glBindTexture(GL_TEXTURE_2D, texture_id[2*model_id+1]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
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, md2_model[model_id]->normal->components,
md2_model[model_id]->normal->width, md2_model[model_id]->normal->height,
0, md2_model[model_id]->normal->format, GL_UNSIGNED_BYTE,
md2_model[model_id]->normal->data);
}
// Load floor texture from disk
floor_texture = (IMAGE_PTR)malloc(sizeof(IMAGE));
floor_texture->data = NULL;
if ( !LoadImageFromDisk(floor_texture, filename[3*NUM_MODELS]) )
{
printf("<!> Unable to load texture from %s\n", filename[3*NUM_MODELS]);
return -1;
}
if( print_info )
printf("<-> Loaded texture from \"%s\"\n", filename[3*NUM_MODELS]);
//Set up floor texture parameters
glBindTexture(GL_TEXTURE_2D, texture_id[NUM_TEXTURES-2]);
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_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
if (enable_anisotropic)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, AnisoLevel);
glTexImage2D( GL_TEXTURE_2D, 0, floor_texture->components,
floor_texture->width, floor_texture->height,
0, floor_texture->format, GL_UNSIGNED_BYTE,
floor_texture->data);
if (floor_texture->data)
{
free(floor_texture->data);
floor_texture->data = NULL;
}
// Load floor normal map from disk
floor_texture = (IMAGE_PTR)malloc(sizeof(IMAGE));
floor_texture->data = NULL;
if ( !LoadImageFromDisk(floor_texture, filename[3*NUM_MODELS+1]) )
{
printf("<!> Unable to load texture from %s\n", filename[3*NUM_MODELS+1]);
return -1;
}
if( print_info )
printf("<-> Loaded texture from \"%s\"\n", filename[3*NUM_MODELS+1]);
//Set up floor texture parameters
glBindTexture(GL_TEXTURE_2D, texture_id[NUM_TEXTURES-1]);
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_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
if (enable_anisotropic)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, AnisoLevel);
glTexImage2D( GL_TEXTURE_2D, 0, floor_texture->components,
floor_texture->width, floor_texture->height,
0, floor_texture->format, GL_UNSIGNED_BYTE,
floor_texture->data);
if (floor_texture->data)
{
free(floor_texture->data);
floor_texture->data = NULL;
}
// Load and compile low-level shaders
glGenProgramsARB(NUM_SHADERS, ids);
if (!CompileShader(GL_VERTEX_PROGRAM_ARB, ids[0], DATA_DIR "data/shaders/light.vp"))
return -1;
if (!CompileShader(GL_FRAGMENT_PROGRAM_ARB, ids[1], DATA_DIR "data/shaders/lightMasked.fp"))
return -1;
// Create program object and compile GLSL shaders
progObj = glCreateProgramObjectARB();
if (!CompileGLSLshaders(&progObj,
DATA_DIR "data/shaders/bumpTBN_SH_VP.glsl",
DATA_DIR "data/shaders/bumpTBN_SH_FP.glsl", GL_FALSE))
return -1;
// Retrieve uniform and attributes locations
glUseProgramObjectARB(progObj);
colorMap = glGetUniformLocationARB(progObj, "colorMap");
bumpMap = glGetUniformLocationARB(progObj, "bumpMap");
shadowMap = glGetUniformLocationARB(progObj, "shadowMap");
tangent = glGetAttribLocation(progObj, "tangent");
binormal = glGetAttribLocation(progObj, "binormal");
for (model_id = 0; model_id < NUM_MODELS; ++model_id)
{
md2_model[model_id]->tangent = tangent;
md2_model[model_id]->binormal = binormal;
}
// Set texture units
glUniform1i( colorMap, 0 );
glUniform1i( bumpMap, 1 );
glUniform1i( shadowMap, 2 );
//Validate shaders
glValidateProgramARB(progObj);
glGetObjectParameterivARB(progObj, GL_OBJECT_VALIDATE_STATUS_ARB, &success);
if (!success)
{
GLbyte infoLog[MAX_INFO_LOG_SIZE];
glGetInfoLogARB(progObj, MAX_INFO_LOG_SIZE, NULL, (char *)infoLog);
printf("<!> Error in program validation\n");
printf("Info log: %s\n", infoLog);
return -1;
}
//Disable GLSL and enable low-level shaders
glUseProgramObjectARB(0);
glEnable(GL_VERTEX_PROGRAM_ARB);
glEnable(GL_FRAGMENT_PROGRAM_ARB);
glBindProgramARB(GL_VERTEX_PROGRAM_ARB, ids[0]);
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, ids[1]);
// Create FrameBuffer
if (!CreateFB( shadow_sz, &FBO, &shadow_tx ))
return -1;
//Prebuild the display lists
FList = glGenLists(1);
glNewList(FList, GL_COMPILE);
DrawGround();
glEndList();
//Init animations and kinematic state
md2_model[0]->anim_state = ANIMATION_RUN;
md2_model[0]->anim_command = ANIMATION_START;
md2_model[0]->delta_rate = 30.f;
md2_model[0]->position.x = 85.f;
md2_model[0]->position.z = 0.f;
md2_model[0]->rotation = 90.f;
md2_model[1]->anim_state = ANIMATION_RUN;
md2_model[1]->anim_command = ANIMATION_START;
md2_model[1]->delta_rate = 30.f;
md2_model[1]->position.x = 85.f;
md2_model[1]->position.z = 0.f;
md2_model[1]->rotation = 90.f;
md2_model[2]->anim_state = ANIMATION_STANDING_IDLE;
md2_model[2]->anim_command = ANIMATION_START;
// Set initial camera position and orientation
xCam = 0.0f;
yCam = 70.0f;
zCam = 200.0f;
eCam = -0.35f;
aCam = 0.0f;
lCam = 0.0f;
vCam = 0.0f;
dCam = 0.0f;
//Set initial light
aLit = 0.0f;
eLit = 0.75f;
// Initialise timer
gettimeofday(&tv, NULL);
t0 = (double)tv.tv_sec + tv.tv_usec / 1000000.0f;
t1 = t0;
t2 = t0;
return 0;
}
bool CRenderSystemGL::ResetRenderSystem(int width, int height, bool fullScreen, float refreshRate)
{
m_width = width;
m_height = height;
glClearColor( 0.0f, 0.0f, 0.0f, 0.0f );
CalculateMaxTexturesize();
CRect rect( 0, 0, width, height );
SetViewPort( rect );
glEnable(GL_TEXTURE_2D);
glEnable(GL_SCISSOR_TEST);
glMatrixProject.Clear();
glMatrixModview->LoadIdentity();
glMatrixProject->Ortho(0.0f, width-1, height-1, 0.0f, -1.0f, 1.0f);
glMatrixProject.Load();
glMatrixModview.Clear();
glMatrixModview->LoadIdentity();
glMatrixModview.Load();
glMatrixTexture.Clear();
glMatrixTexture->LoadIdentity();
glMatrixTexture.Load();
if (IsExtSupported("GL_ARB_multitexture"))
{
//clear error flags
ResetGLErrors();
GLint maxtex;
glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS_ARB, &maxtex);
//some sanity checks
GLenum error = glGetError();
if (error != GL_NO_ERROR)
{
CLog::Log(LOGERROR, "ResetRenderSystem() GL_MAX_TEXTURE_IMAGE_UNITS_ARB returned error %i", (int)error);
maxtex = 3;
}
else if (maxtex < 1 || maxtex > 32)
{
CLog::Log(LOGERROR, "ResetRenderSystem() GL_MAX_TEXTURE_IMAGE_UNITS_ARB returned invalid value %i", (int)maxtex);
maxtex = 3;
}
//reset texture matrix for all textures
for (GLint i = 0; i < maxtex; i++)
{
glActiveTextureARB(GL_TEXTURE0 + i);
glMatrixTexture.Load();
}
glActiveTextureARB(GL_TEXTURE0);
}
glBlendFunc(GL_SRC_ALPHA, GL_ONE);
glEnable(GL_BLEND); // Turn Blending On
glDisable(GL_DEPTH_TEST);
return true;
}
bool CRenderSystemGL::InitRenderSystem()
{
m_bVSync = false;
m_iVSyncMode = 0;
m_iSwapStamp = 0;
m_iSwapTime = 0;
m_iSwapRate = 0;
m_bVsyncInit = false;
m_maxTextureSize = 2048;
m_renderCaps = 0;
m_RenderExtensions = " ";
m_RenderExtensions += (const char*) glGetString(GL_EXTENSIONS);
m_RenderExtensions += " ";
LogGraphicsInfo();
// Get the GL version number
m_RenderVersionMajor = 0;
m_RenderVersionMinor = 0;
const char* ver = (const char*)glGetString(GL_VERSION);
if (ver != 0)
{
sscanf(ver, "%d.%d", &m_RenderVersionMajor, &m_RenderVersionMinor);
m_RenderVersion = ver;
}
if (IsExtSupported("GL_ARB_shading_language_100"))
{
ver = (const char*)glGetString(GL_SHADING_LANGUAGE_VERSION);
if (ver)
{
sscanf(ver, "%d.%d", &m_glslMajor, &m_glslMinor);
}
else
{
m_glslMajor = 1;
m_glslMinor = 0;
}
}
// Get our driver vendor and renderer
const char* tmpVendor = (const char*) glGetString(GL_VENDOR);
m_RenderVendor.clear();
if (tmpVendor != NULL)
m_RenderVendor = tmpVendor;
const char* tmpRenderer = (const char*) glGetString(GL_RENDERER);
m_RenderRenderer.clear();
if (tmpRenderer != NULL)
m_RenderRenderer = tmpRenderer;
// grab our capabilities
if (IsExtSupported("GL_EXT_texture_compression_s3tc"))
m_renderCaps |= RENDER_CAPS_DXT;
if (IsExtSupported("GL_ARB_texture_non_power_of_two"))
{
m_renderCaps |= RENDER_CAPS_NPOT;
if (m_renderCaps & RENDER_CAPS_DXT)
m_renderCaps |= RENDER_CAPS_DXT_NPOT;
}
//Check OpenGL quirks and revert m_renderCaps as needed
CheckOpenGLQuirks();
m_bRenderCreated = true;
return true;
}
bool CRenderSystemGL::InitRenderSystem()
{
m_bVSync = false;
m_bVsyncInit = false;
m_maxTextureSize = 2048;
m_renderCaps = 0;
// Get the GL version number
m_RenderVersionMajor = 0;
m_RenderVersionMinor = 0;
const char* ver = (const char*)glGetString(GL_VERSION);
if (ver != 0)
{
sscanf(ver, "%d.%d", &m_RenderVersionMajor, &m_RenderVersionMinor);
m_RenderVersion = ver;
}
m_RenderExtensions = " ";
if (m_RenderVersionMajor > 3 ||
(m_RenderVersionMajor == 3 && m_RenderVersionMinor >= 2))
{
GLint n;
glGetIntegerv(GL_NUM_EXTENSIONS, &n);
if (n > 0)
{
GLint i;
for (i = 0; i < n; i++)
{
m_RenderExtensions += (const char*)glGetStringi(GL_EXTENSIONS, i);
m_RenderExtensions += " ";
}
}
}
else
{
m_RenderExtensions += (const char*) glGetString(GL_EXTENSIONS);
}
m_RenderExtensions += " ";
if (IsExtSupported("GL_ARB_shading_language_100"))
{
ver = (const char*)glGetString(GL_SHADING_LANGUAGE_VERSION);
if (ver)
{
sscanf(ver, "%d.%d", &m_glslMajor, &m_glslMinor);
}
else
{
m_glslMajor = 1;
m_glslMinor = 0;
}
}
LogGraphicsInfo();
// Get our driver vendor and renderer
const char* tmpVendor = (const char*) glGetString(GL_VENDOR);
m_RenderVendor.clear();
if (tmpVendor != NULL)
m_RenderVendor = tmpVendor;
const char* tmpRenderer = (const char*) glGetString(GL_RENDERER);
m_RenderRenderer.clear();
if (tmpRenderer != NULL)
m_RenderRenderer = tmpRenderer;
// grab our capabilities
if (IsExtSupported("GL_EXT_texture_compression_s3tc"))
m_renderCaps |= RENDER_CAPS_DXT;
if (IsExtSupported("GL_ARB_texture_non_power_of_two"))
{
m_renderCaps |= RENDER_CAPS_NPOT;
if (m_renderCaps & RENDER_CAPS_DXT)
m_renderCaps |= RENDER_CAPS_DXT_NPOT;
}
//Check OpenGL quirks and revert m_renderCaps as needed
CheckOpenGLQuirks();
m_bRenderCreated = true;
if (m_RenderVersionMajor > 3 ||
(m_RenderVersionMajor == 3 && m_RenderVersionMinor >= 2))
{
glGenVertexArrays(1, &m_vertexArray);
glBindVertexArray(m_vertexArray);
}
InitialiseShader();
return true;
}
bool CRenderSystemGLES::InitRenderSystem()
{
GLint maxTextureSize;
glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxTextureSize);
m_maxTextureSize = maxTextureSize;
m_bVSync = false;
m_iVSyncMode = 0;
m_iSwapStamp = 0;
m_iSwapTime = 0;
m_iSwapRate = 0;
m_bVsyncInit = false;
m_renderCaps = 0;
// Get the GLES version number
m_RenderVersionMajor = 0;
m_RenderVersionMinor = 0;
const char* ver = (const char*)glGetString(GL_VERSION);
if (ver != 0)
{
sscanf(ver, "%d.%d", &m_RenderVersionMajor, &m_RenderVersionMinor);
if (!m_RenderVersionMajor)
sscanf(ver, "%*s %*s %d.%d", &m_RenderVersionMajor, &m_RenderVersionMinor);
m_RenderVersion = ver;
}
// Get our driver vendor and renderer
const char *tmpVendor = (const char*) glGetString(GL_VENDOR);
m_RenderVendor.clear();
if (tmpVendor != NULL)
m_RenderVendor = tmpVendor;
const char *tmpRenderer = (const char*) glGetString(GL_RENDERER);
m_RenderRenderer.clear();
if (tmpRenderer != NULL)
m_RenderRenderer = tmpRenderer;
m_RenderExtensions = " ";
const char *tmpExtensions = (const char*) glGetString(GL_EXTENSIONS);
if (tmpExtensions != NULL)
{
m_RenderExtensions += tmpExtensions;
}
m_RenderExtensions += " ";
LogGraphicsInfo();
if (IsExtSupported("GL_TEXTURE_NPOT"))
{
m_renderCaps |= RENDER_CAPS_NPOT;
}
if (IsExtSupported("GL_EXT_texture_format_BGRA8888"))
{
m_renderCaps |= RENDER_CAPS_BGRA;
}
if (IsExtSupported("GL_IMG_texture_format_BGRA8888"))
{
m_renderCaps |= RENDER_CAPS_BGRA;
}
if (IsExtSupported("GL_APPLE_texture_format_BGRA8888"))
{
m_renderCaps |= RENDER_CAPS_BGRA_APPLE;
}
if (IsExtSupported("GL_EXT_unpack_subimage"))
{
m_renderCaps |= RENDER_CAPS_EGL_SUBIMAGE;
}
m_bRenderCreated = true;
InitialiseGUIShader();
return true;
}
bool CRenderSystemGL::InitRenderSystem()
{
m_bVSync = false;
m_iVSyncMode = 0;
m_iSwapStamp = 0;
m_iSwapTime = 0;
m_iSwapRate = 0;
m_bVsyncInit = false;
m_maxTextureSize = 2048;
m_renderCaps = 0;
#if defined(TARGET_DARWIN)
// init glew library
GLenum err = glewInit();
if (GLEW_OK != err)
{
// Problem: glewInit failed, something is seriously wrong
CLog::Log(LOGERROR, "InitRenderSystem() glewInit returned %i: %s", err, glewGetErrorString(err));
return false;
}
#endif
m_RenderExtensions = " ";
m_RenderExtensions += (const char*) glGetString(GL_EXTENSIONS);
m_RenderExtensions += " ";
LogGraphicsInfo();
// Get the GL version number
m_RenderVersionMajor = 0;
m_RenderVersionMinor = 0;
const char* ver = (const char*)glGetString(GL_VERSION);
if (ver != 0)
{
sscanf(ver, "%d.%d", &m_RenderVersionMajor, &m_RenderVersionMinor);
m_RenderVersion = ver;
}
if (IsExtSupported("GL_ARB_shading_language_100"))
{
ver = (const char*)glGetString(GL_SHADING_LANGUAGE_VERSION);
if (ver)
{
sscanf(ver, "%d.%d", &m_glslMajor, &m_glslMinor);
}
else
{
m_glslMajor = 1;
m_glslMinor = 0;
}
}
// Get our driver vendor and renderer
const char* tmpVendor = (const char*) glGetString(GL_VENDOR);
m_RenderVendor.clear();
if (tmpVendor != NULL)
m_RenderVendor = tmpVendor;
const char* tmpRenderer = (const char*) glGetString(GL_RENDERER);
m_RenderRenderer.clear();
if (tmpRenderer != NULL)
m_RenderRenderer = tmpRenderer;
// grab our capabilities
if (IsExtSupported("GL_EXT_texture_compression_s3tc"))
m_renderCaps |= RENDER_CAPS_DXT;
if (IsExtSupported("GL_ARB_texture_non_power_of_two"))
{
m_renderCaps |= RENDER_CAPS_NPOT;
if (m_renderCaps & RENDER_CAPS_DXT)
m_renderCaps |= RENDER_CAPS_DXT_NPOT;
}
//Check OpenGL quirks and revert m_renderCaps as needed
CheckOpenGLQuirks();
m_bRenderCreated = true;
return true;
}
bool CRenderSystemGL::InitRenderSystem()
{
m_bVSync = false;
m_bVsyncInit = false;
m_maxTextureSize = 2048;
// Get the GL version number
m_RenderVersionMajor = 0;
m_RenderVersionMinor = 0;
const char* ver = (const char*)glGetString(GL_VERSION);
if (ver != 0)
{
sscanf(ver, "%d.%d", &m_RenderVersionMajor, &m_RenderVersionMinor);
m_RenderVersion = ver;
}
m_RenderExtensions = " ";
if (m_RenderVersionMajor > 3 ||
(m_RenderVersionMajor == 3 && m_RenderVersionMinor >= 2))
{
GLint n;
glGetIntegerv(GL_NUM_EXTENSIONS, &n);
if (n > 0)
{
GLint i;
for (i = 0; i < n; i++)
{
m_RenderExtensions += (const char*)glGetStringi(GL_EXTENSIONS, i);
m_RenderExtensions += " ";
}
}
}
else
{
m_RenderExtensions += (const char*) glGetString(GL_EXTENSIONS);
}
m_RenderExtensions += " ";
ver = (const char*)glGetString(GL_SHADING_LANGUAGE_VERSION);
if (ver)
{
sscanf(ver, "%d.%d", &m_glslMajor, &m_glslMinor);
}
else
{
m_glslMajor = 1;
m_glslMinor = 0;
}
LogGraphicsInfo();
// Get our driver vendor and renderer
const char* tmpVendor = (const char*) glGetString(GL_VENDOR);
m_RenderVendor.clear();
if (tmpVendor != NULL)
m_RenderVendor = tmpVendor;
const char* tmpRenderer = (const char*) glGetString(GL_RENDERER);
m_RenderRenderer.clear();
if (tmpRenderer != NULL)
m_RenderRenderer = tmpRenderer;
m_bRenderCreated = true;
if (m_RenderVersionMajor > 3 ||
(m_RenderVersionMajor == 3 && m_RenderVersionMinor >= 2))
{
glGenVertexArrays(1, &m_vertexArray);
glBindVertexArray(m_vertexArray);
}
InitialiseShader();
if (IsExtSupported("GL_ARB_texture_non_power_of_two"))
m_supportsNPOT = true;
else
m_supportsNPOT = false;
return true;
}
