void EnableDrawing (HGLRC *hRC)
{
WindowResizedCallback = &WindowResized;
/**
* Edited by Cool Breeze on 16th October 2013
* + Updated the Pixel Format to support 24-bitdepth buffers
* + Correctly create a GL 3.x compliant context
*/
HGLRC LegacyRC;
PIXELFORMATDESCRIPTOR pfd;
int iFormat;
enigma::window_hDC = GetDC (hWnd);
ZeroMemory (&pfd, sizeof (pfd));
pfd.nSize = sizeof (pfd);
pfd.nVersion = 1;
pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
pfd.iPixelType = PFD_TYPE_RGBA;
pfd.cColorBits = 24;
pfd.cDepthBits = 24;
pfd.cStencilBits = 8;
pfd.iLayerType = PFD_MAIN_PLANE;
iFormat = ChoosePixelFormat (enigma::window_hDC, &pfd);
if (iFormat==0) { show_error("Failed to set the format of the OpenGL graphics device.",1); }
SetPixelFormat ( enigma::window_hDC, iFormat, &pfd );
LegacyRC = wglCreateContext( enigma::window_hDC );
wglMakeCurrent( enigma::window_hDC, LegacyRC );
// -- Initialise GLEW
GLenum err = glewInit();
if (GLEW_OK != err)
{
return;
}
// -- Define an array of Context Attributes
int attribs[] =
{
WGL_CONTEXT_MAJOR_VERSION_ARB, 3,
WGL_CONTEXT_MINOR_VERSION_ARB, 3,
//WGL_CONTEXT_PROFILE_MASK_ARB, WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB,
#ifdef DEBUG_MODE
WGL_CONTEXT_FLAGS_ARB, WGL_CONTEXT_DEBUG_BIT_ARB,
#else
WGL_CONTEXT_FLAGS_ARB, 0,
#endif
0
};
if ( wglewIsSupported("WGL_ARB_create_context") )
{
*hRC = wglCreateContextAttribsARB( enigma::window_hDC,0, attribs );
wglMakeCurrent( NULL,NULL );
wglDeleteContext( LegacyRC );
wglMakeCurrent(enigma::window_hDC, *hRC );
}
else // Unable to get a 3.3 Core Context, use the Legacy 1.x context
{
*hRC = LegacyRC;
}
#ifdef DEBUG_MODE
glDebugMessageCallbackARB((GLDEBUGPROCARB)&DebugCallbackARB, 0);
glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB);
printf("OpenGL version supported by this platform (%s): \n", glGetString(GL_VERSION));
GLuint other_ids[] = { 131185 };
glDebugMessageControlARB(GL_DEBUG_SOURCE_API_ARB, GL_DEBUG_TYPE_OTHER_ARB, GL_DONT_CARE, 1, other_ids, GL_FALSE); //Disable some notifications shown below:
//OpenGL: Buffer detailed info: Buffer object 1 (bound to GL_ELEMENT_ARRAY_BUFFER_ARB, usage hint is GL_STATIC_DRAW) will use VIDEO memory as the source for buffer object operations. [source=API type=OTHER severity=UNDEFINED (33387) id=131185]
GLuint performance_ids[] = { 131218, 2 };
glDebugMessageControlARB(GL_DEBUG_SOURCE_API_ARB, GL_DEBUG_TYPE_PERFORMANCE_ARB, GL_DONT_CARE, 2, performance_ids, GL_FALSE); //Disable some notifications shown below:
//OpenGL: Program/shader state performance warning: Vertex shader in program 9 is being recompiled based on GL state. [source=API type=PERFORMANCE severity=MEDIUM id=131218] - This is NVidia only and doesn't tell much
#endif
//TODO: This never reports higher than 8, but display_aa should be 14 if 2,4,and 8 are supported and 8 only when only 8 is supported
glGetIntegerv(GL_MAX_SAMPLES_EXT, &enigma_user::display_aa);
}
bool IsOpenGL()
{
std::string rendererString(reinterpret_cast<const char *>(glGetString(GL_RENDERER)));
return (rendererString.find("OpenGL") != std::string::npos);
}
int main(int argc, char *argv)
{
// Initialize GLFW
if (!glfwInit())
{
exit(EXIT_FAILURE);
}
File::FileManager file;
Manager::ResourceManager resource(&file);
// Create a fallback iniTable with some data
Resource::iniTable fallbackTable;
fallbackTable.SetInt("fallback", 1);
// Create a tree for iniTables in the resource manager using the fallback iniTable as a fallback
resource.addTree<Resource::iniTable>(fallbackTable, "fallback");
std::shared_ptr<Resource::ResourceHandle<Resource::iniTable>> displaySettings = resource.getHandle<Resource::iniTable>(std::string("display.ini"));
resource.loadTaskList.popTask()->execute();
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);//displaySettings->get()->GetInt("major_version"));
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);//displaySettings->get()->GetInt("minor_version"));
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
if (displaySettings->get()->GetInt("resizeable") == 1) {
glfwWindowHint(GLFW_RESIZABLE, GL_TRUE);
}
else {
glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);
}
glfwWindowHint(GLFW_SAMPLES, displaySettings->get()->GetInt("samples"));
Resource::iniTable* resTable = displaySettings->get()->GetSubtable("resolution");
GLFWwindow* window;
if (resTable) {
window = glfwCreateWindow(resTable->GetInt("x"), resTable->GetInt("y"), "Lightning OpenGl Renderer", nullptr, nullptr);
}
else {
fprintf(stderr, "Invalid Display INI Setup");
return EXIT_FAILURE;
}
// Set the required callback functions
glfwSetKeyCallback(window, key_callback);
glfwSetCursorPosCallback(window, mouse_callback);
glfwSetScrollCallback(window, scroll_callback);
// Options
glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
// Check for Valid Context
if (window == nullptr) {
fprintf(stderr, "Failed to Create OpenGL Context");
return EXIT_FAILURE;
}
// Create Context and Load OpenGL Functions
glfwMakeContextCurrent(window);
gladLoadGL();
fprintf(stderr, "OpenGL %s\n", glGetString(GL_VERSION));
//glViewport(0, 0, resTable.GetInt("x"), resTable.GetInt("y"));
// Setup some OpenGL options
glEnable(GL_DEPTH_TEST);
/*
INITIALIZATION
*/
Shader ourShader("vertexShader.vert", "fragshader.frag");
Model ourModel("resource/nanosuit.obj");
float screenWidth = (float)resTable->GetInt("x");
float screenHeight = (float)resTable->GetInt("y");
// Game loop
glClearColor(0.25f, 0.3f, 0.25f, 1.0f);
while (!glfwWindowShouldClose(window))
{
// Set frame time
GLfloat currentFrame = glfwGetTime();
deltaTime = currentFrame - lastFrame;
lastFrame = currentFrame;
// Check and call events
glfwPollEvents();
Do_Movement();
// Clear the colorbuffer
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Draw our first triangle
ourShader.Use();
// Transformation matrices
glm::mat4 projection = glm::perspective(camera.Zoom, (float)screenWidth / (float)screenHeight, 0.1f, 100.0f);
glm::mat4 view = camera.GetViewMatrix();
// Get the uniform locations
GLint viewLoc = glGetUniformLocation(ourShader.Program, "view");
GLint projLoc = glGetUniformLocation(ourShader.Program, "projection");
glUniformMatrix4fv(glGetUniformLocation(ourShader.Program, "projection"), 1, GL_FALSE, glm::value_ptr(projection));
glUniformMatrix4fv(glGetUniformLocation(ourShader.Program, "view"), 1, GL_FALSE, glm::value_ptr(view));
// Draw the loaded model
glm::mat4 model;
model = glm::translate(model, glm::vec3(0.0f, -1.75f, 0.0f)); // Translate it down a bit so it's at the center of the scene
model = glm::scale(model, glm::vec3(0.2f, 0.2f, 0.2f)); // It's a bit too big for our scene, so scale it down
glUniformMatrix4fv(glGetUniformLocation(ourShader.Program, "model"), 1, GL_FALSE, glm::value_ptr(model));
ourModel.Draw(ourShader);
// Swap the buffers
glfwSwapBuffers(window);
}
// Properly de-allocate all resources once they've outlived their purpose
glfwTerminate();
return EXIT_SUCCESS;
}
static bool InitializeOpenGL ()
{
bool hasGLSL = false;
#if GOT_GFX
#ifdef _MSC_VER
// setup minimal required GL
HWND wnd = CreateWindowA(
"STATIC",
"GL",
WS_OVERLAPPEDWINDOW | WS_CLIPSIBLINGS | WS_CLIPCHILDREN,
0, 0, 16, 16,
NULL, NULL,
GetModuleHandle(NULL), NULL );
HDC dc = GetDC( wnd );
PIXELFORMATDESCRIPTOR pfd = {
sizeof(PIXELFORMATDESCRIPTOR), 1,
PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL,
PFD_TYPE_RGBA, 32,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0,
16, 0,
0, PFD_MAIN_PLANE, 0, 0, 0, 0
};
int fmt = ChoosePixelFormat( dc, &pfd );
SetPixelFormat( dc, fmt, &pfd );
HGLRC rc = wglCreateContext( dc );
wglMakeCurrent( dc, rc );
#elif defined(__APPLE__)
CGLPixelFormatAttribute attributes[] = {
kCGLPFAAccelerated, // no software rendering
(CGLPixelFormatAttribute) 0
};
CGLPixelFormatAttribute attributes3[] = {
kCGLPFAAccelerated, // no software rendering
kCGLPFAOpenGLProfile, // core profile with the version stated below
(CGLPixelFormatAttribute) kCGLOGLPVersion_3_2_Core,
(CGLPixelFormatAttribute) 0
};
GLint num;
CGLPixelFormatObj pix;
// create legacy context
CGLChoosePixelFormat(attributes, &pix, &num);
if (pix == NULL)
return false;
CGLCreateContext(pix, NULL, &s_GLContext);
if (s_GLContext == NULL)
return false;
CGLDestroyPixelFormat(pix);
CGLSetCurrentContext(s_GLContext);
// create core 3.2 context
CGLChoosePixelFormat(attributes3, &pix, &num);
if (pix == NULL)
return false;
CGLCreateContext(pix, NULL, &s_GLContext3);
if (s_GLContext3 == NULL)
return false;
CGLDestroyPixelFormat(pix);
#endif
// check if we have GLSL
const char* extensions = (const char*)glGetString(GL_EXTENSIONS);
hasGLSL = extensions != NULL && strstr(extensions, "GL_ARB_shader_objects") && strstr(extensions, "GL_ARB_vertex_shader") && strstr(extensions, "GL_ARB_fragment_shader");
#if defined(__APPLE__)
// using core profile; always has GLSL
hasGLSL = true;
#endif
#ifdef _MSC_VER
if (hasGLSL)
{
glDeleteObjectARB = (PFNGLDELETEOBJECTARBPROC)wglGetProcAddress("glDeleteObjectARB");
glCreateShaderObjectARB = (PFNGLCREATESHADEROBJECTARBPROC)wglGetProcAddress("glCreateShaderObjectARB");
glShaderSourceARB = (PFNGLSHADERSOURCEARBPROC)wglGetProcAddress("glShaderSourceARB");
glCompileShaderARB = (PFNGLCOMPILESHADERARBPROC)wglGetProcAddress("glCompileShaderARB");
glGetInfoLogARB = (PFNGLGETINFOLOGARBPROC)wglGetProcAddress("glGetInfoLogARB");
glGetObjectParameterivARB = (PFNGLGETOBJECTPARAMETERIVARBPROC)wglGetProcAddress("glGetObjectParameterivARB");
}
#endif
#endif
return hasGLSL;
}
bool IsAMD()
{
std::string rendererString(reinterpret_cast<const char *>(glGetString(GL_RENDERER)));
return (rendererString.find("AMD") != std::string::npos) ||
(rendererString.find("ATI") != std::string::npos);
}
bool EGLView::init(const char* viewName, float width, float height, float frameZoomFactor)
{
if(nullptr != _mainWindow) return true;
setViewName(viewName);
setFrameSize(width, height);
setFrameZoomFactor(frameZoomFactor);
glfwWindowHint(GLFW_RESIZABLE,GL_FALSE);
_mainWindow = glfwCreateWindow(_screenSize.width * _frameZoomFactor, _screenSize.height * _frameZoomFactor, _viewName, nullptr, nullptr);
glfwMakeContextCurrent(_mainWindow);
glfwGetFramebufferSize(_mainWindow, &_frameBufferSize[0], &_frameBufferSize[1]);
glfwSetMouseButtonCallback(_mainWindow,EGLViewEventHandler::OnGLFWMouseCallBack);
glfwSetCursorPosCallback(_mainWindow,EGLViewEventHandler::OnGLFWMouseMoveCallBack);
glfwSetCharCallback(_mainWindow, EGLViewEventHandler::OnGLFWCharCallback);
glfwSetKeyCallback(_mainWindow, EGLViewEventHandler::OnGLFWKeyCallback);
glfwSetWindowPosCallback(_mainWindow, EGLViewEventHandler::OnGLFWWindowPosCallback);
// check OpenGL version at first
const GLubyte* glVersion = glGetString(GL_VERSION);
CCLOG("OpenGL version = %s", glVersion);
if ( atof((const char*)glVersion) < 1.5 )
{
char strComplain[256] = {0};
sprintf(strComplain,
"OpenGL 1.5 or higher is required (your version is %s). Please upgrade the driver of your video card.",
glVersion);
MessageBox(strComplain, "OpenGL version too old");
return false;
}
GLenum GlewInitResult = glewInit();
if (GLEW_OK != GlewInitResult)
{
MessageBox((char *)glewGetErrorString(GlewInitResult), "OpenGL error");
return false;
}
if (GLEW_ARB_vertex_shader && GLEW_ARB_fragment_shader)
{
log("Ready for GLSL");
}
else
{
log("Not totally ready :(");
}
if (glewIsSupported("GL_VERSION_2_0"))
{
log("Ready for OpenGL 2.0");
}
else
{
log("OpenGL 2.0 not supported");
}
// if(glew_dynamic_binding() == false)
// {
// MessageBox("No OpenGL framebuffer support. Please upgrade the driver of your video card.", "OpenGL error");
// return false;
// }
//
// Enable point size by default on windows.
glEnable(GL_VERTEX_PROGRAM_POINT_SIZE);
return true;
}
int
main(int argc, char** argv)
{
HDC hDC; /* device context */
HGLRC hRC; /* opengl context */
HWND hWnd; /* window */
MSG msg; /* message */
int i;
char* s;
char t[80];
char* p;
int verbose = 0;
while (--argc) {
if (strcmp("-h", argv[argc]) == 0) {
printf("Usage: wglinfo [-v] [-t] [-m] [-h] [-dispay <dname>] [-nfbc] [-fpcinfo]\n");
printf(" -v: Print visuals info in verbose form.\n");
printf(" -t: Print verbose table (not implemented on Win32)\n");
printf(" -m: Don't print mid table headers (in long tables). (not on Win32)\n");
printf(" -display <dname>: Print GLX visuals on specified server. (not on Win32)\n");
printf(" -nfbc: Don't use fbconfig extension (not available on Win32)\n");
printf(" -fbcinfo: print out additional fbconfig information (not on Win32)\n");
printf(" -h: This screen.\n");
exit(0);
} else if (strcmp("-v", argv[argc]) == 0) {
verbose = 1;
}
}
hWnd = CreateOpenGLWindow("wglinfo", 0, 0, 100, 100, PFD_TYPE_RGBA, 0);
if (hWnd == NULL)
exit(1);
hDC = GetDC(hWnd);
hRC = wglCreateContext(hDC);
wglMakeCurrent(hDC, hRC);
ShowWindow(hWnd, SW_HIDE);
/* output header information */
printf("display: N/A\n");
printf("server wgl vendor string: N/A\n");
printf("server wgl version string: N/A\n");
printf("server wgl extensions (WGL_): N/A\n");
printf("client wgl version: N/A\n");
printf("client wgl extensions (WGL_): none\n");
printf("OpenGL vendor string: %s\n", glGetString(GL_VENDOR));
printf("OpenGL renderer string: %s\n", glGetString(GL_RENDERER));
printf("OpenGL version string: %s\n", glGetString(GL_VERSION));
printf("OpenGL extensions (GL_): \n");
/* do the magic to separate all extensions with comma's, except
for the last one that _may_ terminate in a space. */
i = 0;
s = (char*)glGetString(GL_EXTENSIONS);
t[79] = '\0';
p = &t[0];
while(*s) {
t[i++] = *s;
if(*s == ' ') {
if (*(s+1) != '\0') {
t[i-1] = ',';
t[i] = ' ';
p = &t[i++];
} else { /* zoinks! last one terminated in a space! */
t[i-1] = '\0';
}
}
if(i > 80 - 5) {
*p = t[i] = '\0';
printf(" %s\n", t);
p++;
i = strlen(p);
strcpy(t, p);
}
s++;
}
t[i] = '\0';
printf(" %s.\n\n", t);
/* enumerate all the formats */
VisualInfo(hDC, verbose);
PostQuitMessage(0);
while(GetMessage(&msg, hWnd, 0, 0)) {
TranslateMessage(&msg);
DispatchMessage(&msg);
}
wglMakeCurrent(NULL, NULL);
ReleaseDC(hWnd, hDC);
wglDeleteContext(hRC);
DestroyWindow(hWnd);
return msg.wParam;
}
int
main(int argc, char **argv)
{
GLenum status;
GLboolean hasDSA;
int samples = 0;
int i;
glutInitWindowSize(640, 480);
glutInit(&argc, argv);
for (i=1; i<argc; i++) {
if (argv[i][0] == '-') {
int value = atoi(argv[i]+1);
if (value >= 1) {
samples = value;
continue;
}
}
fprintf(stderr, "usage: %s [-#]\n where # is the number of samples/pixel\n",
programName);
exit(1);
}
if (samples > 0) {
char buffer[200];
if (samples == 1)
samples = 0;
printf("requesting %d samples\n", samples);
sprintf(buffer, "rgb stencil~4 double samples~%d", samples);
glutInitDisplayString(buffer);
} else {
/* Request a double-buffered window with at least 4 stencil bits and
8 samples per pixel. */
glutInitDisplayString("rgb stencil~4 double samples~8");
}
if (!glutGet(GLUT_DISPLAY_MODE_POSSIBLE)) {
printf("fallback GLUT display config!\n");
glutInitDisplayString(NULL);
glutInitDisplayMode(GLUT_RGB | GLUT_ALPHA | GLUT_DOUBLE | GLUT_STENCIL);
}
glutCreateWindow("Welsh dragon NV_path_rendering example");
printf("vendor: %s\n", glGetString(GL_VENDOR));
printf("version: %s\n", glGetString(GL_VERSION));
printf("renderer: %s\n", glGetString(GL_RENDERER));
printf("samples = %d\n", glutGet(GLUT_WINDOW_NUM_SAMPLES));
printf("Executable: %d bit\n", (int)(8*sizeof(int*)));
glutDisplayFunc(display);
glutKeyboardFunc(keyboard);
status = glewInit();
if (status != GLEW_OK) {
fatalError("OpenGL Extension Wrangler (GLEW) failed to initialize");
}
// Use glutExtensionSupported because glewIsSupported is unreliable for DSA.
hasDSA = glutExtensionSupported("GL_EXT_direct_state_access");
if (!hasDSA) {
fatalError("OpenGL implementation doesn't support GL_EXT_direct_state_access (you should be using NVIDIA GPUs...)");
}
initializeNVPR(programName);
if (!has_NV_path_rendering) {
fatalError("required NV_path_rendering OpenGL extension is not present");
}
initGraphics();
glutMainLoop();
return 0;
}
static int gltex_set(struct kmscon_text *txt)
{
struct gltex *gt = txt->data;
int ret;
static char *attr[] = { "position", "texture_position",
"fgcolor", "bgcolor" };
GLint s;
const char *ext;
struct uterm_mode *mode;
bool opengl;
memset(gt, 0, sizeof(*gt));
shl_dlist_init(>->atlases);
ret = shl_hashtable_new(>->glyphs, shl_direct_hash,
shl_direct_equal, NULL,
free_glyph);
if (ret)
return ret;
ret = shl_hashtable_new(>->bold_glyphs, shl_direct_hash,
shl_direct_equal, NULL,
free_glyph);
if (ret)
goto err_htable;
ret = uterm_display_use(txt->disp, &opengl);
if (ret < 0 || !opengl) {
if (ret == -EOPNOTSUPP)
log_error("display doesn't support hardware-acceleration");
goto err_bold_htable;
}
gl_clear_error();
ret = gl_shader_new(>->shader, gl_static_gltex_vert,
gl_static_gltex_frag, attr, 4, log_llog, NULL);
if (ret)
goto err_bold_htable;
gt->uni_proj = gl_shader_get_uniform(gt->shader, "projection");
gt->uni_atlas = gl_shader_get_uniform(gt->shader, "atlas");
gt->uni_advance_htex = gl_shader_get_uniform(gt->shader,
"advance_htex");
gt->uni_advance_vtex = gl_shader_get_uniform(gt->shader,
"advance_vtex");
if (gl_has_error(gt->shader)) {
log_warning("cannot create shader");
goto err_shader;
}
mode = uterm_display_get_current(txt->disp);
gt->sw = uterm_mode_get_width(mode);
gt->sh = uterm_mode_get_height(mode);
txt->cols = gt->sw / FONT_WIDTH(txt);
txt->rows = gt->sh / FONT_HEIGHT(txt);
glGetIntegerv(GL_MAX_TEXTURE_SIZE, &s);
if (s <= 0)
s = 64;
else if (s > 2048)
s = 2048;
gt->max_tex_size = s;
gl_clear_error();
ext = (const char*)glGetString(GL_EXTENSIONS);
if (ext && strstr((const char*)ext, "GL_EXT_unpack_subimage")) {
gt->supports_rowlen = true;
} else {
log_warning("your GL implementation does not support GL_EXT_unpack_subimage, glyph-rendering may be slower than usual");
}
return 0;
err_shader:
gl_shader_unref(gt->shader);
err_bold_htable:
shl_hashtable_free(gt->bold_glyphs);
err_htable:
shl_hashtable_free(gt->glyphs);
return ret;
}
void CCEGLView::initEGLFunctions()
{
m_extensions = glGetString(GL_EXTENSIONS);
m_initializedFunctions = true;
}
// requires a valid gl context
static void QGL_InitVersion (OpenGLBinding& table)
{
char const* const version = reinterpret_cast<char const*>(glGetString(GL_VERSION));
sscanf(version, "%d.%d", &table.major_version, &table.minor_version);
}
static bool glew_dynamic_binding()
{
const char *gl_extensions = (const char*)glGetString(GL_EXTENSIONS);
// If the current opengl driver doesn't have framebuffers methods, check if an extension exists
if (glGenFramebuffers == NULL)
{
CCLog("OpenGL: glGenFramebuffers is NULL, try to detect an extension\n");
if (strstr(gl_extensions, "ARB_framebuffer_object"))
{
CCLog("OpenGL: ARB_framebuffer_object is supported\n");
glIsRenderbuffer = (PFNGLISRENDERBUFFERPROC) wglGetProcAddress("glIsRenderbuffer");
glBindRenderbuffer = (PFNGLBINDRENDERBUFFERPROC) wglGetProcAddress("glBindRenderbuffer");
glDeleteRenderbuffers = (PFNGLDELETERENDERBUFFERSPROC) wglGetProcAddress("glDeleteRenderbuffers");
glGenRenderbuffers = (PFNGLGENRENDERBUFFERSPROC) wglGetProcAddress("glGenRenderbuffers");
glRenderbufferStorage = (PFNGLRENDERBUFFERSTORAGEPROC) wglGetProcAddress("glRenderbufferStorage");
glGetRenderbufferParameteriv = (PFNGLGETRENDERBUFFERPARAMETERIVPROC) wglGetProcAddress("glGetRenderbufferParameteriv");
glIsFramebuffer = (PFNGLISFRAMEBUFFERPROC) wglGetProcAddress("glIsFramebuffer");
glBindFramebuffer = (PFNGLBINDFRAMEBUFFERPROC) wglGetProcAddress("glBindFramebuffer");
glDeleteFramebuffers = (PFNGLDELETEFRAMEBUFFERSPROC) wglGetProcAddress("glDeleteFramebuffers");
glGenFramebuffers = (PFNGLGENFRAMEBUFFERSPROC) wglGetProcAddress("glGenFramebuffers");
glCheckFramebufferStatus = (PFNGLCHECKFRAMEBUFFERSTATUSPROC) wglGetProcAddress("glCheckFramebufferStatus");
glFramebufferTexture1D = (PFNGLFRAMEBUFFERTEXTURE1DPROC) wglGetProcAddress("glFramebufferTexture1D");
glFramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC) wglGetProcAddress("glFramebufferTexture2D");
glFramebufferTexture3D = (PFNGLFRAMEBUFFERTEXTURE3DPROC) wglGetProcAddress("glFramebufferTexture3D");
glFramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC) wglGetProcAddress("glFramebufferRenderbuffer");
glGetFramebufferAttachmentParameteriv = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC) wglGetProcAddress("glGetFramebufferAttachmentParameteriv");
glGenerateMipmap = (PFNGLGENERATEMIPMAPPROC) wglGetProcAddress("glGenerateMipmap");
}
else
if (strstr(gl_extensions, "EXT_framebuffer_object"))
{
CCLog("OpenGL: EXT_framebuffer_object is supported\n");
glIsRenderbuffer = (PFNGLISRENDERBUFFERPROC) wglGetProcAddress("glIsRenderbufferEXT");
glBindRenderbuffer = (PFNGLBINDRENDERBUFFERPROC) wglGetProcAddress("glBindRenderbufferEXT");
glDeleteRenderbuffers = (PFNGLDELETERENDERBUFFERSPROC) wglGetProcAddress("glDeleteRenderbuffersEXT");
glGenRenderbuffers = (PFNGLGENRENDERBUFFERSPROC) wglGetProcAddress("glGenRenderbuffersEXT");
glRenderbufferStorage = (PFNGLRENDERBUFFERSTORAGEPROC) wglGetProcAddress("glRenderbufferStorageEXT");
glGetRenderbufferParameteriv = (PFNGLGETRENDERBUFFERPARAMETERIVPROC) wglGetProcAddress("glGetRenderbufferParameterivEXT");
glIsFramebuffer = (PFNGLISFRAMEBUFFERPROC) wglGetProcAddress("glIsFramebufferEXT");
glBindFramebuffer = (PFNGLBINDFRAMEBUFFERPROC) wglGetProcAddress("glBindFramebufferEXT");
glDeleteFramebuffers = (PFNGLDELETEFRAMEBUFFERSPROC) wglGetProcAddress("glDeleteFramebuffersEXT");
glGenFramebuffers = (PFNGLGENFRAMEBUFFERSPROC) wglGetProcAddress("glGenFramebuffersEXT");
glCheckFramebufferStatus = (PFNGLCHECKFRAMEBUFFERSTATUSPROC) wglGetProcAddress("glCheckFramebufferStatusEXT");
glFramebufferTexture1D = (PFNGLFRAMEBUFFERTEXTURE1DPROC) wglGetProcAddress("glFramebufferTexture1DEXT");
glFramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC) wglGetProcAddress("glFramebufferTexture2DEXT");
glFramebufferTexture3D = (PFNGLFRAMEBUFFERTEXTURE3DPROC) wglGetProcAddress("glFramebufferTexture3DEXT");
glFramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC) wglGetProcAddress("glFramebufferRenderbufferEXT");
glGetFramebufferAttachmentParameteriv = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC) wglGetProcAddress("glGetFramebufferAttachmentParameterivEXT");
glGenerateMipmap = (PFNGLGENERATEMIPMAPPROC) wglGetProcAddress("glGenerateMipmapEXT");
}
else
{
CCLog("OpenGL: No framebuffers extension is supported\n");
CCLog("OpenGL: Any call to Fbo will crash!\n");
return false;
}
}
return true;
}
// the program starts here
void AppMain() {
// initialise GLFW
if(!glfwInit())
throw std::runtime_error("glfwInit failed");
// open a window with GLFW
glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 3);
glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 2);
glfwOpenWindowHint(GLFW_WINDOW_NO_RESIZE, GL_TRUE);
if(!glfwOpenWindow((int)SCREEN_SIZE.x, (int)SCREEN_SIZE.y, 8, 8, 8, 8, 16, 0, GLFW_WINDOW))
throw std::runtime_error("glfwOpenWindow failed. Can your hardware handle OpenGL 3.2?");
// GLFW settings
glfwDisable(GLFW_MOUSE_CURSOR);
glfwSetMousePos(0, 0);
glfwSetMouseWheel(0);
// initialise GLEW
glewExperimental = GL_TRUE; //stops glew crashing on OSX :-/
if(glewInit() != GLEW_OK)
throw std::runtime_error("glewInit failed");
// GLEW throws some errors, so discard all the errors so far
while(glGetError() != GL_NO_ERROR) {}
// print out some info about the graphics drivers
std::cout << "OpenGL version: " << glGetString(GL_VERSION) << std::endl;
std::cout << "GLSL version: " << glGetString(GL_SHADING_LANGUAGE_VERSION) << std::endl;
std::cout << "Vendor: " << glGetString(GL_VENDOR) << std::endl;
std::cout << "Renderer: " << glGetString(GL_RENDERER) << std::endl;
// make sure OpenGL version 3.2 API is available
if(!GLEW_VERSION_3_2)
throw std::runtime_error("OpenGL 3.2 API is not available.");
// OpenGL settings
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
// initialise the gWoodenCrate asset
LoadWoodenCrateAsset();
// create all the instances in the 3D scene based on the gWoodenCrate asset
CreateInstances();
// setup gCamera
gCamera.setPosition(glm::vec3(-4,0,17));
gCamera.setViewportAspectRatio(SCREEN_SIZE.x / SCREEN_SIZE.y);
// run while the window is open
double lastTime = glfwGetTime();
while(glfwGetWindowParam(GLFW_OPENED)){
// update the scene based on the time elapsed since last update
double thisTime = glfwGetTime();
Update(thisTime - lastTime);
lastTime = thisTime;
// draw one frame
Render();
// check for errors
GLenum error = glGetError();
if(error != GL_NO_ERROR)
std::cerr << "OpenGL Error " << error << ": " << (const char*)gluErrorString(error) << std::endl;
//exit program if escape key is pressed
if(glfwGetKey(GLFW_KEY_ESC))
glfwCloseWindow();
}
// clean up and exit
glfwTerminate();
}
//--------------------------------------------------------------
void gamuzaMain::update(){
char temp_message[512];
//////////////////////////////////////////////
// INIT PROGRAM | splash image control
if(ofGetElapsedTimeMillis() > splashWait){
splashFinish = true;
if(flagSystemLoaded){
flagSystemLoaded = false;
sprintf(temp_message,"OpenGL version: %s", glGetString (GL_VERSION));
sendPrivateMessage(GAMUZA_CONSOLE_LOG, temp_message);
sendPrivateMessage(GAMUZA_CONSOLE_LOG, " ");
if(GL_ARB_shader_objects){
sprintf(temp_message,"GL_ARB_shader SUPPORTED by your Graphic Card: %s", glGetString (GL_RENDERER));
sendPrivateMessage(GAMUZA_CONSOLE_LOG, temp_message);
sendPrivateMessage(GAMUZA_CONSOLE_LOG, " ");
}else{
sprintf(temp_message,"GL_ARB_shader NOT SUPPORTED by your Graphic Card: %s", glGetString (GL_RENDERER));
sendPrivateMessage(GAMUZA_CONSOLE_LOG, temp_message);
sendPrivateMessage(GAMUZA_CONSOLE_LOG, "switching to SHADER OFF MODE");
sendPrivateMessage(GAMUZA_CONSOLE_LOG, " ");
}
if(audioActivated){
soundStream.start();
sendPrivateMessage(GAMUZA_CONSOLE_LOG, "soundStream STARTED");
sendPrivateMessage(GAMUZA_CONSOLE_LOG, " ");
for(unsigned int i = 0; i < audioInputChannels; i++){
inputAudioCH[i].computeChannel = true;
}
computeAudioInput = true;
computeAudioOutput = true;
}
if(arduinoActivated){
sendPrivateMessage(GAMUZA_CONSOLE_LOG, "ARDUINO connection established");
sendPrivateMessage(GAMUZA_CONSOLE_LOG, " ");
}
}
//////////////////////////////////////////////
// Main settings control
ofSetVerticalSync(useVSync);
//////////////////////////////////////////////
//////////////////////////////////////////////
// GUI update
updateGui();
gui.update();
//////////////////////////////////////////////
//////////////////////////////////////////////
// FBO Output Texture update
updateFBO();
//////////////////////////////////////////////
//////////////////////////////////////////////
// OPENNI
if(openniActivated && sensorKinect.useKinect && sensorKinect.isOniConnected){
sensorKinect.updateDevice();
}
//////////////////////////////////////////////
//////////////////////////////////////////////
// WEBCAM input devices update
if(trackingActivated){
for(unsigned int i=0;i<numCamInputs;i++){
if(inputCam[i].captureVideo){
inputCam[i].update();
}
}
}
//////////////////////////////////////////////
//////////////////////////////////////////////
// ARDUINO update
if(arduinoActivated && useArduino){
updateArduino();
}
//////////////////////////////////////////////
}
//////////////////////////////////////////////
//////////////////////////////////////////////
// OSC update
updateOSC();
// OSC messages receiving
receiveOSC();
//////////////////////////////////////////////
//////////////////////////////////////////////
// SYSTEM
gamuzaRealFPS = ofGetFrameRate();
gaFrameCounter++;
//////////////////////////////////////////////
}
bool csGraphics2DGLCommon::Open ()
{
if (is_open) return true;
ext.Open ();
OpenDriverDB ();
statecache = new csGLStateCache (&ext);
statecontext = new csGLStateCacheContext (&ext);
statecache->SetContext (statecontext);
statecontext->InitCache();
// initialize font cache object
csGLFontCache* GLFontCache = new csGLFontCache (this);
fontCache = GLFontCache;
statecache->Enable_GL_SCISSOR_TEST ();
/* Some drivers need that to get the initial scissor right
* (Mesa DRI Intel(R) 915GM 20050225 in this case) */
glScissor (0, 0, 1, 1);
if (!csGraphics2D::Open ())
return false;
const char *renderer = (const char *)glGetString (GL_RENDERER);
const char *vendor = (const char *)glGetString (GL_VENDOR);
const char *version = (const char *)glGetString (GL_VERSION);
if (renderer || version || vendor)
Report (CS_REPORTER_SEVERITY_NOTIFY,
"OpenGL renderer: %s (vendor: %s) version %s",
renderer ? renderer : "unknown", vendor ? vendor: "unknown",
version ? version : "unknown");
Report (CS_REPORTER_SEVERITY_NOTIFY,
"Using %s mode at resolution %dx%d.",
FullScreen ? "full screen" : "windowed", fbWidth, fbHeight);
{
csString pfStr;
GetPixelFormatString (currentFormat, pfStr);
Report (CS_REPORTER_SEVERITY_NOTIFY,
"Pixel format: %s", pfStr.GetData());
}
if (currentFormat[glpfvColorBits] < 24)
{
Report (CS_REPORTER_SEVERITY_WARNING,
"WARNING! Crystal Space performs better in 24 or 32 bit display mode!");
}
if (version)
{
// initialize GL version pseudo-extensions
int n, vMajor, vMinor, vRelease;
n = sscanf (version, "%d.%d.%d", &vMajor, &vMinor, &vRelease);
if (n >= 2)
{
// Sanity check
if ((vMajor < 1) || ((vMajor == 1) && (vMinor < 1)))
{
Report (CS_REPORTER_SEVERITY_ERROR,
"OpenGL >= 1.1 is required, but only %d.%d is present.",
vMajor, vMinor);
}
if ((vMajor >= 1) || ((vMajor == 1) && (vMinor >= 2)))
{
//ext.InitGL_version_1_2 ();
}
if ((vMajor >= 1) || ((vMajor == 1) && (vMinor >= 3)))
{
//ext.InitGL_version_1_3 ();
}
}
}
ext.InitGL_ARB_multitexture ();
ext.InitGL_ARB_texture_env_combine ();
if (!ext.CS_GL_ARB_texture_env_combine)
ext.InitGL_EXT_texture_env_combine ();
useCombineTE = ext.CS_GL_ARB_multitexture &&
(ext.CS_GL_ARB_texture_env_combine || ext.CS_GL_EXT_texture_env_combine);
if (useCombineTE)
{
for (GLint u = statecache->GetNumTexCoords(); u-- > 0; )
{
statecache->SetCurrentTCUnit (u);
statecache->ActivateTCUnit (csGLStateCache::activateTexEnv);
glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);
}
}
ext.InitGL_EXT_blend_func_separate ();
ext.InitGL_ARB_multisample();
if (ext.CS_GL_ARB_multisample)
{
GLint glmultisamp = (GLint)currentFormat[glpfvMultiSamples];
glGetIntegerv (GL_SAMPLES_ARB, &glmultisamp);
if (glmultisamp)
{
if (glmultisamp != currentFormat[glpfvMultiSamples])
Report (CS_REPORTER_SEVERITY_NOTIFY,
"Multisample: actually %d samples", (int)glmultisamp);
ext.InitGL_NV_multisample_filter_hint();
if (ext.CS_GL_NV_multisample_filter_hint)
{
glHint (GL_MULTISAMPLE_FILTER_HINT_NV,
multiFavorQuality ? GL_NICEST : GL_FASTEST);
GLint msHint;
glGetIntegerv (GL_MULTISAMPLE_FILTER_HINT_NV, &msHint);
Report (CS_REPORTER_SEVERITY_NOTIFY,
"Multisample settings: %s", ((msHint == GL_NICEST) ? "quality" :
((msHint == GL_FASTEST) ? "performance" : "unknown")));
}
}
else
{
Report (CS_REPORTER_SEVERITY_NOTIFY,
"Multisample: disabled");
}
}
GLFontCache->Setup();
CS::PluginCommon::GL::SetAssumedState (statecache, &ext);
glClearColor (0., 0., 0., 0.);
statecache->SetMatrixMode (GL_MODELVIEW);
glLoadIdentity ();
glViewport (0, 0, vpWidth, vpHeight);
Clear (0);
openComplete = true;
return true;
}
void GL_FindExtensions()
{
// get extension pointers
const char * extensions = (const char *)glGetString( GL_EXTENSIONS );
if ( NULL == extensions )
{
LOG( "glGetString( GL_EXTENSIONS ) returned NULL" );
return;
}
// Unfortunately, the Android log truncates strings over 1024 bytes long,
// even if there are \n inside, so log each word in the string separately.
LOG( "GL_EXTENSIONS:" );
LogStringWords( extensions );
const bool es3 = ( strncmp( (const char *)glGetString( GL_VERSION ), "OpenGL ES 3", 11 ) == 0 );
LOG( "es3 = %s", es3 ? "TRUE" : "FALSE" );
if ( GL_ExtensionStringPresent( "GL_EXT_discard_framebuffer", extensions ) )
{
EXT_discard_framebuffer = true;
glDiscardFramebufferEXT_ = (PFNGLDISCARDFRAMEBUFFEREXTPROC)GetExtensionProc( "glDiscardFramebufferEXT" );
}
if ( GL_ExtensionStringPresent( "GL_IMG_multisampled_render_to_texture", extensions ) )
{
IMG_multisampled_render_to_texture = true;
glRenderbufferStorageMultisampleIMG_ = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEIMG)GetExtensionProc ( "glRenderbufferStorageMultisampleIMG" );
glFramebufferTexture2DMultisampleIMG_ = (PFNGLFRAMEBUFFERTEXTURE2DMULTISAMPLEIMG)GetExtensionProc ( "glFramebufferTexture2DMultisampleIMG" );
}
else if ( GL_ExtensionStringPresent( "GL_EXT_multisampled_render_to_texture", extensions ) )
{
// assign to the same function pointers as the IMG extension
IMG_multisampled_render_to_texture = true;
glRenderbufferStorageMultisampleIMG_ = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEIMG)GetExtensionProc ( "glRenderbufferStorageMultisampleEXT" );
glFramebufferTexture2DMultisampleIMG_ = (PFNGLFRAMEBUFFERTEXTURE2DMULTISAMPLEIMG)GetExtensionProc ( "glFramebufferTexture2DMultisampleEXT" );
}
eglCreateSyncKHR_ = (PFNEGLCREATESYNCKHRPROC)GetExtensionProc( "eglCreateSyncKHR" );
eglDestroySyncKHR_ = (PFNEGLDESTROYSYNCKHRPROC)GetExtensionProc( "eglDestroySyncKHR" );
eglClientWaitSyncKHR_ = (PFNEGLCLIENTWAITSYNCKHRPROC)GetExtensionProc( "eglClientWaitSyncKHR" );
eglSignalSyncKHR_ = (PFNEGLSIGNALSYNCKHRPROC)GetExtensionProc( "eglSignalSyncKHR" );
eglGetSyncAttribKHR_ = (PFNEGLGETSYNCATTRIBKHRPROC)GetExtensionProc( "eglGetSyncAttribKHR" );
if ( GL_ExtensionStringPresent( "GL_OES_vertex_array_object", extensions ) )
{
OES_vertex_array_object = true;
glBindVertexArrayOES_ = (PFNGLBINDVERTEXARRAYOESPROC)eglGetProcAddress("glBindVertexArrayOES");
glDeleteVertexArraysOES_ = (PFNGLDELETEVERTEXARRAYSOESPROC)eglGetProcAddress("glDeleteVertexArraysOES");
glGenVertexArraysOES_ = (PFNGLGENVERTEXARRAYSOESPROC)eglGetProcAddress("glGenVertexArraysOES");
glIsVertexArrayOES_ = (PFNGLISVERTEXARRAYOESPROC)eglGetProcAddress("glIsVertexArrayOES");
}
if ( GL_ExtensionStringPresent( "GL_QCOM_tiled_rendering", extensions ) )
{
QCOM_tiled_rendering = true;
glStartTilingQCOM_ = (PFNGLSTARTTILINGQCOMPROC)eglGetProcAddress("glStartTilingQCOM");
glEndTilingQCOM_ = (PFNGLENDTILINGQCOMPROC)eglGetProcAddress("glEndTilingQCOM");
}
// Enabling this seems to cause strange problems in Unity
if ( GL_ExtensionStringPresent( "GL_EXT_disjoint_timer_query", extensions ) )
{
EXT_disjoint_timer_query = true;
glGenQueriesEXT_ = (PFNGLGENQUERIESEXTPROC)eglGetProcAddress("glGenQueriesEXT");
glDeleteQueriesEXT_ = (PFNGLDELETEQUERIESEXTPROC)eglGetProcAddress("glDeleteQueriesEXT");
glIsQueryEXT_ = (PFNGLISQUERYEXTPROC)eglGetProcAddress("glIsQueryEXT");
glBeginQueryEXT_ = (PFNGLBEGINQUERYEXTPROC)eglGetProcAddress("glBeginQueryEXT");
glEndQueryEXT_ = (PFNGLENDQUERYEXTPROC)eglGetProcAddress("glEndQueryEXT");
glQueryCounterEXT_ = (PFNGLQUERYCOUNTEREXTPROC)eglGetProcAddress("glQueryCounterEXT");
glGetQueryivEXT_ = (PFNGLGETQUERYIVEXTPROC)eglGetProcAddress("glGetQueryivEXT");
glGetQueryObjectivEXT_ = (PFNGLGETQUERYOBJECTIVEXTPROC)eglGetProcAddress("glGetQueryObjectivEXT");
glGetQueryObjectuivEXT_ = (PFNGLGETQUERYOBJECTUIVEXTPROC)eglGetProcAddress("glGetQueryObjectuivEXT");
glGetQueryObjecti64vEXT_ = (PFNGLGETQUERYOBJECTI64VEXTPROC)eglGetProcAddress("glGetQueryObjecti64vEXT");
glGetQueryObjectui64vEXT_ = (PFNGLGETQUERYOBJECTUI64VEXTPROC)eglGetProcAddress("glGetQueryObjectui64vEXT");
glGetInteger64v_ = (PFNGLGETINTEGER64VPROC)eglGetProcAddress("glGetInteger64v");
}
if ( GL_ExtensionStringPresent( "GL_EXT_texture_sRGB_decode", extensions ) )
{
HasEXT_sRGB_texture_decode = true;
}
if ( GL_ExtensionStringPresent( "GL_EXT_texture_filter_anisotropic", extensions ) )
{
EXT_texture_filter_anisotropic = true;
}
GLint MaxTextureSize = 0;
glGetIntegerv( GL_MAX_TEXTURE_SIZE, &MaxTextureSize );
LOG( "GL_MAX_TEXTURE_SIZE = %d", MaxTextureSize );
GLint MaxVertexUniformVectors = 0;
glGetIntegerv( GL_MAX_VERTEX_UNIFORM_VECTORS, &MaxVertexUniformVectors );
LOG( "GL_MAX_VERTEX_UNIFORM_VECTORS = %d", MaxVertexUniformVectors );
GLint MaxFragmentUniformVectors = 0;
glGetIntegerv( GL_MAX_FRAGMENT_UNIFORM_VECTORS, &MaxFragmentUniformVectors );
LOG( "GL_MAX_FRAGMENT_UNIFORM_VECTORS = %d", MaxFragmentUniformVectors );
// ES3 functions we need to getprocaddress to allow linking against ES2 lib
glBlitFramebuffer_ = (PFNGLBLITFRAMEBUFFER_)eglGetProcAddress("glBlitFramebuffer");
glRenderbufferStorageMultisample_ = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLE_)eglGetProcAddress("glRenderbufferStorageMultisample");
glInvalidateFramebuffer_ = (PFNGLINVALIDATEFRAMEBUFFER_)eglGetProcAddress("glInvalidateFramebuffer");
glMapBufferRange_ = (PFNGLMAPBUFFERRANGE_)eglGetProcAddress("glMapBufferRange");
glUnmapBuffer_ = (PFNGLUNMAPBUFFEROESPROC_)eglGetProcAddress("glUnmapBuffer");
}
GraphicsContext3DInternal::GraphicsContext3DInternal(HTMLCanvasElement* canvas,
GraphicsContext3D::Attributes attrs,
HostWindow* hostWindow)
: m_proxy(adoptRef(new GraphicsContext3DProxy()))
, m_compositingLayer(new WebGLLayer(m_proxy))
, m_canvas(canvas)
, m_attrs(attrs)
, m_layerComposited(false)
, m_canvasDirty(false)
, m_width(1)
, m_height(1)
, m_maxwidth(CANVAS_MAX_WIDTH)
, m_maxheight(CANVAS_MAX_HEIGHT)
, m_dpy(EGL_NO_DISPLAY)
, m_config(0)
, m_surface(EGL_NO_SURFACE)
, m_context(EGL_NO_CONTEXT)
, m_syncThread(0)
, m_threadState(THREAD_STATE_STOPPED)
, m_syncTimer(this, &GraphicsContext3DInternal::syncTimerFired)
, m_syncRequested(false)
, m_webGLFPSTimer(0)
, m_extensions(0)
, m_contextId(0)
//[CAPPFIX_WEB_WEBGL] - Handle FBO creation failure
, m_nfbo(0)
//[CAPPFIX_WEB_WEBGL_END]
//[CAPPFIX_WEB_WEBGL] - Improve UI Response Begin
, m_needImproveUIResponseMode(false)
//[CAPPFIX_WEB_WEBGL_END]
{
enableLogging();
LOGWEBGL("GraphicsContext3DInternal() = %p, m_compositingLayer = %p", this, m_compositingLayer);
m_proxy->setGraphicsContext(this);
if (!m_canvas || !m_canvas->document() || !m_canvas->document()->view())
return;
JNIEnv* env = JSC::Bindings::getJNIEnv();
WebViewCore* core = WebViewCore::getWebViewCore(m_canvas->document()->view());
if (!core)
return;
jobject tmp = core->getWebViewJavaObject();
m_webView = env->NewGlobalRef(tmp);
if (!m_webView)
return;
jclass webViewClass = env->GetObjectClass(m_webView);
m_postInvalidate = env->GetMethodID(webViewClass, "postInvalidate", "()V");
env->DeleteLocalRef(webViewClass);
if (!m_postInvalidate)
return;
if (!initEGL())
return;
//[CAPPFIX_WEB_WEBGL] - for WebGL Conformance Test
if (contextCounter > 10)
{
LOGWEBGL("call m_canvas->document()->frame()->script()->lowMemoryNotification()");
m_canvas->document()->frame()->script()->lowMemoryNotification();
}
// [CAPPFIX_WEB_WEBGL_END] - end
if (!createContext(true)) {
LOGWEBGL("Create context failed. Perform JS garbage collection and try again.");
// Probably too many contexts. Force a JS garbage collection, and then try again.
// This typically only happens in Khronos Conformance tests.
m_canvas->document()->frame()->script()->lowMemoryNotification();
if (!createContext(true)) {
LOGWEBGL("Create context still failed: aborting.");
return;
}
}
m_webGLFPSTimer.set(new WebGLFPSTimer());
const char *ext = (const char *)glGetString(GL_EXTENSIONS);
LOGWEBGL("GL_EXTENSIONS = %s", ext);
// Want to keep control of which extensions are used
String extensions = "";
if (strstr(ext, "GL_OES_texture_npot"))
extensions.append("GL_OES_texture_npot");
//[CAPPFIX_WEB_WEBGL] - Do not support extension at this time.
#if 0
if (strstr(ext, "GL_OES_packed_depth_stencil"))
extensions.append(" GL_OES_packed_depth_stencil");
if (strstr(ext, "GL_OES_texture_float"))
extensions.append(" GL_OES_texture_float");
#endif
m_extensions.set(new Extensions3DAndroid(extensions));
//[CAPPFIX_WEB_WEBGL_END]
// ANGLE initialization.
ShBuiltInResources resources;
ShInitBuiltInResources(&resources);
glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &resources.MaxVertexAttribs);
glGetIntegerv(GL_MAX_VERTEX_UNIFORM_VECTORS, &resources.MaxVertexUniformVectors);
glGetIntegerv(GL_MAX_VARYING_VECTORS, &resources.MaxVaryingVectors);
glGetIntegerv(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS, &resources.MaxVertexTextureImageUnits);
glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &resources.MaxCombinedTextureImageUnits);
glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &resources.MaxTextureImageUnits);
glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_VECTORS, &resources.MaxFragmentUniformVectors);
resources.MaxDrawBuffers = 1;
m_compiler.setResources(resources);
m_savedViewport.x = 0;
m_savedViewport.y = 0;
m_savedViewport.width = m_width;
m_savedViewport.height = m_height;
glClearColor(0, 0, 0, 0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
startSyncThread();
//[CAPPFIX_WEB_WEBGL] - for WebGL Conformance Test
//static int contextCounter = 1;
m_contextId = contextCounter++;
}
std::string getGLVersion() const {
return std::string(reinterpret_cast<const char*>(glGetString(GL_VERSION)));
}
static void Init( int argc, char *argv[] )
{
GLUquadricObj *q = gluNewQuadric();
CylinderObj = glGenLists(1);
glNewList(CylinderObj, GL_COMPILE);
glTranslatef(0.0, 0.0, -1.0);
/* cylinder */
gluQuadricNormals(q, GL_SMOOTH);
gluQuadricTexture(q, GL_TRUE);
gluCylinder(q, 0.6, 0.6, 2.0, 24, 1);
/* end cap */
glTranslatef(0.0, 0.0, 2.0);
gluDisk(q, 0.0, 0.6, 24, 1);
/* other end cap */
glTranslatef(0.0, 0.0, -2.0);
gluQuadricOrientation(q, GLU_INSIDE);
gluDisk(q, 0.0, 0.6, 24, 1);
glEndList();
gluDeleteQuadric(q);
/* lighting */
glEnable(GL_LIGHTING);
{
GLfloat gray[4] = {0.2, 0.2, 0.2, 1.0};
GLfloat white[4] = {1.0, 1.0, 1.0, 1.0};
GLfloat teal[4] = { 0.0, 1.0, 0.8, 1.0 };
glMaterialfv(GL_FRONT, GL_DIFFUSE, teal);
glLightfv(GL_LIGHT0, GL_AMBIENT, gray);
glLightfv(GL_LIGHT0, GL_DIFFUSE, white);
glEnable(GL_LIGHT0);
}
/* fitering = nearest, initially */
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
if (!LoadRGBMipmaps(TEXTURE_FILE, GL_RGB)) {
printf("Error: couldn't load texture image\n");
exit(1);
}
glEnable(GL_CULL_FACE); /* don't need Z testing for convex objects */
SetMode(LIT);
if (argc > 1 && strcmp(argv[1], "-info")==0) {
printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER));
printf("GL_VERSION = %s\n", (char *) glGetString(GL_VERSION));
printf("GL_VENDOR = %s\n", (char *) glGetString(GL_VENDOR));
printf("GL_EXTENSIONS = %s\n", (char *) glGetString(GL_EXTENSIONS));
}
}
void COGLGraphicsContext::InitState(void)
{
m_pRenderStr = glGetString(GL_RENDERER);
m_pExtensionStr = glGetString(GL_EXTENSIONS);
m_pVersionStr = glGetString(GL_VERSION);
m_pVendorStr = glGetString(GL_VENDOR);
glMatrixMode(GL_PROJECTION);
OPENGL_CHECK_ERRORS;
glLoadIdentity();
OPENGL_CHECK_ERRORS;
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
OPENGL_CHECK_ERRORS;
glClearDepth(1.0f);
OPENGL_CHECK_ERRORS;
#if SDL_VIDEO_OPENGL
glShadeModel(GL_SMOOTH);
OPENGL_CHECK_ERRORS;
//position viewer
//glMatrixMode(GL_MODELVIEW);
//glLoadIdentity();
glDisable(GL_ALPHA_TEST);
OPENGL_CHECK_ERRORS;
#endif
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
OPENGL_CHECK_ERRORS;
glDisable(GL_BLEND);
OPENGL_CHECK_ERRORS;
glFrontFace(GL_CCW);
OPENGL_CHECK_ERRORS;
glDisable(GL_CULL_FACE);
OPENGL_CHECK_ERRORS;
#if SDL_VIDEO_OPENGL
glDisable(GL_NORMALIZE);
OPENGL_CHECK_ERRORS;
#endif
glEnable(GL_DEPTH_TEST);
OPENGL_CHECK_ERRORS;
glDepthFunc(GL_LEQUAL);
OPENGL_CHECK_ERRORS;
#if SDL_VIDEO_OPENGL
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
OPENGL_CHECK_ERRORS;
#endif
glEnable(GL_BLEND);
OPENGL_CHECK_ERRORS;
#if SDL_VIDEO_OPENGL
glEnable(GL_ALPHA_TEST);
OPENGL_CHECK_ERRORS;
glMatrixMode(GL_PROJECTION);
OPENGL_CHECK_ERRORS;
glLoadIdentity();
OPENGL_CHECK_ERRORS;
glDepthRange(-1, 1);
#elif SDL_VIDEO_OPENGL_ES2
glDepthRangef(0.0f, 1.0f); //RJH test
//glDepthRangef(0.0f, 1.0f);
#endif
OPENGL_CHECK_ERRORS;
}
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
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;
}
/*
===============
GLimp_InitExtensions
===============
*/
static void GLimp_InitExtensions( void )
{
ri.Printf( PRINT_ALL, "Initializing OpenGL extensions\n" );
if ( GLEW_ARB_debug_output )
{
if ( r_glDebugProfile->integer )
{
glDebugMessageCallbackARB( GLimp_DebugCallback, NULL );
glEnable( GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB );
ri.Printf( PRINT_ALL, "...using GL_ARB_debug_output\n" );
}
else
{
ri.Printf( PRINT_ALL, "...ignoring GL_ARB_debug_output\n" );
}
}
else
{
ri.Printf( PRINT_ALL, "...GL_ARB_debug_output not found\n" );
}
// GL_ARB_multitexture
if ( glConfig.driverType != GLDRV_OPENGL3 )
{
if ( GLEW_ARB_multitexture )
{
glGetIntegerv( GL_MAX_TEXTURE_UNITS_ARB, &glConfig.maxActiveTextures );
if ( glConfig.maxActiveTextures > 1 )
{
ri.Printf( PRINT_ALL, "...using GL_ARB_multitexture\n" );
}
else
{
ri.Error( ERR_FATAL, "...not using GL_ARB_multitexture, < 2 texture units" );
}
}
else
{
ri.Error( ERR_FATAL, "...GL_ARB_multitexture not found" );
}
}
// GL_ARB_depth_texture
if ( GLEW_ARB_depth_texture )
{
ri.Printf( PRINT_ALL, "...using GL_ARB_depth_texture\n" );
}
else
{
ri.Error( ERR_FATAL, "...GL_ARB_depth_texture not found" );
}
// GL_ARB_texture_cube_map
if ( GLEW_ARB_texture_cube_map )
{
glGetIntegerv( GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB, &glConfig2.maxCubeMapTextureSize );
ri.Printf( PRINT_ALL, "...using GL_ARB_texture_cube_map\n" );
}
else
{
ri.Error( ERR_FATAL, "...GL_ARB_texture_cube_map not found" );
}
GL_CheckErrors();
// GL_ARB_vertex_program
if ( GLEW_ARB_vertex_program )
{
ri.Printf( PRINT_ALL, "...using GL_ARB_vertex_program\n" );
}
else
{
ri.Error( ERR_FATAL, "...GL_ARB_vertex_program not found" );
}
// GL_ARB_vertex_buffer_object
if ( GLEW_ARB_vertex_buffer_object )
{
ri.Printf( PRINT_ALL, "...using GL_ARB_vertex_buffer_object\n" );
}
else
{
ri.Error( ERR_FATAL, "...GL_ARB_vertex_buffer_object not found" );
}
// GL_ARB_occlusion_query
glConfig2.occlusionQueryAvailable = qfalse;
glConfig2.occlusionQueryBits = 0;
if ( GLEW_ARB_occlusion_query )
{
if ( r_ext_occlusion_query->value )
{
glConfig2.occlusionQueryAvailable = qtrue;
glGetQueryivARB( GL_SAMPLES_PASSED, GL_QUERY_COUNTER_BITS, &glConfig2.occlusionQueryBits );
ri.Printf( PRINT_ALL, "...using GL_ARB_occlusion_query\n" );
}
else
{
ri.Printf( PRINT_ALL, "...ignoring GL_ARB_occlusion_query\n" );
}
}
else
{
ri.Printf( PRINT_ALL, "...GL_ARB_occlusion_query not found\n" );
}
GL_CheckErrors();
// GL_ARB_shader_objects
if ( GLEW_ARB_shader_objects )
{
ri.Printf( PRINT_ALL, "...using GL_ARB_shader_objects\n" );
}
else
{
ri.Error( ERR_FATAL, "...GL_ARB_shader_objects not found" );
}
// GL_ARB_vertex_shader
if ( GLEW_ARB_vertex_shader )
{
int reservedComponents;
GL_CheckErrors();
glGetIntegerv( GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB, &glConfig2.maxVertexUniforms );
GL_CheckErrors();
//glGetIntegerv(GL_MAX_VARYING_FLOATS_ARB, &glConfig.maxVaryingFloats); GL_CheckErrors();
glGetIntegerv( GL_MAX_VERTEX_ATTRIBS_ARB, &glConfig2.maxVertexAttribs );
GL_CheckErrors();
reservedComponents = 16 * 10; // approximation how many uniforms we have besides the bone matrices
/*
if(glConfig.driverType == GLDRV_MESA)
{
// HACK
// restrict to number of vertex uniforms to 512 because of:
// xreal.x86_64: nv50_program.c:4181: nv50_program_validate_data: Assertion `p->param_nr <= 512' failed
glConfig2.maxVertexUniforms = Maths::clamp(glConfig2.maxVertexUniforms, 0, 512);
}
*/
glConfig2.maxVertexSkinningBones = Maths::clamp( ( glConfig2.maxVertexUniforms - reservedComponents ) / 16, 0, MAX_BONES );
glConfig2.vboVertexSkinningAvailable = r_vboVertexSkinning->integer && ( ( glConfig2.maxVertexSkinningBones >= 12 ) ? qtrue : qfalse );
ri.Printf( PRINT_ALL, "...using GL_ARB_vertex_shader\n" );
}
else
{
ri.Error( ERR_FATAL, "...GL_ARB_vertex_shader not found" );
}
GL_CheckErrors();
// GL_ARB_fragment_shader
if ( GLEW_ARB_fragment_shader )
{
ri.Printf( PRINT_ALL, "...using GL_ARB_fragment_shader\n" );
}
else
{
ri.Error( ERR_FATAL, "...GL_ARB_fragment_shader not found" );
}
// GL_ARB_shading_language_100
if ( GLEW_ARB_shading_language_100 )
{
int majorVersion, minorVersion;
Q_strncpyz( glConfig2.shadingLanguageVersionString, ( char * ) glGetString( GL_SHADING_LANGUAGE_VERSION_ARB ),
sizeof( glConfig2.shadingLanguageVersionString ) );
if ( sscanf( glConfig2.shadingLanguageVersionString, "%i.%i", &majorVersion, &minorVersion ) != 2 )
{
ri.Printf( PRINT_ALL, "WARNING: unrecognized shading language version string format\n" );
}
glConfig2.shadingLanguageVersion = majorVersion * 100 + minorVersion;
ri.Printf( PRINT_ALL, "...found shading language version %i\n", glConfig2.shadingLanguageVersion );
ri.Printf( PRINT_ALL, "...using GL_ARB_shading_language_100\n" );
}
else
{
ri.Printf( ERR_FATAL, "...GL_ARB_shading_language_100 not found\n" );
}
GL_CheckErrors();
// GL_ARB_texture_non_power_of_two
glConfig2.textureNPOTAvailable = qfalse;
if ( GLEW_ARB_texture_non_power_of_two )
{
if ( r_ext_texture_non_power_of_two->integer )
{
glConfig2.textureNPOTAvailable = qtrue;
ri.Printf( PRINT_ALL, "...using GL_ARB_texture_non_power_of_two\n" );
}
else
{
ri.Printf( PRINT_ALL, "...ignoring GL_ARB_texture_non_power_of_two\n" );
}
}
else
{
ri.Printf( PRINT_ALL, "...GL_ARB_texture_non_power_of_two not found\n" );
}
// GL_ARB_draw_buffers
glConfig2.drawBuffersAvailable = qfalse;
if ( GLEW_ARB_draw_buffers )
{
glGetIntegerv( GL_MAX_DRAW_BUFFERS_ARB, &glConfig2.maxDrawBuffers );
if ( r_ext_draw_buffers->integer )
{
glConfig2.drawBuffersAvailable = qtrue;
ri.Printf( PRINT_ALL, "...using GL_ARB_draw_buffers\n" );
}
else
{
ri.Printf( PRINT_ALL, "...ignoring GL_ARB_draw_buffers\n" );
}
}
else
{
ri.Printf( PRINT_ALL, "...GL_ARB_draw_buffers not found\n" );
}
// GL_ARB_half_float_pixel
glConfig2.textureHalfFloatAvailable = qfalse;
if ( GLEW_ARB_half_float_pixel )
{
if ( r_ext_half_float_pixel->integer )
{
glConfig2.textureHalfFloatAvailable = qtrue;
ri.Printf( PRINT_ALL, "...using GL_ARB_half_float_pixel\n" );
}
else
{
ri.Printf( PRINT_ALL, "...ignoring GL_ARB_half_float_pixel\n" );
}
}
else
{
ri.Printf( PRINT_ALL, "...GL_ARB_half_float_pixel not found\n" );
}
// GL_ARB_texture_float
glConfig2.textureFloatAvailable = qfalse;
if ( GLEW_ARB_texture_float )
{
if ( r_ext_texture_float->integer )
{
glConfig2.textureFloatAvailable = qtrue;
ri.Printf( PRINT_ALL, "...using GL_ARB_texture_float\n" );
}
else
{
ri.Printf( PRINT_ALL, "...ignoring GL_ARB_texture_float\n" );
}
}
else
{
ri.Printf( PRINT_ALL, "...GL_ARB_texture_float not found\n" );
}
// GL_ARB_texture_rg
glConfig2.textureRGAvailable = qfalse;
if ( glConfig.driverType == GLDRV_OPENGL3 || GLEW_ARB_texture_rg )
{
if ( r_ext_texture_rg->integer )
{
glConfig2.textureRGAvailable = qtrue;
ri.Printf( PRINT_ALL, "...using GL_ARB_texture_rg\n" );
}
else
{
ri.Printf( PRINT_ALL, "...ignoring GL_ARB_texture_rg\n" );
}
}
else
{
ri.Printf( PRINT_ALL, "...GL_ARB_texture_rg not found\n" );
}
// GL_ARB_texture_compression
glConfig.textureCompression = TC_NONE;
if ( GLEW_ARB_texture_compression )
{
if ( r_ext_compressed_textures->integer )
{
glConfig2.ARBTextureCompressionAvailable = qtrue;
ri.Printf( PRINT_ALL, "...using GL_ARB_texture_compression\n" );
}
else
{
ri.Printf( PRINT_ALL, "...ignoring GL_ARB_texture_compression\n" );
}
}
else
{
ri.Printf( PRINT_ALL, "...GL_ARB_texture_compression not found\n" );
}
// GL_ARB_vertex_array_object
glConfig2.vertexArrayObjectAvailable = qfalse;
if ( GLEW_ARB_vertex_array_object )
{
if ( r_ext_vertex_array_object->integer )
{
glConfig2.vertexArrayObjectAvailable = qtrue;
ri.Printf( PRINT_ALL, "...using GL_ARB_vertex_array_object\n" );
}
else
{
ri.Printf( PRINT_ALL, "...ignoring GL_ARB_vertex_array_object\n" );
}
}
else
{
ri.Printf( PRINT_ALL, "...GL_ARB_vertex_array_object not found\n" );
}
// GL_EXT_texture_compression_s3tc
if ( GLEW_EXT_texture_compression_s3tc )
{
if ( r_ext_compressed_textures->integer )
{
glConfig.textureCompression = TC_S3TC;
ri.Printf( PRINT_ALL, "...using GL_EXT_texture_compression_s3tc\n" );
}
else
{
ri.Printf( PRINT_ALL, "...ignoring GL_EXT_texture_compression_s3tc\n" );
}
}
else
{
ri.Printf( PRINT_ALL, "...GL_EXT_texture_compression_s3tc not found\n" );
}
// GL_EXT_texture3D
glConfig2.texture3DAvailable = qfalse;
if ( GLEW_EXT_texture3D )
{
//if(r_ext_texture3d->value)
{
glConfig2.texture3DAvailable = qtrue;
ri.Printf( PRINT_ALL, "...using GL_EXT_texture3D\n" );
}
/*
else
{
ri.Printf(PRINT_ALL, "...ignoring GL_EXT_texture3D\n");
}
*/
}
else
{
ri.Printf( PRINT_ALL, "...GL_EXT_texture3D not found\n" );
}
// GL_EXT_stencil_wrap
glConfig2.stencilWrapAvailable = qfalse;
if ( GLEW_EXT_stencil_wrap )
{
if ( r_ext_stencil_wrap->value )
{
glConfig2.stencilWrapAvailable = qtrue;
ri.Printf( PRINT_ALL, "...using GL_EXT_stencil_wrap\n" );
}
else
{
ri.Printf( PRINT_ALL, "...ignoring GL_EXT_stencil_wrap\n" );
}
}
else
{
ri.Printf( PRINT_ALL, "...GL_EXT_stencil_wrap not found\n" );
}
// GL_EXT_texture_filter_anisotropic
glConfig2.textureAnisotropyAvailable = qfalse;
if ( GLEW_EXT_texture_filter_anisotropic )
{
glGetFloatv( GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &glConfig2.maxTextureAnisotropy );
if ( r_ext_texture_filter_anisotropic->value )
{
glConfig2.textureAnisotropyAvailable = qtrue;
ri.Printf( PRINT_ALL, "...using GL_EXT_texture_filter_anisotropic\n" );
}
else
{
ri.Printf( PRINT_ALL, "...ignoring GL_EXT_texture_filter_anisotropic\n" );
}
}
else
{
ri.Printf( PRINT_ALL, "...GL_EXT_texture_filter_anisotropic not found\n" );
}
GL_CheckErrors();
// GL_EXT_stencil_two_side
if ( GLEW_EXT_stencil_two_side )
{
if ( r_ext_stencil_two_side->value )
{
ri.Printf( PRINT_ALL, "...using GL_EXT_stencil_two_side\n" );
}
else
{
ri.Printf( PRINT_ALL, "...ignoring GL_EXT_stencil_two_side\n" );
}
}
else
{
ri.Printf( PRINT_ALL, "...GL_EXT_stencil_two_side not found\n" );
}
// GL_EXT_depth_bounds_test
if ( GLEW_EXT_depth_bounds_test )
{
if ( r_ext_depth_bounds_test->value )
{
ri.Printf( PRINT_ALL, "...using GL_EXT_depth_bounds_test\n" );
}
else
{
ri.Printf( PRINT_ALL, "...ignoring GL_EXT_depth_bounds_test\n" );
}
}
else
{
ri.Printf( PRINT_ALL, "...GL_EXT_depth_bounds_test not found\n" );
}
// GL_EXT_framebuffer_object
glConfig2.framebufferObjectAvailable = qfalse;
if ( GLEW_EXT_framebuffer_object )
{
glGetIntegerv( GL_MAX_RENDERBUFFER_SIZE_EXT, &glConfig2.maxRenderbufferSize );
glGetIntegerv( GL_MAX_COLOR_ATTACHMENTS_EXT, &glConfig2.maxColorAttachments );
if ( r_ext_framebuffer_object->value )
{
glConfig2.framebufferObjectAvailable = qtrue;
ri.Printf( PRINT_ALL, "...using GL_EXT_framebuffer_object\n" );
}
else
{
ri.Printf( PRINT_ALL, "...ignoring GL_EXT_framebuffer_object\n" );
}
}
else
{
ri.Printf( PRINT_ALL, "...GL_EXT_framebuffer_object not found\n" );
}
GL_CheckErrors();
// GL_EXT_packed_depth_stencil
glConfig2.framebufferPackedDepthStencilAvailable = qfalse;
if ( GLEW_EXT_packed_depth_stencil && glConfig.driverType != GLDRV_MESA )
{
if ( r_ext_packed_depth_stencil->integer )
{
glConfig2.framebufferPackedDepthStencilAvailable = qtrue;
ri.Printf( PRINT_ALL, "...using GL_EXT_packed_depth_stencil\n" );
}
else
{
ri.Printf( PRINT_ALL, "...ignoring GL_EXT_packed_depth_stencil\n" );
}
}
else
{
ri.Printf( PRINT_ALL, "...GL_EXT_packed_depth_stencil not found\n" );
}
// GL_EXT_framebuffer_blit
glConfig2.framebufferBlitAvailable = qfalse;
if ( GLEW_EXT_framebuffer_blit )
{
if ( r_ext_framebuffer_blit->integer )
{
glConfig2.framebufferBlitAvailable = qtrue;
ri.Printf( PRINT_ALL, "...using GL_EXT_framebuffer_blit\n" );
}
else
{
ri.Printf( PRINT_ALL, "...ignoring GL_EXT_framebuffer_blit\n" );
}
}
else
{
ri.Printf( PRINT_ALL, "...GL_EXT_framebuffer_blit not found\n" );
}
// GL_EXTX_framebuffer_mixed_formats
/*
glConfig.framebufferMixedFormatsAvailable = qfalse;
if(GLEW_EXTX_framebuffer_mixed_formats)
{
if(r_extx_framebuffer_mixed_formats->integer)
{
glConfig.framebufferMixedFormatsAvailable = qtrue;
ri.Printf(PRINT_ALL, "...using GL_EXTX_framebuffer_mixed_formats\n");
}
else
{
ri.Printf(PRINT_ALL, "...ignoring GL_EXTX_framebuffer_mixed_formats\n");
}
}
else
{
ri.Printf(PRINT_ALL, "...GL_EXTX_framebuffer_mixed_formats not found\n");
}
*/
// GL_ATI_separate_stencil
if ( GLEW_ATI_separate_stencil )
{
if ( r_ext_separate_stencil->value )
{
ri.Printf( PRINT_ALL, "...using GL_ATI_separate_stencil\n" );
}
else
{
ri.Printf( PRINT_ALL, "...ignoring GL_ATI_separate_stencil\n" );
}
}
else
{
ri.Printf( PRINT_ALL, "...GL_ATI_separate_stencil not found\n" );
}
// GL_SGIS_generate_mipmap
glConfig2.generateMipmapAvailable = qfalse;
if ( GLEW_SGIS_generate_mipmap )
{
if ( r_ext_generate_mipmap->value )
{
glConfig2.generateMipmapAvailable = qtrue;
ri.Printf( PRINT_ALL, "...using GL_SGIS_generate_mipmap\n" );
}
else
{
ri.Printf( PRINT_ALL, "...ignoring GL_SGIS_generate_mipmap\n" );
}
}
else
{
ri.Printf( PRINT_ALL, "...GL_SGIS_generate_mipmap not found\n" );
}
// GL_GREMEDY_string_marker
if ( GLEW_GREMEDY_string_marker )
{
ri.Printf( PRINT_ALL, "...using GL_GREMEDY_string_marker\n" );
}
else
{
ri.Printf( PRINT_ALL, "...GL_GREMEDY_string_marker not found\n" );
}
#ifdef GLEW_ARB_get_program_binary
if( GLEW_ARB_get_program_binary )
{
int formats = 0;
glGetIntegerv( GL_NUM_PROGRAM_BINARY_FORMATS, &formats );
if ( !formats )
{
ri.Printf( PRINT_ALL, "...GL_ARB_get_program_binary found, but with no binary formats\n");
glConfig2.getProgramBinaryAvailable = qfalse;
}
else
{
ri.Printf( PRINT_ALL, "...using GL_ARB_get_program_binary\n");
glConfig2.getProgramBinaryAvailable = qtrue;
}
}
else
#endif
{
ri.Printf( PRINT_ALL, "...GL_ARB_get_program_binary not found\n");
glConfig2.getProgramBinaryAvailable = qfalse;
}
}
bool ANGLETest::extensionEnabled(const std::string &extName)
{
return checkExtensionExists(reinterpret_cast<const char *>(glGetString(GL_EXTENSIONS)),
extName);
}
/*
===============
GLimp_Init
This routine is responsible for initializing the OS specific portions
of OpenGL
===============
*/
qboolean GLimp_Init( void )
{
glConfig.driverType = GLDRV_ICD;
r_sdlDriver = ri.Cvar_Get( "r_sdlDriver", "", CVAR_ROM );
r_allowResize = ri.Cvar_Get( "r_allowResize", "0", 0 );
r_centerWindow = ri.Cvar_Get( "r_centerWindow", "0", 0 );
r_displayIndex = ri.Cvar_Get( "r_displayIndex", "0", 0 );
ri.Cmd_AddCommand( "minimize", GLimp_Minimize );
if ( ri.Cvar_VariableIntegerValue( "com_abnormalExit" ) )
{
ri.Cvar_Set( "r_mode", va( "%d", R_MODE_FALLBACK ) );
ri.Cvar_Set( "r_fullscreen", "0" );
ri.Cvar_Set( "r_centerWindow", "0" );
ri.Cvar_Set( "com_abnormalExit", "0" );
}
#if defined( SMP ) && defined( SDL_VIDEO_DRIVER_X11 ) && !SDL_VERSION_ATLEAST( 2, 0, 0 )
XInitThreads();
#endif
// Create the window and set up the context
if ( GLimp_StartDriverAndSetMode( r_mode->integer, r_fullscreen->integer, qfalse ) )
{
goto success;
}
// Finally, try the default screen resolution
if ( r_mode->integer != R_MODE_FALLBACK )
{
ri.Printf( PRINT_ALL, "Setting r_mode %d failed, falling back on r_mode %d\n", r_mode->integer, R_MODE_FALLBACK );
if ( GLimp_StartDriverAndSetMode( R_MODE_FALLBACK, qfalse, qfalse ) )
{
goto success;
}
}
// Nothing worked, give up
SDL_QuitSubSystem( SDL_INIT_VIDEO );
return qfalse;
success:
// These values force the UI to disable driver selection
glConfig.hardwareType = GLHW_GENERIC;
// get our config strings
Q_strncpyz( glConfig.vendor_string, ( char * ) glGetString( GL_VENDOR ), sizeof( glConfig.vendor_string ) );
Q_strncpyz( glConfig.renderer_string, ( char * ) glGetString( GL_RENDERER ), sizeof( glConfig.renderer_string ) );
if ( *glConfig.renderer_string && glConfig.renderer_string[ strlen( glConfig.renderer_string ) - 1 ] == '\n' )
{
glConfig.renderer_string[ strlen( glConfig.renderer_string ) - 1 ] = 0;
}
Q_strncpyz( glConfig.version_string, ( char * ) glGetString( GL_VERSION ), sizeof( glConfig.version_string ) );
if ( glConfig.driverType == GLDRV_OPENGL3 )
{
GLint numExts, i;
glGetIntegerv( GL_NUM_EXTENSIONS, &numExts );
glConfig.extensions_string[ 0 ] = '\0';
for ( i = 0; i < numExts; ++i )
Q_strcat( glConfig.extensions_string, sizeof( glConfig.extensions_string ), ( char * ) glGetStringi( GL_EXTENSIONS, i ) );
}
else
{
Q_strncpyz( glConfig.extensions_string, ( char * ) glGetString( GL_EXTENSIONS ), sizeof( glConfig.extensions_string ) );
}
if ( Q_stristr( glConfig.renderer_string, "mesa" ) ||
Q_stristr( glConfig.renderer_string, "gallium" ) ||
Q_stristr( glConfig.vendor_string, "nouveau" ) ||
Q_stristr( glConfig.vendor_string, "mesa" ) )
{
// suckage
glConfig.driverType = GLDRV_MESA;
}
if ( Q_stristr( glConfig.renderer_string, "geforce" ) )
{
if ( Q_stristr( glConfig.renderer_string, "8400" ) ||
Q_stristr( glConfig.renderer_string, "8500" ) ||
Q_stristr( glConfig.renderer_string, "8600" ) ||
Q_stristr( glConfig.renderer_string, "8800" ) ||
Q_stristr( glConfig.renderer_string, "9500" ) ||
Q_stristr( glConfig.renderer_string, "9600" ) ||
Q_stristr( glConfig.renderer_string, "9800" ) ||
Q_stristr( glConfig.renderer_string, "gts 240" ) ||
Q_stristr( glConfig.renderer_string, "gts 250" ) ||
Q_stristr( glConfig.renderer_string, "gtx 260" ) ||
Q_stristr( glConfig.renderer_string, "gtx 275" ) ||
Q_stristr( glConfig.renderer_string, "gtx 280" ) ||
Q_stristr( glConfig.renderer_string, "gtx 285" ) ||
Q_stristr( glConfig.renderer_string, "gtx 295" ) ||
Q_stristr( glConfig.renderer_string, "gt 320" ) ||
Q_stristr( glConfig.renderer_string, "gt 330" ) ||
Q_stristr( glConfig.renderer_string, "gt 340" ) ||
Q_stristr( glConfig.renderer_string, "gt 415" ) ||
Q_stristr( glConfig.renderer_string, "gt 420" ) ||
Q_stristr( glConfig.renderer_string, "gt 425" ) ||
Q_stristr( glConfig.renderer_string, "gt 430" ) ||
Q_stristr( glConfig.renderer_string, "gt 435" ) ||
Q_stristr( glConfig.renderer_string, "gt 440" ) ||
Q_stristr( glConfig.renderer_string, "gt 520" ) ||
Q_stristr( glConfig.renderer_string, "gt 525" ) ||
Q_stristr( glConfig.renderer_string, "gt 540" ) ||
Q_stristr( glConfig.renderer_string, "gt 550" ) ||
Q_stristr( glConfig.renderer_string, "gt 555" ) ||
Q_stristr( glConfig.renderer_string, "gts 450" ) ||
Q_stristr( glConfig.renderer_string, "gtx 460" ) ||
Q_stristr( glConfig.renderer_string, "gtx 470" ) ||
Q_stristr( glConfig.renderer_string, "gtx 480" ) ||
Q_stristr( glConfig.renderer_string, "gtx 485" ) ||
Q_stristr( glConfig.renderer_string, "gtx 560" ) ||
Q_stristr( glConfig.renderer_string, "gtx 570" ) ||
Q_stristr( glConfig.renderer_string, "gtx 580" ) ||
Q_stristr( glConfig.renderer_string, "gtx 590" ) )
{
glConfig.hardwareType = GLHW_NV_DX10;
}
}
else if ( Q_stristr( glConfig.renderer_string, "quadro fx" ) )
{
if ( Q_stristr( glConfig.renderer_string, "3600" ) )
{
glConfig.hardwareType = GLHW_NV_DX10;
}
}
else if ( Q_stristr( glConfig.renderer_string, "gallium" ) &&
Q_stristr( glConfig.renderer_string, " amd " ) )
{
// anything prior to R600 is listed as ATI.
glConfig.hardwareType = GLHW_ATI_DX10;
}
else if ( Q_stristr( glConfig.renderer_string, "rv770" ) ||
Q_stristr( glConfig.renderer_string, "eah4850" ) ||
Q_stristr( glConfig.renderer_string, "eah4870" ) ||
// previous three are too specific?
Q_stristr( glConfig.renderer_string, "radeon hd" ) )
{
glConfig.hardwareType = GLHW_ATI_DX10;
}
else if ( Q_stristr( glConfig.renderer_string, "radeon" ) )
{
glConfig.hardwareType = GLHW_ATI;
}
reportDriverType( qfalse );
reportHardwareType( qfalse );
{ // allow overriding where the user really does know better
cvar_t *forceGL;
glDriverType_t driverType = GLDRV_UNKNOWN;
glHardwareType_t hardwareType = GLHW_UNKNOWN;
forceGL = ri.Cvar_Get( "r_glForceDriver", "", CVAR_LATCH );
if ( !Q_stricmp( forceGL->string, "icd" ))
{
driverType = GLDRV_ICD;
}
else if ( !Q_stricmp( forceGL->string, "standalone" ))
{
driverType = GLDRV_STANDALONE;
}
else if ( !Q_stricmp( forceGL->string, "opengl3" ))
{
driverType = GLDRV_OPENGL3;
}
else if ( !Q_stricmp( forceGL->string, "mesa" ))
{
driverType = GLDRV_MESA;
}
forceGL = ri.Cvar_Get( "r_glForceHardware", "", CVAR_LATCH );
if ( !Q_stricmp( forceGL->string, "generic" ))
{
hardwareType = GLHW_GENERIC;
}
else if ( !Q_stricmp( forceGL->string, "ati" ))
{
hardwareType = GLHW_ATI;
}
else if ( !Q_stricmp( forceGL->string, "atidx10" ) ||
!Q_stricmp( forceGL->string, "radeonhd" ))
{
hardwareType = GLHW_ATI_DX10;
}
else if ( !Q_stricmp( forceGL->string, "nvdx10" ))
{
hardwareType = GLHW_NV_DX10;
}
if ( driverType != GLDRV_UNKNOWN )
{
glConfig.driverType = driverType;
reportDriverType( qtrue );
}
if ( hardwareType != GLHW_UNKNOWN )
{
glConfig.hardwareType = hardwareType;
reportHardwareType( qtrue );
}
}
// initialize extensions
GLimp_InitExtensions();
ri.Cvar_Get( "r_availableModes", "", CVAR_ROM );
// This depends on SDL_INIT_VIDEO, hence having it here
ri.IN_Init( window );
return qtrue;
}
bool IsD3D9()
{
std::string rendererString(reinterpret_cast<const char *>(glGetString(GL_RENDERER)));
return (rendererString.find("Direct3D9") != std::string::npos);
}
/*
===============
GLimp_SetMode
===============
*/
static int GLimp_SetMode( int mode, qboolean fullscreen, qboolean noborder )
{
const char *glstring;
int perChannelColorBits;
int alphaBits, depthBits, stencilBits;
int samples;
int i = 0;
SDL_Surface *icon = NULL;
SDL_DisplayMode desktopMode;
Uint32 flags = SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL;
int x, y;
GLenum glewResult;
ri.Printf( PRINT_ALL, "Initializing OpenGL display\n" );
if ( r_allowResize->integer )
{
flags |= SDL_WINDOW_RESIZABLE;
}
if ( r_centerWindow->integer )
{
// center window on specified display
x = SDL_WINDOWPOS_CENTERED_DISPLAY( r_displayIndex->integer );
y = SDL_WINDOWPOS_CENTERED_DISPLAY( r_displayIndex->integer );
}
else
{
x = SDL_WINDOWPOS_UNDEFINED_DISPLAY( r_displayIndex->integer );
y = SDL_WINDOWPOS_UNDEFINED_DISPLAY( r_displayIndex->integer );
}
icon = SDL_CreateRGBSurfaceFrom( ( void * ) CLIENT_WINDOW_ICON.pixel_data,
CLIENT_WINDOW_ICON.width,
CLIENT_WINDOW_ICON.height,
CLIENT_WINDOW_ICON.bytes_per_pixel * 8,
CLIENT_WINDOW_ICON.bytes_per_pixel * CLIENT_WINDOW_ICON.width,
#ifdef Q3_LITTLE_ENDIAN
0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000
#else
0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF
#endif
);
if ( SDL_GetDesktopDisplayMode( r_displayIndex->integer, &desktopMode ) == 0 )
{
displayAspect = ( float ) desktopMode.w / ( float ) desktopMode.h;
ri.Printf( PRINT_ALL, "Display aspect: %.3f\n", displayAspect );
}
else
{
Com_Memset( &desktopMode, 0, sizeof( SDL_DisplayMode ) );
ri.Printf( PRINT_ALL, "Cannot determine display aspect (%s), assuming 1.333\n", SDL_GetError() );
}
ri.Printf( PRINT_ALL, "...setting mode %d:", mode );
if ( mode == -2 )
{
// use desktop video resolution
if ( desktopMode.h > 0 )
{
glConfig.vidWidth = desktopMode.w;
glConfig.vidHeight = desktopMode.h;
}
else
{
glConfig.vidWidth = 640;
glConfig.vidHeight = 480;
ri.Printf( PRINT_ALL, "Cannot determine display resolution, assuming 640x480\n" );
}
glConfig.windowAspect = ( float ) glConfig.vidWidth / ( float ) glConfig.vidHeight;
}
else if ( !R_GetModeInfo( &glConfig.vidWidth, &glConfig.vidHeight, &glConfig.windowAspect, mode ) )
{
ri.Printf( PRINT_ALL, " invalid mode\n" );
return RSERR_INVALID_MODE;
}
ri.Printf( PRINT_ALL, " %d %d\n", glConfig.vidWidth, glConfig.vidHeight );
do
{
if ( glContext != NULL )
{
SDL_GL_DeleteContext( glContext );
glContext = NULL;
}
if ( window != NULL )
{
SDL_GetWindowPosition( window, &x, &y );
ri.Printf( PRINT_DEVELOPER, "Existing window at %dx%d before being destroyed\n", x, y );
SDL_DestroyWindow( window );
window = NULL;
}
// we come back here if we couldn't get a visual and there's
// something we can switch off
if ( fullscreen )
{
flags |= SDL_WINDOW_FULLSCREEN;
glConfig.isFullscreen = qtrue;
}
else
{
if ( noborder )
{
flags |= SDL_WINDOW_BORDERLESS;
}
glConfig.isFullscreen = qfalse;
}
colorBits = r_colorbits->integer;
if ( ( !colorBits ) || ( colorBits >= 32 ) )
{
colorBits = 24;
}
alphaBits = r_alphabits->integer;
if ( alphaBits < 0 )
{
alphaBits = 0;
}
depthBits = r_depthbits->integer;
if ( !depthBits )
{
depthBits = 24;
}
stencilBits = r_stencilbits->integer;
samples = r_ext_multisample->integer;
for ( i = 0; i < 16; i++ )
{
int testColorBits, testDepthBits, testStencilBits;
// 0 - default
// 1 - minus colorbits
// 2 - minus depthbits
// 3 - minus stencil
if ( ( i % 4 ) == 0 && i )
{
// one pass, reduce
switch ( i / 4 )
{
case 2:
if ( colorBits == 24 )
{
colorBits = 16;
}
break;
case 1:
if ( depthBits == 24 )
{
depthBits = 16;
}
else if ( depthBits == 16 )
{
depthBits = 8;
}
case 3:
if ( stencilBits == 24 )
{
stencilBits = 16;
}
else if ( stencilBits == 16 )
{
stencilBits = 8;
}
}
}
testColorBits = colorBits;
testDepthBits = depthBits;
testStencilBits = stencilBits;
if ( ( i % 4 ) == 3 )
{
// reduce colorbits
if ( testColorBits == 24 )
{
testColorBits = 16;
}
}
if ( ( i % 4 ) == 2 )
{
// reduce depthbits
if ( testDepthBits == 24 )
{
testDepthBits = 16;
}
else if ( testDepthBits == 16 )
{
testDepthBits = 8;
}
}
if ( ( i % 4 ) == 1 )
{
// reduce stencilbits
if ( testStencilBits == 24 )
{
testStencilBits = 16;
}
else if ( testStencilBits == 16 )
{
testStencilBits = 8;
}
else
{
testStencilBits = 0;
}
}
if ( testColorBits == 24 )
{
perChannelColorBits = 8;
}
else
{
perChannelColorBits = 4;
}
SDL_GL_SetAttribute( SDL_GL_RED_SIZE, perChannelColorBits );
SDL_GL_SetAttribute( SDL_GL_GREEN_SIZE, perChannelColorBits );
SDL_GL_SetAttribute( SDL_GL_BLUE_SIZE, perChannelColorBits );
SDL_GL_SetAttribute( SDL_GL_ALPHA_SIZE, alphaBits );
SDL_GL_SetAttribute( SDL_GL_DEPTH_SIZE, testDepthBits );
SDL_GL_SetAttribute( SDL_GL_STENCIL_SIZE, testStencilBits );
SDL_GL_SetAttribute( SDL_GL_MULTISAMPLEBUFFERS, samples ? 1 : 0 );
SDL_GL_SetAttribute( SDL_GL_MULTISAMPLESAMPLES, samples );
SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
#if !SDL_VERSION_ATLEAST( 2, 0, 0 )
SDL_GL_SetAttribute( SDL_GL_SWAP_CONTROL, r_swapInterval->integer );
#endif
#if SDL_VERSION_ATLEAST( 2, 0, 0 )
if ( !r_glAllowSoftware->integer )
{
SDL_GL_SetAttribute( SDL_GL_ACCELERATED_VISUAL, 1 );
}
if ( r_glCoreProfile->integer || r_glDebugProfile->integer )
{
int major = r_glMajorVersion->integer;
int minor = r_glMinorVersion->integer;
SDL_GL_SetAttribute( SDL_GL_CONTEXT_MAJOR_VERSION, major );
SDL_GL_SetAttribute( SDL_GL_CONTEXT_MINOR_VERSION, minor );
if ( r_glCoreProfile->integer )
{
SDL_GL_SetAttribute( SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE );
}
else
{
SDL_GL_SetAttribute( SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_COMPATIBILITY );
}
if ( r_glDebugProfile->integer )
{
SDL_GL_SetAttribute( SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_DEBUG_FLAG );
}
}
#endif
window = SDL_CreateWindow( CLIENT_WINDOW_TITLE, x, y, glConfig.vidWidth, glConfig.vidHeight, flags );
if ( !window )
{
ri.Printf( PRINT_DEVELOPER, "SDL_CreateWindow failed: %s\n", SDL_GetError() );
continue;
}
SDL_SetWindowIcon( window, icon );
glContext = SDL_GL_CreateContext( window );
if ( !glContext )
{
ri.Printf( PRINT_DEVELOPER, "SDL_GL_CreateContext failed: %s\n", SDL_GetError() );
continue;
}
#if SDL_VERSION_ATLEAST( 2, 0, 0 )
SDL_GL_SetSwapInterval( r_swapInterval->integer );
#endif
SDL_ShowCursor( 0 );
glConfig.colorBits = testColorBits;
glConfig.depthBits = testDepthBits;
glConfig.stencilBits = testStencilBits;
ri.Printf( PRINT_ALL, "Using %d Color bits, %d depth, %d stencil display.\n",
glConfig.colorBits, glConfig.depthBits, glConfig.stencilBits );
break;
}
if ( samples && ( !glContext || !window ) )
{
r_ext_multisample->integer = 0;
}
} while ( ( !glContext || !window ) && samples );
SDL_FreeSurface( icon );
glewResult = glewInit();
if ( glewResult != GLEW_OK )
{
// glewInit failed, something is seriously wrong
ri.Error( ERR_FATAL, "GLW_StartOpenGL() - could not load OpenGL subsystem: %s", glewGetErrorString( glewResult ) );
}
else
{
ri.Printf( PRINT_ALL, "Using GLEW %s\n", glewGetString( GLEW_VERSION ) );
}
int GLmajor, GLminor;
sscanf( ( const char * ) glGetString( GL_VERSION ), "%d.%d", &GLmajor, &GLminor );
if ( GLmajor < 2 || ( GLmajor == 2 && GLminor < 1 ) )
{
// missing shader support, switch to 1.x renderer
return RSERR_OLD_GL;
}
if ( GLmajor < 3 || ( GLmajor == 3 && GLminor < 2 ) )
{
// shaders are supported, but not all GL3.x features
ri.Printf( PRINT_ALL, "Using enhanced (GL3) Renderer in GL 2.x mode...\n" );
}
else
{
ri.Printf( PRINT_ALL, "Using enhanced (GL3) Renderer in GL 3.x mode...\n" );
glConfig.driverType = GLDRV_OPENGL3;
}
#if defined( SMP ) && !SDL_VERSION_ATLEAST( 2, 0, 0 )
// setup context for SDL_GL_MakeCurrent
SDL_GL_GetCurrentContext();
#endif
GLimp_DetectAvailableModes();
glstring = ( char * ) glGetString( GL_RENDERER );
ri.Printf( PRINT_ALL, "GL_RENDERER: %s\n", glstring );
return RSERR_OK;
}
int main(int argc, char **argv){
bool want_gl_debugging = false;
bool want_msaa = false; // doesn't currently work, probably needs extension
if(argc == 2 && (strncmp(argv[1], "debug_gl", 9) == 0)){
want_gl_debugging = true;
}
START_TIMER(SDL_initialization_and_GL_context_creation);
if(SDL_Init(SDL_INIT_EVERYTHING) == 1){
printf("SDL failed to initialize: %s\n", SDL_GetError());
return 1;
}
get_controller();
SDL_Window *win = SDL_CreateWindow("SDL2/GL4.3", 0, 0, 1280, 720, SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE);
SDL_SetWindowGrab(win, SDL_TRUE);
if(win == NULL){
printf("SDL failed to create window: %s\n", SDL_GetError());
return 1;
}
if(want_msaa){
printf("setting msaa\n");
if(SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 4) != 0){
printf("failed to set MULTISAMPLEBUFFERS\n");
}
if(SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 16) != 0){
printf("failed to set MULTISAMPLESAMPLES\n");
}
glEnable(GL_MULTISAMPLE);
}
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);
if(want_gl_debugging){
SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_DEBUG_FLAG);
}
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE); // it looks like we always get a core context anyway.
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
SDL_GLContext glcontext = SDL_GL_CreateContext(win);
if(glcontext == NULL){
printf("SDL failed to create context: %s\n", SDL_GetError());
return 1;
}
int loaded_gl = ogl_LoadFunctions();
if(!loaded_gl){
printf("Failed to load OpenGL entry points.\n");
return 1;
}
int context_flags;
SDL_GL_GetAttribute(SDL_GL_CONTEXT_FLAGS, &context_flags);
bool have_debug_context = (context_flags & SDL_GL_CONTEXT_DEBUG_FLAG) == SDL_GL_CONTEXT_DEBUG_FLAG;
printf("OpenGL vendor: " TERMCOLOR_HIGHLIGHT "'%s'\n" TERMCOLOR_DEFAULT, glGetString(GL_VENDOR));
printf("OpenGL renderer: " TERMCOLOR_HIGHLIGHT "'%s'\n" TERMCOLOR_DEFAULT, glGetString(GL_RENDERER));
printf("OpenGL version: " TERMCOLOR_HIGHLIGHT "'%s'\n" TERMCOLOR_DEFAULT, glGetString(GL_VERSION));
printf("GLSL version: " TERMCOLOR_HIGHLIGHT "'%s'\n" TERMCOLOR_DEFAULT, glGetString(GL_SHADING_LANGUAGE_VERSION));
printf("Debug context: " TERMCOLOR_BOLD "%s" TERMCOLOR_DEFAULT "\n", have_debug_context ? "yes" : "no");
int profile_flags;
SDL_GL_GetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, &profile_flags);
printf("Core context: " TERMCOLOR_BOLD "%s" TERMCOLOR_DEFAULT "\n", (profile_flags & SDL_GL_CONTEXT_PROFILE_CORE) != 0 ? "yes" : "no");
if(have_debug_context && want_gl_debugging){
printf(TERMCOLOR_HIGHLIGHT "We have debug extensions & context, installing debug callbacks..." TERMCOLOR_DEFAULT "\n");
glDebugMessageCallback(debug_callback, stderr);
glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, NULL, GL_TRUE);
}
else {
const char *reason = NULL;
if(!want_gl_debugging)
reason = "debugging not requested (use 'debug_gl command line argument)";
else if(!have_debug_context)
reason = "could not acquire debug context";
else
reason = "unknown";
printf(TERMCOLOR_ERROR "Not installing GL debug hooks. Reason: %s" TERMCOLOR_DEFAULT "\n", reason);
}
STOP_TIMER_AND_PRINT(SDL_initialization_and_GL_context_creation);
START_TIMER(user_init);
init(WINDOW_WIDTH, WINDOW_HEIGHT);
STOP_TIMER_AND_PRINT(user_init);
START_TIMER(total_renderloop_runtime);
bool continue_loop = true;
while(continue_loop){
continue_loop = render(win);
SDL_Event e;
while(SDL_PollEvent(&e)){
if(e.type == SDL_QUIT){
printf("received SDL_QUIT\n");
goto exiting;
}
else if(e.type == SDL_MOUSEMOTION){
mousemove(e.motion.xrel, e.motion.yrel);
//SDL_WarpMouseInWindow(win, WINDOW_WIDTH/2, WINDOW_HEIGHT/2);
//printf("relative movement: %d, %d\n", e.motion.xrel, e.motion.yrel);
}
else if(e.type == SDL_WINDOWEVENT && e.window.event == SDL_WINDOWEVENT_RESIZED){
resize(e.window.data1, e.window.data2);
}
}
}
exiting:
STOP_TIMER_AND_PRINT(total_renderloop_runtime);
quit();
SDL_GL_DeleteContext(glcontext);
SDL_Quit();
return 0;
}
/*!***************************************************************************
@Function LoadExtensions
@Description Initialises IMG extensions
*****************************************************************************/
void CPVRTgles2Ext::LoadExtensions()
{
glMultiDrawElementsEXT = 0;
glMultiDrawArraysEXT = 0;
glMapBufferOES = 0;
glUnmapBufferOES = 0;
glGetBufferPointervOES = 0;
glDiscardFramebufferEXT = 0;
glBindVertexArrayOES = 0;
glDeleteVertexArraysOES = 0;
glGenVertexArraysOES = 0;
glIsVertexArrayOES = 0;
glRenderbufferStorageMultisampleIMG = 0;
glFramebufferTexture2DMultisampleIMG = 0;
// Supported extensions provide new entry points for OpenGL ES 2.0.
const GLubyte *pszGLExtensions;
/* Retrieve GL extension string */
pszGLExtensions = glGetString(GL_EXTENSIONS);
#if !defined(TARGET_OS_IPHONE)
/* GL_EXT_multi_draw_arrays */
if (strstr((char *)pszGLExtensions, "GL_EXT_multi_draw_arrays"))
{
glMultiDrawElementsEXT = (PFNGLMULTIDRAWELEMENTS) PVRGetProcAddress(glMultiDrawElementsEXT);
glMultiDrawArraysEXT = (PFNGLMULTIDRAWARRAYS) PVRGetProcAddress(glMultiDrawArraysEXT);
}
/* GL_EXT_multi_draw_arrays */
if (strstr((char *)pszGLExtensions, "GL_OES_mapbuffer"))
{
glMapBufferOES = (PFNGLMAPBUFFEROES) PVRGetProcAddress(glMapBufferOES);
glUnmapBufferOES = (PFNGLUNMAPBUFFEROES) PVRGetProcAddress(glUnmapBufferOES);
glGetBufferPointervOES = (PFNGLGETBUFFERPOINTERVOES) PVRGetProcAddress(glGetBufferPointervOES);
}
/* GL_OES_vertex_array_object */
if (strstr((char *)pszGLExtensions, "GL_OES_vertex_array_object"))
{
glBindVertexArrayOES = (PFNGLBINDVERTEXARRAYOES) PVRGetProcAddress(glBindVertexArrayOES);
glDeleteVertexArraysOES = (PFNGLDELETEVERTEXARRAYSOES) PVRGetProcAddress(glDeleteVertexArraysOES);
glGenVertexArraysOES = (PFNGLGENVERTEXARRAYSOES) PVRGetProcAddress(glGenVertexArraysOES);
glIsVertexArrayOES = (PFNGLISVERTEXARRAYOES) PVRGetProcAddress(glIsVertexArrayOES);
}
/* GL_IMG_multisampled_render_to_texture */
if (strstr((char *)pszGLExtensions, "GL_IMG_multisampled_render_to_texture"))
{
glRenderbufferStorageMultisampleIMG = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEIMG)PVRGetProcAddress(glRenderbufferStorageMultisampleIMG);
glFramebufferTexture2DMultisampleIMG = (PFNGLFRAMEBUFFERTEXTURE2DMULTISAMPLEIMG)PVRGetProcAddress(glFramebufferTexture2DMultisampleIMG);
}
#endif
#if defined(GL_EXT_discard_framebuffer)
/* GL_EXT_discard_framebuffer */
if (strstr((char *)pszGLExtensions, "GL_EXT_discard_framebuffer"))
{
glDiscardFramebufferEXT = (PFNGLDISCARDFRAMEBUFFEREXT) PVRGetProcAddress(glDiscardFramebufferEXT);
}
#endif
}
/*!***************************************************************************
@Function Init
@Description Initialises IMG extensions
*****************************************************************************/
void CPVRTglesExt::Init()
{
const GLubyte *pszGLExtensions;
/* Retrieve GL extension string */
pszGLExtensions = glGetString(GL_EXTENSIONS);
/* GL_OES_matrix_palette */
if (strstr((char *)pszGLExtensions, "GL_OES_matrix_palette"))
{
glCurrentPaletteMatrixOES = (PFNGLCURRENTPALETTEMATRIXOES)eglGetProcAddress("glCurrentPaletteMatrixOES");
glLoadPaletteFromModelViewMatrixOES = (PFNGLLOADPALETTEFROMMODELVIEWMATRIXOES)eglGetProcAddress("glLoadPaletteFromModelViewMatrixOES");
glMatrixIndexPointerOES = (PFNGLMATRIXINDEXPOINTEROES)eglGetProcAddress("glMatrixIndexPointerOES");
glWeightPointerOES = (PFNGLWEIGHTPOINTEROES)eglGetProcAddress("glWeightPointerOES");
}
/* GL_IMG_user_clip_plane */
if (strstr((char *)pszGLExtensions, "GL_IMG_user_clip_plane"))
{
/* glClipPlanexIMG and glClipPlanefIMG */
glClipPlanexIMG = (PFNGLCLIPPLANEXIMG)eglGetProcAddress("glClipPlanexIMG");
glClipPlanefIMG = (PFNGLCLIPPLANEFIMG)eglGetProcAddress("glClipPlanefIMG");
}
/* GL_IMG_vertex_program */
if (strstr((char *)pszGLExtensions, "GL_IMG_vertex_program"))
{
/* glVertexAttribPointerARB */
glVertexAttribPointerARB = (PFNGLVERTEXATTRIBPOINTERARB)eglGetProcAddress("glVertexAttribPointerARB");
/* glEnableVertexAttribArrayARB */
glEnableVertexAttribArrayARB = (PFNGLENABLEVERTEXATTRIBARRAYARB)eglGetProcAddress("glEnableVertexAttribArrayARB");
/* glDisableVertexAttribArrayARB */
glDisableVertexAttribArrayARB = (PFNGLDISABLEVERTEXATTRIBARRAYARB)eglGetProcAddress("glDisableVertexAttribArrayARB");
/* glProgramStringARB */
glProgramStringARB = (PFNGLPROGRAMSTRINGARB)eglGetProcAddress("glProgramStringARB");
/* glBindProgramARB */
glBindProgramARB = (PFNGLBINDPROGRAMARB)eglGetProcAddress("glBindProgramARB");
/* glDeleteProgramsARB */
glDeleteProgramsARB = (PFNGLDELETEPROGRAMSARB)eglGetProcAddress("glDeleteProgramsARB");
/* glIsProgramARB */
glIsProgramARB = (PFNGLISPROGRAMARB)eglGetProcAddress("glIsProgramARB");
/* glGenProgramsARB */
glGenProgramsARB = (PFNGLGENPROGRAMSARB)eglGetProcAddress("glGenProgramsARB");
/* glVertexAttrib4fvARB */
glVertexAttrib4fvARB = (PFNGLVERTEXATTRIB4FVARB)eglGetProcAddress("glVertexAttrib4fvARB");
/* glVertexAttrib4xvIMG */
glVertexAttrib4xvIMG = (PFNGLVERTEXATTRIB4XVIMG)eglGetProcAddress("glVertexAttrib4xvIMG");
/* glProgramLocalParameter4xIMG */
glProgramLocalParameter4xIMG = (PFNGLPROGRAMLOCALPARAMETER4XIMG)eglGetProcAddress("glProgramLocalParameter4xIMG");
/* glProgramLocalParameter4xvIMG */
glProgramLocalParameter4xvIMG = (PFNGLPROGRAMLOCALPARAMETER4XVIMG)eglGetProcAddress("glProgramLocalParameter4xvIMG");
/* glProgramEnvParameter4xIMG */
glProgramEnvParameter4xIMG = (PFNGLPROGRAMENVPARAMETER4XIMG)eglGetProcAddress("glProgramEnvParameter4xIMG");
/* glProgramEnvParameter4xvIMG */
glProgramEnvParameter4xvIMG = (PFNGLPROGRAMENVPARAMETER4XVIMG)eglGetProcAddress("glProgramEnvParameter4xvIMG");
/* glProgramEnvParameter4fARB */
glProgramEnvParameter4fARB = (PFNGLPROGRAMENVPARAMETER4FARB)eglGetProcAddress("glProgramEnvParameter4fARB");
/* glProgramEnvParameter4fvARB */
glProgramEnvParameter4fvARB = (PFNGLPROGRAMENVPARAMETER4FVARB)eglGetProcAddress("glProgramEnvParameter4fvARB");
/* glProgramLocalParameter4fARB */
glProgramLocalParameter4fARB = (PFNGLPROGRAMLOCALPARAMETER4FARB)eglGetProcAddress("glProgramLocalParameter4fARB");
/* glProgGL_OES_draw_textureramLocalParameter4fvARB */
glProgramLocalParameter4fvARB = (PFNGLPROGRAMLOCALPARAMETER4FVARB)eglGetProcAddress("glProgramLocalParameter4fvARB");
}
/* GL_OES_draw_texture */
if (strstr((char *)pszGLExtensions, "GL_OES_draw_texture"))
{
/* glDrawTexiOES */
glDrawTexiOES = (PFNGLDRAWTEXIOES)eglGetProcAddress("glDrawTexiOES");
/* glDrawTexivOES */
glDrawTexivOES = (PFNGLDRAWTEXIVOES)eglGetProcAddress("glDrawTexivOES");
/* glDrawTexsOES */
glDrawTexsOES = (PFNGLDRAWTEXSOES)eglGetProcAddress("glDrawTexsOES");
/* glDrawTexsvOES */
glDrawTexsvOES = (PFNGLDRAWTEXSVOES)eglGetProcAddress("glDrawTexsvOES");
/* glDrawTexxOES */
glDrawTexxOES = (PFNGLDRAWTEXXOES)eglGetProcAddress("glDrawTexxOES");
/* glDrawTexxvOES */
glDrawTexxvOES = (PFNGLDRAWTEXXVOES)eglGetProcAddress("glDrawTexxvOES");
/* glDrawTexfOES */
glDrawTexfOES = (PFNGLDRAWTEXFOES)eglGetProcAddress("glDrawTexfOES");
/* glDrawTexfvOES */
glDrawTexfvOES = (PFNGLDRAWTEXFVOES)eglGetProcAddress("glDrawTexfvOES");
}
/* IMG_texture_stream */
if (strstr((char *)pszGLExtensions, "GL_IMG_texture_stream"))
{
glGetTexStreamDeviceAttribivIMG = (PFNGLGETTEXSTREAMDEVICEATTRIBIVIMG)eglGetProcAddress("glGetTexStreamDeviceAttribivIMG");
glTexBindStreamIMG = (PFNGLTEXBINDSTREAMIMG)eglGetProcAddress("glTexBindStreamIMG");
glGetTexStreamDeviceNameIMG = (PFNGLGETTEXSTREAMDEVICENAMEIMG)eglGetProcAddress("glGetTexStreamDeviceNameIMG");
}
/* GL_EXT_multi_draw_arrays */
if (strstr((char *)pszGLExtensions, "GL_EXT_multi_draw_arrays"))
{
glMultiDrawElementsEXT = (PFNGLMULTIDRAWELEMENTS)eglGetProcAddress("glMultiDrawElementsEXT");
}
}
static void Init( int argc, char *argv[] )
{
const char *file;
GLenum format;
if (!glutExtensionSupported("GL_MESA_ycbcr_texture")) {
printf("Sorry, GL_MESA_ycbcr_texture is required\n");
exit(0);
}
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
if (argc > 1)
file = argv[1];
else
file = TEXTURE_FILE;
/* First load the texture as YCbCr.
*/
glBindTexture(GL_TEXTURE_2D, yuvObj);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
ImageYUV = LoadYUVImage(file, &ImgWidth, &ImgHeight );
if (!ImageYUV) {
printf("Couldn't read %s\n", TEXTURE_FILE);
exit(0);
}
printf("Image: %dx%d\n", ImgWidth, ImgHeight);
glTexImage2D(GL_TEXTURE_2D, 0,
GL_YCBCR_MESA,
ImgWidth, ImgHeight, 0,
GL_YCBCR_MESA,
GL_UNSIGNED_SHORT_8_8_MESA, ImageYUV);
glEnable(GL_TEXTURE_2D);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
/* Now load the texture as RGB.
*/
glBindTexture(GL_TEXTURE_2D, rgbObj);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
ImageRGB = LoadRGBImage(file, &ImgWidth, &ImgHeight, &format );
if (!ImageRGB) {
printf("Couldn't read %s\n", TEXTURE_FILE);
exit(0);
}
printf("Image: %dx%d\n", ImgWidth, ImgHeight);
glTexImage2D(GL_TEXTURE_2D, 0,
format,
ImgWidth, ImgHeight, 0,
format,
GL_UNSIGNED_BYTE, ImageRGB);
glEnable(GL_TEXTURE_2D);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glShadeModel(GL_FLAT);
glClearColor(0.3, 0.3, 0.4, 1.0);
if (argc > 1 && strcmp(argv[1], "-info")==0) {
printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER));
printf("GL_VERSION = %s\n", (char *) glGetString(GL_VERSION));
printf("GL_VENDOR = %s\n", (char *) glGetString(GL_VENDOR));
printf("GL_EXTENSIONS = %s\n", (char *) glGetString(GL_EXTENSIONS));
}
printf( "Both images should appear the same.\n" );
}
