Main.cpp

Go to the documentation of this file.

/*
 * Main.cpp
 *
 * Part of Fly! Legacy project
 *
 * Copyright 2003 Chris Wallace
 *
 * Fly! Legacy is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 * Fly! Legacy is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 *   along with Fly! Legacy; if not, write to the Free Software
 *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

// Disable MSVC warnings for truncated debug names
#ifdef _MSC_VER
#pragma warning( disable : 4786 )
#endif


#include <math.h>
#include <GL/glut.h>
#include <plib/ssg.h>
#include <plib/ssgAux.h>

#include "../Ssg/ssgLocal.h"

#include "../Include/FlyLegacy.h"
#include "../Include/Globals.h"
#include "../Include/Situation.h"
#include "../Include/KeyMap.h"
#include "../Include/Ui.h"
#include "../Include/Database.h"
#include "../Include/Utility.h"
#include "../Include/LogFile.h"
#include "../Include/Pod.h"


// General-purpose global settings
SGlobals *globals = NULL;

//
// GLUT idle function
//
#ifdef _WIN32
static BYTE savedkeys[256];

typedef struct {
  BYTE          vk;
  EKeyboardKeys key;
} SNonGlutKey;

SNonGlutKey nonGlutKeys[] =
{
  { VK_CAPITAL, KB_KEY_CAPSLOCK },
  { VK_NUMLOCK, KB_KEY_NUMLOCK },
  { VK_SCROLL,  KB_KEY_SCROLLLOCK },
  { VK_SUBTRACT,  KB_KEY_KEYPAD_MINUS },
  { VK_CLEAR,   KB_KEY_CENTER },
  { VK_ADD,   KB_KEY_KEYPAD_PLUS },
  { VK_RETURN,  KB_KEY_KEYPAD_ENTER },
  { VK_DIVIDE,  KB_KEY_KEYPAD_SLASH },
};
#endif

#ifdef _WIN32
//
// Array for storage of gamma ramp data
//
static WORD savedGammaRamp[3][0x100];
static HDC  hdc = 0;
#endif // _WIN32

// Forward declare GLUT callback functions
static void idle (void);
static void reshape (int w, int h);
static void motion (int x, int y);
static void passive_motion (int x, int y);
static void mouse (int button, int updown, int x, int y);
static void keyboard (unsigned char key, int x, int y);
static void special (int key, int x, int y);
static void redraw (void);

//
// Initialize OpenGL, GLUT, PLIB graphics libraries, etc.
//   Code in this function may be dependent on INI settings and globals
//
static void InitGraphics ()
{
  int   fake_argc = 1 ;
  char *fake_argv[3] ;
  fake_argv[0] = "Fly! Legacy";
  fake_argv[1] = "Fly! Legacy";
  fake_argv[2] = NULL ;

  // Get screen resolution from globals
  int w = globals->screenWidth;
  int h = globals->screenHeight;
  int bpp = globals->screenDepth;
  int refresh = globals->screenRefresh;

  // Get fullscreen mode from INI settings
  int autoFullScreen = 0;
  GetIniVar ("Graphics", "autoFullScreen", &autoFullScreen);

  // Initialise GLUT
  glutInit               ( &fake_argc, fake_argv ) ;
  glutInitDisplayMode    ( GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH ) ;
  if (autoFullScreen) {
    char game[64];
    sprintf (game, "%dx%d:%d@%d", w, h, bpp, refresh);
    glutGameModeString (game);
    glutEnterGameMode ();
  } else {
    glutInitWindowPosition ( 0, 0 ) ;
    glutInitWindowSize     ( w, h ) ;
    glutCreateWindow       ( fake_argv[1] ) ;
  }
  glutIdleFunc (idle);
  glutMouseFunc (mouse);
  glutMotionFunc (motion);
  glutPassiveMotionFunc (passive_motion);
  glutDisplayFunc (redraw);
  glutReshapeFunc (reshape);
  glutKeyboardFunc (keyboard);
  glutSpecialFunc (special);

  // Miscellaneous one-time GL setup
  glClearColor ( 0, 0, 0, 1.0f ) ;

#ifdef _WIN32
  // Get display gamma value from graphics INI settings
  float gamma = 1.0f;
  GetIniFloat ("Graphics", "displayGamma", &gamma);

  // Get current gamma ramp to be restored at exit
  hdc = wglGetCurrentDC ();
  if (!GetDeviceGammaRamp (hdc, savedGammaRamp)) {
    WARNINGLOG ("Failed to get Win32 gamma ramp");
  }

  // Calculate gamma ramp table
  float invgamma = 1.0f / gamma;
  WORD ramp[3][0x100];
  for (int i=0; i<0x100; i++) {
    float factor = pow((float)i / 256.0f, invgamma);
    if (factor > 1.0f) factor = 1.0f;
    WORD value = (WORD)((factor * 65535.0f) + 0.5f);
    ramp[0][i] = value;
    ramp[1][i] = value;
    ramp[2][i] = value;
  }

  // Set the new gamma ramp
  if (!SetDeviceGammaRamp (hdc, ramp)) {
    WARNINGLOG ("Failed to set Win32 gamma ramp");
  }
#endif // _WIN32

  // Disable GLUT cursor
  glutSetCursor (GLUT_CURSOR_NONE);

  // Initialise SSG

  char *mark1 = new char[32];
  strcpy (mark1, "ssgInit Start");
  ssgInit ();
  char *mark2 = new char[32];
  strcpy (mark2, "ssgInit End");

  globals->context = new ssgContext;
  ssgSetNearFar (1.0, 1.0E20); 
}

void InitFonts (void)
{
  char *mark1 = new char[32];
  strcpy (mark1, "ftascm10 Start");
  strcpy (globals->fonts.ftascm10.fontName, "ART\\FTASCM10.RAW");
  LoadFont (&globals->fonts.ftascm10);
  char *mark2 = new char[32];
  strcpy (mark2, "ftascm10 End");
  strcpy (globals->fonts.ftdigi9.fontName, "ART\\FTDIGI9.RAW");
  LoadFont (&globals->fonts.ftdigi9);
  strcpy (globals->fonts.ftdigi9b.fontName, "ART\\FTDIGI9B.RAW");
  LoadFont (&globals->fonts.ftdigi9b);
  strcpy (globals->fonts.ftdigi9d.fontName, "ART\\FTDIGI9D.RAW");
  LoadFont (&globals->fonts.ftdigi9d);
  strcpy (globals->fonts.ftdigi13.fontName, "ART\\FTDIGI13.RAW");
  LoadFont (&globals->fonts.ftdigi13);
  strcpy (globals->fonts.ftmicro5.fontName, "ART\\FTMICRO5.RAW");
  LoadFont (&globals->fonts.ftmicro5);
  strcpy (globals->fonts.ftmno14b.fontName, "ART\\FTMNO14B.RAW");
  LoadFont (&globals->fonts.ftmno14b);
  strcpy (globals->fonts.ftmono12.fontName, "ART\\FTMONO12.RAW");
  LoadFont (&globals->fonts.ftmono12);
  strcpy (globals->fonts.ftsmal10.fontName, "ART\\FTSMAL10.RAW");
  LoadFont (&globals->fonts.ftsmal10);
  strcpy (globals->fonts.ftthin24.fontName, "ART\\FTTHIN24.RAW");
  LoadFont (&globals->fonts.ftthin24);
  strcpy (globals->fonts.fttiny7.fontName, "ART\\FTTINY7.RAW");
  LoadFont (&globals->fonts.fttiny7);
  strcpy (globals->fonts.ftasci10.fontName, "ART\\FTASCI10.RAW");
  LoadFont (&globals->fonts.ftasci10);

/*
  strcpy (globals->fonts.ftnorm14.fontName, "ART\\FTNORM14.RAW");
  LoadFont (&globals->fonts.ftnorm14);
  strcpy (globals->fonts.ftnorm28.fontName, "ART\\FTNORM28.RAW");
  LoadFont (&globals->fonts.ftnorm28);
  strcpy (globals->fonts.fttiny7w.fontName, "ART\\FTTINY7W.RAW");
  LoadFont (&globals->fonts.fttiny7w);
  strcpy (globals->fonts.ftdos12.fontName, "ART\\FTDOS12.RAW");
  LoadFont (&globals->fonts.ftdos12);
*/
}

void cleanup_fonts (void)
{
  FreeFont (&globals->fonts.ftascm10);
  FreeFont (&globals->fonts.ftdigi9);
  FreeFont (&globals->fonts.ftdigi9b);
  FreeFont (&globals->fonts.ftdigi9d);
  FreeFont (&globals->fonts.ftdigi13);
  FreeFont (&globals->fonts.ftmicro5);
  FreeFont (&globals->fonts.ftmno14b);
  FreeFont (&globals->fonts.ftmono12);
  FreeFont (&globals->fonts.ftsmal10);
  FreeFont (&globals->fonts.ftthin24);
  FreeFont (&globals->fonts.fttiny7);
  FreeFont (&globals->fonts.ftasci10);
//  FreeFont (&globals->fonts.ftnorm14);
//  FreeFont (&globals->fonts.ftnorm28);
//  FreeFont (&globals->fonts.fttiny7w);
//  FreeFont (&globals->fonts.ftdos12);
}


CDatabase*   dbAirport;
CDatabase*   dbAtsRoute;
CDatabase*   dbComm;
CDatabase*   dbCountry;
CDatabase*   dbState;
CDatabase*   dbIls;
CDatabase*   dbNavaid;
CDatabase*   dbObstruct;
CDatabase*   dbRunway;
CDatabase*   dbWaypoint;

//
// Initialize databases
//   Code in this function may be dependent on INI settings and POD filesystem
//
void LoadDatabases (void)
{
  // Load Airport database
  dbAirport = new CDatabase ("Airport.dbt");
  dbAirport->Mount ("Airport.dbd");
  dbAirport->AddIndex ("Airport.dbi");
  dbAirport->AddIndex ("AprtCtry.dbi");
  dbAirport->AddIndex ("AprtStat.dbi");
  dbAirport->AddIndex ("AprtFaa.dbi");
  dbAirport->AddIndex ("AprtIcao.dbi");
  dbAirport->AddIndex ("AprtGlob.dbi");
  dbAirport->AddIndex ("AprtName.dbi");

  // Load ATS (Air Traffic System) Routing database
  dbAtsRoute = new CDatabase ("AtsRoute.dbt");
  dbAtsRoute->Mount ("AtsRoute.dbd");

  // Load Comm facility database
  dbComm = new CDatabase ("Comm.dbt");
  dbComm->Mount ("Comm.dbd");
  dbComm->AddIndex ("Comm.dbi");
  dbComm->AddIndex ("CommGlob.dbi");
  
  // Load Country name database
  dbCountry = new CDatabase ("Country.dbt");
  dbCountry->Mount ("Country.dbd");
  dbCountry->AddIndex ("Country.dbi");
  dbCountry->AddIndex ("CtryName.dbi");

  // Load State name database
  dbState = new CDatabase ("State.dbt");
  dbState->Mount ("State.dbd");
  dbState->AddIndex ("Statctry.dbi");
  dbState->AddIndex ("State.dbi");
  dbState->AddIndex ("StatName.dbi");

  // Load ILS Facility database
  dbIls = new CDatabase ("Ils.dbt");
  dbIls->Mount ("Ils.dbd");
  dbIls->AddIndex ("Ils.dbi");
  dbIls->AddIndex ("IlsGlob.dbi");
  dbIls->AddIndex ("IlsLocal.dbi");

  // Load Navaid database
  dbNavaid = new CDatabase ("Navaid.dbt");
  dbNavaid->Mount ("Navaid.dbd");
  dbNavaid->AddIndex ("Navaid.dbi");
  dbNavaid->AddIndex ("NavNdbId.dbi");
  dbNavaid->AddIndex ("NavNdbNm.dbi");
  dbNavaid->AddIndex ("NavVorId.dbi");
  dbNavaid->AddIndex ("NavVorNm.dbi");

  // Load Obstruction database
  dbObstruct = new CDatabase ("Obstruct.dbt");
  dbObstruct->Mount ("Obstruct.dbd");
  dbObstruct->AddIndex ("ObstGlob.dbi");

  // Load Runway database
  dbRunway = new CDatabase ("Runway.dbt");
  dbRunway->Mount ("Runway.dbd");
  dbRunway->AddIndex ("Runway.dbi");

  // Load Waypoint database
  dbWaypoint = new CDatabase ("Waypoint.dbt");
  dbWaypoint->Mount ("Waypoint.dbd");
  dbWaypoint->AddIndex ("Waypoint.dbi");
  dbWaypoint->AddIndex ("WayKey.dbi");
}

void UnloadDatabases (void)
{
  delete dbAirport;
  delete dbAtsRoute;
  delete dbComm;
  delete dbCountry;
  delete dbState;
  delete dbIls;
  delete dbNavaid;
  delete dbObstruct;
  delete dbRunway;
  delete dbWaypoint;
}

//
// Initialize global variable structure.
//   Code in this function may be dependent on INI settings.
//   Code in this function may not be dependent on POD filesystem
//
static void InitGlobalsNoPodFilesystem (void)
{
  bool iniChanged = false;

  globals = new SGlobals;

  // Log files
  globals->logDebug = new CLogFile ("Logs\\Debug.log", "w");
  globals->logWarning = new CLogFile ("Logs\\Warning.log", "w");

  //
  // Screen resolution/colour depth
  //

  // Get screen resolution/depth
  int w = 1024;
  GetIniVar ("Graphics", "gamePIXX", &w);

  int h = 768;
  GetIniVar ("Graphics", "gamePIXY", &h);

  // Validate screen width/height
  bool screen640 = (w == 640) && (h == 480);
  bool screen800 = (w == 800) && (h == 600);
  bool screen1024 = (w == 1024) && (h == 768);
  if (!(screen640 || screen800 || screen1024)) {
    // Default to 1024 x 768
    if (globals->logWarning) globals->logWarning->Write ("Invalid screen resolution in INI settings, default to 1024x768");
    w = 1024;
    h = 768;
    SetIniVar ("Graphics", "gamePIXX", w);
    SetIniVar ("Graphics", "gamePIXY", h);
    iniChanged = true;
  }

  // Get colour depth from globals and validate
  int bpp = 32;
  GetIniVar ("Graphics", "gameBitsPerPixel", &bpp);
  if ((bpp != 16) && (bpp != 32)) {
    // Default to 32
    if (globals->logWarning) globals->logWarning->Write ("Invalid screen colour depth in INI settings, default to 32bpp");
    bpp = 32;
    SetIniVar ("Graphics", "gameBitsPerPixel", bpp);
    iniChanged = true;
  }

  // Get refresh rate
  int refresh = 0;
  GetIniVar ("Graphics", "gameRefreshRate", &refresh);

  // Store screen settings in global variables
  globals->screenWidth = w;
  globals->screenHeight = h;
  globals->screenDepth = bpp;
  globals->screenRefresh = refresh;

  //
  // Panel scrolling parameters
  //
  int i = -1;
  GetIniVar ("Cockpit", "mouseScrollingEnabled", &i);
  if (i == -1) {
    // Parameter was not set
    i = 1;
    SetIniVar ("Cockpit", "mouseScrollingEnabled", i);
    iniChanged = true;
  }
  globals->mouseScrollingEnabled = (i != 0);

  // Panel scroll step
  i = -1;
  GetIniVar ("Cockpit", "panelScrollStep", &i);
  if (i == -1) {
    // Parameter was not set
    i = 10;
    SetIniVar ("Cockpit", "panelScrollStep", i);
    iniChanged = true;
  }
  globals->panelScrollStep = i;

  // Panel creep (mouse scroll) step
  i = -1;
  GetIniVar ("Cockpit", "panelCreepStep", &i);
  if (i == -1) {
    // Parameter was not set
    i = 10;
    SetIniVar ("Cockpit", "panelCreepStep", i);
    iniChanged = true;
  }
  globals->panelCreepStep = i;

  // Global settings
  globals->settings = new SGlobalSettings;

  // Render sky dome in wireframe mode
  i = -1;
  GetIniVar ("Graphics", "skydomeWireframe", &i);
  if (i == -1) {
    // Parameter was not set, assign default
    i = 0;
    SetIniVar ("Graphics", "skydomeWireframe", i);
    iniChanged = true;
  }
  globals->settings->skydomeWireframe = (i != 0);

  // Render terrain in wireframe mode
  i = -1;
  GetIniVar ("Graphics", "terrainWireframe", &i);
  if (i == -1) {
    // Parameter was not set, assign default
    i = 0;
    SetIniVar ("Graphics", "terrainWireframe", i);
    iniChanged = true;
  }
  globals->settings->terrainWireframe = (i != 0);

  // Render aircraft in wireframe mode
  i = -1;
  GetIniVar ("Graphics", "aircraftWireframe", &i);
  if (i == -1) {
    // Parameter was not set, assign default
    i = 0;
    SetIniVar ("Graphics", "aircraftWireframe", i);
    iniChanged = true;
  }
  globals->settings->aircraftWireframe = (i != 0);

  // Display terrain in relief-shaded mode instead of textured
  i = -1;
  GetIniVar ("Graphics", "terrainReliefShaded", &i);
  if (i == -1) {
    // Parameter was not set, assign default
    i = 0;
    SetIniVar ("Graphics", "terrainReliefShaded", i);
    iniChanged = true;
  }
  globals->settings->terrainReliefShaded = (i != 0);

  // Save INI settings if we have changed anything
  if (iniChanged) {
    SaveIniSettings ();
  }

  // Time Manager
  globals->timemgr = new CTimeManager;
  globals->timemgr->Prepare ();
  globals->timemgr->SetTimeScale (1.0);

  // Audio Manager
  globals->audiomgr = new CAudioManager;
  globals->audiomgr->Init ();

  // Cursor manager
  globals->cursormgr = new CCursorManager;

  // Slew manager
  globals->slewmgr = new CSlewManager;

  // Frame rate trackers
  globals->simRate = new CFrameRateTracker (200);
  globals->drawRate = new CFrameRateTracker (200);

  // Initialize various application object pointers
  globals->sit = NULL;
  globals->keymap = NULL;
  globals->terrainmgr = NULL;
  globals->skymgr = NULL;
  globals->fuimgr = NULL;
}

static void InitGlobalsWithPodFilesystem (void)
{
  LoadDatabases ();

  // Terrain manager
  globals->terrainmgr = new CTerrainManager;

  // Sky manager
  globals->skymgr = new CSkyManager;

  // FUI (Fly! User Interface) manager
  globals->fuimgr = new CFuiManager;
  FILE *f = fopen ("Debug\\Fui.txt", "w");
  globals->fuimgr->Print (f);
  fclose (f);
}


//
// Application cleanup/shutdown functions
//
void CleanupGlobals (void)
{
  cleanup_ui ();
  cleanup_fonts();

  if (globals->settings != NULL)    delete globals->settings;
  if (globals->context != NULL)     delete globals->context;
  if (globals->sit != NULL)         delete globals->sit;
  if (globals->keymap != NULL)      delete globals->keymap;
  if (globals->timemgr != NULL)     delete globals->timemgr;
  if (globals->cursormgr != NULL)   delete globals->cursormgr;
  if (globals->audiomgr != NULL)    delete globals->audiomgr;
  if (globals->fuimgr != NULL)      delete globals->fuimgr;
  if (globals->terrainmgr != NULL)  delete globals->terrainmgr;
  if (globals->skymgr != NULL)      delete globals->skymgr;
  if (globals->slewmgr != NULL)     delete globals->slewmgr;
  if (globals->logDebug != NULL)    delete globals->logDebug;
  if (globals->logWarning != NULL)  delete globals->logWarning;

  // Clean up POD filesystems
  pshutdown (&globals->pfs);

  delete globals;
}


#if defined(_DEBUG) && defined(HAVE_CRTDBG_H)
//
// Define global for memory state debugging
//
_CrtMemState memoryState;
#endif

//
// This function should be called prior to program exit in order to
//   gracefully shut down, deallocate heap memory, close open files, etc.
//
void ShutdownAll (void)
{
  // Unload all databases
  UnloadDatabases ();

  // Clean up INI settings database
  UnloadIniSettings ();

  // Clean up global variables
  CleanupGlobals ();

#ifdef _WIN32
  // Restore saved gamma ramp
  if (!SetDeviceGammaRamp (hdc, savedGammaRamp)) {
    if (globals->logWarning) globals->logWarning->Write ("Failed to set Win32 gamma ramp");
  }
#endif // _WIN32
}


static void idle (void)
{
#ifdef WIN32
  // PROTOTYPE : Windows keyboard handling.  GLUT keyboard events do not support
  //  all numeric keypad keys (e.g. 5, Enter, +, etc.) that are required.
  //  This prototype is temporary until a better workaround can be found.
  //  It may just be required to implement this in another thread and have
  //  keyboard events sent to the main thread.

  BYTE keys[256];
  GetKeyboardState(keys);

  // Update the key modifier state
  int flymod = KB_MODIFIER_NONE;
  bool shift = (keys[VK_SHIFT] & 0x80) != 0;
  if (shift) {
    flymod |= KB_MODIFIER_SHIFT;
  }
  bool ctrl = (keys[VK_CONTROL] & 0x80) != 0;
  if (ctrl) {
    flymod |= KB_MODIFIER_CTRL;
  }
  bool alt = (keys[VK_MENU] & 0x80) != 0;
  if (alt) {
    flymod |= KB_MODIFIER_ALT;
  }

  // Initialize table of key states on first call to this function
  static bool first = true;
  if (first) {
    // Initialize key state array on the first call to this function
    first = false;
    for (int i=0; i<256; i++) {
      savedkeys[i] = (keys[i] & 0x80) != 0;
    }
  }

  // Check for keys that are not supported by GLUT, and pass them to the sim
  //   on keydown events.
  int nKeys = sizeof(nonGlutKeys) / sizeof(SNonGlutKey);
  for (int i=0; i<nKeys; i++) {
    BYTE vk = nonGlutKeys[i].vk;
    if (keys[vk] & 0x80) {
      // Key is pressed; check if saved key state is pressed
      if (!savedkeys[vk]) {
        // Key state has changed from unpressed to pressed
        savedkeys[vk] = true;
        globals->keymap->KeyPress (nonGlutKeys[i].key, (EKeyboardModifiers)flymod);
      }
    } else {
      // Key is not pressed; clear saved key state
      savedkeys[vk] = false;
    }
  }
#endif // WIN32
}


//
// GLUT window reshape
//
static void reshape ( int w, int h )
{
  glViewport ( 0, 0, w, h ) ;
}


//
// GLUT mouse motion event
//
void motion ( int x, int y )
{
  bool used = false;

  // Send mouse motion data to FUI
  if (globals->fuimgr) used = globals->fuimgr->MouseMove (x, y);

  if (!used) {
    // Send mouse motion data to PUI for potential processing
    puMouse (x, y);

    // Send mouse motion for camera manager for panel scrolling
    if (globals->sit) {
      CPanel *panl = globals->sit->GetCurrentPanel ();
      if (panl) {
        // Send mouse event to panel
        panl->MouseMotion (x, y);
      }
    }
  }

  // Send mouse motion to cursor manager
  if (globals->cursormgr) {
    globals->cursormgr->MouseMotion (x, y);
  }

  // Force screen redraw
  glutPostRedisplay () ;
}


//
// GLUT passive mouse motion event
//
void passive_motion ( int x, int y )
{
  bool used = false;

  // Send mouse motion data to FUI
  if (globals->fuimgr) used = globals->fuimgr->MouseMove (x, y);

  if (!used) {
    // Send mouse motion data to PUI
    puMouse (x, y);

    // Send mouse motion for camera manager for panel scrolling
    if (globals->sit) {
      CPanel *panl = globals->sit->GetCurrentPanel ();
      if (panl) {
        // Send mouse event to panel
        panl->MouseMotion (x, y);
      }
    }
  }

  // Send mouse motion to cursor manager
  if (globals->cursormgr) {
    globals->cursormgr->MouseMotion (x, y);
  }

  // Force screen redraw
  glutPostRedisplay () ;
}


//
// GLUT mouse event
//
void mouse ( int button, int updown, int x, int y )
{
  bool used = false;

  // Send mouse click events to FUI for processing
  EMouseButton b = MOUSE_BUTTON_LEFT;
  switch (updown) {
  case GLUT_DOWN:
    switch (button) {
    case GLUT_LEFT_BUTTON:
      b = MOUSE_BUTTON_LEFT;
      break;

    case GLUT_MIDDLE_BUTTON:
      b = MOUSE_BUTTON_MIDDLE;
      break;

    case GLUT_RIGHT_BUTTON:
      b = MOUSE_BUTTON_RIGHT;
      break;
    }
    used = globals->fuimgr->MouseClick (x, y, b);
    break;

  case GLUT_UP:
    switch (button) {
    case GLUT_LEFT_BUTTON:
      b = MOUSE_BUTTON_LEFT;
      break;

    case GLUT_MIDDLE_BUTTON:
      b = MOUSE_BUTTON_MIDDLE;
      break;

    case GLUT_RIGHT_BUTTON:
      b = MOUSE_BUTTON_RIGHT;
      break;
    }
    used = globals->fuimgr->MouseStopClick (x, y, b);
    break;
  }

  if (!used) {
    // Send mouse event to PUI for potential processing
    puMouse (button, updown, x, y);

    // Send mouse motion for camera manager for gauge interaction
    if (globals->sit) {
      CPanel *panl = globals->sit->GetCurrentPanel ();
      if (panl) {
        // Send mouse event to panel
        panl->MouseClick (button, updown, x, y);
      }
    }
  }

  // Force screen redraw
  glutPostRedisplay () ;
}


//
// GLUT keyboard event
//
static void keyboard (unsigned char key, int x, int y)
{
  // Pass keystroke to PUI keyboard handler
  if (!puKeyboard (key, PU_DOWN)) {

    // Ignore keypresses if there is no keymap definition
    if (globals->keymap == NULL) return;

    // Convert GLUT modifiers to FlyLegacy modifiers
    int glutmod = glutGetModifiers ();
    EKeyboardModifiers flymod = glutModifiersToFlyLegacyModifiers (glutmod);

    // Get FlyLegacy key code
    EKeyboardKeys flykey;
    if (glutKeyToFlyLegacyKey (key, &flykey)) {
      globals->keymap->KeyPress (flykey, flymod);
    } else {
      if (globals->logWarning) globals->logWarning->Write ("keyboard : Unmapped GLUT key %d", key);
    }
  }
}

//
// GLUT special keys event
//
static void special (int key, int x, int y)
{
  // Pass keystroke to PUI keyboard handler 
  if (!puKeyboard (key + PU_KEY_GLUT_SPECIAL_OFFSET, PU_DOWN)) {

    // Non-windows keyboard event handling

    // Ignore keypresses if there is no keymap definition
    if (globals->keymap == NULL) return;

    // Get GLUT modifiers and convert to FlyLegacy modifiers
    int glutmod = glutGetModifiers ();
    EKeyboardModifiers flymod = glutModifiersToFlyLegacyModifiers (glutmod);

    // Get FlyLegacy key code
    EKeyboardKeys flykey;
    if (glutSpecialToFlyLegacyKey (key, &flykey)) {
      globals->keymap->KeyPress (flykey, flymod);
    } else {
      if (globals->logWarning) globals->logWarning->Write ("special : Unmapped GLUT key %d", key);
    }
  }
}


//
// Initialize splash screen
//
SBitmap *bmSplash = NULL;
SSurface *surfSplash = NULL;

static void InitSplashScreen (void)
{
  // Load splash screen .PBM
  bmSplash = new SBitmap;
  strcpy (bmSplash->bitmapName, "UI\\LOADING SCREEN\\OPENING.PBM");
  LoadBitmap (bmSplash) ;
  int w, h;
  GetBitmapSize (bmSplash, &w, &h);

  // Create SSurface
  surfSplash = CreateSurface (globals->screenWidth, globals->screenHeight);
  EraseSurface (surfSplash);
  surfSplash->xScreen = 0;
  surfSplash->yScreen = 0;

  // Draw bitmap to surface
  int x = (globals->screenWidth - w) / 2;
  int y = (globals->screenHeight - h) / 2;
  DrawBitmap (surfSplash, bmSplash, x, y, 0);

  // Overlay text
  char buildString[80];
  sprintf (buildString, "%s Build %d.%d.%03d", 
           FLY_LEGACY_TITLE,
           FLY_LEGACY_MAJOR_VERSION,
           FLY_LEGACY_MINOR_VERSION,
           FLY_LEGACY_BUILD);
  unsigned int black = MakeRGB (0, 0, 0);
  unsigned int white = MakeRGB (255, 255, 255);
  x = globals->screenWidth / 2;
  y = ((globals->screenHeight - h) / 2) + 20;
  DrawTextC (surfSplash, &globals->fonts.ftthin24, x+1, y+1, black, buildString);
  DrawTextC (surfSplash, &globals->fonts.ftthin24, x, y, white, buildString);
}

static void Draw2D (SSurface *surf)
{
  // Set projection matrix to 2D screen size
  glMatrixMode(GL_PROJECTION);
  glPushMatrix();
  glLoadIdentity();
  gluOrtho2D (0, globals->screenWidth, 0, globals->screenHeight);

  // Set up OpenGL drawing state
  glPushAttrib (GL_ENABLE_BIT);
  glEnable (GL_ALPHA_TEST);
  glDisable (GL_DEPTH_TEST);
  glDisable (GL_LIGHTING);
  glDisable (GL_COLOR_MATERIAL);
  glDisable (GL_TEXTURE_2D);

  // Blit the surface
  glRasterPos2i (0, 0);
  Blit (surf);

  // Restore original OpenGL state
  glPopAttrib();

  // Restore original projection matrix
  glMatrixMode(GL_PROJECTION);
  glPopMatrix();

  // Check for an OpenGL error
  GLenum e = glGetError ();
  if (e != GL_NO_ERROR) {
    gtfo ("CPanel::Draw:Return : GL Error 0x%04X", e);
  }
}

static void RedrawSplashScreen (void)
{
  // Blit surface
  Draw2D (surfSplash);
}

static void CleanupSplashScreen (void)
{
  FreeBitmap (bmSplash);
  delete bmSplash;
  FreeSurface (surfSplash);
}

//
// Initialization occurs while splash screen is displayed
//
static void Initialize (void)
{
  // Set default cursor.  This depends on initialization of the cursor manager
  //   and POD filesystems (to find the cursor control and image files)
  globals->crsrArrow = globals->cursormgr->BindCursor ("MPARROW.CSR");
  globals->cursormgr->SetCursor (globals->crsrArrow);

  // Initialize various subsystems.  These initialization functions may be
  //   dependent on INI settings and/or POD filesystem
  init_keyboard ();
  init_globe_tile_table ();

  InitGlobalsWithPodFilesystem();
}

//
// Redraw function when application is in loading screen state
//
SBitmap *bmLoading;
SSurface *surfLoading;
static void InitLoadingScreen (void)
{
  // Loading screen .PBM
  bmLoading = new SBitmap;
  strcpy (bmLoading->bitmapName, "UI\\LOADING SCREEN\\LOADING.PBM");
  LoadBitmap (bmLoading);
  int w, h;
  GetBitmapSize (bmLoading, &w, &h);

  // Create SSurface
  surfLoading = CreateSurface (globals->screenWidth, globals->screenHeight);
  EraseSurface (surfLoading);
  surfLoading->xScreen = 0;
  surfLoading->yScreen = 0;

  // Draw bitmap to surface
  if ((w > globals->screenWidth) || (h > globals->screenHeight)) {
    // Image is larger than the screen...just copy a portion to fit the surface
    int x1 = (w - globals->screenWidth) / 2;
    int y1 = (h - globals->screenHeight) / 2;
    int x2 = x1 + globals->screenWidth;
    int y2 = y1 + globals->screenHeight;
    DrawBitmapPartial (surfLoading, bmLoading, 0, 0, x1, y1, x2, y2, 0);
  } else {
    // Image is smaller or equal to the screen size
    int x = (globals->screenWidth - w) / 2;
    int y = (globals->screenHeight - h) / 2;
    DrawBitmap (surfLoading, bmLoading, x, y, 0);
  }
}

static void RedrawLoadingScreen (void)
{
  // Overlay % progress

  // Blit surface
  Draw2D (surfLoading);
}

static void CleanupLoadingScreen (void)
{
  if (bmLoading != NULL) {
    FreeBitmap (bmLoading);
    delete bmLoading;
    bmLoading = NULL;
  }

  if (surfLoading != NULL) { 
    FreeSurface (surfLoading);
    surfLoading = NULL;
  }
}

//
// Redraw function when application is in load situation state
//
static void LoadStartupSituation (void)
{
  // Load default situation
  char sitFilename[80];
  strcpy (sitFilename, "");
  GetIniString ("UI", "startupSituation", sitFilename, 80);
  if (strlen (sitFilename) == 0) {
    // No default startup situation specified in INI settings
    strcpy (sitFilename, "Default.sit");
    SetIniString ("UI", "startupSituation", sitFilename);
    SaveIniSettings ();
  }

  char *mark1 = new char[32];
  strcpy (mark1, "sit start");
  globals->sit = new CSituation (sitFilename);
  char *mark2 = new char[32];
  strcpy (mark2, "sit end");

//  globals->sit = new CSituation ("Default.sit");  // Default for testing
//  globals->sit = new CSituation ("Flyhawk.sit");  // Flyhawk  - Cessna 172
//  globals->sit = new CSituation ("TRI1.sit");   // Harvey   - Piper Malibu
//  globals->sit = new CSituation ("TRI1B.sit");  // TRI3     - "Dragonfly" Malibu
//  globals->sit = new CSituation ("TRI2.sit");   // Java     - Piper Navajo
//  globals->sit = new CSituation ("TRI3.sit");   // TRI3     - Beech KingAir
//  globals->sit = new CSituation ("TRI3B.sit");  // TRI3B    - "Barracuda" KingAir
//  globals->sit = new CSituation ("TRI4.sit");   // TRI4     - Peregrine 800TR
//  globals->sit = new CSituation ("Pilatus.sit");  // Pilatus  - Pilatus PC-12
//  globals->sit = new CSituation ("Stearman.sit"); // Stearman - Stearman Biplane
//  globals->sit = new CSituation ("Stearflt.sit"); // Stearflt - Stearman w/Floats
}

//
// Redraw function when application is in simulation state
//
static unsigned int   nFrames = 0;      // Sim frame rate counter
static float          tFrames = 0.0f;   // Sim frame rate timer
static float          frameRate = 0.0f; // Sim frame rate

static void RedrawSimulation (void)
{
  // Call the time manager to indicate that another cycle is occurring.
  //   This represents the redraw cycle, not necessarily the simulation
  //   cycle, though at present they are coupled.
  globals->timemgr->Update ();
  float dRealT = globals->timemgr->GetDeltaRealTime();
  float dSimT  = globals->timemgr->GetDeltaSimTime();

  // Accumulate frame rate statistics every second
  nFrames++;
  tFrames += dRealT;
  if (tFrames > 1.0f) {
    frameRate = (float)nFrames / tFrames;
    tFrames = 0.0f;
    nFrames = 0;
  }

//  char debug[80];
//  sprintf (debug, "dT = %f   frameRate=%5.2f", dRealT, frameRate);
//  DrawNoticeToUser (debug, 1);

  // Update situation
  if (globals->sit != NULL) {
    globals->sit->Timeslice (dSimT);
  }

  // The global CSituation object contains all information about the current
  //   simulation state, user vehicle, camera mode, etc.
  globals->sit->Draw (dRealT);

  // Draw UI components
  DrawUi (dRealT);
  globals->fuimgr->Draw ();

  // Draw cursor
  globals->cursormgr->Draw ();
}

//
// Initialize splash screen
//
SBitmap *bmExit = NULL;
SSurface *surfExit = NULL;

static void InitExitScreen (void)
{
  // Load screen .PBM
  bmExit = new SBitmap;
  strcpy (bmExit->bitmapName, "UI\\LOADING SCREEN\\LEAVING.PBM");
  LoadBitmap (bmExit);
  int w, h;
  GetBitmapSize (bmExit, &w, &h);

  // Create SSurface
  surfExit = CreateSurface (globals->screenWidth, globals->screenHeight);
  EraseSurface (surfExit);
  surfExit->xScreen = 0;
  surfExit->yScreen = 0;

  // Draw bitmap to surface
  int x = (globals->screenWidth - w) / 2;
  int y = (globals->screenHeight - h) / 2;
  DrawBitmap (surfExit, bmExit, x, y, 0);

  // Draw text
  char exitMsg[80];
  strcpy (exitMsg, "You are cleared for departure...");
  unsigned int white = MakeRGB (255, 255, 255);
  DrawTextC (surfExit, &globals->fonts.ftthin24,
             globals->screenWidth / 2, globals->screenHeight - 40,
             white, exitMsg);
}

static void RedrawExitScreen (void)
{
  // Blit surface
  Draw2D (surfExit);
}

static void CleanupExitScreen (void)
{
  FreeBitmap (bmExit);
  delete bmExit;
  FreeSurface (surfExit);
}

static void ExitApp ()
{
  // Gracefully shut down and clean up before exiting
  ShutdownAll ();

  // Exit fullscreen mode
  glutLeaveGameMode ();

  CleanupExitScreen ();

#if defined(_DEBUG) && defined(HAVE_CRTDBG_H)
  // Check for memory leaks
  HANDLE hfile = CreateFile ("Logs\\MemoryLeaks.log",
                             GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
                             FILE_ATTRIBUTE_NORMAL, NULL);
  _CrtSetReportMode (_CRT_WARN, _CRTDBG_MODE_FILE);
  _CrtSetReportFile (_CRT_WARN, hfile);
  _CrtSetReportMode (_CRT_ERROR, _CRTDBG_MODE_FILE);
  _CrtSetReportFile (_CRT_ERROR, hfile);
  _CrtMemDumpAllObjectsSince(&memoryState);
  CloseHandle (hfile);
#endif

//  fprintf (stdout, "Press Enter key to exit...");
//  char s[80];
//  gets(s);

#if defined(WIN32) && defined(_DEBUG)
  // Avoid MSVC6 crash on exit() when debugging
  TerminateProcess (GetCurrentProcess(), 0);
#else
  exit (0);
#endif // _WIN32 && _DEBUG
}

//
// GLUT redraw event
//
static void redraw ()
{
  // Clear the back buffer
  glEnable (GL_DEPTH_TEST);
  glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

  switch (globals->appState) {
  case APP_SPLASH_SCREEN:
    // Display splash screen
    InitSplashScreen ();
    RedrawSplashScreen ();
    globals->appState = APP_INIT;
    break;

  case APP_INIT:
    {
    // Perform application initialization
    Initialize();
    RedrawSplashScreen ();
    globals->appState = APP_GENERATE_SITUATION;
    }
    break;

  case APP_GENERATE_SITUATION:
    // Currently nothing to do.
    
    RedrawSplashScreen ();
    globals->appState = APP_LOADING_SCREEN;
    break;

  case APP_LOADING_SCREEN:
    // Display "Loading..." screen
    InitLoadingScreen ();
    RedrawLoadingScreen ();
    CleanupSplashScreen ();
    globals->appState = APP_LOAD_SITUATION;
    break;

  case APP_LOAD_SITUATION:
    // Load situation
    {
    LoadStartupSituation ();
    RedrawLoadingScreen ();
    globals->appState = APP_PREPARE;
    }
    break;

  case APP_PREPARE:
    // Prepare situation for simulation
    globals->sit->Prepare ();
    globals->appState = APP_SIMULATION;
    RedrawLoadingScreen ();
    CleanupLoadingScreen ();
    break;

  case APP_SIMULATION:
    // Run simulation
    RedrawSimulation ();
    break;

  case APP_EXIT_SCREEN:
    // Display Exit screen
    InitExitScreen ();
    RedrawExitScreen ();
    globals->appState = APP_EXIT;
    break;

  case APP_EXIT:
    // Exit application...program does not return from this function
    ExitApp ();
    break;
  }

  glutPostRedisplay ();
  glutSwapBuffers ();
}


int main (int argc, char **argv)
{
#if defined(_DEBUG) && defined(HAVE_CRTDBG_H)

  _CrtMemCheckpoint (&memoryState);
#endif

  // Load application settings from INI file
  LoadIniSettings ();

  // Initialize global variables.  Some globals are dependent on INI settings
  //   so this initialization must be done after the INI file has been loaded
  InitGlobalsNoPodFilesystem ();
  globals->appState = APP_SPLASH_SCREEN;

  // Initialize OpenGL and GLUT to enable game mode activation
  InitGraphics ();

  // Initialize the system pod filesystem.  The top-level reference to the POD
  //   filesystem is stored in the global variable struct, so this must
  //   be called after globals have been instantiated.
  char flyRootFolder[64];
  strcpy (flyRootFolder, "");
  GetIniString ("UI", "flyRootFolder", flyRootFolder, 64);
  if (strlen (flyRootFolder) == 0) {
    strcpy (flyRootFolder, "C:\\Program Files\\Terminal Reality\\Fly! II");
    SetIniString ("UI", "flyRootFolder", flyRootFolder);
    SaveIniSettings ();
  }
  pinit (&globals->pfs, flyRootFolder, false);
  char *mark1 = new char[32];
  strcpy (mark1, "padd Start");
  paddpodfolder (&globals->pfs, "System");
  char *mark2 = new char[32];
  strcpy (mark2, "System End");
  padddiskfolder (&globals->pfs, "Saved Simulations");
  padddiskfolder (&globals->pfs, "System");
  padddiskfolder (&globals->pfs, "Art");
  padddiskfolder (&globals->pfs, "BT");
  padddiskfolder (&globals->pfs, "Data");
  padddiskfolder (&globals->pfs, "Ui");
  padddiskfolder (&globals->pfs, "World");
  padddiskfolder (&globals->pfs, "Scenery");
  paddpodfolder (&globals->pfs, "Aircraft");
  paddpodfolder (&globals->pfs, "Scenery\\Shared");
  char *mark9 = new char[32];
  strcpy (mark9, "padd End");
 
/*
  // DEBUG : Dump pod filesystem contents
  FILE *fPfsDump = fopen ("Logs\\PfsDump.log", "w");
  if (fPfsDump) {
    pfsdump (&globals->pfs, fPfsDump);
  }
  fclose (fPfsDump);
*/

  // Initialize subsystems so that mouse and keyboard callbacks can be handled
  init_ui ();
  char *mark3 = new char[32];
  strcpy (mark3, "fonts Start");
  InitFonts ();
  char *mark4 = new char[32];
  strcpy (mark4, "fonts End");

  // Enter GLUT main loop.
  glutMainLoop ();

  // Check for an OpenGL error
  GLenum e = glGetError ();
  if (e != GL_NO_ERROR) {
    gtfo ("main() : GL Error 0x%08x", e);
  }

  return 0;
}


#ifdef _WINDOWS
//
// Windows main() function
//
int APIENTRY WinMain (HINSTANCE hInstance,
                      HINSTANCE hPrevInstance,
                      LPSTR lpCmdLine,
                      int nShowCmd)
{
  main(0, NULL);
  return 0;
}
#endif // _WINDOWS


void GTFO::operator() (const char* fmt, ...)
{
  glutLeaveGameMode ();

  CLogFile *log = new CLogFile ("Logs\\gtfo.log", "a");

  char usermsg[512];
  // Format user message from varargs
  if (fmt != NULL) {
    va_list argp;
    va_start(argp, fmt);
    vsprintf(usermsg, fmt, argp);
    va_end(argp);
  } else {
    // NULL user message format string
    strcpy (usermsg, "");
  }

  // Trim all but last two path components from filename
  char separator = '\\';
  int nSeparators = 0;
  int len = strlen(m_file);

  // Initialize file buffer with entire filename
  char file[1024];
  char *c;
  for (c = (m_file + len); c >= m_file; c--) {
    if (*c == separator) {
      nSeparators++;
      if (nSeparators == 2) {
        // Found two separators...extract remnant to buffer
        c++;
        break;
      }
    }
  }
  strcpy (file, c);

  // Output log message
  log->Write ("Abnormal exit\n  File: %s  Line: %d\n  %s\n\n", file, m_line, usermsg);

  delete log;

#if defined(WIN32) && defined(_DEBUG)
  TerminateProcess (GetCurrentProcess(), 0);
#endif
  exit (0);
}

void WARN::operator() (const char* fmt, ...)
{
  if (globals->logWarning != NULL) {
    char usermsg[512];
    // Format user message from varargs
    if (fmt != NULL) {
      va_list argp;
      va_start(argp, fmt);
      vsprintf(usermsg, fmt, argp);
      va_end(argp);
    } else {
      // NULL user message format string
      strcpy (usermsg, "");
    }

    // Trim all but last two path components from filename
    char separator = '\\';
    int nSeparators = 0;
    int len = strlen(m_file);

    // Initialize file buffer with entire filename
    char file[1024];
    char *c;
    for (c = (m_file + len); c >= m_file; c--) {
      if (*c == separator) {
        nSeparators++;
        if (nSeparators == 2) {
          // Found two separators...extract remnant to buffer
          c++;
          break;
        }
      }
    }
    strcpy (file, c);

    // Output log message
    globals->logWarning->Write ("Warning\n  File: %s  Line: %d\n  %s\n\n",
      file, m_line, usermsg);
  }
}

void DEBUG::operator() (const char* fmt, ...)
{
  if (globals->logDebug != NULL) {
    char usermsg[512];
    // Format user message from varargs
    if (fmt != NULL) {
      va_list argp;
      va_start(argp, fmt);
      vsprintf(usermsg, fmt, argp);
      va_end(argp);
    } else {
      // NULL user message format string
      strcpy (usermsg, "");
    }

    // Trim all but last two path components from filename
    char separator = '\\';
    int nSeparators = 0;
    int len = strlen(m_file);

    // Initialize file buffer with entire filename
    char file[1024];
    char *c;
    for (c = (m_file + len); c >= m_file; c--) {
      if (*c == separator) {
        nSeparators++;
        if (nSeparators == 2) {
          // Found two separators...extract remnant to buffer
          c++;
          break;
        }
      }
    }
    strcpy (file, c);

    // Output log message
    globals->logDebug->Write ("Debug\n  File: %s  Line: %d\n  %s\n\n",
      file, m_line, usermsg);
  }
}

Documentation generated by