Situation.cpp

Go to the documentation of this file.

/*
 * Situation.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
 *
 */

#include <time.h>

#include "../Include/Globals.h"
#include "../Include/Situation.h"
#include "../Include/Ui.h"
#include "../Include/Utility.h"
#include "../Include/Subsystems.h"
#include "../Include/Gauges.h"

using namespace std;


//
// CSlewManager manages the user vehicle position when it is in slew mode
//

CSlewManager::CSlewManager (void)
{
  enabled = false;
  nRate = eRate = aRate = 0;
}


void CSlewManager::Enable (void) 
{
  enabled = true;
}


void CSlewManager::Disable (void) 
{
  ZeroRate ();
  enabled = false;
}


bool CSlewManager::IsEnabled (void) 
{
  return enabled;
}


float CSlewManager::GetNorthRate (void) 
{
  return nRate;
}

float CSlewManager::GetEastRate (void) 
{
  return eRate;
}

float CSlewManager::GetAltRate (void) 
{
  return aRate;
}

void CSlewManager::SetNorthRate (float rate) 
{
  nRate = rate;
}

void CSlewManager::SetEastRate (float rate) 
{
  eRate = rate;
}

void CSlewManager::SetAltRate (float rate) 
{
  aRate = rate;
}

void CSlewManager::ZeroRate (void)
{
  nRate = eRate = aRate = 0;
}

void CSlewManager::Update (float dT)
{
  if (enabled) {
    CVehicleObject *user = globals->sit->GetUserVehicle ();
    if (user) {
      // Update user vehicle position
      SPosition pos = user->GetPosition ();

      // Range checking against latitude and altitude extremes is done in
      //   CUserVehicle::SetPosition
      pos.alt += (aRate * dT);
      pos.lat += (nRate * dT);
      pos.lon += (eRate * dT);
      user->SetPosition (pos);

      /*
      // DEBUG
      char debug[80];
      sprintf (debug, "Slew : aRate=%f nRate=%f eRate=%f\n", aRate, nRate, eRate);
      DrawNoticeToUser (debug, 1);
      */
    }
  }
};


//
// CSituation
//

CSituation::CSituation (const char *sitFilename)
{
  // Perform base initialization
  user = NULL;
  cmgr = NULL;
  kmgr = NULL;
  rootModels = new ssgRoot;
  rootUserVehicle = new ssgRoot;

  // Get panel sound effect source
  sfx_source_panel = globals->audiomgr->CreateSource ();
  CGauge::sfx_source = sfx_source_panel;

  // Open SIT file from pod filesystem
  SStream s;
  strcpy (s.filename, "Saved Simulations\\");
  strcat (s.filename, sitFilename);
  strcpy (s.mode, "r");
  if (OpenStream (&s)) {
    // Successfully opened stream
    ReadFrom (this, &s);
  } else {
    gtfo ("CSituation : Cannot open SIT file %s", s.filename);
  }
  CloseStream (&s);
}

CSituation::~CSituation (void)
{
  vector<CWorldObjectBase*>::iterator i;
  for (i=wobjList.begin(); i!=wobjList.end(); i++) {
    CWorldObjectBase *pObj = *i;
    delete pObj;
  }

  // Clean up SSG roots
  rootModels->removeAllKids();
  delete rootModels;
  rootUserVehicle->removeAllKids();
  delete rootUserVehicle;
}

int CSituation::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  switch (tag) {
  case 'wobj':
    {
      // Determine the type of world object
      char s[80];
      ReadString (s, 80, stream);
      Tag type = StringToTag (s);
      switch (type) {
      case TYPE_FLY_WORLDOBJECT:
        {
          // Instantiate new CWorldObject
          CWorldObject *wobj = new CWorldObject ();
          ReadFrom (wobj, stream);
          wobjList.push_back (wobj);
        }
        break;

      case TYPE_FLY_MODELOBJECT:
        {
          // Instantiate new CModelObject
          CModelObject *mobj = new CModelObject ();
          ReadFrom (mobj, stream);
          wobjList.push_back (mobj);

          // Add top-level SSG entity to model root
          ssgEntity *e = mobj->GetSSGEntity();
          if (e != NULL) {
            rootModels->addKid (e);
          }
        }
        break;

      case TYPE_FLY_SIMULATEDOBJECT:
        {
          // Instantiate new CSimulatedObject
          CSimulatedObject *sobj = new CSimulatedObject ();
          ReadFrom (sobj, stream);
          wobjList.push_back (sobj);

          // Add top-level SSG entity to model root
          ssgEntity *e = sobj->GetSSGEntity();
          if (e != NULL) {
            rootModels->addKid (e);
          }
        }
        break;

      case TYPE_FLY_VEHICLE:
        {
          // Instantiate new CVehicleObject
          CVehicleObject *vehi = new CVehicleObject ();
          ReadFrom (vehi, stream);
          wobjList.push_back (vehi);
          if (vehi->isUserVehicle()) {
            user = vehi;
            userType = TYPE_FLY_VEHICLE;

            ssgEntity *e = vehi->GetSSGEntity();
            if (e != NULL) {
              rootModels->addKid (e);
            }
          } else {
            ssgEntity *e = vehi->GetSSGEntity();
            if (e != NULL) {
              rootUserVehicle->addKid (e);
            }
          }
        }
        break;

      case TYPE_FLY_GROUNDVEHICLE:
        {
          // Instantiate new CGroundVehicleObject
          CGroundVehicleObject *gveh = new CGroundVehicleObject ();
          ReadFrom (gveh, stream);
          wobjList.push_back (gveh);
          if (gveh->isUserVehicle()) {
            user = gveh;
            userType = TYPE_FLY_GROUNDVEHICLE;

            ssgEntity *e = gveh->GetSSGEntity();
            if (e != NULL) {
              rootModels->addKid (e);
            }
          } else {
            ssgEntity *e = gveh->GetSSGEntity();
            if (e != NULL) {
              rootUserVehicle->addKid (e);
            }
          }
        }
        break;

      case TYPE_FLY_AIRPLANE:
        {
          // Instantiate new CAirplaneObject
          CAirplaneObject *plan = new CAirplaneObject ();
          ReadFrom (plan, stream);
          wobjList.push_back (plan);
          if (plan->isUserVehicle()) {
            user = plan;
            userType = TYPE_FLY_AIRPLANE;

            ssgEntity *e = plan->GetSSGEntity();
            if (e != NULL) {
              rootUserVehicle->addKid (e);
            }
          } else {
            ssgEntity *e = plan->GetSSGEntity();
            if (e != NULL) {
              rootModels->addKid (e);
            }
          }
        }
        break;

      case TYPE_FLY_HELICOPTER:
        {
          // Instantiate new CHelicopterObject
          CHelicopterObject *heli = new CHelicopterObject ();
          ReadFrom (heli, stream);
          wobjList.push_back (heli);
          if (heli->isUserVehicle()) {
            user = heli;
            userType = TYPE_FLY_HELICOPTER;

            ssgEntity *e = heli->GetSSGEntity();
            if (e != NULL) {
              rootUserVehicle->addKid (e);
            }
          } else {
            ssgEntity *e = heli->GetSSGEntity();
            if (e != NULL) {
              rootModels->addKid (e);
            }
          }
        }
        break;
      }
      rc = TAG_READ;
    }
    break;

  default:
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CSituation::Read : Unknown tag <%s>", s);
  }

  return rc;
}

void CSituation::ReadFinished (void)
{
  // Validate that user vehicle pointer has been set
  if (user == NULL) {
    gtfo ("CSituation : NULL user vehicle");
  }

  // Validate pointer to camera manager
  cmgr = user->GetCameraManager();
  if (cmgr == NULL) {
    gtfo ("CSituation : NULL camera manager for user vehicle");
  }

  // Validate pointer to cockpit manager
  kmgr = user->GetCockpitManager();
  if (kmgr == NULL) {
    gtfo ("CSituation : NULL cockpit manager for user vehicle");
  }
}

CCamera* CSituation::GetCurrentCamera (void)
{
  return cmgr->GetActiveCamera ();
}

CPanel* CSituation::GetCurrentPanel (void)
{
  return kmgr->GetCurrentPanel ();
}

CVehicleObject* CSituation::GetUserVehicle (void)
{
  return user;
}

EFlyObjectType CSituation::GetUserVehicleType (void)
{
  return userType;
}

void CSituation::PrintUserVehicle (FILE *f)
{
  rootUserVehicle->print (f);
}

//
// The Prepare method is called after loading of the situation, but
//   prior to the first Timeslice call.  It allows any initial real-time
//   preparation to be done, inter-system communication setup, etc.
//
void CSituation::Prepare (void)
{

  // Prepare terrain manager
  globals->terrainmgr->Prepare ();
}


//
// This method is called on every simulation cycle, in order to update
//   the simulation world and all entities within it.  This method
//   calls the Draw method when it is deemed necessary to redraw the
//   sim world onscreen.
//
void CSituation::Timeslice (float dT)
{
  // Update the slew manager
  globals->slewmgr->Update (dT);

  // Update sky parameters
  globals->skymgr->Update (dT);

  // Update user vehicle subsystems
  CVehicleObject *vehi = globals->sit->GetUserVehicle ();
  EFlyObjectType userType = globals->sit->GetUserVehicleType ();
  switch (userType) {
  case TYPE_FLY_AIRPLANE:
    {
      CAirplaneObject *planObj = (CAirplaneObject *)vehi;
      CAirplane *plan = planObj->pAirplane;
      if (plan) {
        // Airplane object is valid
        plan->Timeslice (dT);
      }
    }
    break;
  default:
    // User vehicle not yet supported; do nothing
    ;
  }

//  SDateTime dt = timemgr->GetLocalDateTime ();
//  char debug[80];
//  sprintf (debug, "%02d/%02d/%04d  %02d:%02d:%02d  %f",
//    dt.date.day, dt.date.month, dt.date.year,
//    dt.time.hour, dt.time.minute, dt.time.second, mjd);
//  DrawNoticeToUser (debug, 1);
  
  // Check for an OpenGL error
  GLenum e = glGetError ();
  if (e != GL_NO_ERROR) {
    gtfo ("CSituation::Update : GL Error 0x%04X", e);
  }
}

void CSituation::Draw (float dT)
{
  // All drawing of the scene (except for PUI user interface widgets) is
  //   controlled from this method.  For now, all SSG context manipulation
  //   is done here, although it might be better to move it into the
  //   individual sub-object Draw methods someday.

  // Get camera attributes from the camera manager attached to the user vehicle
  SPosition userPos = user->GetPosition();

  char debug[80];
//  sprintf (debug, "slew nRate=%f eRate=%f aRate=%f", nRate, eRate, aRate);
  sprintf (debug, "pos : lat=%f lon=%f alt=%f", userPos.lat, userPos.lon, userPos.alt);
  DrawNoticeToUser (debug, 1);

  SVector userOrient = user->GetOrientation();
  SPosition eyePos;
  SVector eyeOrient;
  cmgr->UpdateCamera (&userPos, &userOrient, &eyePos, &eyeOrient, dT);

  // Set field of view
  float aspect = 4.0f / 3.0f;
  float fovX = 50.0f;
  float fovY = fovX / aspect;
  ssgSetFOV (fovX, fovY) ;

  //
  // Draw the opaque background sky elements (sky dome, sun, moon, etc.)
  //
  globals->skymgr->SetCamera (eyePos, eyeOrient);
  globals->skymgr->PreDraw ();

  // Draw the terrain (ground textures, airports, scenery models, etc.)
  globals->terrainmgr->SetPosition (userPos);
  globals->terrainmgr->SetCamera (eyePos, userPos, eyeOrient);
  globals->terrainmgr->Draw ();

  // Draw non-user vehicle models
  ssgCullAndDraw (rootModels);



  // If the current camera is of type CCameraCockpit, draw the panel
  CCamera *cam = cmgr->GetActiveCamera ();
  if (cam->GetCameraType() == CAMERA_COCKPIT) {
    // Ensure current panel is selected in CCockpitManager
    CCameraCockpit* camCock = (CCameraCockpit*) cam;
    Tag tag = camCock->GetCockpitPanel ();
    if (tag != user->GetPanel ()) {
      user->SetPanel (tag);
    }

    // Draw the panel
    user->DrawPanel ();
  } else {
    if (!cam->IsInteriorCamera ()) {
      ssgCullAndDraw (rootUserVehicle);
    }
  }

  //
  // Draw the translucent sky elements (clouds etc.)
  //
  // sky->PostDraw ();

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

Documentation generated by