自学教程：C++ FREEGLUT_EXIT_IF_NOT_INITIALISED函数代码示例

/* * General settings assignment method */void FGAPIENTRY glutSetOption( GLenum eWhat, int value ){    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSetOption" );    /*     * XXX In chronological code add order.  (WHY in that order?)     */    switch( eWhat )    {    case GLUT_INIT_WINDOW_X:        fgState.Position.X = (GLint)value;        break;    case GLUT_INIT_WINDOW_Y:        fgState.Position.Y = (GLint)value;        break;    case GLUT_INIT_WINDOW_WIDTH:        fgState.Size.X = (GLint)value;        break;    case GLUT_INIT_WINDOW_HEIGHT:        fgState.Size.Y = (GLint)value;        break;    case GLUT_INIT_DISPLAY_MODE:        fgState.DisplayMode = (unsigned int)value;        break;    case GLUT_ACTION_ON_WINDOW_CLOSE:        fgState.ActionOnWindowClose = value;        break;    case GLUT_RENDERING_CONTEXT:        fgState.UseCurrentContext =            ( value == GLUT_USE_CURRENT_CONTEXT ) ? GL_TRUE : GL_FALSE;        break;    case GLUT_DIRECT_RENDERING:        fgState.DirectContext = value;        break;    case GLUT_WINDOW_CURSOR:        if( fgStructure.CurrentWindow != NULL )            fgStructure.CurrentWindow->State.Cursor = value;        break;    case GLUT_AUX:      fgState.AuxiliaryBufferNumber = value;      break;    case GLUT_MULTISAMPLE:      fgState.SampleNumber = value;      break;    case GLUT_SKIP_STALE_MOTION_EVENTS:      fgState.SkipStaleMotion = value;      break;    default:        fgWarning( "glutSetOption(): missing enum handle %d", eWhat );        break;    }}

/* * Draws a solid cone */void FGAPIENTRY glutSolidCone( GLdouble base, GLdouble height, GLint slices, GLint stacks ){    int i,j;    /* Step in z and radius as stacks are drawn. */    double z0,z1;    double r0,r1;    const double zStep = height / ( ( stacks > 0 ) ? stacks : 1 );    const double rStep = base / ( ( stacks > 0 ) ? stacks : 1 );    /* Scaling factors for vertex normals */    const double cosn = ( height / sqrt ( height * height + base * base ));    const double sinn = ( base   / sqrt ( height * height + base * base ));    /* Pre-computed circle */    double *sint,*cost;    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidCone" );    fghCircleTable(&sint,&cost,-slices);    /* Cover the circular base with a triangle fan... */    z0 = 0.0;    z1 = zStep;    r0 = base;    r1 = r0 - rStep;    glBegin(GL_TRIANGLE_FAN);        glNormal3d(0.0,0.0,-1.0);        glVertex3d(0.0,0.0, z0 );        for (j=0; j<=slices; j++)            glVertex3d(cost[j]*r0, sint[j]*r0, z0);    glEnd();    /* Cover each stack with a quad strip, except the top stack */    for( i=0; i<stacks-1; i++ )    {        glBegin(GL_QUAD_STRIP);            for(j=0; j<=slices; j++)            {                glNormal3d(cost[j]*sinn, sint[j]*sinn, cosn);                glVertex3d(cost[j]*r0,   sint[j]*r0,   z0  );                glVertex3d(cost[j]*r1,   sint[j]*r1,   z1  );            }            z0 = z1; z1 += zStep;            r0 = r1; r1 -= rStep;        glEnd();    }    /* The top stack is covered with individual triangles */    glBegin(GL_TRIANGLES);        glNormal3d(cost[0]*sinn, sint[0]*sinn, cosn);        for (j=0; j<slices; j++)        {            glVertex3d(cost[j+0]*r0,   sint[j+0]*r0,   z0    );            glVertex3d(0,              0,              height);            glNormal3d(cost[j+1]*sinn, sint[j+1]*sinn, cosn  );            glVertex3d(cost[j+1]*r0,   sint[j+1]*r0,   z0    );        }    glEnd();    /* Release sin and cos tables */    free(sint);    free(cost);}

/* * Draws a wire torus */void FGAPIENTRY glutWireTorus( GLdouble dInnerRadius, GLdouble dOuterRadius, GLint nSides, GLint nRings ){  double  iradius = dInnerRadius, oradius = dOuterRadius, phi, psi, dpsi, dphi;  double *vertex, *normal;  int    i, j;  double spsi, cpsi, sphi, cphi ;  FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireTorus" );  if ( nSides < 1 ) nSides = 1;  if ( nRings < 1 ) nRings = 1;  /* Allocate the vertices array */  vertex = (double *)calloc( sizeof(double), 3 * nSides * nRings );  normal = (double *)calloc( sizeof(double), 3 * nSides * nRings );  glPushMatrix();  dpsi =  2.0 * M_PI / (double)nRings ;  dphi = -2.0 * M_PI / (double)nSides ;  psi  = 0.0;  for( j=0; j<nRings; j++ )  {    cpsi = cos ( psi ) ;    spsi = sin ( psi ) ;    phi = 0.0;    for( i=0; i<nSides; i++ )    {      int offset = 3 * ( j * nSides + i ) ;      cphi = cos ( phi ) ;      sphi = sin ( phi ) ;      *(vertex + offset + 0) = cpsi * ( oradius + cphi * iradius ) ;      *(vertex + offset + 1) = spsi * ( oradius + cphi * iradius ) ;      *(vertex + offset + 2) =                    sphi * iradius  ;      *(normal + offset + 0) = cpsi * cphi ;      *(normal + offset + 1) = spsi * cphi ;      *(normal + offset + 2) =        sphi ;      phi += dphi;    }    psi += dpsi;  }  for( i=0; i<nSides; i++ )  {    glBegin( GL_LINE_LOOP );    for( j=0; j<nRings; j++ )    {      int offset = 3 * ( j * nSides + i ) ;      glNormal3dv( normal + offset );      glVertex3dv( vertex + offset );    }    glEnd();  }  for( j=0; j<nRings; j++ )  {    glBegin(GL_LINE_LOOP);    for( i=0; i<nSides; i++ )    {      int offset = 3 * ( j * nSides + i ) ;      glNormal3dv( normal + offset );      glVertex3dv( vertex + offset );    }    glEnd();  }  free ( vertex ) ;  free ( normal ) ;  glPopMatrix();}

void FGAPIENTRY glutSetMenuData(void* data){    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSetMenuData" );    fgStructure.CurrentMenu->UserData=data;}

/* * Draws a solid sphere */void FGAPIENTRY glutSolidSphere(GLdouble radius, GLint slices, GLint stacks){    int i,j;    /* Adjust z and radius as stacks are drawn. */    double z0,z1;    double r0,r1;    /* Pre-computed circle */    double *sint1,*cost1;    double *sint2,*cost2;    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidSphere" );    fghCircleTable(&sint1,&cost1,-slices);    fghCircleTable(&sint2,&cost2,stacks*2);    /* The top stack is covered with a triangle fan */    z0 = 1.0;    z1 = cost2[(stacks>0)?1:0];    r0 = 0.0;    r1 = sint2[(stacks>0)?1:0];    glBegin(GL_TRIANGLE_FAN);        glNormal3d(0,0,1);        glVertex3d(0,0,radius);        for (j=slices; j>=0; j--)        {            glNormal3d(cost1[j]*r1,        sint1[j]*r1,        z1       );            glVertex3d(cost1[j]*r1*radius, sint1[j]*r1*radius, z1*radius);        }    glEnd();    /* Cover each stack with a quad strip, except the top and bottom stacks */    for( i=1; i<stacks-1; i++ )    {        z0 = z1; z1 = cost2[i+1];        r0 = r1; r1 = sint2[i+1];        glBegin(GL_QUAD_STRIP);            for(j=0; j<=slices; j++)            {                glNormal3d(cost1[j]*r1,        sint1[j]*r1,        z1       );                glVertex3d(cost1[j]*r1*radius, sint1[j]*r1*radius, z1*radius);                glNormal3d(cost1[j]*r0,        sint1[j]*r0,        z0       );                glVertex3d(cost1[j]*r0*radius, sint1[j]*r0*radius, z0*radius);            }        glEnd();    }    /* The bottom stack is covered with a triangle fan */    z0 = z1;    r0 = r1;    glBegin(GL_TRIANGLE_FAN);        glNormal3d(0,0,-1);        glVertex3d(0,0,-radius);        for (j=0; j<=slices; j++)        {            glNormal3d(cost1[j]*r0,        sint1[j]*r0,        z0       );            glVertex3d(cost1[j]*r0*radius, sint1[j]*r0*radius, z0*radius);        }    glEnd();    /* Release sin and cos tables */    free(sint1);    free(cost1);    free(sint2);    free(cost2);}

/* * Returns various device information. */int FGAPIENTRY glutDeviceGet( GLenum eWhat ){    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutDeviceGet" );    /* XXX WARNING: we are mostly lying in this function. */    switch( eWhat )    {    case GLUT_HAS_KEYBOARD:        /*         * We always have a keyboard present on PC machines...         *         * XXX I think that some of my PCs will boot without a keyboard.         * XXX Also, who says that we are running on a PC?  UNIX/X11         * XXX is much more generic, and X11 can go over a network.         * XXX Though in actuality, we can probably assume BOTH a         * XXX mouse and keyboard for most/all of our users.         */        return TRUE ;#if TARGET_HOST_UNIX_X11    case GLUT_HAS_MOUSE:        return TRUE ;    case GLUT_NUM_MOUSE_BUTTONS:        /*         * Return the number of mouse buttons available. This is a big guess.         *         * XXX We can probe /var/run/dmesg.boot which is world-readable.         * XXX This would be somewhat system-dependant, but is doable.         * XXX E.g., on NetBSD, my USB mouse registers:         * XXX   ums0 at uhidev0: 3 buttons and Z dir.         * XXX We can also probe /var/log/XFree86/..*/.log to get         * XXX lines such as:         * XXX   (**) Option "Buttons" "5"         * XXX   (**) Option "ZAxisMapping" "4 5"         * XXX   (**) Mouse0: ZAxisMapping: buttons 4 and 5         * XXX   (**) Mouse0: Buttons: 5         * XXX ...which tells us even more, and is a bit less         * XXX system-dependant.  (Other than MS-WINDOWS, all         * XXX target hosts with actual users are probably running         * XXX XFree86...)  It is at least worth taking a look at         * XXX this file.         */        return 3 ;#elif TARGET_HOST_WIN32 || TARGET_HOST_WINCE    case GLUT_HAS_MOUSE:        /*         * The Windows can be booted without a mouse.         * It would be nice to have this reported.         */        return GetSystemMetrics( SM_MOUSEPRESENT );    case GLUT_NUM_MOUSE_BUTTONS:        /* We are much more fortunate under Win32 about this... */#if TARGET_HOST_WINCE        return 1;#else        return GetSystemMetrics( SM_CMOUSEBUTTONS );#endif /* TARGET_HOST_WINCE */#endif    case GLUT_HAS_JOYSTICK:        return fgJoystickDetect ();    case GLUT_OWNS_JOYSTICK:        return fgState.JoysticksInitialised;    case GLUT_JOYSTICK_POLL_RATE:        return fgStructure.CurrentWindow ? fgStructure.CurrentWindow->State.JoystickPollRate : 0;    /* XXX The following two are only for Joystick 0 but this is an improvement */    case GLUT_JOYSTICK_BUTTONS:        return glutJoystickGetNumButtons ( 0 );    case GLUT_JOYSTICK_AXES:        return glutJoystickGetNumAxes ( 0 );    case GLUT_HAS_SPACEBALL:    case GLUT_HAS_DIAL_AND_BUTTON_BOX:    case GLUT_HAS_TABLET:        return FALSE;    case GLUT_NUM_SPACEBALL_BUTTONS:    case GLUT_NUM_BUTTON_BOX_BUTTONS:    case GLUT_NUM_DIALS:    case GLUT_NUM_TABLET_BUTTONS:        return 0;    case GLUT_DEVICE_IGNORE_KEY_REPEAT:        return fgStructure.CurrentWindow ? fgStructure.CurrentWindow->State.IgnoreKeyRepeat : 0;    case GLUT_DEVICE_KEY_REPEAT:        return fgState.KeyRepeat;//.........这里部分代码省略.........

/* * Enters the game mode */int FGAPIENTRY glutEnterGameMode( void ){    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutEnterGameMode" );    if( fgStructure.GameModeWindow )        fgAddToWindowDestroyList( fgStructure.GameModeWindow );    else        fghRememberState( );    if( ! fghChangeDisplayMode( GL_FALSE ) )    {        fgWarning( "failed to change screen settings" );        return 0;    }    fgStructure.GameModeWindow = fgCreateWindow(        NULL, "FREEGLUT", GL_TRUE, 0, 0,        GL_TRUE, fgState.GameModeSize.X, fgState.GameModeSize.Y,        GL_TRUE, GL_FALSE    );    fgStructure.GameModeWindow->State.Width  = fgState.GameModeSize.X;    fgStructure.GameModeWindow->State.Height = fgState.GameModeSize.Y;    fgStructure.GameModeWindow->State.NeedToResize = GL_TRUE;#if TARGET_HOST_POSIX_X11    /*     * Sync needed to avoid a real race, the Xserver must have really created     * the window before we can grab the pointer into it:     */    XSync( fgDisplay.Display, False );    /*     * Grab the pointer to confine it into the window after the calls to     * XWrapPointer() which ensure that the pointer really enters the window.     *     * We also need to wait here until XGrabPointer() returns GrabSuccess,     * otherwise the new window is not viewable yet and if the next function     * (XSetInputFocus) is called with a not yet viewable window, it will exit     * the application which we have to aviod, so wait until it's viewable:     */    while( GrabSuccess != XGrabPointer(               fgDisplay.Display, fgStructure.GameModeWindow->Window.Handle,               TRUE,               ButtonPressMask | ButtonReleaseMask | ButtonMotionMask               | PointerMotionMask,               GrabModeAsync, GrabModeAsync,               fgStructure.GameModeWindow->Window.Handle, None, CurrentTime) )        usleep( 100 );    /*     * Change input focus to the new window. This will exit the application     * if the new window is not viewable yet, see the XGrabPointer loop above.     */    XSetInputFocus(        fgDisplay.Display,        fgStructure.GameModeWindow->Window.Handle,        RevertToNone,        CurrentTime    );    /* Move the Pointer to the middle of the fullscreen window */    XWarpPointer(        fgDisplay.Display,        None,        fgDisplay.RootWindow,        0, 0, 0, 0,        fgState.GameModeSize.X/2, fgState.GameModeSize.Y/2    );#   ifdef HAVE_X11_EXTENSIONS_XF86VMODE_H    if( fgDisplay.DisplayModeValid )    {        int x, y;        Window child;        /* Change to viewport to the window topleft edge: */        if( !XF86VidModeSetViewPort( fgDisplay.Display, fgDisplay.Screen, 0, 0 ) )            fgWarning( "XF86VidModeSetViewPort failed" );        /*         * Final window repositioning: It could be avoided using an undecorated         * window using override_redirect, but this * would possily require         * more changes and investigation.         */        /* Get the current postion of the drawable area on screen */        XTranslateCoordinates(            fgDisplay.Display,            fgStructure.CurrentWindow->Window.Handle,            fgDisplay.RootWindow,            0, 0, &x, &y,            &child        );        /* Move the decorataions out of the topleft corner of the display */        XMoveWindow( fgDisplay.Display, fgStructure.CurrentWindow->Window.Handle,//.........这里部分代码省略.........

/* A. Donev: Destruction callback for menus */void FGAPIENTRY glutMenuDestroyFunc( void (* callback)( void ) ){    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutMenuDestroyFunc" );    if( fgStructure.CurrentMenu )        fgStructure.CurrentMenu->Destroy = callback;}

/* * Sets the global menu status callback for the current window */void FGAPIENTRY glutMenuStatusFunc( void (* callback)( int, int, int ) ){    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutMenuStatusFunc" );    fgState.MenuStatusCallback = callback;}

/* * Window destruction callbacks */void FGAPIENTRY glutCloseFunc( void (* callback)( void ) ){    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutCloseFunc" );    SET_CALLBACK( Destroy );}

void FGAPIENTRY glutWMCloseFunc( void (* callback)( void ) ){    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWMCloseFunc" );    glutCloseFunc( callback );}

/* * Window mouse entry/leave callback */void FGAPIENTRY glutEntryFunc( void (* callback)( int ) ){    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutEntryFunc" );    SET_CALLBACK( Entry );}

/* * Sets the mouse wheel callback for the current window */void FGAPIENTRY glutMouseWheelFunc( void (* callback)( int, int, int, int ) ){    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutMouseWheelFunc" );    SET_CALLBACK( MouseWheel );}

int * FGAPIENTRY glutGetModeValues(GLenum eWhat, int * size){  int * array;#if TARGET_HOST_POSIX_X11  int attributes[9];  GLXFBConfig * fbconfigArray;  /*  Array of FBConfigs  */  int fbconfigArraySize;        /*  Number of FBConfigs in the array  */  int attribute_name = 0;#endif  FREEGLUT_EXIT_IF_NOT_INITIALISED("glutGetModeValues");  array = NULL;  *size = 0;  switch (eWhat)    {#if TARGET_HOST_POSIX_X11    case GLUT_AUX:    case GLUT_MULTISAMPLE:      attributes[0] = GLX_BUFFER_SIZE;      attributes[1] = GLX_DONT_CARE;      switch (eWhat)        {        case GLUT_AUX:          /*            FBConfigs are now sorted by increasing number of auxiliary            buffers.  We want at least one buffer.          */          attributes[2] = GLX_AUX_BUFFERS;          attributes[3] = 1;          attributes[4] = None;          attribute_name = GLX_AUX_BUFFERS;          break;        case GLUT_MULTISAMPLE:          attributes[2] = GLX_AUX_BUFFERS;          attributes[3] = GLX_DONT_CARE;          attributes[4] = GLX_SAMPLE_BUFFERS;          attributes[5] = 1;          /*            FBConfigs are now sorted by increasing number of samples per            pixel.  We want at least one sample.          */          attributes[6] = GLX_SAMPLES;          attributes[7] = 1;          attributes[8] = None;          attribute_name = GLX_SAMPLES;          break;        }      fbconfigArray = glXChooseFBConfig(fgDisplay.Display,                                        fgDisplay.Screen,                                        attributes,                                        &fbconfigArraySize);      if (fbconfigArray != NULL)        {          int * temp_array;          int previous_value;          int i;          temp_array = malloc(sizeof(int) * fbconfigArraySize);          previous_value = 0;          for (i = 0; i < fbconfigArraySize; i++)            {              int value;              glXGetFBConfigAttrib(fgDisplay.Display,                                   fbconfigArray[i],                                   attribute_name,                                   &value);              if (value > previous_value)                {                  temp_array[*size] = value;                  previous_value = value;                  (*size)++;                }            }          array = malloc(sizeof(int) * (*size));          for (i = 0; i < *size; i++)            {              array[i] = temp_array[i];            }          free(temp_array);          XFree(fbconfigArray);        }      break;//.........这里部分代码省略.........

/* * Sets the global idle callback */void FGAPIENTRY glutIdleFunc( void (* callback)( void ) ){    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutIdleFunc" );    fgState.IdleCallback = callback;}

/* * Sets the overlay display callback for the current window */void FGAPIENTRY glutOverlayDisplayFunc( void (* callback)( void ) ){    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutOverlayDisplayFunc" );    SET_CALLBACK( OverlayDisplay );}

/* * General settings query method */int FGAPIENTRY glutGet( GLenum eWhat ){#if TARGET_HOST_WIN32 || TARGET_HOST_WINCE    int returnValue ;    GLboolean boolValue ;#endif    switch (eWhat)    {    case GLUT_INIT_STATE:        return fgState.Initialised;    case GLUT_ELAPSED_TIME:        return fgElapsedTime();    }    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutGet" );    /* XXX In chronological code add order.  (WHY in that order?) */    switch( eWhat )    {    /* Following values are stored in fgState and fgDisplay global structures */    case GLUT_SCREEN_WIDTH:         return fgDisplay.ScreenWidth   ;    case GLUT_SCREEN_HEIGHT:        return fgDisplay.ScreenHeight  ;    case GLUT_SCREEN_WIDTH_MM:      return fgDisplay.ScreenWidthMM ;    case GLUT_SCREEN_HEIGHT_MM:     return fgDisplay.ScreenHeightMM;    case GLUT_INIT_WINDOW_X:        return fgState.Position.X      ;    case GLUT_INIT_WINDOW_Y:        return fgState.Position.Y      ;    case GLUT_INIT_WINDOW_WIDTH:    return fgState.Size.X          ;    case GLUT_INIT_WINDOW_HEIGHT:   return fgState.Size.Y          ;    case GLUT_INIT_DISPLAY_MODE:    return fgState.DisplayMode     ;    /*     * The window/context specific queries are handled mostly by     * fghGetConfig().     */    case GLUT_WINDOW_NUM_SAMPLES:        /* XXX Multisampling. Return what I know about multisampling. */        return 0;#if TARGET_HOST_UNIX_X11    /*     * The rest of GLX queries under X are general enough to use a macro to     * check them     */#   define GLX_QUERY(a,b) case a: return fghGetConfig( b );    GLX_QUERY( GLUT_WINDOW_RGBA,                GLX_RGBA                );    GLX_QUERY( GLUT_WINDOW_DOUBLEBUFFER,        GLX_DOUBLEBUFFER        );    GLX_QUERY( GLUT_WINDOW_BUFFER_SIZE,         GLX_BUFFER_SIZE         );    GLX_QUERY( GLUT_WINDOW_STENCIL_SIZE,        GLX_STENCIL_SIZE        );    GLX_QUERY( GLUT_WINDOW_DEPTH_SIZE,          GLX_DEPTH_SIZE          );    GLX_QUERY( GLUT_WINDOW_RED_SIZE,            GLX_RED_SIZE            );    GLX_QUERY( GLUT_WINDOW_GREEN_SIZE,          GLX_GREEN_SIZE          );    GLX_QUERY( GLUT_WINDOW_BLUE_SIZE,           GLX_BLUE_SIZE           );    GLX_QUERY( GLUT_WINDOW_ALPHA_SIZE,          GLX_ALPHA_SIZE          );    GLX_QUERY( GLUT_WINDOW_ACCUM_RED_SIZE,      GLX_ACCUM_RED_SIZE      );    GLX_QUERY( GLUT_WINDOW_ACCUM_GREEN_SIZE,    GLX_ACCUM_GREEN_SIZE    );    GLX_QUERY( GLUT_WINDOW_ACCUM_BLUE_SIZE,     GLX_ACCUM_BLUE_SIZE     );    GLX_QUERY( GLUT_WINDOW_ACCUM_ALPHA_SIZE,    GLX_ACCUM_ALPHA_SIZE    );    GLX_QUERY( GLUT_WINDOW_STEREO,              GLX_STEREO              );#   undef GLX_QUERY    /* Colormap size is handled in a bit different way than all the rest */    case GLUT_WINDOW_COLORMAP_SIZE:        if( (fghGetConfig( GLX_RGBA )) || (fgStructure.CurrentWindow == NULL) )        {            /*             * We've got a RGBA visual, so there is no colormap at all.             * The other possibility is that we have no current window set.             */            return 0;        }        return fgStructure.CurrentWindow->Window.VisualInfo->visual->map_entries;    /*     * Those calls are somewhat similiar, as they use XGetWindowAttributes()     * function     */    case GLUT_WINDOW_X:    case GLUT_WINDOW_Y:    case GLUT_WINDOW_BORDER_WIDTH:    case GLUT_WINDOW_HEADER_HEIGHT:    {        int x, y;        Window w;        if( fgStructure.CurrentWindow == NULL )            return 0;        XTranslateCoordinates(            fgDisplay.Display,            fgStructure.CurrentWindow->Window.Handle,            fgDisplay.RootWindow,            0, 0, &x, &y, &w);//.........这里部分代码省略.........

/* * Sets the window status callback for the current window */void FGAPIENTRY glutWindowStatusFunc( void (* callback)( int ) ){    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWindowStatusFunc" );    SET_CALLBACK( WindowStatus );}

/* * Return the state of the GLUT API overlay subsystem. A misery ;-) */int FGAPIENTRY glutLayerGet( GLenum eWhat ){    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutLayerGet" );    /*     * This is easy as layers are not implemented ;-)     *     * XXX Can we merge the UNIX/X11 and WIN32 sections?  Or     * XXX is overlay support planned?     */    switch( eWhat )    {#if TARGET_HOST_UNIX_X11    case GLUT_OVERLAY_POSSIBLE:        return FALSE;    case GLUT_LAYER_IN_USE:        return GLUT_NORMAL;    case GLUT_HAS_OVERLAY:        return FALSE;    case GLUT_TRANSPARENT_INDEX:        /*         * Return just anything, which is always defined as zero         *         * XXX HUH?         */        return 0;    case GLUT_NORMAL_DAMAGED:        /* XXX Actually I do not know. Maybe. */        return FALSE;    case GLUT_OVERLAY_DAMAGED:        return -1;#elif TARGET_HOST_WIN32 || TARGET_HOST_WINCE    case GLUT_OVERLAY_POSSIBLE:/*      return fgSetupPixelFormat( fgStructure.CurrentWindow, GL_TRUE,                                   PFD_OVERLAY_PLANE ); */      return FALSE ;    case GLUT_LAYER_IN_USE:        return GLUT_NORMAL;    case GLUT_HAS_OVERLAY:        return FALSE;    case GLUT_TRANSPARENT_INDEX:        /*         * Return just anything, which is always defined as zero         *         * XXX HUH?         */        return 0;    case GLUT_NORMAL_DAMAGED:        /* XXX Actually I do not know. Maybe. */        return FALSE;    case GLUT_OVERLAY_DAMAGED:        return -1;#endif    default:        fgWarning( "glutLayerGet(): missing enum handle %d", eWhat );        break;    }    /* And fail. That's good. Programs do love failing. */    return -1;}

/* * Sets the tablet buttons callback for the current window */void FGAPIENTRY glutTabletButtonFunc( void (* callback)( int, int, int, int ) ){    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutTabletButtonFunc" );    SET_CALLBACK( TabletButton );}

/* * A.Donev: Set and retrieve the menu's user data */void* FGAPIENTRY glutGetMenuData( void ){    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutGetMenuData" );    return fgStructure.CurrentMenu->UserData;}

/* * Sets the multi-pointer passive motion callback for the current window */void FGAPIENTRY glutMultiPassiveFunc( void (* callback)(int, int, int ) ){    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutMultiPassiveFunc" );    SET_CALLBACK( MultiPassive );}

/* * Enters the freeglut processing loop. * Stays until the "ExecState" changes to "GLUT_EXEC_STATE_STOP". */void FGAPIENTRY glutMainLoopMT( void ){    //int action; //MT#if TARGET_HOST_WIN32 || TARGET_HOST_WINCE    SFG_Window *window = (SFG_Window *)fgStructure.Windows.First ;#endif    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutMainLoop" );#if TARGET_HOST_WIN32 || TARGET_HOST_WINCE    /*     * Processing before the main loop:  If there is a window which is open and     * which has a visibility callback, call it.  I know this is an ugly hack,     * but I'm not sure what else to do about it.  Ideally we should leave     * something uninitialized in the create window code and initialize it in     * the main loop, and have that initialization create a "WM_ACTIVATE"     * message.  Then we would put the visibility callback code in the     * "case WM_ACTIVATE" block below.         - John Fay -- 10/24/02     */    while( window )    {        if ( FETCH_WCB( *window, Visibility ) )        {            SFG_Window *current_window = fgStructure.CurrentWindow ;            INVOKE_WCB( *window, Visibility, ( window->State.Visible ) );            fgSetWindow( current_window );        }        window = (SFG_Window *)window->Node.Next ;    }#endif    fgState.ExecState = GLUT_EXEC_STATE_RUNNING ;    while( fgState.ExecState == GLUT_EXEC_STATE_RUNNING )    {        SFG_Window *window;        glutMainLoopEvent( );        /*         * Step through the list of windows, seeing if there are any         * that are not menus         */        for( window = ( SFG_Window * )fgStructure.Windows.First;             window;             window = ( SFG_Window * )window->Node.Next )            if ( ! ( window->IsMenu ) )                break;        if( ! window )            fgState.ExecState = GLUT_EXEC_STATE_STOP;        else        {            if( fgState.IdleCallback )            {                if( fgStructure.CurrentWindow &&                    fgStructure.CurrentWindow->IsMenu )                    /* fail safe */                    fgSetWindow( window );                fgState.IdleCallback( );            }            fghSleepForEvents( );        }    }#if 0 //Marc Toussaint    /*     * When this loop terminates, destroy the display, state and structure     * of a freeglut session, so that another glutInit() call can happen     *     * Save the "ActionOnWindowClose" because "fgDeinitialize" resets it.     */    action = fgState.ActionOnWindowClose;    fgDeinitialize( );    if( action == GLUT_ACTION_EXIT )        exit( 0 );#endif}

/* * Sets the Reshape callback for the current window */void FGAPIENTRY glutReshapeFunc( void (* callback)( int, int ) ){    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutReshapeFunc" );    SET_CALLBACK( Reshape );}

/* * Draws a wire sphere */void FGAPIENTRY glutWireSphere(GLdouble radius, GLint slices, GLint stacks){    int i,j;    /* Adjust z and radius as stacks and slices are drawn. */    double r;    double x,y,z;    /* Pre-computed circle */    double *sint1,*cost1;    double *sint2,*cost2;    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireSphere" );    fghCircleTable(&sint1,&cost1,-slices  );    fghCircleTable(&sint2,&cost2, stacks*2);    /* Draw a line loop for each stack */    for (i=1; i<stacks; i++)    {        z = cost2[i];        r = sint2[i];        glBegin(GL_LINE_LOOP);            for(j=0; j<=slices; j++)            {                x = cost1[j];                y = sint1[j];                glNormal3d(x,y,z);                glVertex3d(x*r*radius,y*r*radius,z*radius);            }        glEnd();    }    /* Draw a line loop for each slice */    for (i=0; i<slices; i++)    {        glBegin(GL_LINE_STRIP);            for(j=0; j<=stacks; j++)            {                x = cost1[i]*sint2[j];                y = sint1[i]*sint2[j];                z = cost2[j];                glNormal3d(x,y,z);                glVertex3d(x*radius,y*radius,z*radius);            }        glEnd();    }    /* Release sin and cos tables */    free(sint1);    free(cost1);    free(sint2);    free(cost2);}

/* * Sets the Keyboard callback for the current window */void FGAPIENTRY glutKeyboardFunc( void (* callback)                                  ( unsigned char, int, int ) ){    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutKeyboardFunc" );    SET_CALLBACK( Keyboard );}

/* * Draws a wire cone */void FGAPIENTRY glutWireCone( GLdouble base, GLdouble height, GLint slices, GLint stacks){    int i,j;    /* Step in z and radius as stacks are drawn. */    double z = 0.0;    double r = base;    const double zStep = height / ( ( stacks > 0 ) ? stacks : 1 );    const double rStep = base / ( ( stacks > 0 ) ? stacks : 1 );    /* Scaling factors for vertex normals */    const double cosn = ( height / sqrt ( height * height + base * base ));    const double sinn = ( base   / sqrt ( height * height + base * base ));    /* Pre-computed circle */    double *sint,*cost;    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWireCone" );    fghCircleTable(&sint,&cost,-slices);    /* Draw the stacks... */    for (i=0; i<stacks; i++)    {        glBegin(GL_LINE_LOOP);            for( j=0; j<slices; j++ )            {                glNormal3d(cost[j]*sinn, sint[j]*sinn, cosn);                glVertex3d(cost[j]*r,    sint[j]*r,    z   );            }        glEnd();        z += zStep;        r -= rStep;    }    /* Draw the slices */    r = base;    glBegin(GL_LINES);        for (j=0; j<slices; j++)        {            glNormal3d(cost[j]*sinn, sint[j]*sinn, cosn  );            glVertex3d(cost[j]*r,    sint[j]*r,    0.0   );            glVertex3d(0.0,          0.0,          height);        }    glEnd();    /* Release sin and cos tables */    free(sint);    free(cost);}

/* * Sets the Special callback for the current window */void FGAPIENTRY glutSpecialFunc( void (* callback)( int, int, int ) ){    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSpecialFunc" );    SET_CALLBACK( Special );}

/* * Draws a solid torus */void FGAPIENTRY glutSolidTorus( GLdouble dInnerRadius, GLdouble dOuterRadius, GLint nSides, GLint nRings ){  double  iradius = dInnerRadius, oradius = dOuterRadius, phi, psi, dpsi, dphi;  double *vertex, *normal;  int    i, j;  double spsi, cpsi, sphi, cphi ;  FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSolidTorus" );  if ( nSides < 1 ) nSides = 1;  if ( nRings < 1 ) nRings = 1;  /* Increment the number of sides and rings to allow for one more point than surface */  nSides ++ ;  nRings ++ ;  /* Allocate the vertices array */  vertex = (double *)calloc( sizeof(double), 3 * nSides * nRings );  normal = (double *)calloc( sizeof(double), 3 * nSides * nRings );  glPushMatrix();  dpsi =  2.0 * M_PI / (double)(nRings - 1) ;  dphi = -2.0 * M_PI / (double)(nSides - 1) ;  psi  = 0.0;  for( j=0; j<nRings; j++ )  {    cpsi = cos ( psi ) ;    spsi = sin ( psi ) ;    phi = 0.0;    for( i=0; i<nSides; i++ )    {      int offset = 3 * ( j * nSides + i ) ;      cphi = cos ( phi ) ;      sphi = sin ( phi ) ;      *(vertex + offset + 0) = cpsi * ( oradius + cphi * iradius ) ;      *(vertex + offset + 1) = spsi * ( oradius + cphi * iradius ) ;      *(vertex + offset + 2) =                    sphi * iradius  ;      *(normal + offset + 0) = cpsi * cphi ;      *(normal + offset + 1) = spsi * cphi ;      *(normal + offset + 2) =        sphi ;      phi += dphi;    }    psi += dpsi;  }    glBegin( GL_QUADS );  for( i=0; i<nSides-1; i++ )  {    for( j=0; j<nRings-1; j++ )    {      int offset = 3 * ( j * nSides + i ) ;      glNormal3dv( normal + offset );      glVertex3dv( vertex + offset );      glNormal3dv( normal + offset + 3 );      glVertex3dv( vertex + offset + 3 );      glNormal3dv( normal + offset + 3 * nSides + 3 );      glVertex3dv( vertex + offset + 3 * nSides + 3 );      glNormal3dv( normal + offset + 3 * nSides );      glVertex3dv( vertex + offset + 3 * nSides );    }  }  glEnd();  free ( vertex ) ;  free ( normal ) ;  glPopMatrix();}

/* * Returns various device information. */int FGAPIENTRY glutDeviceGet( GLenum eWhat ){    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutDeviceGet" );    /* XXX WARNING: we are mostly lying in this function. */    switch( eWhat )    {    case GLUT_HAS_KEYBOARD:        /*         * Win32 is assumed a keyboard, and this cannot be queried,         * except for WindowsCE.         *         * X11 has a core keyboard by definition, although it can         * be present as a virtual/dummy keyboard. For now, there         * is no reliable way to tell if a real keyboard is present.         */#if defined(_WIN32_CE)        return ( GetKeyboardStatus() & KBDI_KEYBOARD_PRESENT ) ? 1 : 0;#   if FREEGLUT_LIB_PRAGMAS#       pragma comment (lib,"Kbdui.lib")#   endif#else        return 1;#endif#if TARGET_HOST_POSIX_X11    /* X11 has a mouse by definition */    case GLUT_HAS_MOUSE:        return 1 ;    case GLUT_NUM_MOUSE_BUTTONS:        /* We should be able to pass NULL when the last argument is zero,         * but at least one X server has a bug where this causes a segfault.         *         * In XFree86/Xorg servers, a mouse wheel is seen as two buttons         * rather than an Axis; "freeglut_main.c" expects this when         * checking for a wheel event.         */        {            unsigned char map;            int nbuttons = XGetPointerMapping(fgDisplay.Display, &map,0);            return nbuttons;        }#elif TARGET_HOST_MS_WINDOWS    case GLUT_HAS_MOUSE:        /*         * MS Windows can be booted without a mouse.         */        return GetSystemMetrics( SM_MOUSEPRESENT );    case GLUT_NUM_MOUSE_BUTTONS:#  if defined(_WIN32_WCE)        return 1;#  else        return GetSystemMetrics( SM_CMOUSEBUTTONS );#  endif#endif    case GLUT_HAS_JOYSTICK:        return fgJoystickDetect ();    case GLUT_OWNS_JOYSTICK:        return fgState.JoysticksInitialised;    case GLUT_JOYSTICK_POLL_RATE:        return fgStructure.CurrentWindow ? fgStructure.CurrentWindow->State.JoystickPollRate : 0;    /* XXX The following two are only for Joystick 0 but this is an improvement */    case GLUT_JOYSTICK_BUTTONS:        return glutJoystickGetNumButtons ( 0 );    case GLUT_JOYSTICK_AXES:        return glutJoystickGetNumAxes ( 0 );    case GLUT_HAS_DIAL_AND_BUTTON_BOX:        return fgInputDeviceDetect ();    case GLUT_NUM_DIALS:        if ( fgState.InputDevsInitialised ) return 8;        return 0;     case GLUT_NUM_BUTTON_BOX_BUTTONS:        return 0;    case GLUT_HAS_SPACEBALL:        return fgHasSpaceball();    case GLUT_HAS_TABLET:        return 0;    case GLUT_NUM_SPACEBALL_BUTTONS:        return fgSpaceballNumButtons();//.........这里部分代码省略.........