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" ); }