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