rSysDep Class Reference

#include <rSysdep.h>

List of all members.

Public Types
enum	rSwapMode { rSwap_Fastest = 0, rSwap_glFlush = 1, rSwap_glFinish = 2 }
Static Public Member Functions
static bool	InitGL ()
static void	ExitGL ()
static void	SwapGL ()
static void	ClearGL ()
static void	StartNetSyncThread (rNetIdler *idler)
static void	StopNetSyncThread ()
Static Public Attributes
static rSwapMode	swapMode_ = rSysDep::rSwap_glFlush
Classes
class	rNetIdler

---

Detailed Description

Definition at line 31 of file rSysdep.h.

---

Member Enumeration Documentation

enum rSysDep::rSwapMode

Enumerator:

rSwap_Fastest
rSwap_glFlush
rSwap_glFinish

Definition at line 34 of file rSysdep.h.

    {
        rSwap_Fastest = 0,
        rSwap_glFlush = 1,
        rSwap_glFinish = 2
                         /*
                                 rSwap_150Hz = 5,
                                 rSwap_100Hz = 7,
                                 rSwap_80Hz  = 9,
                                 rSwap_60Hz  = 11
                         */
    };

---

Member Function Documentation

bool rSysDep::InitGL

(

)

[static]

Definition at line 102 of file rSysdep.cpp.

References rScreenSettings::colorDepth, currentScreensetting, and NULL.

Referenced by lowlevel_sr_InitDisplay().

00102                                       :
00103 bool  rSysDep::InitGL(){
00104     SDL_SysWMinfo system;
00105     SDL_VERSION(&system.version);
00106     if (!SDL_GetWMInfo(&system)){
00107         std::cerr << "Video information not available!\n";
00108         return(false);
00109     }
00110 
00111     /*
00112     con << "SDL version: " << (int)system.version.major
00113          << "." <<  (int)system.version.minor << "." <<  (int)system.version.patch << '\n';
00114     */
00115 
00116     /*
00117     //#ifdef HAVE_FXMESA
00118     if(!ctx){
00119       int x=fxQueryHardware();
00120       if(x){
00121         std::cerr << "No 3Dfx hardware available.\n" << x << '\n';
00122         return(false);
00123       }
00124 
00125       GLint attribs[]={FXMESA_DOUBLEBUFFER,FXMESA_DEPTH_SIZE,16,FXMESA_NONE};
00126       ctx=fxMesaCreateBestContext(0,sr_screenWidth,sr_screenHeight,attribs);
00127 
00128       if (!ctx){
00129         std::cerr << "Could not create FX rendering context!\n";
00130         return(false);
00131       }
00132 
00133       fxMesaMakeCurrent(ctx);
00134     }
00135     */
00136 #ifdef WIN32
00137     // windows GL initialisation stolen from
00138     // http://www.geocities.com/SiliconValley/Code/1219/opengl32.html
00139 
00140     if (!hRC){
00141         HWND hWnd=system.window;
00142 
00143         PIXELFORMATDESCRIPTOR pfd;
00144         int iFormat;
00145 
00146         // get the device context (DC)
00147         hDC = GetDC( hWnd );
00148         if (!hDC) return false;
00149 
00150         // set the pixel format for the DC
00151         ZeroMemory( &pfd, sizeof( pfd ) );
00152         pfd.nSize = sizeof( pfd );
00153         pfd.nVersion = 1;
00154         pfd.dwFlags = PFD_DRAW_TO_WINDOW |
00155                       PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
00156         pfd.iPixelType = PFD_TYPE_RGBA;
00157         pfd.cColorBits = currentScreensetting.colorDepth ? 24 : 16;
00158         pfd.cDepthBits = 16;
00159         pfd.iLayerType = PFD_MAIN_PLANE;
00160         iFormat = ChoosePixelFormat( hDC, &pfd );
00161         SetPixelFormat( hDC, iFormat, &pfd );
00162 
00163         // create and enable the render context (RC)
00164         hRC = wglCreateContext( hDC );
00165         if (!hRC || !wglMakeCurrent( hDC, hRC ))
00166             return false;
00167     }
00168 
00169 #elif defined(unix) || defined(__unix__)
00170     if (system.subsystem!=SDL_SYSWM_X11){
00171         std::cerr << "System is not X11!\n";
00172         std::cerr << (int)system.subsystem << "!=" << (int)SDL_SYSWM_X11 <<'\n';
00173         return false;
00174     }
00175 
00176     if (!dpy){
00177 
00178         dpy=system.info.x11.display;
00179         win=system.info.x11.window;
00180 
00181         int errorbase,tEventbase;
00182         if (glXQueryExtension(dpy,&errorbase,&tEventbase) == False){
00183             std::cerr << "OpenGL through GLX not supported.\n";
00184             return false;
00185         }
00186 
00187         int configuration[]={GLX_DOUBLEBUFFER,GLX_RGBA,GLX_DEPTH_SIZE ,12, GLX_RED_SIZE,1,
00188                              GLX_BLUE_SIZE,1,GLX_GREEN_SIZE,1,None
00189                             };
00190 
00191         XVisualInfo *vi=glXChooseVisual(dpy,DefaultScreen(dpy),configuration);
00192 
00193         if (vi== NULL){
00194             std::cerr << "Could not initialize Visual.\n";
00195             return false;
00196         }
00197 
00198         cx=glXCreateContext(dpy,vi,
00199                             NULL,True);
00200 
00201         if (cx== NULL){
00202             std::cerr << "Could not initialize GL context.\n";
00203             return false;
00204         }
00205 
00206         if (!glXMakeCurrent(dpy,win,cx)){
00207             dpy=0;
00208             return false;
00209         }
00210     }
00211 
00212 #endif
00213 
00214     return true;
}

Here is the caller graph for this function:

void rSysDep::ExitGL

(

)

[static]

Definition at line 216 of file rSysdep.cpp.

References NULL.

Referenced by sr_ExitDisplay().

                     {
    SDL_SysWMinfo system;
    SDL_GetWMInfo(&system);

    /*
    #ifdef HAVE_FXMESA

    if(ctx){
      fxMesaDestroyContext(ctx);
      ctx=NULL;
      fxCloseHardware();
    }
    */

#if defined(WIN32)
    HWND hWnd=system.window;

    // windows GL cleanup stolen from
    // http://www.geocities.com/SiliconValley/Code/1219/opengl32.html
    if (hRC){

        wglMakeCurrent( NULL, NULL );
        wglDeleteContext( hRC );
        ReleaseDC( hWnd, hDC );

        hRC=NULL;
        hDC=NULL;
    }
#elif defined(unix) || defined(__unix__)
    if (dpy){

        //    glXReleaseBuffersMESA( dpy, win );
        glXMakeCurrent(dpy,None,NULL);
        glXDestroyContext(dpy, cx );
        dpy=NULL;
    }
#endif

Here is the caller graph for this function:

void rSysDep::SwapGL

(

)

[static]

Definition at line 807 of file rSysdep.cpp.

References breakpoint(), ClearGL(), PerformanceCounter::Count(), rPerFrameTask::DoPerFrameTasks(), tRecorderBase::IsPlayingBack(), tRecorderBase::IsRunning(), lastSuccess, make_screenshot(), rSwap_Fastest, rSwap_glFinish, rSwap_glFlush, s_benchmark, s_fastForward, s_fastForwardTo, s_nextFastForwardFrameReal, s_nextFastForwardFrameRecorded, s_videoout, sr_FF_Maxstep, sr_FF_MaxstepReal, sr_FF_MaxstepRel, sr_glOut, sr_LockSDL(), sr_MotionBlur(), sr_netLock, sr_screenshotIsPlanned, sr_UnlockSDL(), st_Breakpoint(), swapMode_, tDelayForce(), tRealSysTimeFloat(), tSysTimeFloat(), and rScreenSettings::useSDL.

Referenced by gServerBrowser::BrowseLAN(), gServerBrowser::BrowseSpecialMaster(), ConnectToServerCore(), gGame::GameLoop(), uMenu::Message(), uMenu::OnEnter(), Render(), and welcome().

                    {
    static std::auto_ptr< rTextureRenderTarget > blurTarget(0);

    if ( s_benchmark )
    {
        static PerformanceCounter counter;
        counter.Count();
    }

    double time = tSysTimeFloat();
    double realTime = tRealSysTimeFloat();

    bool next_glOut = sr_glOut;

    /* static double mytime = time; //ljr
    if (false && time < mytime + 1. / 29.97) {
        printf("skipping! %f %f\n", time, mytime);
        next_glOut = false;
    } else {
        printf("rendering %f %f\n", time, mytime);
        mytime = time;
        next_glOut = true;
    } */

    // adapt playback speed to recorded speed
    if ( !s_benchmark && !s_fastForward && tRecorder::IsPlayingBack() )
    {
        static double timeOffset=0;
        static double lastRendered=0;

        // calculate how much we're behind the rendering schedule
        double behind = - time + realTime + timeOffset;
        // std::cout << behind << " " << sr_glOut << "\n";

        // large delays can only be caused by breakpoints or map downloads; ignore them
        if ( behind > .5 || realTime > lastRendered + .2 )
        {
            timeOffset -= behind;
            next_glOut = true;
        }
        else
        {
            // we're a bit behind, skip the next frame
            if ( behind > .1 )
            {
                next_glOut = false;
            }
            else if ( sr_glOut )
            {
                lastRendered=realTime;
                // we're ahead, pause a bit
                if  ( behind < -.5 )
                    timeOffset -= behind;
                else if ( behind < -.1 )
                {
                    int delay = int( -( behind + .1 ) * 1000000 );
                    // std::cout << behind << ":" << delay << "\n";
                    tDelayForce( delay );
                }
            }
            else
            {
                // we're not behind any more. Reactivate rendering.
                next_glOut = true;
            }
        }

        if ( next_glOut )
            lastRendered=realTime;
    }

    if (!sr_glOut)
    {
        // display next frame in fast foward mode
        if ( s_fastForward && ( time > s_nextFastForwardFrameRecorded || realTime > s_nextFastForwardFrameReal ) || next_glOut )
        {
            sr_glOut = true;
            rSysDep::ClearGL();
        }

        // in playback or recording mode, always execute frame tasks, they may be improtant for consistency
        if ( tRecorder::IsRunning() ) {
            rPerFrameTask::DoPerFrameTasks();
#ifdef HAVE_LIBRUBY
            rPerFrameTaskRuby::DoPerFrameTasks();
#endif
        }


        return;
    }


    rPerFrameTask::DoPerFrameTasks();
#ifdef HAVE_LIBRUBY
    rPerFrameTaskRuby::DoPerFrameTasks();
#endif

    // unlock the mutex while waiting for the swap operation to finish
    SDL_mutexV(  sr_netLock );
    sr_LockSDL();

    // actiate motion blur (does not use the game state, so it's OK to call here )
    bool shouldSwap = sr_MotionBlur( time, blurTarget );

    switch ( swapMode_ )
    {
    case rSwap_Fastest:
        break;
    case rSwap_glFlush:
        glFlush();
        break;
    case rSwap_glFinish:
        glFinish();
        break;
    }

    if ( shouldSwap )
    {
#if defined(SDL_OPENGL)
        if (lastSuccess.useSDL)
            SDL_GL_SwapBuffers();
        //#elif defined(HAVE_FXMESA)
        //fxMesaSwapBuffers();
#endif

#ifdef DIRTY
        if (!lastSuccess.useSDL){
#if defined(WIN32)
            SwapBuffers( hDC );
#elif defined(unix) || defined(__unix__)
            glXSwapBuffers(dpy,win);
#endif
        }
#endif
    }

    if (sr_screenshotIsPlanned){
        make_screenshot();
        sr_screenshotIsPlanned=false;
    }
    else if (s_videoout)
        make_screenshot();

    sr_UnlockSDL();
    // lock mutex again
    SDL_mutexP(  sr_netLock );


    // disable output in fast forward mode
    if ( s_fastForward && tRecorder::IsPlayingBack() )
    {
        if ( time < s_fastForwardTo )
        {
            // next displayed frame should be ten percent closer to the target, but at most 10 seconds
            s_nextFastForwardFrameRecorded = ( s_fastForwardTo - time ) * sr_FF_MaxstepRel;
            if ( s_nextFastForwardFrameRecorded > sr_FF_Maxstep )
                s_nextFastForwardFrameRecorded = sr_FF_Maxstep ;
            s_nextFastForwardFrameRecorded += time;
            s_nextFastForwardFrameReal = realTime + sr_FF_MaxstepReal ;

            next_glOut = false;
        }
        else
        {
            std::cout << "End of fast forward mode.\n";
            st_Breakpoint();
            s_fastForward = false;
        }
    }

    //#ifdef DEBUG
    if ( !s_fastForward )
    {
        breakpoint();
    }
    //#endif

    // store frame time for next frame
    // lastFrame = tRealSysTimeFloat();

    sr_glOut = next_glOut;

Here is the call graph for this function:

Here is the caller graph for this function:

void rSysDep::ClearGL

(

)

[static]

Definition at line 1023 of file rSysdep.cpp.

References sr_glOut.

Referenced by gServerBrowser::BrowseLAN(), gServerBrowser::BrowseSpecialMaster(), ConnectToServerCore(), gGame::GameLoop(), uMenu::Message(), uMenu::OnEnter(), Render(), SwapGL(), and welcome().

                      {
    if (sr_glOut){

        /*
        if (sr_screenshotIsPlanned){
          make_screenshot();
          sr_screenshotIsPlanned=false;
        }
        */

        glClearColor(0.0,0.0,0.0,1.0);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    }

Here is the caller graph for this function:

void rSysDep::StartNetSyncThread

(

rNetIdler *

idler

)

[static]

Definition at line 556 of file rSysdep.cpp.

References tRecorderBase::IsRunning(), sr_netLock, sr_NetSyncThread(), and sr_netSyncThread.

{
    sr_netIdler = idler;

    return; // BUG This thread is crashing ruby

    // can't use thrading trouble while recording
    if ( tRecorder::IsRunning() )
        return;

    if ( sr_netSyncThread )
        return;

    // create lock
    if ( !sr_netLock )
        sr_netLock = SDL_CreateMutex();

    // start thread
    sr_netSyncThread = SDL_CreateThread( sr_NetSyncThread, sr_netLock );
    if ( !sr_netSyncThread )
        return;

    // lock mutex, the thread should only do work while the main thread is waiting for the refresh
    SDL_mutexP( sr_netLock );

Here is the call graph for this function:

void rSysDep::StopNetSyncThread

(

)

[static]

Definition at line 582 of file rSysdep.cpp.

References NULL, sr_netLock, sr_netSyncThread, and sr_netSyncThreadGoOn.

Referenced by net_game().

{
    // stop and delete thread
    if ( sr_netSyncThread )
    {
        SDL_mutexV(  sr_netLock );
        sr_netSyncThreadGoOn = false;
        SDL_WaitThread( sr_netSyncThread, NULL );
        sr_netSyncThread = NULL;
        sr_netIdler = NULL;
    }

    // delete lock
    if ( sr_netLock )
    {
        SDL_DestroyMutex( sr_netLock );
        sr_netLock = NULL;
    }

Here is the caller graph for this function:

---

Member Data Documentation

rSysDep::rSwapMode rSysDep::swapMode_ = rSysDep::rSwap_glFlush [static]

Definition at line 69 of file rSysdep.h.

Referenced by sr_LoadDefaultConfig(), and SwapGL().

---

The documentation for this class was generated from the following files:

• src/render/rSysdep.h
• src/render/rSysdep.cpp

---