bool LinuxGLContext::SwapBuffers() { glXSwapBuffers(display_, wnd_); return true; }
void CGLContextGLX::SwapBuffers(int &mode) { if(mode == 3) { glFinish(); unsigned int before = 0, after = 0; if (m_glXGetVideoSyncSGI(&before) != 0) CLog::Log(LOGERROR, "%s - glXGetVideoSyncSGI - Failed to get current retrace count", __FUNCTION__); glXSwapBuffers(m_dpy, m_glxWindow); glFinish(); if(m_glXGetVideoSyncSGI(&after) != 0) CLog::Log(LOGERROR, "%s - glXGetVideoSyncSGI - Failed to get current retrace count", __FUNCTION__); if (after == before) m_iVSyncErrors = 1; else m_iVSyncErrors--; if (m_iVSyncErrors > 0) { CLog::Log(LOGINFO, "GL: retrace count didn't change after buffer swap, switching to vsync mode 4"); m_iVSyncErrors = 0; mode = 4; } if (m_iVSyncErrors < -200) { CLog::Log(LOGINFO, "GL: retrace count change for %d consecutive buffer swap, switching to vsync mode 2", -m_iVSyncErrors); m_iVSyncErrors = 0; mode = 2; } } else if (mode == 4) { glFinish(); unsigned int before = 0, swap = 0, after = 0; if (m_glXGetVideoSyncSGI(&before) != 0) CLog::Log(LOGERROR, "%s - glXGetVideoSyncSGI - Failed to get current retrace count", __FUNCTION__); if(m_glXWaitVideoSyncSGI(2, (before+1)%2, &swap) != 0) CLog::Log(LOGERROR, "%s - glXWaitVideoSyncSGI - Returned error", __FUNCTION__); glXSwapBuffers(m_dpy, m_glxWindow); glFinish(); if (m_glXGetVideoSyncSGI(&after) != 0) CLog::Log(LOGERROR, "%s - glXGetVideoSyncSGI - Failed to get current retrace count", __FUNCTION__); if (after == before) CLog::Log(LOGERROR, "%s - glXWaitVideoSyncSGI - Woke up early", __FUNCTION__); if (after > before + 1) m_iVSyncErrors++; else m_iVSyncErrors = 0; if (m_iVSyncErrors > 30) { CLog::Log(LOGINFO, "GL: retrace count seems to be changing due to the swapbuffers call, switching to vsync mode 3"); mode = 3; m_iVSyncErrors = 0; } } else glXSwapBuffers(m_dpy, m_glxWindow); }
ENTRYPOINT void draw_pinion (ModeInfo *mi) { pinion_configuration *pp = &pps[MI_SCREEN(mi)]; Display *dpy = MI_DISPLAY(mi); Window window = MI_WINDOW(mi); Bool wire_p = MI_IS_WIREFRAME(mi); if (!pp->glx_context) return; glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), *(pp->glx_context)); if (!pp->button_down_p) { if (!debug_one_gear_p || pp->ngears == 0) scroll_gears (mi); spin_gears (mi); } glShadeModel(GL_SMOOTH); glEnable(GL_DEPTH_TEST); glEnable(GL_NORMALIZE); glEnable(GL_CULL_FACE); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glPushMatrix (); { gltrackball_rotate (pp->trackball); mi->polygon_count = 0; glScalef (16, 16, 16); /* map vp_width/height to the screen */ if (debug_one_gear_p) /* zoom in */ glScalef (3, 3, 3); else if (debug_p) /* show the "visible" and "layout" areas */ { GLfloat ow = pp->layout_right - pp->render_left; GLfloat rw = pp->render_right - pp->render_left; GLfloat s = (pp->vp_width / ow) * 0.85; glScalef (s, s, s); glTranslatef (-(ow - rw) / 2, 0, 0); } else { GLfloat s = 1.2; glScalef (s, s, s); /* zoom in a little more */ glRotatef (-35, 1, 0, 0); /* tilt back */ glRotatef ( 8, 0, 1, 0); /* tilt left */ glTranslatef (0.02, 0.1, 0); /* pan up */ } draw_gears (mi); if (debug_p) { if (!wire_p) glDisable(GL_LIGHTING); glColor3f (0.6, 0, 0); glBegin(GL_LINE_LOOP); glVertex3f (pp->render_left, pp->vp_top, 0); glVertex3f (pp->render_right, pp->vp_top, 0); glVertex3f (pp->render_right, pp->vp_bottom, 0); glVertex3f (pp->render_left, pp->vp_bottom, 0); glEnd(); glColor3f (0.4, 0, 0); glBegin(GL_LINES); glVertex3f (pp->vp_left, pp->vp_top, 0); glVertex3f (pp->vp_left, pp->vp_bottom, 0); glVertex3f (pp->vp_right, pp->vp_top, 0); glVertex3f (pp->vp_right, pp->vp_bottom, 0); glEnd(); glColor3f (0, 0.4, 0); glBegin(GL_LINE_LOOP); glVertex3f (pp->layout_left, pp->vp_top, 0); glVertex3f (pp->layout_right, pp->vp_top, 0); glVertex3f (pp->layout_right, pp->vp_bottom, 0); glVertex3f (pp->layout_left, pp->vp_bottom, 0); glEnd(); if (!wire_p) glEnable(GL_LIGHTING); } if (pp->draw_tick++ > 10) /* only do this every N frames */ { pp->draw_tick = 0; find_mouse_gear (mi); new_label (mi); } } glPopMatrix (); glCallList (pp->title_list); if (mi->fps_p) do_fps (mi); glFinish(); glXSwapBuffers(dpy, window); }
void swapBuffers(void) { glXSwapBuffers(display, window); }
void swap_buffers(void) { glXSwapBuffers( dpy, glxWin ); //glXSwapBuffersMscOML(dpy, glxWin, 0, 0, 0); }
void eventLoop (void) { XEvent event; struct pollfd ufd; int timeDiff; struct timeval tv; Region tmpRegion; CompDisplay *display = compDisplays; CompScreen *s = display->screens; int timeToNextRedraw = 0; CompWindow *move = 0; int px = 0, py = 0; CompTimeout *t; tmpRegion = XCreateRegion (); if (!tmpRegion) { fprintf (stderr, "%s: Couldn't create region\n", programName); return; } ufd.fd = ConnectionNumber (display->display); ufd.events = POLLIN; for (;;) { if (display->dirtyPluginList) updatePlugins (display); if (restartSignal) { execvp (programName, programArgv); exit (1); } while (XPending (display->display)) { XNextEvent (display->display, &event); /* translate root window */ if (testMode) { Window root, child; switch (event.type) { case ButtonPress: if (!move) { px = event.xbutton.x; py = event.xbutton.y; move = findWindowAt (display, event.xbutton.window, px, py); if (move) { XRaiseWindow (display->display, move->id); continue; } } case ButtonRelease: move = 0; root = translateToRootWindow (display, event.xbutton.window); XTranslateCoordinates (display->display, event.xbutton.root, root, event.xbutton.x_root, event.xbutton.y_root, &event.xbutton.x_root, &event.xbutton.y_root, &child); event.xbutton.root = root; break; case KeyPress: case KeyRelease: root = translateToRootWindow (display, event.xkey.window); XTranslateCoordinates (display->display, event.xkey.root, root, event.xkey.x_root, event.xkey.y_root, &event.xkey.x_root, &event.xkey.y_root, &child); event.xkey.root = root; break; case MotionNotify: if (move) { XMoveWindow (display->display, move->id, move->attrib.x + event.xbutton.x - px, move->attrib.y + event.xbutton.y - py); px = event.xbutton.x; py = event.xbutton.y; continue; } root = translateToRootWindow (display, event.xmotion.window); XTranslateCoordinates (display->display, event.xmotion.root, root, event.xmotion.x_root, event.xmotion.y_root, &event.xmotion.x_root, &event.xmotion.y_root, &child); event.xmotion.root = root; default: break; } } /* add virtual modifiers */ switch (event.type) { case ButtonPress: event.xbutton.state |= CompPressMask; event.xbutton.state = realToVirtualModMask (display, event.xbutton.state); break; case ButtonRelease: event.xbutton.state |= CompReleaseMask; event.xbutton.state = realToVirtualModMask (display, event.xbutton.state); break; case KeyPress: event.xkey.state |= CompPressMask; event.xkey.state = realToVirtualModMask (display, event.xkey.state); break; case KeyRelease: event.xkey.state |= CompReleaseMask; event.xkey.state = realToVirtualModMask (display, event.xkey.state); break; case MotionNotify: event.xmotion.state = realToVirtualModMask (display, event.xmotion.state); break; default: break; } (*display->handleEvent) (display, &event); } if (s->allDamaged || REGION_NOT_EMPTY (s->damage)) { if (timeToNextRedraw == 0) { /* wait for X drawing requests to finish glXWaitX (); */ gettimeofday (&tv, 0); timeDiff = TIMEVALDIFF (&tv, &s->lastRedraw); (*s->preparePaintScreen) (s, timeDiff); if (s->allDamaged) { EMPTY_REGION (s->damage); s->allDamaged = 0; (*s->paintScreen) (s, &defaultScreenPaintAttrib, &defaultWindowPaintAttrib, &s->region, PAINT_SCREEN_REGION_MASK | PAINT_SCREEN_FULL_MASK); glXSwapBuffers (s->display->display, s->root); } else { XIntersectRegion (s->damage, &s->region, tmpRegion); EMPTY_REGION (s->damage); if ((*s->paintScreen) (s, &defaultScreenPaintAttrib, &defaultWindowPaintAttrib, tmpRegion, PAINT_SCREEN_REGION_MASK)) { BoxPtr pBox; int nBox, y; glEnable (GL_SCISSOR_TEST); glDrawBuffer (GL_FRONT); pBox = tmpRegion->rects; nBox = tmpRegion->numRects; while (nBox--) { y = s->height - pBox->y2; glBitmap (0, 0, 0, 0, pBox->x1 - s->rasterX, y - s->rasterY, NULL); s->rasterX = pBox->x1; s->rasterY = y; glScissor (pBox->x1, y, pBox->x2 - pBox->x1, pBox->y2 - pBox->y1); glCopyPixels (pBox->x1, y, pBox->x2 - pBox->x1, pBox->y2 - pBox->y1, GL_COLOR); pBox++; } glDrawBuffer (GL_BACK); glDisable (GL_SCISSOR_TEST); glFlush (); } else { (*s->paintScreen) (s, &defaultScreenPaintAttrib, &defaultWindowPaintAttrib, &s->region, PAINT_SCREEN_FULL_MASK); glXSwapBuffers (s->display->display, s->root); } } s->lastRedraw = tv; (*s->donePaintScreen) (s); /* remove destroyed windows */ while (s->pendingDestroys) { CompWindow *w; for (w = s->windows; w; w = w->next) { if (w->destroyed) { addWindowDamage (w); removeWindow (w); break; } } s->pendingDestroys--; } } timeToNextRedraw = getTimeToNextRedraw (s, &s->lastRedraw); if (timeToNextRedraw) timeToNextRedraw = poll (&ufd, 1, timeToNextRedraw); } else { if (timeouts) { if (timeouts->left > 0) poll (&ufd, 1, timeouts->left); gettimeofday (&tv, 0); timeDiff = TIMEVALDIFF (&tv, &lastTimeout); for (t = timeouts; t; t = t->next) t->left -= timeDiff; while (timeouts && timeouts->left <= 0) { t = timeouts; if ((*t->callBack) (t->closure)) { timeouts = t->next; addTimeout (t); } else { timeouts = t->next; free (t); } } s->lastRedraw = lastTimeout = tv; } else { poll (&ufd, 1, 1000); gettimeofday (&s->lastRedraw, 0); } /* just redraw immediately */ timeToNextRedraw = 0; } } }
void GlxContext::display() { if (m_window) glXSwapBuffers(m_display, m_window); }
// Frame lifecycle members void GUIWindow::SwapBuffers() { glXSwapBuffers(display, window); }
ENTRYPOINT void draw_tentacles (ModeInfo *mi) { tentacles_configuration *tc = &tcs[MI_SCREEN(mi)]; Display *dpy = MI_DISPLAY(mi); Window window = MI_WINDOW(mi); int i; if (!tc->glx_context) return; glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), *(tc->glx_context)); glShadeModel(GL_SMOOTH); glEnable(GL_DEPTH_TEST); glEnable(GL_NORMALIZE); glEnable(GL_CULL_FACE); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glPushMatrix (); glRotatef(current_device_rotation(), 0, 0, 1); # if 1 glScalef (3, 3, 3); # else glPushAttrib (GL_ENABLE_BIT); glPushMatrix(); { GLfloat s = 8.7/1600; glScalef(s,s,s); } glTranslatef(-800,-514,0); glDisable(GL_LIGHTING); glDisable(GL_TEXTURE_1D); glDisable(GL_TEXTURE_2D); glColor3f (1, 1, 1); glBegin(GL_LINE_LOOP); glVertex3f(0,0,0); glVertex3f(0,1028,0); glVertex3f(1600,1028,0); glVertex3f(1600,0,0); glEnd(); glPopMatrix(); glPopAttrib(); # endif gltrackball_rotate (tc->trackball); mi->polygon_count = 0; if (debug_p) { glPushAttrib (GL_ENABLE_BIT); glDisable (GL_LIGHTING); glDisable (GL_TEXTURE_1D); glDisable (GL_TEXTURE_2D); glColor3f (1, 1, 1); glLineWidth (1); glBegin(GL_LINES); glVertex3f(-0.5, 0, 0); glVertex3f(0.5, 0, 0); glVertex3f(0, -0.5, 0); glVertex3f(0, 0.5, 0); glEnd(); glPopAttrib(); } else { GLfloat rx = 45; GLfloat ry = -45; GLfloat rz = 70; if (tc->left_p) ry = -ry, rz = -rz; glRotatef (ry, 0, 1, 0); glRotatef (rx, 1, 0, 0); glRotatef (rz, 0, 0, 1); if (intersect_p) glTranslatef (0, -2.0, -4.5); else glTranslatef (0, -2.5, -5.0); } if (!tc->button_down_p) for (i = 0; i < tc->ntentacles; i++) move_tentacle (tc->tentacles[i]); #if 1 for (i = 0; i < tc->ntentacles; i++) { if (! intersect_p) glClear(GL_DEPTH_BUFFER_BIT); draw_tentacle (tc->tentacles[i], True); if (cel_p) draw_tentacle (tc->tentacles[i], False); } #else glScalef (3, 3, 3); glScalef (1, 1, 4); glColor3f(1,1,1); glPolygonMode (GL_FRONT_AND_BACK, GL_FILL); draw_sucker (tc->tentacles[0], True); if (cel_p) { glPolygonMode (GL_FRONT_AND_BACK, GL_LINE); glLineWidth (tc->line_thickness); glColor4fv (tc->outline_color); draw_sucker (tc->tentacles[0], False); } #endif glPopMatrix (); if (mi->fps_p) do_fps (mi); glFinish(); glXSwapBuffers(dpy, window); }
static void Redraw(struct window *h) { pthread_mutex_lock(&h->drawMutex); if (!glXMakeCurrent(h->Dpy, h->Win, h->Context)) { Error(h->DisplayName, "glXMakeCurrent failed in Redraw"); pthread_mutex_unlock(&h->drawMutex); return; } h->Angle += 1.0; glShadeModel(GL_FLAT); glClearColor(0.25, 0.25, 0.25, 1.0); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glEnable(GL_TEXTURE_2D); glEnable(GL_DEPTH_TEST); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); glColor3f(1, 1, 1); glPushMatrix(); if (h->Id == 0) glRotatef(h->Angle, 0, 1, -1); else if (h->Id == 1) glRotatef(-(h->Angle), 0, 1, -1); else if (h->Id == 2) glRotatef(h->Angle, 0, 1, 1); else if (h->Id == 3) glRotatef(-(h->Angle), 0, 1, 1); glBindTexture(GL_TEXTURE_2D, Textures[0]); glBegin(GL_POLYGON); glTexCoord2f(0, 0); glVertex3f(-1, -1, -1); glTexCoord2f(1, 0); glVertex3f(-1, 1, -1); glTexCoord2f(1, 1); glVertex3f(-1, 1, 1); glTexCoord2f(0, 1); glVertex3f(-1, -1, 1); glEnd(); glBegin(GL_POLYGON); glTexCoord2f(0, 0); glVertex3f(1, -1, -1); glTexCoord2f(1, 0); glVertex3f(1, 1, -1); glTexCoord2f(1, 1); glVertex3f(1, 1, 1); glTexCoord2f(0, 1); glVertex3f(1, -1, 1); glEnd(); glBindTexture(GL_TEXTURE_2D, Textures[1]); glBegin(GL_POLYGON); glTexCoord2f(0, 0); glVertex3f(-1, -1, -1); glTexCoord2f(1, 0); glVertex3f( 1, -1, -1); glTexCoord2f(1, 1); glVertex3f( 1, -1, 1); glTexCoord2f(0, 1); glVertex3f(-1, -1, 1); glEnd(); glBegin(GL_POLYGON); glTexCoord2f(0, 0); glVertex3f(-1, 1, -1); glTexCoord2f(1, 0); glVertex3f( 1, 1, -1); glTexCoord2f(1, 1); glVertex3f( 1, 1, 1); glTexCoord2f(0, 1); glVertex3f(-1, 1, 1); glEnd(); glBindTexture(GL_TEXTURE_2D, Textures[2]); glBegin(GL_POLYGON); glTexCoord2f(0, 0); glVertex3f(-1, -1, -1); glTexCoord2f(1, 0); glVertex3f( 1, -1, -1); glTexCoord2f(1, 1); glVertex3f( 1, 1, -1); glTexCoord2f(0, 1); glVertex3f(-1, 1, -1); glEnd(); glBegin(GL_POLYGON); glTexCoord2f(0, 0); glVertex3f(-1, -1, 1); glTexCoord2f(1, 0); glVertex3f( 1, -1, 1); glTexCoord2f(1, 1); glVertex3f( 1, 1, 1); glTexCoord2f(0, 1); glVertex3f(-1, 1, 1); glEnd(); glPopMatrix(); glXSwapBuffers(h->Dpy, h->Win); if (!glXMakeCurrent(h->Dpy, None, NULL)) { Error(h->DisplayName, "glXMakeCurrent failed in Redraw"); } pthread_mutex_unlock(&h->drawMutex); }
void X11OpenGLWindow::endRendering() { glXSwapBuffers(m_data->m_dpy, m_data->m_win); }
void OpenGLWindowRenderTarget::Present(void) { glXSwapBuffers(mWindowDisplay, mWindowHandle); }
static void event_loop(Display *dpy, Window win) { float frame_usage = 0.0; while (1) { while (XPending(dpy) > 0) { XEvent event; XNextEvent(dpy, &event); switch (event.type) { case Expose: /* we'll redraw below */ break; case ConfigureNotify: reshape(event.xconfigure.width, event.xconfigure.height); break; case KeyPress: { char buffer[10]; int r, code; code = XLookupKeysym(&event.xkey, 0); if (code == XK_Left) { view_roty += 5.0; } else if (code == XK_Right) { view_roty -= 5.0; } else if (code == XK_Up) { view_rotx += 5.0; } else if (code == XK_Down) { view_rotx -= 5.0; } else { r = XLookupString(&event.xkey, buffer, sizeof(buffer), NULL, NULL); if (buffer[0] == 27) { /* escape */ return; } } } } } /* next frame */ angle += 2.0; draw(); glXSwapBuffers(dpy, win); if ( get_frame_usage != NULL ) { GLfloat temp; (*get_frame_usage)( dpy, win, & temp ); frame_usage += temp; } /* calc framerate */ { static int t0 = -1; static int frames = 0; int t = current_time(); if (t0 < 0) t0 = t; frames++; if (t - t0 >= 5.0) { GLfloat seconds = t - t0; GLfloat fps = frames / seconds; if ( get_frame_usage != NULL ) { printf("%d frames in %3.1f seconds = %6.3f FPS (%3.1f%% usage)\n", frames, seconds, fps, (frame_usage * 100.0) / (float) frames ); } else { printf("%d frames in %3.1f seconds = %6.3f FPS\n", frames, seconds, fps); } t0 = t; frames = 0; frame_usage = 0.0; } } } }
void Update() { #ifdef LINUX glXSwapBuffers(dpy, glWin); #endif // LINUX implementation }
void cInterfaceGLX::Swap() { glXSwapBuffers(GLWin.dpy, GLWin.win); }
void screen_refresh() { glXSwapBuffers(enigma::x11::disp, enigma::x11::win); enigma::update_mouse_variables(); window_set_caption(room_caption); }
// Called to end the current frame int glxWindow::endFrame(void) { glXSwapBuffers(pDisplay, xWindow); return 0; }
void _glfwPlatformSwapBuffers(_GLFWwindow* window) { glXSwapBuffers(_glfw.x11.display, window->x11.handle); }
static void clutter_stage_glx_redraw (ClutterStageWindow *stage_window) { ClutterBackendX11 *backend_x11; ClutterBackendGLX *backend_glx; ClutterStageX11 *stage_x11; ClutterStageGLX *stage_glx; GLXDrawable drawable; unsigned int video_sync_count; gboolean may_use_clipped_redraw; gboolean use_clipped_redraw; CLUTTER_STATIC_TIMER (painting_timer, "Redrawing", /* parent */ "Painting actors", "The time spent painting actors", 0 /* no application private data */); CLUTTER_STATIC_TIMER (swapbuffers_timer, "Redrawing", /* parent */ "glXSwapBuffers", "The time spent blocked by glXSwapBuffers", 0 /* no application private data */); CLUTTER_STATIC_TIMER (blit_sub_buffer_timer, "Redrawing", /* parent */ "glx_blit_sub_buffer", "The time spent in _glx_blit_sub_buffer", 0 /* no application private data */); stage_x11 = CLUTTER_STAGE_X11 (stage_window); if (stage_x11->xwin == None) return; stage_glx = CLUTTER_STAGE_GLX (stage_window); backend_x11 = stage_x11->backend; backend_glx = CLUTTER_BACKEND_GLX (backend_x11); CLUTTER_TIMER_START (_clutter_uprof_context, painting_timer); if (G_LIKELY (backend_glx->can_blit_sub_buffer) && /* NB: a zero width redraw clip == full stage redraw */ stage_glx->bounding_redraw_clip.width != 0 && /* some drivers struggle to get going and produce some junk * frames when starting up... */ G_LIKELY (stage_glx->frame_count > 3) && /* While resizing a window clipped redraws are disabled to avoid * artefacts. See clutter-event-x11.c:event_translate for a * detailed explanation */ G_LIKELY (stage_x11->clipped_redraws_cool_off == 0)) { may_use_clipped_redraw = TRUE; } else may_use_clipped_redraw = FALSE; if (may_use_clipped_redraw && G_LIKELY (!(clutter_paint_debug_flags & CLUTTER_DEBUG_DISABLE_CLIPPED_REDRAWS))) use_clipped_redraw = TRUE; else use_clipped_redraw = FALSE; if (use_clipped_redraw) { CLUTTER_NOTE (CLIPPING, "Stage clip pushed: x=%d, y=%d, width=%d, height=%d\n", stage_glx->bounding_redraw_clip.x, stage_glx->bounding_redraw_clip.y, stage_glx->bounding_redraw_clip.width, stage_glx->bounding_redraw_clip.height); cogl_clip_push_window_rectangle (stage_glx->bounding_redraw_clip.x, stage_glx->bounding_redraw_clip.y, stage_glx->bounding_redraw_clip.width, stage_glx->bounding_redraw_clip.height); _clutter_stage_do_paint (stage_x11->wrapper, &stage_glx->bounding_redraw_clip); cogl_clip_pop (); } else { CLUTTER_NOTE (CLIPPING, "Unclipped stage paint\n"); _clutter_stage_do_paint (stage_x11->wrapper, NULL); } if (may_use_clipped_redraw && G_UNLIKELY ((clutter_paint_debug_flags & CLUTTER_DEBUG_REDRAWS))) { static CoglMaterial *outline = NULL; ClutterGeometry *clip = &stage_glx->bounding_redraw_clip; ClutterActor *actor = CLUTTER_ACTOR (stage_x11->wrapper); CoglHandle vbo; float x_1 = clip->x; float x_2 = clip->x + clip->width; float y_1 = clip->y; float y_2 = clip->y + clip->height; float quad[8] = { x_1, y_1, x_2, y_1, x_2, y_2, x_1, y_2 }; CoglMatrix modelview; if (outline == NULL) { outline = cogl_material_new (); cogl_material_set_color4ub (outline, 0xff, 0x00, 0x00, 0xff); } vbo = cogl_vertex_buffer_new (4); cogl_vertex_buffer_add (vbo, "gl_Vertex", 2, /* n_components */ COGL_ATTRIBUTE_TYPE_FLOAT, FALSE, /* normalized */ 0, /* stride */ quad); cogl_vertex_buffer_submit (vbo); cogl_push_matrix (); cogl_matrix_init_identity (&modelview); _clutter_actor_apply_modelview_transform (actor, &modelview); cogl_set_modelview_matrix (&modelview); cogl_set_source (outline); cogl_vertex_buffer_draw (vbo, COGL_VERTICES_MODE_LINE_LOOP, 0 , 4); cogl_pop_matrix (); cogl_object_unref (vbo); } cogl_flush (); CLUTTER_TIMER_STOP (_clutter_uprof_context, painting_timer); drawable = stage_glx->glxwin ? stage_glx->glxwin : stage_x11->xwin; /* If we might ever use _clutter_backend_glx_blit_sub_buffer then we * always need to keep track of the video_sync_count so that we can * throttle blits. * * Note: we get the count *before* we issue any glXCopySubBuffer or * blit_sub_buffer request in case the count would go up before * returning control to us. */ if (backend_glx->can_blit_sub_buffer && backend_glx->get_video_sync) backend_glx->get_video_sync (&video_sync_count); /* push on the screen */ if (use_clipped_redraw) { ClutterGeometry *clip = &stage_glx->bounding_redraw_clip; ClutterGeometry copy_area; ClutterActor *actor; CLUTTER_NOTE (BACKEND, "_glx_blit_sub_buffer (window: 0x%lx, " "x: %d, y: %d, " "width: %d, height: %d)", (unsigned long) drawable, stage_glx->bounding_redraw_clip.x, stage_glx->bounding_redraw_clip.y, stage_glx->bounding_redraw_clip.width, stage_glx->bounding_redraw_clip.height); /* XXX: It seems there will be a race here in that the stage * window may be resized before glXCopySubBufferMESA is handled * and so we may copy the wrong region. I can't really see how * we can handle this with the current state of X but at least * in this case a full redraw should be queued by the resize * anyway so it should only exhibit temporary artefacts. */ actor = CLUTTER_ACTOR (stage_x11->wrapper); copy_area.y = clutter_actor_get_height (actor) - clip->y - clip->height; copy_area.x = clip->x; copy_area.width = clip->width; copy_area.height = clip->height; /* glXCopySubBufferMESA and glBlitFramebuffer are not integrated * with the glXSwapIntervalSGI mechanism which we usually use to * throttle the Clutter framerate to the vertical refresh and so * we have to manually wait for the vblank period... */ /* Here 'is_synchronized' only means that the blit won't cause a * tear, ie it won't prevent multiple blits per retrace if they * can all be performed in the blanking period. If that's the * case then we still want to use the vblank sync menchanism but * we only need it to throttle redraws. */ if (!backend_glx->blit_sub_buffer_is_synchronized) { /* XXX: note that glXCopySubBuffer, at least for Intel, is * synchronized with the vblank but glBlitFramebuffer may * not be so we use the same scheme we do when calling * glXSwapBuffers without the swap_control extension and * call glFinish () before waiting for the vblank period. * * See where we call glXSwapBuffers for more details. */ glFinish (); wait_for_vblank (backend_glx); } else if (backend_glx->get_video_sync) { /* If we have the GLX_SGI_video_sync extension then we can * be a bit smarter about how we throttle blits by avoiding * any waits if we can see that the video sync count has * already progressed. */ if (backend_glx->last_video_sync_count == video_sync_count) wait_for_vblank (backend_glx); } else wait_for_vblank (backend_glx); CLUTTER_TIMER_START (_clutter_uprof_context, blit_sub_buffer_timer); _clutter_backend_glx_blit_sub_buffer (backend_glx, drawable, copy_area.x, copy_area.y, copy_area.width, copy_area.height); CLUTTER_TIMER_STOP (_clutter_uprof_context, blit_sub_buffer_timer); } else { CLUTTER_NOTE (BACKEND, "glXSwapBuffers (display: %p, window: 0x%lx)", backend_x11->xdpy, (unsigned long) drawable); /* If we have GLX swap buffer events then glXSwapBuffers will return * immediately and we need to track that there is a swap in * progress... */ if (clutter_feature_available (CLUTTER_FEATURE_SWAP_EVENTS)) stage_glx->pending_swaps++; if (backend_glx->vblank_type != CLUTTER_VBLANK_GLX_SWAP && backend_glx->vblank_type != CLUTTER_VBLANK_NONE) { /* If we are going to wait for VBLANK manually, we not only * need to flush out pending drawing to the GPU before we * sleep, we need to wait for it to finish. Otherwise, we * may end up with the situation: * * - We finish drawing - GPU drawing continues * - We go to sleep - GPU drawing continues * VBLANK - We call glXSwapBuffers - GPU drawing continues * - GPU drawing continues * - Swap buffers happens * * Producing a tear. Calling glFinish() first will cause us * to properly wait for the next VBLANK before we swap. This * obviously does not happen when we use _GLX_SWAP and let * the driver do the right thing */ glFinish (); wait_for_vblank (backend_glx); } CLUTTER_TIMER_START (_clutter_uprof_context, swapbuffers_timer); glXSwapBuffers (backend_x11->xdpy, drawable); CLUTTER_TIMER_STOP (_clutter_uprof_context, swapbuffers_timer); _cogl_swap_buffers_notify (); } backend_glx->last_video_sync_count = video_sync_count; /* reset the redraw clipping for the next paint... */ stage_glx->initialized_redraw_clip = FALSE; stage_glx->frame_count++; }
ENTRYPOINT void draw_cube (ModeInfo *mi) { cube_configuration *bp = &bps[MI_SCREEN(mi)]; Display *dpy = MI_DISPLAY(mi); Window window = MI_WINDOW(mi); if (!bp->glx_context) return; glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), *bp->glx_context); glShadeModel(GL_SMOOTH); glEnable(GL_DEPTH_TEST); glEnable(GL_NORMALIZE); glEnable(GL_CULL_FACE); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glPushMatrix (); glScalef(1.1, 1.1, 1.1); { double x, y, z; get_position (bp->rot, &x, &y, &z, !bp->button_down_p); glTranslatef((x - 0.5) * 4, (y - 0.5) * 4, (z - 0.5) * 2); gltrackball_rotate (bp->trackball); get_rotation (bp->rot, &x, &y, &z, !bp->button_down_p); glRotatef (x * 360, 1.0, 0.0, 0.0); glRotatef (y * 360, 0.0, 1.0, 0.0); glRotatef (z * 360, 0.0, 0.0, 1.0); } mi->polygon_count = 0; glScalef (6, 6, 6); mi->polygon_count = draw_cubes (mi, bp->cubes); glPopMatrix (); if (!bp->button_down_p) tick_oscillators (mi); if (! bp->oscillators && !bp->button_down_p && !(random() % 60)) { bp->cubes->pos.x = bp->cubes->pos.y = bp->cubes->pos.z = 0; bp->cubes->rot.x = bp->cubes->rot.y = bp->cubes->rot.z = 0; add_random_oscillator (mi); } if (mi->fps_p) do_fps (mi); glFinish(); glXSwapBuffers(dpy, window); }
void GLXGraphicsystem::swapBuffers() { glXSwapBuffers(m_x11display, m_window); }
void MWindow::swapBuffer(void) { glXSwapBuffers(display, window); }
// --------------------------------------------------------------------------- // Function: renderGL // Design: Belongs (mostly) to OpenGL component // Purpose: Main rendering of the 3D desktop // Updated: Sep 10, 2012 // TODO: Split into separate functions // --------------------------------------------------------------------------- void renderGL(Desktop3DLocation& loc, double timeDiff_, RendererPlugin *renderer) { static int frame = 0, time, timebase = 0, count = 0; frame++; count++; count %= 360; time = glutGet(GLUT_ELAPSED_TIME); if (time - timebase > 1000) { fprintf(stderr, "FPS:%4.2f\n", frame * 1000.0 / (time - timebase)); timebase = time; frame = 0; } if (!initedOpenGL) { initedOpenGL = true; if(renderer->getWindowID()) window = renderer->getWindowID(); if (OGRE3D || IRRLICHT) { if(renderer->getOpenGLContext()) context = renderer->getOpenGLContext(); if(!IRRLICHT && !OGRE3D) { std::cerr << "context: " << context << ", " << glXGetCurrentContext() << std::endl; std::cerr << "dpy: " << dpy << ", window: " << window << std::endl; if(!context) { context = glXGetCurrentContext(); } std::cerr << "context: " << context << ", " << glXGetCurrentContext() << std::endl; bool r = glXMakeCurrent(dpy, window, context); std::cerr << "R: " << r << std::endl; } glewExperimental = true; GLenum err = glewInit(); std::cerr << "Inited GLEW: " << err << std::endl; if (GLEW_OK != err) { // GLEW failed! exit(1); } fbconfig = getFBConfigFromContext(dpy, context); std::cerr << "Got fbconfig: " << fbconfig << std::endl; } if(!OGRE3D) { checkForErrors(); std::cerr << "init_distortion_shader" << std::endl; bool success = init_distortion_shader(); if (!success) { std::cerr << "Failed to init distortion shader!" << std::endl; exit(1); } success = init_distortion_shader_cache(); if (!success) { std::cerr << "Failed to init distortion shader cache!" << std::endl; exit(1); } if (USE_FBO) prep_framebuffers(); } renderer->setDesktopTexture(desktopTexture); getCursorTexture(); } if ((renderToTexture || OGRE3D) && !IRRLICHT) { saveState(); renderDesktopToTexture(); restoreState(); } renderer->step(loc, timeDiff_); if(renderer->needsSwapBuffers()) { glXSwapBuffers(display, window); } }
/* Swap buffers convenience function */ void GLwDrawingAreaSwapBuffers(Widget w) { glXSwapBuffers(XtDisplay(w),XtWindow(w)); }
int main(void) { int done=0; srand(time(NULL)); initXWindows(); init_opengl(); // game objected declaration Game game; game.n=0; int xOrigin = 100; int yOrigin = 250; int width = 80; int height = 10; // box shape declaration game.box[0].width = width; game.box[0].height = height; game.box[0].center.x = xOrigin; game.box[0].center.y = yOrigin; game.box[1].width = width; game.box[1].height = height; game.box[1].center.x = xOrigin + 50; game.box[1].center.y = yOrigin - 30; game.box[2].width = width; game.box[2].height = height; game.box[2].center.x = xOrigin + 100; game.box[2].center.y = yOrigin - 60; game.box[3].width = width; game.box[3].height = height; game.box[3].center.x = xOrigin + 150; game.box[3].center.y = yOrigin - 90; game.box[4].width = width; game.box[4].height = height; game.box[4].center.x = xOrigin + 200; game.box[4].center.y = yOrigin - 120; game.circle.center.x = 400; game.circle.center.y = -20; game.circle.radius = 100; //starting animation while(!done) { while(XPending(dpy)) { XEvent e; XNextEvent(dpy, &e); check_mouse(&e, &game); done = check_keys(&e, &game); } movement(&game); render(&game); glXSwapBuffers(dpy, win); } cleanupXWindows(); return 0; }
void CGLWindow_X::SwapBuffers() { glXSwapBuffers( m_display, m_window ); }
void glutSwapBuffers() { glXSwapBuffers(dpy, win); }
StWinHandles::StWinHandles() #ifdef _WIN32 : ThreadWnd(0), EventMsgThread(true), hWindow(NULL), hWindowGl(NULL), hWinTmp(NULL), myMKeyStop(GlobalAddAtom(MAKEINTATOM(VK_MEDIA_STOP))), myMKeyPlay(GlobalAddAtom(MAKEINTATOM(VK_MEDIA_PLAY_PAUSE))), myMKeyPrev(GlobalAddAtom(MAKEINTATOM(VK_MEDIA_PREV_TRACK))), myMKeyNext(GlobalAddAtom(MAKEINTATOM(VK_MEDIA_NEXT_TRACK))), ThreadGL(0), hDC(NULL) { // #elif defined(__linux__) : hWindow(0), hWindowGl(0), stXDisplay(), iconImage(0), iconShape(0), xDNDRequestType(None), xDNDSrcWindow(0), xDNDVersion(0), xrandrEventBase(0), isRecXRandrEvents(false) { // #endif } StWinHandles::~StWinHandles() { close(); } void StWinHandles::glSwap() { #ifdef _WIN32 if(hDC != NULL) { SwapBuffers(hDC); } #elif defined(__linux__) if(!stXDisplay.isNull() && hRC->makeCurrent(hWindowGl)) { // if GL rendering context is bound to another drawable - we got BadMatch error glXSwapBuffers(stXDisplay->hDisplay, hWindowGl); } #endif } bool StWinHandles::glMakeCurrent() { #ifdef _WIN32 if(hDC != NULL && !hRC.isNull()) { return hRC->isCurrent(hDC) || hRC->makeCurrent(hDC); } #elif defined(__linux__) if(!stXDisplay.isNull() && !hRC.isNull()) { return hRC->makeCurrent(hWindowGl); } #endif return false; } /** * Auxiliary macros. */ #define ST_GL_ERROR_CHECK(theTrueCondition, theErrCode, theErrDesc) \ if(!(theTrueCondition)) { \ stError(theErrDesc); \ return theErrCode; \ } int StWinHandles::glCreateContext(StWinHandles* theSlave, const StRectI_t& theRect, const int theDepthSize, const bool theIsQuadStereo, const bool theDebugCtx) { #ifdef _WIN32 ThreadGL = StThread::getCurrentThreadId(); ST_DEBUG_LOG("WinAPI, glCreateContext, ThreadGL= " + ThreadGL + ", ThreadWnd= " + ThreadWnd); hDC = GetDC(hWindowGl); ST_GL_ERROR_CHECK(hDC != NULL, STWIN_ERROR_WIN32_GLDC, "WinAPI, Can't create Master GL Device Context"); if(theSlave != NULL) { theSlave->ThreadGL = ThreadGL; theSlave->hDC = GetDC(theSlave->hWindowGl); ST_GL_ERROR_CHECK(theSlave->hDC != NULL, STWIN_ERROR_WIN32_GLDC, "WinAPI, Can't create Slave GL Device Context"); } PIXELFORMATDESCRIPTOR aPixFrmtDesc = THE_PIXELFRMT_DOUBLE; aPixFrmtDesc.cDepthBits = (BYTE )theDepthSize; if(theIsQuadStereo) { aPixFrmtDesc.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_GDI | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER | PFD_STEREO; } int aPixFrmtId = ChoosePixelFormat(hDC, &aPixFrmtDesc); ST_GL_ERROR_CHECK(aPixFrmtId != 0, STWIN_ERROR_WIN32_PIXELFORMATF, "WinAPI, Can't find a suitable PixelFormat for Master"); if(theSlave != NULL && ChoosePixelFormat(theSlave->hDC, &aPixFrmtDesc) != aPixFrmtId) { ST_ERROR_LOG("Slave window returns another pixel format! Try to ignore..."); } if(theIsQuadStereo) { DescribePixelFormat(hDC, aPixFrmtId, sizeof(PIXELFORMATDESCRIPTOR), &aPixFrmtDesc); if((aPixFrmtDesc.dwFlags & PFD_STEREO) == 0) { ST_ERROR_LOG("WinAPI, Quad Buffered stereo not supported"); } else { //bool isVistaPlus = StSys::isVistaPlus(); //bool isWin8Plus = StSys::isWin8Plus(); ///myNeedsFullscr } } HMODULE aModule = GetModuleHandleW(NULL); hWinTmp = CreateWindowExW(WS_EX_TOOLWINDOW | WS_EX_WINDOWEDGE | WS_EX_NOACTIVATE, ClassTmp.toCString(), L"TmpWnd", WS_POPUP | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_DISABLED, theRect.left() + 2, theRect.top() + 2, 4, 4, NULL, NULL, aModule, NULL); ST_GL_ERROR_CHECK(hWinTmp != NULL, STWIN_ERROR_WIN32_GLDC, "WinAPI, Temporary window creation error"); HDC aDevCtxTmp = GetDC(hWinTmp); ST_GL_ERROR_CHECK(aPixFrmtId != 0, STWIN_ERROR_WIN32_PIXELFORMATF, "WinAPI, Can't find a suitable PixelFormat for Tmp"); ST_GL_ERROR_CHECK(SetPixelFormat(aDevCtxTmp, aPixFrmtId, &aPixFrmtDesc), STWIN_ERROR_WIN32_PIXELFORMATS, "WinAPI, Can't set the PixelFormat for Master"); StWinGlrcH aRendCtxTmp = new StWinGlrc(aDevCtxTmp, NULL); ST_GL_ERROR_CHECK(aRendCtxTmp->isValid(), STWIN_ERROR_WIN32_GLRC_CREATE, "WinAPI, Can't create GL Rendering Context"); ST_GL_ERROR_CHECK(aRendCtxTmp->makeCurrent(aDevCtxTmp), STWIN_ERROR_WIN32_GLRC_ACTIVATE, "WinAPI, Can't activate Tmp GL Rendering Context"); StGLContext aCtx; ST_GL_ERROR_CHECK(aCtx.stglInit(), STWIN_ERROR_WIN32_GLRC_ACTIVATE, "WinAPI, Broken Tmp GL Rendering Context"); if(aCtx.extAll->wglChoosePixelFormatARB != NULL) { const int aPixAttribs[] = { WGL_DRAW_TO_WINDOW_ARB, GL_TRUE, WGL_SUPPORT_OPENGL_ARB, GL_TRUE, WGL_DOUBLE_BUFFER_ARB, GL_TRUE, WGL_STEREO_ARB, theIsQuadStereo ? GL_TRUE : GL_FALSE, WGL_PIXEL_TYPE_ARB, WGL_TYPE_RGBA_ARB, //WGL_SAMPLE_BUFFERS_ARB, 1, //WGL_SAMPLES_ARB, 8, // WGL_CONTEXT_ROBUST_ACCESS_BIT_ARB 0x00000004 WGL_COLOR_BITS_ARB, 24, WGL_DEPTH_BITS_ARB, theDepthSize, WGL_STENCIL_BITS_ARB, 0, 0, 0, }; unsigned int aFrmtsNb = 0; aCtx.extAll->wglChoosePixelFormatARB(hDC, aPixAttribs, NULL, 1, &aPixFrmtId, &aFrmtsNb); } ST_GL_ERROR_CHECK(SetPixelFormat(hDC, aPixFrmtId, &aPixFrmtDesc), STWIN_ERROR_WIN32_PIXELFORMATS, "WinAPI, Can't set the PixelFormat for Master"); ST_GL_ERROR_CHECK(theSlave == NULL || SetPixelFormat(theSlave->hDC, aPixFrmtId, &aPixFrmtDesc), STWIN_ERROR_WIN32_PIXELFORMATS, "WinAPI, Can't set the PixelFormat for Slave"); HGLRC aRendCtx = NULL; if(aCtx.extAll->wglCreateContextAttribsARB != NULL) { // Beware! NVIDIA drivers reject context creation when WGL_CONTEXT_PROFILE_MASK_ARB are specified // but not WGL_CONTEXT_MAJOR_VERSION_ARB/WGL_CONTEXT_MINOR_VERSION_ARB int aCtxAttribs[] = { //WGL_CONTEXT_MAJOR_VERSION_ARB, 3, //WGL_CONTEXT_MINOR_VERSION_ARB, 2, //WGL_CONTEXT_PROFILE_MASK_ARB, WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB, //WGL_CONTEXT_CORE_PROFILE_BIT_ARB, WGL_CONTEXT_FLAGS_ARB, theDebugCtx ? WGL_CONTEXT_DEBUG_BIT_ARB : 0, 0, 0 }; aRendCtx = aCtx.extAll->wglCreateContextAttribsARB(hDC, NULL, aCtxAttribs); } aRendCtxTmp.nullify(); destroyWindow(hWinTmp); hRC = new StWinGlrc(hDC, aRendCtx); ST_GL_ERROR_CHECK(hRC->isValid(), STWIN_ERROR_WIN32_GLRC_CREATE, "WinAPI, Can't create GL Rendering Context"); if(theSlave != NULL) { theSlave->hRC = hRC; } ST_GL_ERROR_CHECK(hRC->makeCurrent(hDC), STWIN_ERROR_WIN32_GLRC_ACTIVATE, "WinAPI, Can't activate Master GL Rendering Context"); return STWIN_INIT_SUCCESS; #elif defined(__linux__) // create an OpenGL rendering context hRC = new StWinGlrc(stXDisplay, theDebugCtx); ST_GL_ERROR_CHECK(hRC->isValid(), STWIN_ERROR_X_GLRC_CREATE, "GLX, could not create rendering context for Master"); if(theSlave != NULL) { theSlave->hRC = hRC; // bind the rendering context to the window ST_GL_ERROR_CHECK(hRC->makeCurrent(theSlave->hWindowGl), STWIN_ERROR_X_GLRC_CREATE, "GLX, Can't activate Slave GL Rendering Context"); } // bind the rendering context to the window ST_GL_ERROR_CHECK(hRC->makeCurrent(hWindowGl), STWIN_ERROR_X_GLRC_CREATE, "GLX, Can't activate Master GL Rendering Context"); return STWIN_INIT_SUCCESS; #endif }
bool CWinSystemX11GL::PresentRenderImpl(const CDirtyRegionList& dirty) { CheckDisplayEvents(); if(m_iVSyncMode == 3) { glFinish(); unsigned int before = 0, after = 0; if(m_glXGetVideoSyncSGI(&before) != 0) CLog::Log(LOGERROR, "%s - glXGetVideoSyncSGI - Failed to get current retrace count", __FUNCTION__); glXSwapBuffers(m_dpy, m_glWindow); glFinish(); if(m_glXGetVideoSyncSGI(&after) != 0) CLog::Log(LOGERROR, "%s - glXGetVideoSyncSGI - Failed to get current retrace count", __FUNCTION__); if(after == before) m_iVSyncErrors = 1; else m_iVSyncErrors--; if(m_iVSyncErrors > 0) { CLog::Log(LOGINFO, "GL: retrace count didn't change after buffer swap, switching to vsync mode 4"); m_iVSyncErrors = 0; m_iVSyncMode = 4; } if(m_iVSyncErrors < -200) { CLog::Log(LOGINFO, "GL: retrace count change for %d consecutive buffer swap, switching to vsync mode 2", -m_iVSyncErrors); m_iVSyncErrors = 0; m_iVSyncMode = 2; } } else if (m_iVSyncMode == 4) { glFinish(); unsigned int before = 0, swap = 0, after = 0; if(m_glXGetVideoSyncSGI(&before) != 0) CLog::Log(LOGERROR, "%s - glXGetVideoSyncSGI - Failed to get current retrace count", __FUNCTION__); if(m_glXWaitVideoSyncSGI(2, (before+1)%2, &swap) != 0) CLog::Log(LOGERROR, "%s - glXWaitVideoSyncSGI - Returned error", __FUNCTION__); glXSwapBuffers(m_dpy, m_glWindow); glFinish(); if(m_glXGetVideoSyncSGI(&after) != 0) CLog::Log(LOGERROR, "%s - glXGetVideoSyncSGI - Failed to get current retrace count", __FUNCTION__); if(after == before) CLog::Log(LOGERROR, "%s - glXWaitVideoSyncSGI - Woke up early", __FUNCTION__); if(after > before + 1) m_iVSyncErrors++; else m_iVSyncErrors = 0; if(m_iVSyncErrors > 30) { CLog::Log(LOGINFO, "GL: retrace count seems to be changing due to the swapbuffers call, switching to vsync mode 3"); m_iVSyncMode = 3; m_iVSyncErrors = 0; } } else if (m_iVSyncMode == 5) { int64_t ust, msc, sbc; if(m_glXGetSyncValuesOML(m_dpy, m_glWindow, &ust, &msc, &sbc)) m_glXSwapBuffersMscOML(m_dpy, m_glWindow, msc, 0, 0); else CLog::Log(LOGERROR, "%s - glXSwapBuffersMscOML - Failed to get current retrace count", __FUNCTION__); } else glXSwapBuffers(m_dpy, m_glWindow); return true; }
void __plg_swapBuffers() { glXSwapBuffers(plgCurrentDisplay, plgCurrentWindow); }