The SGI_swap_control extension introduces the function glXSwapIntervalSGI().

To use the video sync extension, follow these steps:

The SGI_video_sync extension introduces the following functions:

For example, two Onyx InfiniteReality systems may be working together to generate a single visual experience. The first Onyx system may be generating an “out the window view” while the second Onyx system may be generating a sensor display. The swap group extension would work well if the two InfiniteReality graphics pipelines were in the same system, but a swap group cannot span two Onyx systems. Even though the two displays are driven by independent systems, you still want the swaps to be synchronized.

The swap barrier solution requires the user to connect a physical coaxial cable to the Swap Ready port of each InfiniteReality pipeline. The multiple pipelines should also be genlocked together (synchronizing their video refresh rates). Genlocking a system means synchronizing it with another video signal serving as a master timing source.

You can use the swap barrier extension through the OpenGL Performer API rather than calling the extension directly.

A swap group is bound to a swap barrier. The buffer swaps of each swap group using that barrier will wait until every swap group using that barrier is ready to swap (where readiness is defined in “Buffer Swap Conditions”). All buffer swaps of all groups using that barrier will take place concurrently when every group is ready.

The set of swap groups using the swap barrier include not only all swap groups on the calling application's system, but also any swap groups set up by other systems that have been cabled together by the Swap Ready ports of their graphics pipeline. This extension extends the set of conditions that must be met before a buffer swap can take place.

Applications call glXBindSwapBarriersSGIX(), which has the following format:

void glXBindSwapBarrierSGIX(Display *dpy, GLXDrawable drawable, int barrier)

The function glXBindSwapBarriersSGIX() binds the swap group that contains drawable to barrier. Subsequent buffer swaps for that group will be subject to this binding until the group is unbound from barrier. If barrier is zero, the group is unbound from its current barrier, if any.

To find out how many swap barriers a graphics pipeline (an X screen) supports, applications call glXQueryMaxSwapbarriersSGIX(), which has the following syntax:

Bool glXQueryMaxSwapBarriersSGIX (Display *dpy, int screen, int max)

The function glXQueryMaxSwapBarriersSGIX() returns in max the maximum number of barriers supported by an implementation on screen.

The function glXQueryMaxSwapBarriersSGIX() returns GL_TRUE if it succeeds and GL_FALSE if it fails. If it fails, max is unchanged.

While the swap barrier extension has the capability to support multiple swap barriers per graphics pipeline, InfiniteReality (the only graphics hardware currently supporting the swap barrier extension) provides only one swap barrier.

The SGI_swap_barrier extension introduces the following functions:

Synchronizing the swapping of multiple drawables ensures that buffer swaps among multiple windows (potentially on different screens) swap at exactly the same time.

Consider the following example:

render(left_window);
render(right_window);
glXSwapBuffers(left_window);
glXSwapBuffers(right_window);

The left_window and right_window are on two different screens (different monitors) but are meant to generate a single logical scene (split across the two screens). While the programmer intends for the two swaps to happen simultaneously, the two glXSwapBuffers() calls are distinct requests, and buffer swaps are tied to the monitor's rate of vertical refresh. Most of the time, the two glXSwapBuffers() calls will swap both windows at the next monitor vertical refresh. Because the two glXSwapBuffers() calls are not atomic, the following cases are possible:

Someone watching the results in the two windows would very briefly see the new left_window contents, but alongside the old right_window contents. This “stutter” between the two window swaps is always annoying and at times simply unacceptable.

The swap group extension allows applications to “tie together” the swapping of multiple windows. Joining the left_window and right_window into a swap group ensures that the windows swap together atomically. This could be done during initialization by making the following call:

glXJoinSwapGroupSGIX(dpy, left_window, right_window);

Subsequent windows can also be added to the swap group. For example, if there was also a middle window, it could be added to the swap group by making the following call:

glXJoinSwapGroupSGIX(dpy, middle_window, right_window);

The only routine added by the swap group extension is glXJoinSwapGroupSGIX(), which has following format:

void glXJoinSwapGroupSGIX(Display *dpy, GLXDrawable drawable, 
                          GLXDrawable member) 

Applications can call glXJoinSwapGroupSGIX() to add drawable to the swap group containing member as a member. If drawable is already a member of a different group, it is implicitly removed from that group first. If member is None, drawable is removed from its swap group, if any.

Applications can reference a swap group by naming any drawable in the group; there is no other way to refer to a group.

Before a buffer swap can take place, a set of conditions must be satisfied. Both the drawable and the group must be ready, satisfying the following conditions:

 A group is ready if all windows in the group are ready.

The function glXJoinSwapGroupSGIX() is part of the X stream. Note that a swap group is limited to GLX drawables managed by a single X server. If you have to synchronize buffer swaps between monitors on different machines, you need the swap barrier extension (see “SGIX_swap_barrier—The Swap Barrier Extension”).

The SGIX_swap_group extension introduces the function glJoinSwapGroupSGIX().

Whether frame synchronous or swap synchronous update is used is set by calling glXChannelRectSyncSGIX(), which has the following format:

int glXChannelRectSyncSGIX (Display *dpy, int screen,int channel,
                            GLenum synctype);

The synctype parameter can be either GLX_SYNC_FRAME_SGIX or GLX_SYNC_SWAP_SGIX.

The extension can control fill-rate requirements for real-time visualization applications or to support a larger number of video output channels on a system with limited framebuffer memory.

To use the video resize extensions, follow these steps:

The following example from the man page for glxChannelRectSGIX() illustrates how to use the extension:

XSGIvcChannelInfo   *pChanInfo = NULL;

... open display and screen ...
glXBindChannelToWindowSGIX( display,screen,channel,window );
glXQueryChannelDeltasSGIX( display,screen,channel, &dx,&dy,&dw,&dh );

XSGIvcQueryChannelInfo( display, screen, channel, &pChanInfo );

X = pChanInfo->source.x;
Y = pChanInfo->source.y;
W = pChanInfo->source.width;
H = pChanInfo->source.height;

... open an X window (preferably with no borders so will not get ...
... moved by window manager) at location X,Y,W,H (X coord system) ...

while( ... )
{
    ...determine area(width,height) that will be drawn based on... 
    ...requirements. Make area smaller if application is fill limited..

    w =  width - ( width % dw );
    h =  height - ( height % dh );

    glViewport( 0,0,w,h );

    glXChannelRectSGIX( display,screen,channel, 0,0,w,h );

    ... draw scene ...

    glXSwapBuffers( display,window );
}

The SGIX_video_resize extension introduces the following functions: