void createBufferObject()
{
VL_CHECK_OGL();
VL_CHECK(Has_BufferObject)
if (Has_BufferObject && handle() == 0)
{
VL_CHECK(mByteCountBufferObject == 0)
VL_glGenBuffers( 1, &mHandle ); VL_CHECK_OGL();
mByteCountBufferObject = 0;
VL_CHECK(handle())
}
/**
* Calls glBindFramebuffer(target, 0) thus activating the the framebuffer 0, that is, the normal OpenGL buffers.
* \note This method is overridden in FBORenderTarget in order to activate the appropriate framebuffer object.
*/
virtual void bindFramebuffer(EFrameBufferBind target = FBB_FRAMEBUFFER)
{
VL_CHECK_OGL()
// the base render target is the framebuffer 0, that is, the normal OpenGL buffers
VL_glBindFramebuffer(target, 0); VL_CHECK_OGL()
// bind draw buffers
bindDrawBuffers();
// bind read buffer
bindReadBuffer();
VL_CHECK_OGL()
}
inline std::string getOpenGLExtensions()
{
std::string ext;
if (Has_GL_Version_3_0||Has_GL_Version_4_0)
{
int count = 0;
glGetIntegerv(GL_NUM_EXTENSIONS, &count);
for( int i=0; i<count; ++i )
{
ext += std::string((char*)glGetStringi(GL_EXTENSIONS, i)) + " ";
VL_CHECK_OGL();
}
}
else
{
VL_CHECK(glGetString(GL_EXTENSIONS));
ext = (const char*)glGetString(GL_EXTENSIONS);
// make sure also the last extension ends with a space
ext.push_back(' ');
}
return ext;
}
//-----------------------------------------------------------------------------
bool vl::initializeOpenGL()
{
Is_OpenGL_Initialized = false;
// clear errors
glGetError();
// check OpenGL context is present
if (glGetError() != GL_NO_ERROR)
return false;
// - - - OpenGL function pointers - - -
// opengl function pointer initialization
#if defined(VL_OPENGL)
#define VL_GL_FUNCTION(TYPE, NAME) NAME = (TYPE)getGLProcAddress(#NAME);
#include <vlGraphics/GL/GLFunctionList.hpp>
#endif
// opengl function pointer initialization
#if defined(VL_OPENGL_ES1)
#define VL_GL_FUNCTION(TYPE, NAME) NAME = (TYPE)getGLProcAddress(#NAME);
#include <vlGraphics/GL/GLES1FunctionList.hpp>
#endif
// opengl function pointer initialization
#if defined(VL_OPENGL_ES2)
#define VL_GL_FUNCTION(TYPE, NAME) NAME = (TYPE)getGLProcAddress(#NAME);
#include <vlGraphics/GL/GLES2FunctionList.hpp>
#endif
// - - - OpenGL versions - - -
// GLES detect
#if defined(VL_OPENGL_ES1)
Has_GLES = Has_GLES_Version_1_1 = true;
#endif
#if defined(VL_OPENGL_ES2)
Has_GLES = Has_GLES_Version_2_0 = true;
#endif
// GL versions
// OpenGL ES returns "OpenGL ES-XX N.M"
const char* version_string = (const char*)glGetString(GL_VERSION);
// These stay zero for GLES
const int vmaj = Has_GLES ? 0 : version_string[0] - '0';
const int vmin = Has_GLES ? 0 : version_string[2] - '0';
// Check fixed function pipeline
#if defined(VL_OPENGL_ES2)
Is_OpenGL_Core_Profile = false;
Is_OpenGL_Forward_Compatible = false;
Has_Fixed_Function_Pipeline = false;
#elif defined(VL_OPENGL_ES1)
Is_OpenGL_Core_Profile = false;
Is_OpenGL_Forward_Compatible = false;
Has_Fixed_Function_Pipeline = true;
#else
Is_OpenGL_Forward_Compatible = false;
if( vmaj >= 3 )
{
int forward_compatible = 0;
glGetIntegerv( GL_CONTEXT_FLAGS, &forward_compatible ); VL_CHECK_OGL();
Is_OpenGL_Forward_Compatible = (forward_compatible & GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT) != 0;
}
Is_OpenGL_Core_Profile = false;
const int version = vmaj*10 + vmin;
if( version >= 32 )
{
// Valid for WGL and GLX
#define CONTEXT_CORE_PROFILE_BIT 0x00000001
#define CONTEXT_COMPATIBILITY_PROFILE_BIT 0x00000002
#define CONTEXT_PROFILE_MASK 0x9126
// Note:
// - This should be non-0 by when using wglCreateContextAttribs() and is == 0 when creating a GL context in the old way.
// - Creating a context in the old way returns the highest compatible OpenGL version available thus the presence
// of CONTEXT_COMPATIBILITY_PROFILE_BIT is not enough, we need to check the absence of CONTEXT_CORE_PROFILE_BIT
int context_flags = 0;
glGetIntegerv( CONTEXT_PROFILE_MASK, &context_flags ); VL_CHECK_OGL();
Is_OpenGL_Core_Profile = (context_flags & CONTEXT_CORE_PROFILE_BIT) != 0;
}
Has_Fixed_Function_Pipeline = !Is_OpenGL_Forward_Compatible && !Is_OpenGL_Core_Profile;
#endif
Has_GL_Version_1_1 = (vmaj == 1 && vmin >= 1) || (vmaj > 1 && Has_Fixed_Function_Pipeline);
Has_GL_Version_1_2 = (vmaj == 1 && vmin >= 2) || (vmaj > 1 && Has_Fixed_Function_Pipeline);
Has_GL_Version_1_3 = (vmaj == 1 && vmin >= 3) || (vmaj > 1 && Has_Fixed_Function_Pipeline);
Has_GL_Version_1_4 = (vmaj == 1 && vmin >= 4) || (vmaj > 1 && Has_Fixed_Function_Pipeline);
Has_GL_Version_1_5 = (vmaj == 1 && vmin >= 5) || (vmaj > 1 && Has_Fixed_Function_Pipeline);
Has_GL_Version_2_0 = (vmaj == 2 && vmin >= 0) || (vmaj > 2 && Has_Fixed_Function_Pipeline);
Has_GL_Version_2_1 = (vmaj == 2 && vmin >= 1) || (vmaj > 2 && Has_Fixed_Function_Pipeline);
Has_GL_Version_3_0 = (vmaj == 3 && vmin >= 0) || (vmaj > 3 && Has_Fixed_Function_Pipeline);
Has_GL_Version_3_1 = (vmaj == 3 && vmin >= 1) || (vmaj > 3 && Has_Fixed_Function_Pipeline);
Has_GL_Version_3_2 = (vmaj == 3 && vmin >= 2) || (vmaj > 3 && Has_Fixed_Function_Pipeline);
Has_GL_Version_3_3 = (vmaj == 3 && vmin >= 3) || (vmaj > 3 && Has_Fixed_Function_Pipeline);
Has_GL_Version_4_0 = (vmaj == 4 && vmin >= 0) || (vmaj > 4 && Has_Fixed_Function_Pipeline);
Has_GL_Version_4_1 = (vmaj == 4 && vmin >= 1) || (vmaj > 4 && Has_Fixed_Function_Pipeline);
// - - - Extension strings init - - -
std::string extensions = getOpenGLExtensions();
#define VL_EXTENSION(extension) Has_##extension = strstr(extensions.c_str(), #extension" ") != NULL;
#include <vlGraphics/GL/GLExtensionList.hpp>
#undef VL_EXTENSION
#define VL_GLES_EXTENSION(extension) Has_##extension = strstr(extensions.c_str(), #extension" ") != NULL;
#include <vlGraphics/GL/GLESExtensionList.hpp>
#undef VL_GLES_EXTENSION
#if defined(VL_OPENGL_ES1)
// mic fixme
// POWERVR emulator bugs: http://www.imgtec.com/forum/forum_posts.asp?TID=1379
if (Has_GL_OES_texture_cube_map && glTexGenfOES == 0)
{
Has_GL_OES_texture_cube_map = false;
Has_Cubemap_Textures = false;
Log::error("GL_OES_texture_cube_map exposed but glTexGenfOES == NULL!\n"); /*VL_TRAP();*/
}
if(Has_GL_OES_blend_func_separate && glBlendFuncSeparateOES == 0)
{
Has_GL_OES_blend_func_separate = false;
Log::error("GL_OES_blend_func_separate exposed but glBlendFuncSeparateOES == NULL!\n"); /*VL_TRAP();*/
}
if (Has_GL_OES_fixed_point && glAlphaFuncxOES == NULL)
{
Log::warning("GL_OES_fixed_point functions are not exposed with their OES suffix!\n");
}
if (Has_GL_OES_single_precision && glDepthRangefOES == NULL)
{
Log::warning("GL_OES_single_precision functions are not exposed with their OES suffix!\n");
}
#endif
// - - - Helper defines - - -
// Note that GL extensions pertaining to deprecated features seem to be exposed under Core profiles even if they are not supported (like Has_GL_SGIS_generate_mipmap)
Has_GLSL = Has_GL_ARB_shading_language_100 || Has_GL_Version_2_0 || Has_GL_Version_3_0 || Has_GL_Version_4_0 || Has_GLES_Version_2_0;
Has_GLSL_120_Or_More = Has_GL_Version_2_1 || Has_GL_Version_3_0 || Has_GL_Version_4_0;
Has_GLSL_130_Or_More = Has_GL_Version_3_0 || Has_GL_Version_4_0;
Has_GLSL_140_Or_More = Has_GL_Version_3_1 || Has_GL_Version_4_0;
Has_GLSL_150_Or_More = Has_GL_Version_3_2 || Has_GL_Version_4_0;
Has_GLSL_330_Or_More = Has_GL_Version_3_3 || Has_GL_Version_4_0;
Has_GLSL_400_Or_More = Has_GL_Version_4_0;
Has_GLSL_410_Or_More = Has_GL_Version_4_1;
Has_Geometry_Shader = Has_GL_NV_geometry_shader4 || Has_GL_EXT_geometry_shader4 || Has_GL_ARB_geometry_shader4 || Has_GL_Version_3_2 || Has_GL_Version_4_0;
Has_BufferObject = Has_GL_ARB_vertex_buffer_object || Has_GL_Version_1_5 || Has_GL_Version_3_0 || Has_GL_Version_4_0 || Has_GLES;
Has_FBO = Has_GL_EXT_framebuffer_object || Has_GL_ARB_framebuffer_object || Has_GL_Version_3_0 || Has_GL_Version_4_0 || Has_GL_OES_framebuffer_object || Has_GLES_Version_2_0;
Has_PBO = Has_GL_ARB_pixel_buffer_object || Has_GL_EXT_pixel_buffer_object || Has_GL_Version_2_1 || Has_GL_Version_3_0 || Has_GL_Version_4_0;
// We only support GL_ANGLE_framebuffer_blit for GLES, see also:
// http://www.khronos.org/registry/gles/extensions/IMG/IMG_multisampled_render_to_texture.txt
// http://www.khronos.org/registry/gles/extensions/APPLE/APPLE_framebuffer_multisample.txt
Has_FBO_Multisample = Has_GL_Version_4_0 || Has_GL_Version_3_0 || Has_GL_ARB_framebuffer_object || Has_GL_EXT_framebuffer_multisample || Has_GL_ANGLE_framebuffer_multisample;
Has_Cubemap_Textures = Has_GL_ARB_texture_cube_map || Has_GL_Version_1_3 || Has_GL_Version_3_0 || Has_GL_Version_4_0 || Has_GL_OES_texture_cube_map || Has_GLES_Version_2_0;
Has_Texture_Rectangle = Has_GL_ARB_texture_rectangle || Has_GL_NV_texture_rectangle || Has_GL_Version_3_1 || Has_GL_Version_4_0;
Has_Texture_Array = Has_GL_EXT_texture_array || Has_GL_Version_3_0 || Has_GL_Version_4_0;
Has_Texture_Buffer = Has_GL_ARB_texture_buffer_object || Has_GL_EXT_texture_buffer_object || Has_GL_Version_3_1 || Has_GL_Version_4_0;
Has_Texture_Multisample = Has_GL_ARB_texture_multisample || Has_GL_Version_3_2 || Has_GL_Version_4_0;
Has_Texture_3D = Has_GL_EXT_texture3D || Has_GL_Version_1_2 || Has_GL_Version_3_0 || Has_GL_Version_4_0 || Has_GL_OES_texture_3D;
Has_Multitexture = Has_GL_ARB_multitexture || Has_GL_Version_1_3 || Has_GL_Version_3_0 || Has_GL_Version_4_0 || Has_GLES;
Has_Primitive_Restart = Has_GL_Version_3_1 || Has_GL_Version_4_0;
Has_Occlusion_Query = Has_GL_ARB_occlusion_query || Has_GL_Version_1_5 || Has_GL_Version_3_0 || Has_GL_Version_4_0;
Has_Transform_Feedback = Has_GL_NV_transform_feedback || Has_GL_EXT_transform_feedback || Has_GL_Version_3_0 || Has_GL_Version_4_0;
Has_glGenerateMipmaps = Has_GL_ARB_framebuffer_object || Has_GL_Version_3_0 || Has_GL_Version_4_0 || Has_GLES_Version_2_0;
Has_GL_GENERATE_MIPMAP = (Has_GL_SGIS_generate_mipmap && Has_Fixed_Function_Pipeline) || Has_GL_Version_1_4 || Has_GLES_Version_1_1;
Has_Point_Sprite = Has_GL_NV_point_sprite || Has_GL_ARB_point_sprite || Has_GLSL || Has_GLES_Version_1_1;
Has_Base_Vertex = Has_GL_Version_3_2 || Has_GL_Version_4_0 || Has_GL_ARB_draw_elements_base_vertex;
Has_Primitive_Instancing = Has_GL_Version_3_1 || Has_GL_Version_4_0 || Has_GL_ARB_draw_instanced || Has_GL_EXT_draw_instanced;
// - - - Resolve supported enables - - -
// Common ones
Is_Enable_Supported[EN_BLEND] = true;
Is_Enable_Supported[EN_CULL_FACE] = true;
Is_Enable_Supported[EN_DEPTH_TEST] = true;
Is_Enable_Supported[EN_STENCIL_TEST] = true;
Is_Enable_Supported[EN_DITHER] = true;
Is_Enable_Supported[EN_POLYGON_OFFSET_FILL] = true;
Is_Enable_Supported[EN_POLYGON_OFFSET_LINE] = !Has_GLES;
Is_Enable_Supported[EN_POLYGON_OFFSET_POINT] = !Has_GLES;
Is_Enable_Supported[EN_COLOR_LOGIC_OP] = !Has_GLES_Version_2_0;
Is_Enable_Supported[EN_MULTISAMPLE] = !Has_GLES_Version_2_0;
// Smooth
Is_Enable_Supported[EN_POINT_SMOOTH] = Has_GL_Version_1_1||Has_GLES_Version_1_1;
Is_Enable_Supported[EN_LINE_SMOOTH] = !Has_GLES_Version_2_0;
Is_Enable_Supported[EN_POLYGON_SMOOTH] = !Has_GLES;
// Stipple
Is_Enable_Supported[EN_LINE_STIPPLE] = Has_GL_Version_1_1;
Is_Enable_Supported[EN_POLYGON_STIPPLE] = Has_GL_Version_1_1;
// Point sprites
// Point sprites when !Has_Fixed_Function_Pipeline is considered always enabled but GL_POINT_SPRITE should not be called even if GL_OES_point_sprite, GL_ARB_point_sprite etc. are exposed!
// Note that calling glIsEnabled() with the two below under a Core profile returns true for the same reason.
Is_Enable_Supported[EN_POINT_SPRITE] = (Has_GL_NV_point_sprite||Has_GL_ARB_point_sprite||Has_GL_Version_2_0||Has_GL_OES_point_sprite||Has_GLES_Version_1_1) && Has_Fixed_Function_Pipeline;
Is_Enable_Supported[EN_PROGRAM_POINT_SIZE] = Has_GLSL && !Has_GLES_Version_2_0; // Only OpenGL ES 2 does not support glPointSize()/GL_POINT_SIZE
// Fixed function pipeline
Is_Enable_Supported[EN_ALPHA_TEST] = Has_GL_Version_1_1||Has_GLES_Version_1_1;
Is_Enable_Supported[EN_LIGHTING] = Has_GL_Version_1_1||Has_GLES_Version_1_1;
Is_Enable_Supported[EN_COLOR_SUM] = Has_GL_Version_1_1;
Is_Enable_Supported[EN_FOG] = Has_GL_Version_1_1||Has_GLES_Version_1_1;
Is_Enable_Supported[EN_NORMALIZE] = Has_GL_Version_1_1||Has_GLES_Version_1_1;
Is_Enable_Supported[EN_RESCALE_NORMAL] = Has_GL_Version_1_2||Has_GLES_Version_1_1;
// Available only under OpenGL 2.x
Is_Enable_Supported[EN_VERTEX_PROGRAM_TWO_SIDE] = ((Has_GL_ARB_vertex_program||Has_GL_NV_vertex_program) && Has_GL_Version_1_1) || Has_GL_Version_2_0;
// OpenGL 3.2
Is_Enable_Supported[EN_TEXTURE_CUBE_MAP_SEAMLESS] = Has_GL_AMD_seamless_cubemap_per_texture||Has_GL_ARB_seamless_cube_map||Has_GL_Version_3_2||Has_GL_Version_4_0;
// Clipping planes
int max_clip_planes = 0;
// OpenGL ES 2 is the only one without clipping planes!
if (!Has_GLES_Version_2_0)
{
glGetIntegerv(GL_MAX_CLIP_DISTANCES, &max_clip_planes); // GL_MAX_CLIP_DISTANCES == GL_MAX_CLIP_PLANES
}
Is_Enable_Supported[EN_CLIP_DISTANCE0] = max_clip_planes >= 1;
Is_Enable_Supported[EN_CLIP_DISTANCE1] = max_clip_planes >= 2;
Is_Enable_Supported[EN_CLIP_DISTANCE2] = max_clip_planes >= 3;
Is_Enable_Supported[EN_CLIP_DISTANCE3] = max_clip_planes >= 4;
Is_Enable_Supported[EN_CLIP_DISTANCE4] = max_clip_planes >= 5;
Is_Enable_Supported[EN_CLIP_DISTANCE5] = max_clip_planes >= 6;
Is_Enable_Supported[EN_CLIP_DISTANCE6] = max_clip_planes >= 7;
Is_Enable_Supported[EN_CLIP_DISTANCE7] = max_clip_planes >= 8;
// Multisampling
Is_Enable_Supported[EN_SAMPLE_ALPHA_TO_COVERAGE] = Has_GL_Version_1_3||!Has_Fixed_Function_Pipeline||Has_GLES;
Is_Enable_Supported[EN_SAMPLE_ALPHA_TO_ONE] = Has_GL_Version_1_3||Has_GL_Version_3_0||Has_GL_Version_4_0||Has_GLES_Version_1_1;
Is_Enable_Supported[EN_SAMPLE_COVERAGE] = Has_GL_Version_1_3||!Has_Fixed_Function_Pipeline||Has_GLES;
#ifndef NDEBUG
// Enables management debug code
VL_CHECK_OGL();
bool got_error = false;
for(int i=0; i<EN_EnableCount; ++i)
{
glDisable(Translate_Enable[i]); // glIsEnabled() for some reason is not reliable!
bool supported = glGetError() == GL_NO_ERROR;
if (supported != Is_Enable_Supported[i])
{
Log::error( Say("%s: capability %s supported! This is a harmless glitch either in your GL driver or in VL.\n") << Translate_Enable_String[i] << (supported? "*IS*" : "*IS NOT*") );
got_error = true;
}
}
if(got_error)
{
printf("OpenGL Version = %s\n", glGetString(GL_VERSION));
#define PRINT_INFO(STRING) printf(#STRING" = %d\n", STRING?1:0)
PRINT_INFO(Is_OpenGL_Core_Profile);
PRINT_INFO(Is_OpenGL_Forward_Compatible);
PRINT_INFO(Has_GL_Version_4_1);
PRINT_INFO(Has_GL_Version_4_0);
PRINT_INFO(Has_GL_Version_3_3);
PRINT_INFO(Has_GL_Version_3_2);
PRINT_INFO(Has_GL_Version_3_1);
PRINT_INFO(Has_GL_Version_3_0);
PRINT_INFO(Has_GL_Version_2_1);
PRINT_INFO(Has_GL_Version_2_0);
PRINT_INFO(Has_GL_Version_1_5);
PRINT_INFO(Has_GL_Version_1_4);
PRINT_INFO(Has_GL_Version_1_3);
PRINT_INFO(Has_GL_Version_1_2);
PRINT_INFO(Has_GL_Version_1_1);
// VL_TRAP();
}
#endif
VL_CHECK_OGL();
return Is_OpenGL_Initialized = true;
}
