void EglOnXBackend::present() { if (lastDamage().isEmpty()) return; const QRegion displayRegion(0, 0, displayWidth(), displayHeight()); const bool fullRepaint = supportsBufferAge() || (lastDamage() == displayRegion); if (fullRepaint || !surfaceHasSubPost) { if (gs_tripleBufferNeedsDetection) { eglWaitGL(); m_swapProfiler.begin(); } // the entire screen changed, or we cannot do partial updates (which implies we enabled surface preservation) eglSwapBuffers(dpy, surface); if (gs_tripleBufferNeedsDetection) { eglWaitGL(); if (char result = m_swapProfiler.end()) { gs_tripleBufferUndetected = gs_tripleBufferNeedsDetection = false; if (result == 'd' && GLPlatform::instance()->driver() == Driver_NVidia) { // TODO this is a workaround, we should get __GL_YIELD set before libGL checks it if (qstrcmp(qgetenv("__GL_YIELD"), "USLEEP")) { options->setGlPreferBufferSwap(0); eglSwapInterval(dpy, 0); qWarning() << "\nIt seems you are using the nvidia driver without triple buffering\n" "You must export __GL_YIELD=\"USLEEP\" to prevent large CPU overhead on synced swaps\n" "Preferably, enable the TripleBuffer Option in the xorg.conf Device\n" "For this reason, the tearing prevention has been disabled.\n" "See https://bugs.kde.org/show_bug.cgi?id=322060\n"; } } setBlocksForRetrace(result == 'd'); } } if (supportsBufferAge()) { eglQuerySurface(dpy, surface, EGL_BUFFER_AGE_EXT, &m_bufferAge); } } else { // a part of the screen changed, and we can use eglPostSubBufferNV to copy the updated area foreach (const QRect & r, lastDamage().rects()) { eglPostSubBufferNV(dpy, surface, r.left(), displayHeight() - r.bottom() - 1, r.width(), r.height()); } } setLastDamage(QRegion()); if (!supportsBufferAge()) { eglWaitGL(); xcb_flush(connection()); } }
/* EGLBoolean eglWaitGL ( void ) */ static jboolean android_eglWaitGL (JNIEnv *_env, jobject _this) { EGLBoolean _returnValue = (EGLBoolean) 0; _returnValue = eglWaitGL(); return (jboolean)_returnValue; }
/*!*********************************************************************** @Function ApiRenderComplete @description Perform API operations required after a frame has finished (e.g., flipping). *************************************************************************/ void PVRShellInit::ApiRenderComplete() { bool bRes; if(m_pShell->m_pShellData->bNeedPixmap) { /* "Clients rendering to single buffered surfaces (e.g. pixmap surfaces) should call eglWaitGL before accessing the native pixmap from the client." */ eglWaitGL(); // Pixmap support: Copy the rendered pixmap to the display if(m_pShell->m_pShellData->bNeedPixmapDisableCopy) { bRes = true; } else { bRes = OsPixmapCopy(); } } else { if(m_pShell->m_pShellData->bNoShellSwapBuffer) return; bRes = (eglSwapBuffers (m_EGLDisplay, m_EGLWindow) == EGL_TRUE); } if(!bRes) { // check for context loss #ifdef EGL_VERSION_1_3 if(eglGetError() == EGL_CONTEXT_LOST) #else if((eglGetError() == EGL_CONTEXT_LOST_IMG) && m_bPowerManagementSupported) #endif { m_pShell->ReleaseView(); OsDoReleaseAPI(); if(ApiInitAPI()) { m_pShell->InitView(); } } else { if(m_pShell->m_pShellData->bNeedPixmap) m_pShell->PVRShellOutputDebug("failed to copy pixmap\n"); else m_pShell->PVRShellOutputDebug("eglSwapBuffers failed\n"); } } }
/* private native int _eglWaitGL ( ) ; */ KNIEXPORT KNI_RETURNTYPE_INT Java_javax_microedition_khronos_egl_EGL10Impl__1eglWaitGL() { jint returnValue = (jint)eglWaitGL(); #ifdef DEBUG printf("eglWaitGL() = %d\n", returnValue); #endif KNI_ReturnInt(returnValue); }
//swapping buffers void common_eglswapbuffers( struct globalStruct *globals, EGLDisplay eglDisplay, EGLSurface eglSurface ) { if(globals->inSurfaceType == SGXPERF_SURFACE_TYPE_WINDOW) eglSwapBuffers(eglDisplay, eglSurface); else if(globals->inSurfaceType == SGXPERF_SURFACE_TYPE_PIXMAP_16 || globals->inSurfaceType == SGXPERF_SURFACE_TYPE_PIXMAP_32) eglWaitGL(); }
static void _egl_beg (s52engine *engine) { // On Android, Blit x10 slower whitout if (EGL_FALSE == eglWaitGL()) { g_print("_egl_beg(): eglWaitGL() failed. [0x%x]\n", eglGetError()); return; } if (EGL_FALSE == eglMakeCurrent(engine->eglDisplay, engine->eglSurface, engine->eglSurface, engine->eglContext)) { g_print("_egl_beg(): eglMakeCurrent() failed. [0x%x]\n", eglGetError()); } return; }
void EGLXTransportSurfaceClient::destroy() { GLTransportSurfaceClient::destroy(); if (m_eglImage) { m_eglImage->destroy(); m_eglImage = nullptr; } eglWaitGL(); if (m_image) { XDestroyImage(m_image); m_image = 0; } }
// Wait for client OpenGL/OpenVG operations to complete before // using native rendering operations. void QEglContext::waitClient() { #ifdef EGL_OPENGL_ES_API if (apiType == OpenGL) { eglBindAPI(EGL_OPENGL_ES_API); eglWaitClient(); } #else if (apiType == OpenGL) eglWaitGL(); #endif #ifdef EGL_OPENVG_API if (apiType == OpenVG) { eglBindAPI(EGL_OPENVG_API); eglWaitClient(); } #endif }
int PND_gl_swapwindow(_THIS, SDL_Window * window) { SDL_VideoData *phdata = (SDL_VideoData *) _this->driverdata; SDL_WindowData *wdata = (SDL_WindowData *) window->driverdata; if (phdata->egl_initialized != SDL_TRUE) { return SDL_SetError("PND: GLES initialization failed, no OpenGL ES support"); } /* Many applications do not uses glFinish(), so we call it for them */ glFinish(); /* Wait until OpenGL ES rendering is completed */ eglWaitGL(); eglSwapBuffers(phdata->egl_display, wdata->gles_surface); return 0; }
void EGLTextureFromPixmap::destroy() { eglWaitNative(EGL_CORE_NATIVE_ENGINE); if (m_surface != EGL_NO_SURFACE) eglReleaseTexImage(EGLHelper::eglDisplay(), m_surface, EGL_BACK_BUFFER); if (m_eglImage) { EGLHelper::destroyEGLImage(m_eglImage); m_eglImage = 0; } if (m_surface != EGL_NO_SURFACE) { eglDestroySurface(EGLHelper::eglDisplay(), m_surface); m_surface = EGL_NO_SURFACE; } eglWaitGL(); }
static void clutter_backend_egl_redraw (ClutterBackend *backend, ClutterStage *stage) { ClutterBackendEGL *backend_egl = CLUTTER_BACKEND_EGL (backend); ClutterStageEGL *stage_egl; ClutterStageWindow *impl; impl = _clutter_stage_get_window (stage); if (!impl) return; g_assert (CLUTTER_IS_STAGE_EGL (impl)); stage_egl = CLUTTER_STAGE_EGL (impl); eglWaitNative (EGL_CORE_NATIVE_ENGINE); clutter_actor_paint (CLUTTER_ACTOR (stage)); cogl_flush (); eglWaitGL(); eglSwapBuffers (backend_egl->edpy, stage_egl->egl_surface); }
EGLBoolean eglWaitClient() { return eglWaitGL(); }
static jboolean jni_eglWaitGL(JNIEnv *_env, jobject _this) { return EglBoolToJBool(eglWaitGL()); }
PyObject *egl_swapbuffers(PyObject *self, PyObject *args) { eglWaitGL(); eglSwapBuffers(display, surface); Py_INCREF(Py_None); return Py_None; }
static int test_transparentalpha(display_t * disp) { int32_t surfattr[] = { gconfig_TRANSPARENT_ALPHA, 1, gconfig_BITS_BUFFER, 32, gconfig_NONE }; windowconfig_t winattr[] = { windowconfig_INIT_TITLE("test-graphic-window"), windowconfig_INIT_SIZE(100, 100), windowconfig_INIT_POS(50, 100), windowconfig_INIT_NONE }; window_t top = window_FREE; window_t bottom = window_FREE; gconfig_t gconf = gconfig_FREE; uint32_t snr = defaultscreennr_display(disp); EGLContext eglcontext = EGL_NO_CONTEXT; // prepare TEST(0 == init_gconfig(&gconf, disp, surfattr)); eglcontext = eglCreateContext(gl_display(disp), gl_gconfig(&gconf), EGL_NO_CONTEXT, 0); TEST(EGL_NO_CONTEXT != eglcontext); // TEST init_window: gconfig_TRANSPARENT_ALPHA: draw overlay on top of bottom TEST(0 == init_window(&top, disp, snr, 0, &gconf, winattr)); TEST(0 == init_window(&bottom, disp, snr, 0, &gconf, winattr)); // TEST swapbuffer_window: bottom window opaque color TEST(0 == show_x11window(os_window(&bottom))); WAITFOR(disp, os_window(&bottom)->state == x11window_state_SHOWN); TEST(EGL_TRUE == eglMakeCurrent(gl_display(disp), (void*)gl_window(&bottom), (void*)gl_window(&bottom), eglcontext)); glClearColor(1, 0, 0, 1); glClear(GL_COLOR_BUFFER_BIT); TEST(0 == swapbuffer_window(&bottom, disp)); eglWaitGL(); // red color TEST(0 == compare_color(os_window(&bottom), 100, 100, 1, 0, 0)); // TEST swapbuffer_window: top window with transparent value TEST(0 == show_x11window(os_window(&top))); WAITFOR(disp, os_window(&top)->state == x11window_state_SHOWN); TEST(EGL_TRUE == eglMakeCurrent(gl_display(disp), (void*)gl_window(&top), (void*)gl_window(&top), eglcontext)); glClearColor(0, 0, 1, 0); // transparent blue glClear(GL_COLOR_BUFFER_BIT); TEST(0 == swapbuffer_window(&top, disp)); eglWaitGL(); // resulting color is the combination of red and blue TEST(0 == compare_color(os_window(&bottom), 100, 100, 1, 0, 1)); // unprepare TEST(EGL_TRUE == eglMakeCurrent(gl_display(disp), EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT)); TEST(EGL_TRUE == eglDestroyContext(gl_display(disp), eglcontext)); TEST(0 == free_gconfig(&gconf)); TEST(0 == free_window(&bottom)); TEST(0 == free_window(&top)); WAITFOR(disp, false); eglReleaseThread(); return 0; ONERR: eglMakeCurrent(gl_display(disp), EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); if (eglcontext != EGL_NO_CONTEXT) eglDestroyContext(gl_display(disp), eglcontext); (void) free_gconfig(&gconf); (void) free_window(&top); (void) free_window(&bottom); return EINVAL; }
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR pCmdLine, int nCmdShow) { int i; // Windows variables HWND hWnd=0; HDC hDC=0; // EGL variables EGLDisplay eglDisplay=0; EGLConfig eglConfig=0; EGLSurface eglSurface=0; EGLContext eglContext=0; NativeWindowType eglWindow=0; EGLint pi32ConfigAttribs[128]; unsigned int nWidth; unsigned int nHeight; ATOM registerClass; RECT sRect; EGLint iMajorVersion, iMinorVersion; int iConfigs; /* Step 0 - Create a NativeWindowType that we can use for OpenGL ES output */ // Register the windows class WNDCLASS sWC; sWC.style=CS_HREDRAW | CS_VREDRAW; sWC.lpfnWndProc=WndProc; sWC.cbClsExtra=0; sWC.cbWndExtra=0; sWC.hInstance=hInstance; sWC.hIcon=0; sWC.hCursor=0; sWC.lpszMenuName=0; sWC.hbrBackground=(HBRUSH)GetStockObject(WHITE_BRUSH); sWC.lpszClassName=WINDOW_CLASS; nWidth=WINDOW_WIDTH; nHeight=WINDOW_HEIGHT; registerClass=RegisterClass(&sWC); if (!registerClass) { MessageBox(0, _T("Failed to register the window class"), _T("Error"), MB_OK | MB_ICONEXCLAMATION); } // Create the eglWindow SetRect(&sRect, 0, 0, nWidth, nHeight); AdjustWindowRectEx(&sRect, WS_CAPTION | WS_SYSMENU, 0, 0); hWnd=CreateWindow(WINDOW_CLASS, _T("GLU ES Tesselation test"), WS_VISIBLE | WS_SYSMENU, 0, 0, nWidth, nHeight, NULL, NULL, hInstance, NULL); eglWindow=hWnd; // Get the associated device context hDC=GetDC(hWnd); if (!hDC) { MessageBox(0, _T("Failed to create the device context"), _T("Error"), MB_OK|MB_ICONEXCLAMATION); goto cleanup; } /* Step 1 - Get the default display. EGL uses the concept of a "display" which in most environments corresponds to a single physical screen. Since we usually want to draw to the main screen or only have a single screen to begin with, we let EGL pick the default display. Querying other displays is platform specific. */ eglDisplay=eglGetDisplay((NativeDisplayType)hDC); if(eglDisplay==EGL_NO_DISPLAY) { eglDisplay=eglGetDisplay((NativeDisplayType)EGL_DEFAULT_DISPLAY); } /* Step 2 - Initialize EGL. EGL has to be initialized with the display obtained in the previous step. We cannot use other EGL functions except eglGetDisplay and eglGetError before eglInitialize has been called. If we're not interested in the EGL version number we can just pass NULL for the second and third parameters. */ if (!eglInitialize(eglDisplay, &iMajorVersion, &iMinorVersion)) { MessageBox(0, _T("eglInitialize() failed."), _T("Error"), MB_OK | MB_ICONEXCLAMATION); goto cleanup; } /* Step 3 - Specify the required configuration attributes. An EGL "configuration" describes the pixel format and type of surfaces that can be used for drawing. For now we just want to use a 16 bit RGB surface that is a Window surface, i.e. it will be visible on screen. The list has to contain key/value pairs, terminated with EGL_NONE. */ i=0; pi32ConfigAttribs[i++]=EGL_RED_SIZE; pi32ConfigAttribs[i++]=5; pi32ConfigAttribs[i++]=EGL_GREEN_SIZE; pi32ConfigAttribs[i++]=6; pi32ConfigAttribs[i++]=EGL_BLUE_SIZE; pi32ConfigAttribs[i++]=5; pi32ConfigAttribs[i++]=EGL_ALPHA_SIZE; pi32ConfigAttribs[i++]=0; pi32ConfigAttribs[i++]=EGL_DEPTH_SIZE; pi32ConfigAttribs[i++]=16; pi32ConfigAttribs[i++]=EGL_SURFACE_TYPE; pi32ConfigAttribs[i++]=EGL_WINDOW_BIT; pi32ConfigAttribs[i++]=EGL_NONE; /* Step 4 - Find a config that matches all requirements. eglChooseConfig provides a list of all available configurations that meet or exceed the requirements given as the second argument. In most cases we just want the first config that meets all criteria, so we can limit the number of configs returned to 1. */ if (!eglChooseConfig(eglDisplay, pi32ConfigAttribs, &eglConfig, 1, &iConfigs) || (iConfigs != 1)) { MessageBox(0, _T("eglChooseConfig() failed."), _T("Error"), MB_OK|MB_ICONEXCLAMATION); goto cleanup; } /* Step 5 - Create a surface to draw to. Use the config picked in the previous step and the native window handle when available to create a window surface. A window surface is one that will be visible on screen inside the native display (or fullscreen if there is no windowing system). Pixmaps and pbuffers are surfaces which only exist in off-screen memory. */ eglSurface=eglCreateWindowSurface(eglDisplay, eglConfig, eglWindow, NULL); if (eglSurface==EGL_NO_SURFACE) { eglGetError(); // Clear error eglSurface=eglCreateWindowSurface(eglDisplay, eglConfig, NULL, NULL); } if (!TestEGLError(hWnd, "eglCreateWindowSurface")) { goto cleanup; } /* Step 6 - Create a context. EGL has to create a context for OpenGL ES. Our OpenGL ES resources like textures will only be valid inside this context (or shared contexts) */ eglContext=eglCreateContext(eglDisplay, eglConfig, NULL, NULL); if (!TestEGLError(hWnd, "eglCreateContext")) { goto cleanup; } /* Step 7 - Bind the context to the current thread and use our window surface for drawing and reading. Contexts are bound to a thread. This means you don't have to worry about other threads and processes interfering with your OpenGL ES application. We need to specify a surface that will be the target of all subsequent drawing operations, and one that will be the source of read operations. They can be the same surface. */ eglMakeCurrent(eglDisplay, eglSurface, eglSurface, eglContext); if (!TestEGLError(hWnd, "eglMakeCurrent")) { goto cleanup; } /* Initialize scene */ init_scene(WINDOW_WIDTH, WINDOW_HEIGHT); /* Render stuff */ do { MSG msg; render_scene(); glFinish(); eglWaitGL(); eglSwapBuffers(eglDisplay, eglSurface); if (done) { break; } PeekMessage(&msg, hWnd, 0, 0, PM_REMOVE); TranslateMessage(&msg); DispatchMessage(&msg); } while(1); /* Step 8 - Terminate OpenGL ES and destroy the window (if present). eglTerminate takes care of destroying any context or surface created with this display, so we don't need to call eglDestroySurface or eglDestroyContext here. */ cleanup: eglMakeCurrent(eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); eglTerminate(eglDisplay); /* Step 9 - Destroy the eglWindow. Again, this is platform specific and delegated to a separate function. */ // Release the device context if (hDC) { ReleaseDC(hWnd, hDC); } // Destroy the eglWindow if (hWnd) { DestroyWindow(hWnd); } return 0; }
static jboolean jni_eglWaitGL(JNIEnv *_env, jobject _this) { return eglWaitGL(); }
JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengles_EGL_eglWaitGL(JNIEnv *env, jclass clazz) { return eglWaitGL(); }
int main(int argc, char** argv) { gf_3d_target_t target; gf_display_t gf_disp; EGLConfig config; EGLContext econtext; EGLint num_config; gf_dev_info_t info; gf_layer_info_t linfo; gf_display_info_t disp_info; GLuint width, height; GLuint it; /* initialize the graphics device */ if (gf_dev_attach(&gfdev, NULL, &info)!=GF_ERR_OK) { perror("gf_dev_attach()"); return -1; } /* Setup the layer we will use */ if (gf_display_attach(&gf_disp, gfdev, 0, &disp_info)!=GF_ERR_OK) { fprintf(stderr, "gf_display_attach() failed\n"); return -1; } width=disp_info.xres; height=disp_info.yres; layer_idx=disp_info.main_layer_index; /* get an EGL display connection */ display=eglGetDisplay(gfdev); if (display==EGL_NO_DISPLAY) { fprintf(stderr, "eglGetDisplay() failed\n"); return -1; } if (gf_layer_attach(&layer, gf_disp, layer_idx, 0)!=GF_ERR_OK) { fprintf(stderr, "gf_layer_attach() failed\n"); return -1; } /* initialize the EGL display connection */ if (eglInitialize(display, NULL, NULL)!=EGL_TRUE) { fprintf(stderr, "eglInitialize: error 0x%x\n", eglGetError()); return -1; } for (it=0;; it++) { /* Walk through all possible pixel formats for this layer */ if (gf_layer_query(layer, it, &linfo)==-1) { fprintf(stderr, "Couldn't find a compatible frame " "buffer configuration on layer %d\n", layer_idx); return -1; } /* * We want the color buffer format to match the layer format, * so request the layer format through EGL_NATIVE_VISUAL_ID. */ attribute_list[1]=linfo.format; /* Look for a compatible EGL frame buffer configuration */ if (eglChooseConfig(display, attribute_list, &config, 1, &num_config)==EGL_TRUE) { if (num_config>0) { break; } } } /* create a 3D rendering target */ if (gf_3d_target_create(&target, layer, NULL, 0, width, height, linfo.format)!=GF_ERR_OK) { fprintf(stderr, "Unable to create rendering target\n"); return -1; } gf_layer_set_src_viewport(layer, 0, 0, width-1, height-1); gf_layer_set_dst_viewport(layer, 0, 0, width-1, height-1); gf_layer_enable(layer); /* * The layer settings haven't taken effect yet since we haven't * called gf_layer_update() yet. This is exactly what we want, * since we haven't supplied a valid surface to display yet. * Later, the OpenGL ES library calls will call gf_layer_update() * internally, when displaying the rendered 3D content. */ /* create an EGL rendering context */ econtext=eglCreateContext(display, config, EGL_NO_CONTEXT, NULL); if (econtext==EGL_NO_CONTEXT) { fprintf(stderr, "Create context failed: 0x%x\n", eglGetError()); return -1; } /* create an EGL window surface */ surface=eglCreateWindowSurface(display, config, target, NULL); if (surface==EGL_NO_SURFACE) { fprintf(stderr, "Create surface failed: 0x%x\n", eglGetError()); return -1; } /* connect the context to the surface */ if (eglMakeCurrent(display, surface, surface, econtext)==EGL_FALSE) { fprintf(stderr, "Make current failed: 0x%x\n", eglGetError()); return -1; } init_scene(width, height); do { render_scene(); glFinish(); eglWaitGL(); eglSwapBuffers(display, surface); } while(1); return 0; }