Cameras.cpp

Go to the documentation of this file.

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

using namespace std;


//
// CCamera base class methods
//
CCamera::CCamera (void)
{
  fov = 60; // Degrees
  r = 50;   // Feet?

  // Set min/max bounds for range
  
  rmin = 50;
  rmax = 500;

  // Initialize heading, pitch
  h = p = 0;
}


inline float CCamera::GetFOV (void)
{
  return fov;
}

//
// Decrease camera FOV by 5 degrees
//
void CCamera::ZoomRatioIn (void)
{
  fov -= 5;
  if (fov < 20) fov = 20;
}

//
// Increase camera FOV by 5 degrees
//
void CCamera::ZoomRatioOut (void)
{
  fov += 5;
  if (fov > 90) fov = 90;
}


//
// Zoom in by 10% of current range
//
void CCamera::ZoomIn (void)
{
  r /= 1.10;
  if (r < rmin) r = rmin;
}

//
// Zoom in by 5% of current range
//
void CCamera::ZoomInSlow (void)
{
  r /= 1.05;
  if (r < rmin) r = rmin;
}

//
// Zoom in by 25% of current range
//
void CCamera::ZoomInFast (void)
{
  r /= 1.25;
  if (r < rmin) r = rmin;
}

//
// Zoom out by 10% of current range
//
void CCamera::ZoomOut (void)
{
  r *= 1.10;
  if (r > rmax) r = rmax;
}

//
// Zoom out by 5% of current range
//
void CCamera::ZoomOutSlow (void)
{
  r *= 1.05;
  if (r > rmax) r = rmax;
}

//
// Zoom out by 25% of current range
//
void CCamera::ZoomOutFast (void)
{
  r *= 1.25;
  if (r > rmax) r = rmax;
}


//
// Reset zoom range to default
//
void CCamera::ZoomReset (void)
{
  r = 50;   // Feet
}

//
// Calculate offset of camera from target origin
//
void CCamera::GetCameraOffset (SVector *v)
{
  v->x = r;
  v->y = 0;
  v->z = r;
}


//
// Calculate Euler angle orientation of camera
//
void CCamera::GetCameraOrientation (SVector *v)
{
  v->h = h;
  v->p = p;
  v->r = r;
}

void CCamera::UpdateCamera (SPosition *targetPosition, SVector *targetOrientation,
                            SPosition *eyePosition, SVector *eyeOrientation,
                            const float dT)
{
  // Get offset, add to target position
  SVector v;
  GetCameraOffset (&v);
  *eyePosition = AddVector (*targetPosition, v);

  // Get orientation, add to target orientation
  SVector orient;
  GetCameraOrientation (&orient);
  eyeOrientation->h = WrapTwoPi (targetOrientation->h + orient.h);
  eyeOrientation->p = WrapTwoPi (targetOrientation->p + orient.p);
  eyeOrientation->r = WrapTwoPi (targetOrientation->r + orient.r);
}


/*
 * CCockpitPanel class represents one node in the graph of interconnected
 *   cockpit panels encapsulated within the CCockpitCamera object.
 *
 * Each node is identified by the unique panel ID (which is passed to
 *   CCockpitManager to activate the current panel) and the IDs of
 *   the four panels to the left, right, up and down.
 */

typedef enum {
  PANEL_LEFT    = 0,
  PANEL_RIGHT   = 1,
  PANEL_UP      = 2,
  PANEL_DOWN    = 3
} EPanelScrollDirection;


CCockpitPanel::CCockpitPanel (void) :
  id (0),
  main (false),
  hdg (0.0f),
  pitch (0.0f)
{
  pnls[0] = pnls[1] = pnls[2] = pnls[3] = StringToTag ("NONE");
  ofst_x = ofst_y = ofst_z = 0;
  xscr_x = xscr_y = 0;
  umdl = 0;
}

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

  switch (tag) {
  case 'id__':
    ReadTag (&id, stream);
    rc = TAG_READ;
    break;

  case 'main':
    main = true;
    rc = TAG_READ;
    break;

  case 'hdg_':
    ReadFloat (&hdg, stream);
    rc = TAG_READ;
    break;

  case 'ptch':
    ReadFloat (&pitch, stream);
    rc = TAG_READ;
    break;

  case 'pnls':
    // Read four panel ID tags corresponding to the panels to the L, R, U and D
    ReadTag (&pnls[0], stream);
    ReadTag (&pnls[1], stream);
    ReadTag (&pnls[2], stream);
    ReadTag (&pnls[3], stream);
    rc = TAG_READ;
    break;

  case 'ofst':
    ReadFloat (&ofst_x, stream);
    ReadFloat (&ofst_y, stream);
    ReadFloat (&ofst_z, stream);
    rc = TAG_READ;
    break;

  case 'xscr':
    ReadFloat (&xscr_x, stream);
    ReadFloat (&xscr_y, stream);
    rc = TAG_READ;
    break;

  case 'umdl':
    ReadInt (&umdl, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CCockpitPanel::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// Cockpit (vehicle interior) camera
//
CCameraCockpit::CCameraCockpit (void)
{
  seat_hpr.h = seat_hpr.p = seat_hpr.r = 0;
  seat_xyz.x = seat_xyz.y = seat_xyz.z = 0;

  // Initialize active panel to none
  pCockpitPanel = NULL;
}

CCameraCockpit::~CCameraCockpit (void)
{
  // Delete panels
  map<Tag,CCockpitPanel*>::iterator iter;
  for (iter=panl.begin(); iter!=panl.end(); iter++) {
    CCockpitPanel *p = iter->second;
    delete p;
  }
}

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

  switch (tag) {
  case 'seat':
    // Read seat orientation (in degrees relative to straight ahead)
    ReadDouble (&seat_hpr.h, stream);
    ReadDouble (&seat_hpr.p, stream);
    ReadDouble (&seat_hpr.r, stream);

    // Convert orientation angles to radians
    seat_hpr.h = DegToRad (seat_hpr.h);
    seat_hpr.p = DegToRad (seat_hpr.p);
    seat_hpr.r = DegToRad (seat_hpr.r);

    // Read seat offset (in feet from model center)
    ReadDouble (&seat_xyz.x, stream);
    ReadDouble (&seat_xyz.y, stream);
    ReadDouble (&seat_xyz.z, stream);
    rc = TAG_READ;
    break;

  case 'panl':
    {
      CCockpitPanel *cock_panel = new CCockpitPanel;
      ReadFrom (cock_panel, stream);
      Tag tag = cock_panel->id;
      panl[tag] = cock_panel;
    }
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CCockpitPanel::Read : Unknown tag %s", s);
  }

  return rc;
}

void CCameraCockpit::ReadFinished (void)
{
  // Set the default panel ID to the first with the <main> tag present
  map<Tag,CCockpitPanel*>::iterator iter;
  for (iter=panl.begin(); iter!=panl.end(); iter++) {
    CCockpitPanel *p = iter->second;
    if (p->main) {
      if (pCockpitPanel == NULL) {
        // This is the first <main> panel...assign it as the default
        pCockpitPanel = p;
      } else {
        // There should be only one <main> panel, generate a warning
        globals->logWarning->Write ("CCameraCockpit : Multiple <main> panels");
      }
    }
  }
}

//
// Calculate offset of camera from target origin
//

void CCameraCockpit::GetCameraOffset (SVector *v)
{
  v->x = 0;
  v->y = 0;
  v->z = -5.0;

  // Offsets must be converted from LHS->RHS system (swap y and z coords)
//  v->x = seat_xyz.x;
//  v->y = seat_xyz.z;
//  v->z = seat_xyz.y;
}

//
// Calculate Euler angle orientation of camera
//
void CCameraCockpit::GetCameraOrientation (SVector *v)
{
  v->h = seat_hpr.h;
  v->p = seat_hpr.r;
  v->r = seat_hpr.p;
}

CCockpitPanel*  CCameraCockpit::FindCockpitPanel (Tag tag)
{
  CCockpitPanel* rc = NULL;

  map<Tag,CCockpitPanel*>::iterator iter = panl.find(tag);
  if (iter != panl.end()) {
    rc = iter->second;
  }

  return rc;
}

void CCameraCockpit::ActivateCockpitPanel (Tag tag)
{
  CCockpitPanel *p = FindCockpitPanel(tag);
  if (p != NULL) {
    pCockpitPanel = p;
    seat_hpr.h = p->hdg;
    seat_hpr.p = p->pitch;
  } else {
    globals->logWarning->Write ("CCameraCockpit::ActivateCockpitPanel : NULL cockpit panel");
  }
}

Tag  CCameraCockpit::GetCockpitPanel (void)
{
  Tag rc = 0;

  if (pCockpitPanel) rc = pCockpitPanel->id;

  return rc;
}

//
// Pan Left - switch panels to the one to the left
//
void CCameraCockpit::PanLeft (void)
{
  if (pCockpitPanel) {
    Tag tag = pCockpitPanel->pnls[PANEL_LEFT];
    if (tag != StringToTag ("NONE")) {
      ActivateCockpitPanel (tag);
    }
  }
}

//
// Pan Right - switch panels to the one to the right
//
void CCameraCockpit::PanRight (void)
{
  if (pCockpitPanel) {
    Tag tag = pCockpitPanel->pnls[PANEL_RIGHT];
    if (tag != StringToTag ("NONE")) {
      ActivateCockpitPanel (tag);
    }
  }
}

//
// Pan Up
//
void CCameraCockpit::PanUp (void)
{
  if (pCockpitPanel) {
    Tag tag = pCockpitPanel->pnls[PANEL_UP];
    if (tag != StringToTag ("NONE")) {
      ActivateCockpitPanel (tag);
    }
  }
}

//
// Pan Down
//
void CCameraCockpit::PanDown (void)
{
  if (pCockpitPanel) {
    Tag tag = pCockpitPanel->pnls[PANEL_DOWN];
    if (tag != StringToTag ("NONE")) {
      ActivateCockpitPanel (tag);
    }
  }
}

//
// User preset positions
//
void CCameraCockpit::User1 (void)
{
  DrawNoticeToUser ("User Position 1", 5);
}

void CCameraCockpit::DefineUser1 (void)
{
  DrawNoticeToUser ("Defined User Position 1", 5);
}

void CCameraCockpit::User2 (void)
{
  DrawNoticeToUser ("User Position 2", 5);
}

void CCameraCockpit::DefineUser2 (void)
{
  DrawNoticeToUser ("Defined User Position 2", 5);
}

void CCameraCockpit::User3 (void)
{
  DrawNoticeToUser ("User Position 3", 5);
}

void CCameraCockpit::DefineUser3 (void)
{
  DrawNoticeToUser ("Defined User Position 3", 5);
}

void CCameraCockpit::User4 (void)
{
  DrawNoticeToUser ("User Position 4", 5);
}

void CCameraCockpit::DefineUser4 (void)
{
  DrawNoticeToUser ("Defined User Position 4", 5);
}

void CCameraCockpit::User5 (void)
{
  DrawNoticeToUser ("User Position 5", 5);
}

void CCameraCockpit::DefineUser5 (void)
{
  DrawNoticeToUser ("Defined User Position 5", 5);
}

void CCameraCockpit::User6 (void)
{
  DrawNoticeToUser ("User Position 6", 5);
}

void CCameraCockpit::DefineUser6 (void)
{
  DrawNoticeToUser ("Defined User Position 6", 5);
}

void CCameraCockpit::User7 (void)
{
  DrawNoticeToUser ("User Position 7", 5);
}

void CCameraCockpit::DefineUser7 (void)
{
  DrawNoticeToUser ("Defined User Position 7", 5);
}

void CCameraCockpit::User8 (void)
{
  DrawNoticeToUser ("User Position 8", 5);
}

void CCameraCockpit::DefineUser8 (void)
{
  DrawNoticeToUser ("Defined User Position 8", 5);
}

void CCameraCockpit::HeadPitchUp (void)
{
  DrawNoticeToUser ("Head Up", 5);
}

void CCameraCockpit::HeadPitchDown (void)
{
  DrawNoticeToUser ("Head Down", 5);
}


//
// CCameraSpot
//
// External spot camera, fixed orientation with user vehicle
//

CCameraSpot::CCameraSpot (void)
: CCamera()
{
  theta = DegToRad (-30.0f);
  phi = DegToRad (15.0f);
}

//
// Calculate offset of camera from target origin
//
void CCameraSpot::GetCameraOffset (SVector *v)
{
  CVehicleObject *vehicle = globals->sit->GetUserVehicle();
  SVector orient = vehicle->GetOrientation();

  float camTheta = orient.h + theta;
  float camPhi = orient.p + phi;
  v->x = r * sin (camTheta) * cos (camPhi);
  v->y = -r * cos (camTheta) * cos (camPhi);
  v->z = r * sin (camPhi);
}

//
// Calculate Euler angle orientation of camera
//
void CCameraSpot::GetCameraOrientation (SVector *v)
{
  CVehicleObject *vehicle = globals->sit->GetUserVehicle();
  SVector orient = vehicle->GetOrientation();
  v->h = orient.h + theta;
  v->p = orient.p + phi;
  v->r = orient.r;
}

//
// Pan Left - rotate clockwise
//
void CCameraSpot::PanLeft (void)
{
  theta = WrapTwoPi (theta - DegToRad (1.0f));
}

//
// Pan Right - rotate counterclockwise
//
void CCameraSpot::PanRight (void)
{
  theta = WrapTwoPi (theta + DegToRad (1.0f));
}

//
// Pan Up - rotate towards top of model, clamping at 90 degrees
//
void CCameraSpot::PanUp (void)
{
  phi += DegToRad (1.0f);
  if (phi > (PI/2)) phi = PI/2;
}

//
// Pan Down - rotate towards bottom of model, clamping at 90 degrees
//
void CCameraSpot::PanDown (void)
{
  phi -= DegToRad (1.0f);
  if (phi < (-PI/2)) phi = -PI/2;
}


//
// CCameraObserver
//
// External spot camera, fixed orientation with ground
//

CCameraObserver::CCameraObserver (void)
: CCamera()
{
  theta = DegToRad (-30.0f);
  phi = DegToRad (15.0f);
}

//
// Calculate offset of camera from target origin
//
void CCameraObserver::GetCameraOffset (SVector *v)
{
  v->x = r * sin (theta) * cos (phi);
  v->y = r * sin (phi);
  v->z = -r * cos (theta) * cos (phi);
}

//
// Calculate Euler angle orientation of camera
//
void CCameraObserver::GetCameraOrientation (SVector *v)
{
  v->h = theta;
  v->p = phi;
  v->r = 0;
}

//
// Pan Left - rotate clockwise
//
void CCameraObserver::PanLeft (void)
{
  theta = WrapTwoPi (theta - DegToRad (1.0f));
}

//
// Pan Right - rotate counterclockwise
//
void CCameraObserver::PanRight (void)
{
  theta = WrapTwoPi (theta + DegToRad (1.0f));
}

//
// Pan Up - rotate towards top of model, clamping at 90 degrees
//
void CCameraObserver::PanUp (void)
{
  phi += DegToRad (1.0f);
  if (phi > (PI/2)) phi = PI/2;
}

//
// Pan Down - rotate towards bottom of model, clamping at 90 degrees
//
void CCameraObserver::PanDown (void)
{
  phi -= DegToRad (1.0f);
  if (phi < (-PI/2)) phi = -PI/2;
}


//
// Flyby Camera
//

//
// Calculate offset of camera from target origin
//
void CCameraFlyby::GetCameraOffset (SVector *v)
{
  v->x = r * 0.5;
  v->y = r;
  v->z = 0;
}


//
// Calculate Euler angle orientation of camera
//
void CCameraFlyby::GetCameraOrientation (SVector *v)
{
  v->h = 5 * PI / 4;
  v->p = 0;
  v->r = 0;
}


//
// External tower camera
//

//
// Calculate offset of camera from target origin
//
void CCameraTower::GetCameraOffset (SVector *v)
{
  v->x = r * 10;
  v->y = r * 10;
  v->z = 0;
}


//
// Calculate Euler angle orientation of camera
//
void CCameraTower::GetCameraOrientation (SVector *v)
{
  v->h = 5 * PI / 4;
  v->p = 0;
  v->r = 0;
}



//
// Overhead camera
//
// When selected, the eyepoint for this camera is placed above the aircraft
//   looking down towards the ground.
//

//
// Calculate offset of camera from target origin
//
void CCameraOverhead::GetCameraOffset (SVector *v)
{
  v->x = 0;
  v->y = 0;
  v->z = r;
}

//
// Calculate Euler angle orientation of camera
//
void CCameraOverhead::GetCameraOrientation (SVector *v)
{
  v->h = 0;
  v->p = -PI/2;
  v->r = 0;
}

Documentation generated by