WorldObjects.cpp

Go to the documentation of this file.

/*
 * WorldObjects.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 "../Include/Globals.h"
#include "../Include/FlyLegacy.h"
#include "../Include/WorldObjects.h"
#include "../Include/Utility.h"

//
// CWorldObject
//

CWorldObject::CWorldObject (void) : geopRead (false), iangRead (false)
{
  type = TYPE_FLY_WORLDOBJECT;
  geop.lat = geop.lon = geop.alt = 0;
  iang.h = iang.p = iang.r = 0;
}

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

  switch (tag) {
  case 'type':
    // Object type
    ReadTag (&type, stream);
    break;

  case 'geop':
    // Geographical position, in WGS84 geodetic coordinates
    ReadPosition (&geop, stream);
    geop.alt += 50.0;
    geopRead = true;
    rc = TAG_READ;
    break;

  case 'iang':
    // Inertial angular position, in radians (heading relative to true north)
    ReadVector (&iang, stream);
    iangRead = true;
    rc = TAG_READ;
    break;

  default:
    // This is the end of the line...if the tag is not recognized then
    //   generate a warning
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CWorldObject::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}


void  CWorldObject::ReadFinished (void)
{
  if (!geopRead) {
    // No <geop> tag was specified, set default position to KSFO runway ??
    geop.lat = 0;
    geop.lon = 0;
    geop.alt = 0;
  }
  SetPosition (geop);

  if (!iangRead) {
    // No <iang> tag was specified, set default orientation to true north
    iang.h = 0;
    iang.p = 0;
    iang.r = 0;
  }
}

Tag CWorldObject::GetType (void)
{
  return type;
}

SPosition CWorldObject::GetPosition (void)
{
  return geop;
}

void CWorldObject::SetPosition (SPosition pos)
{
  // Clamp altitude to 100K
  const double altClamp = 1.0E+5;
  if (pos.alt > altClamp) pos.alt = altClamp;

  // Clamp latitude to globe tile maximum latitude
  const double latClamp = 85.199627944116 * 3600.0;
  if (pos.lat > latClamp)  pos.lat = latClamp;
  if (pos.lat < -latClamp) pos.lat = latClamp;

  geop = pos;
}

SVector   CWorldObject::GetOrientation (void)
{
  return iang;
}

void      CWorldObject::SetOrientation (SVector v)
{
  iang = v;
}


//
// CModelManager
//

CModelManager::CModelManager (void)
{
  tag = 0;
  model = NULL;
}

CModelManager::~CModelManager (void)
{
  if (model != NULL) delete model;
}

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

  switch (tag) {
  case 'modl':
    {
      // Static model
      ReadTag (&tag, stream);
      char modelName[64];
      ReadString (modelName, 64, stream);

      char fullName[64];
      strcpy (fullName, "MODELS\\");
      strcat (fullName, modelName);
      char *p = strrchr (modelName, '.');
      if (p != NULL) {
        if (stricmp (p, ".SMF") == 0) {
          if (model == NULL) {
            char *mark1 = new char[32];
            strcpy (mark1, "CModelSMF Start");
            model = new CModelSMF (fullName);
            char *mark2 = new char[32];
            strcpy (mark2, "CModelSMF End");
          } else {
            gtfo ("CModelManager : Duplicated <modl> tag : %s", fullName);
          }
        }
      }
    }
    rc = TAG_READ;
    break;
  }

  return rc;
}

ssgEntity *CModelManager::GetSSGEntity (void)
{
  ssgEntity *rc = NULL;

  if (model != NULL) rc = model->GetSSGEntity ();

  return rc;
}

//
// CModelObject
//

CModelObject::CModelObject (void)
: CWorldObject ()
{
  type = TYPE_FLY_MODELOBJECT;
  flags = 0;
  detail = 0;
  dayModel = NULL;
  nightModel = NULL;
  daynight = NULL;

  top = new ssgTransform;
  top->setName ("CModelObject Top");
}

CModelObject::~CModelObject (void)
{
  if (dayModel != NULL) delete dayModel;
  if (nightModel != NULL) delete nightModel;
}

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

  switch (tag) {
  case 'flag':
    // Gestalt flags
    ReadUInt (&flags, stream);
    rc = TAG_READ;
    break;

  case 'detl':
    // Detail level
    ReadInt (&detail, stream);
    rc = TAG_READ;
    break;

  case 'kmmd':
    // Day model
    dayModel = new CModelManager;
    ReadFrom (dayModel, stream);
    rc = TAG_READ;
    break;

  case 'kmmn':
    // Night model
    nightModel = new CModelManager;
    ReadFrom (nightModel, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    // Allow parent class to process the tag
    rc = CWorldObject::Read (stream, tag);
  }

  return rc;
}

void  CModelObject::ReadFinished (void)
{
  // Add day and/or night models
  if ((dayModel != NULL) || (nightModel != NULL)){
    // Create selector for day/night models
    daynight = new ssgSelector;
    daynight->setName ("Day/Night Selector");
    daynight->selectStep(0);
    top->addKid (daynight);
    
    if (dayModel != NULL) {
      daynight->addKid (dayModel->GetSSGEntity());
    }
    if (nightModel != NULL) {
      daynight->addKid (nightModel->GetSSGEntity());
    }
  }

  // Call ReadFinished() method of parent
  CWorldObject::ReadFinished ();
}

void CModelObject::SetPosition (SPosition geop)
{
  CWorldObject::SetPosition (geop);

  // Get model rotation Euler angles, convert to degrees
  SVector rot = GetOrientation ();
  rot.h = RadToDeg (rot.h);
  rot.p = RadToDeg (rot.p);
  rot.r = RadToDeg (rot.r);

  // Update transform
  sgMat4 pos;
  SVector v = PosToScaledFlatCartesianQgt (geop);

  sgMakeTransMat4 (pos, v.x, v.y, v.z);

  sgMat4 orient;
  sgMakeRotMat4 (orient, rot.r, rot.p, rot.h);

  // Apply transform matrix to top-level transform
  sgMat4 T;
  sgCopyMat4 (T, pos);
  sgPreMultMat4 (T, orient);
  top->setTransform (T);
}

ssgEntity *CModelObject::GetSSGEntity (void)
{
  return top;
}

//
// CSimulatedObject
//

CSimulatedObject::CSimulatedObject (void)
: CModelObject ()
{
  type = TYPE_FLY_SIMULATEDOBJECT;
}

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

  if (rc != TAG_READ) {
    // Allow parent class to process the tag
    rc = CModelObject::Read (stream, tag);
  }

  return rc;
}

void  CSimulatedObject::ReadFinished (void)
{
  // Call ReadFinished() method of parent
  CModelObject::ReadFinished ();
}

//
// CVehicleObject
//

CVehicleObject::CVehicleObject (void)
: CSimulatedObject ()
{
  type = TYPE_FLY_VEHICLE;
  user = false;
  vmode = CAMERA_INVALID;
}

CVehicleObject::~CVehicleObject (void)
{
}

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

  switch (tag) {
  case 'user':
    // No arguments, this tag indicates that this is the user vehicle
    user = true;
    rc = TAG_READ;

  case 'vmod':
    {
      // View mode, references one of the pre-defined cameras
      char s[256];
      ReadString (s, sizeof(s), stream);
      rc = TAG_READ;
    }
    break;

  default:
    // Allow parent class to process the tag
    rc = CSimulatedObject::Read (stream, tag);
  }

  return rc;
}

void CVehicleObject::ReadFinished (void)
{
  // Call ReadFinished() method of parent
  CSimulatedObject::ReadFinished ();
}

bool  CVehicleObject::isUserVehicle (void)
{
  return user;
}

CCameraManager* CVehicleObject::GetCameraManager (void)
{
  return NULL;
}

CCockpitManager* CVehicleObject::GetCockpitManager (void)
{
  return NULL;
}

//
// CGroundVehicleObject
//

CGroundVehicleObject::CGroundVehicleObject (void)
{
  type = TYPE_FLY_GROUNDVEHICLE;
}

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

  if (rc != TAG_READ) {
    // Allow parent class to process the tag
    rc = CVehicleObject::Read (stream, tag);
  }

  return rc;
}


//
// CAirplaneObject
//

CAirplaneObject::CAirplaneObject (void)
{
  type = TYPE_FLY_AIRPLANE;
  strcpy (nfoFilename, "");
  pAirplane = NULL;
}

CAirplaneObject::~CAirplaneObject (void)
{
  if (pAirplane != NULL) delete pAirplane;
}

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

  switch (tag) {
  case '_NFO':
    // Aircraft Info (.NFO) file
    ReadString (nfoFilename, sizeof(nfoFilename), stream);
    rc = TAG_READ;
    break;
  }

  if (rc != TAG_READ) {
    // Allow parent class to process the tag
    rc = CVehicleObject::Read (stream, tag);
  }

  return rc;
}

void  CAirplaneObject::ReadFinished (void)
{
  if (strlen(nfoFilename) == 0) {
    // Error, no <_NFO> tag was specified
    gtfo ("CAirplaneObject : Missing <_NFO> tag");
  } else {
    char *mark1 = new char[32];
    strcpy (mark1, "airplane start");
    pAirplane = new CAirplane (nfoFilename);
    char *mark2 = new char[32];
    strcpy (mark2, "airplane end");
  }

  // Call ReadFinished() method of parent
  CVehicleObject::ReadFinished ();

  // Add top-level SSG Entity for aircraft visual model
  top->addKid (pAirplane->lod->GetSSGEntity ());
}

CCameraManager* CAirplaneObject::GetCameraManager (void)
{
  CCameraManager *rc = NULL;

  if (pAirplane) {
    rc = pAirplane->cam;
  }

  return rc;
}


CCockpitManager*  CAirplaneObject::GetCockpitManager (void)
{
  CCockpitManager *rc = NULL;

  if (pAirplane) {
    rc = pAirplane->pit;
  }

  return rc;
}


Tag CAirplaneObject::GetPanel (void)
{
  return pAirplane->pit->GetPanel ();
}


void CAirplaneObject::SetPanel (Tag tag)
{
  pAirplane->pit->SetPanel (tag);
}


void CAirplaneObject::DrawPanel (void)
{
  pAirplane->pit->Draw ();
}


//
// CHelicopterObject
//

CHelicopterObject::CHelicopterObject (void)
{
  type = TYPE_FLY_HELICOPTER;
  strcpy (nfoFilename, "");
  pHelicopter = NULL;
}

CHelicopterObject::~CHelicopterObject (void)
{
  if (pHelicopter != NULL) delete pHelicopter;
}

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

  switch (tag) {
  case '_NFO':
    // Helicopter Info (.NFO) file
    ReadString (nfoFilename, sizeof(nfoFilename), stream);
    rc = TAG_READ;
    break;
  }

  if (rc != TAG_READ) {
    // Allow parent class to process the tag
    rc = CVehicleObject::Read (stream, tag);
  }

  return rc;
}

Documentation generated by