Cameras.h

Go to the documentation of this file.

/*
 * Cameras.h
 *
 * 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
 *
 */

#ifndef CAMERAS_H_
#define CAMERAS_H_


#include "FlyLegacy.h"
#include <map>


//
// Abstract class common to all cameras.  All subclasses must implement the
//   mandatory UpdateCamera method
//
class CCamera : public CStreamObject {
public:
  // Constructors
  CCamera (void);
  virtual ~CCamera (void) {}

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag)
  {
    return TAG_IGNORED;
  }

  // CCamera methods

  //
  // The Activate() method is called when a specific camera instance is
  //   activated by the CCameraManager
  //
//  virtual void  Activate (void) = 0;

  // UpdateCamera is a pure virtual method and therefore must be implemented by
  //   all descended classes.  The position and orientation of the target
  //   object are supplied in the targetPosition and targetOrientation arguments;
  //   these should never be updated.  The eyePosition and eyeOrientation parameters
  //   should be updated with the camera's position and orientation.
  //
  virtual void GetCameraOffset (SVector *v);
  virtual void GetCameraOrientation (SVector *v);
  virtual void UpdateCamera (SPosition *targetPosition, SVector *targetOrientation,
                           SPosition *eyePosition, SVector *eyeOrientation,
                 const float dT);
  virtual float GetFOV (void);
  virtual Tag   GetCameraType (void) { return CAMERA_INVALID; }
  virtual void  GetCameraName (char* name, int maxLength)
  {
    strncpy (name, "Invalid Camera", maxLength);
  }
  virtual int   IsInteriorCamera (void) { return 0; }

  // Camera FOV manipulation methods.
  virtual void  ZoomRatioIn (void);
  virtual void  ZoomRatioOut (void);
  virtual void  ZoomIn (void);
  virtual void  ZoomInSlow (void);
  virtual void  ZoomInFast (void);
  virtual void  ZoomOut (void);
  virtual void  ZoomOutSlow (void);
  virtual void  ZoomOutFast (void);
  virtual void  ZoomReset (void);

  // Camera position manipulation methods.  These do nothing by default, specific
  //   camera subclasses must implement them
  virtual void  PanLeft (void) {}
  virtual void  PanRight (void) {}
  virtual void  PanUp (void) {}
  virtual void  PanDown (void) {}

  // User position methods.  These are traditionally implemented just for the
  //   cockpit camera, though there's no reason why they couldn't be implemented
  //   for external cameras as well.
  virtual void  User1 (void) {}
  virtual void  DefineUser1 (void) {}
  virtual void  User2 (void) {}
  virtual void  DefineUser2 (void) {}
  virtual void  User3 (void) {}
  virtual void  DefineUser3 (void) {}
  virtual void  User4 (void) {}
  virtual void  DefineUser4 (void) {}
  virtual void  User5 (void) {}
  virtual void  DefineUser5 (void) {}
  virtual void  User6 (void) {}
  virtual void  DefineUser6 (void) {}
  virtual void  User7 (void) {}
  virtual void  DefineUser7 (void) {}
  virtual void  User8 (void) {}
  virtual void  DefineUser8 (void) {}
  virtual void  HeadPitchUp (void) {}
  virtual void  HeadPitchDown (void) {}

protected:
  float     fov;        // Field of view in degrees
  float     h, p;       // Heading and pitch
  float     r;          // Range
  float     rmin, rmax; // Min/max range
  SVector   orientation;
};


//
// This class represents a single instance of a cockpit panel within a cockpit
//   camera definition.  Members include the unique ID tag of the panel,
//   the orientation of the eye position when that panel is active, and
//   a list of which panel ID tags are situated to the left, right, up and down
//   from the panel.
//
// Example:
//
//    <panl> ---- panel ----
//    <bgno> ---- begin ----
//      <id__> ---- id ----
//      frnt
//      <main> ---- default ----
//      <hdg_> ---- heading ----
//      0.0
//      <ptch> ---- pitch ----
//      7.4
//      <pnls> ---- panels (L,R,U,D) ----
//      uplt
//      uprt
//      NONE
//      floo
//    <endo> ---- end ----
//

class CCockpitPanel : public CStreamObject {
public:
  CCockpitPanel (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

public:
  Tag     id;       // Panel ID, as specified in a PNL file
  bool    main;     // Is this the main (default) panel?
  float   hdg;      // Viewpoint heading (y-axis rotation)
  float   pitch;      // Viewpoint pitch (x-axis rotation)
  Tag     pnls[4];    // Links to IDs of other panels in cockpit
  float   ofst_x;     // Exterior render offset
  float   ofst_y;
  float   ofst_z;
  float   xscr_x;     // Exterior scroll factor
  float   xscr_y;
  int     umdl;     // Use exterior model
};



//
// Cockpit (vehicle interior) camera
//
class CCameraCockpit : public CCamera {
public:
  CCameraCockpit (void);
  virtual ~CCameraCockpit (void);

  // CStreamObject methods
  virtual int     Read (SStream *stream, Tag tag);
  virtual void    ReadFinished (void);

  // CCamera methods
  virtual void  GetCameraOffset (SVector *v);
  virtual void  GetCameraOrientation (SVector *v);
  virtual Tag   GetCameraType (void) { return CAMERA_COCKPIT; }
  virtual void  GetCameraName (char* name, int maxLength)
  {
    strncpy (name, "Cockpit Camera", maxLength);
  }
  virtual int  IsInteriorCamera (void) { return 1; }

  virtual void  PanLeft (void);
  virtual void  PanRight (void);
  virtual void  PanUp (void);
  virtual void  PanDown (void);

  virtual void  User1 (void);
  virtual void  User2 (void);
  virtual void  User3 (void);
  virtual void  User4 (void);
  virtual void  User5 (void);
  virtual void  User6 (void);
  virtual void  User7 (void);
  virtual void  User8 (void);
  virtual void  DefineUser1 (void);
  virtual void  DefineUser2 (void);
  virtual void  DefineUser3 (void);
  virtual void  DefineUser4 (void);
  virtual void  DefineUser5 (void);
  virtual void  DefineUser6 (void);
  virtual void  DefineUser7 (void);
  virtual void  DefineUser8 (void);
  virtual void  HeadPitchUp (void);
  virtual void  HeadPitchDown (void);

  // CCameraCockpit methods
  Tag       GetCockpitPanel (void);
  void      ActivateCockpitPanel (Tag tag);

private:
  CCockpitPanel*  FindCockpitPanel (Tag tag);

protected:
  // Data members
  SVector   seat_hpr;   // Orientation of cockpit seat
  SVector   seat_xyz;   // Position of cockpit seat wrt model center
  std::map<Tag,CCockpitPanel*> panl;

  // Pointer to CCockpitPanel of currently active panel
  CCockpitPanel*  pCockpitPanel;
};


//
// External spot camera
//
class CCameraSpot : public CCamera {
public:
  // Constructors/Destructors
  CCameraSpot (void);

  // CCamera methods
  virtual void GetCameraOffset (SVector *v);
  virtual void GetCameraOrientation (SVector *v);

  virtual Tag   GetCameraType (void) { return CAMERA_SPOT; }
  virtual void  GetCameraName (char* name, int maxLength)
  {
    strncpy (name, "External Camera", maxLength);
  }
  virtual int   IsInteriorCamera (void) { return 0; }

  virtual void  PanLeft (void);
  virtual void  PanRight (void);
  virtual void  PanUp (void);
  virtual void  PanDown (void);

protected:
  float     theta, phi;
};


//
// External observer camera
//
class CCameraObserver : public CCamera {
public:
  // Constructors/Destructors
  CCameraObserver (void);

  // CCamera methods
  virtual void GetCameraOffset (SVector *v);
  virtual void GetCameraOrientation (SVector *v);

  virtual Tag   GetCameraType (void) { return CAMERA_OBSERVER; }
  virtual void  GetCameraName (char* name, int maxLength)
  {
    strncpy (name, "Observer Camera", maxLength);
  }
  virtual int   IsInteriorCamera (void) { return 0; }

  virtual void  PanLeft (void);
  virtual void  PanRight (void);
  virtual void  PanUp (void);
  virtual void  PanDown (void);

protected:
  float     theta, phi;
};


//
// External fly-by camera
//
class CCameraFlyby : public CCamera {
public:
  // CCamera methods
  virtual void GetCameraOffset (SVector *v);
  virtual void GetCameraOrientation (SVector *v);

  virtual Tag   GetCameraType (void)
  {
    return CAMERA_FLYBY;
  }

  virtual void  GetCameraName (char* name, int maxLength)
  {
    strncpy (name, "Fly-by Camera", maxLength);
  }

  virtual int   IsInteriorCamera (void)
  {
    return 0; // False for exterior camera
  }


/*
  virtual void  PanLeft (void);
  virtual void  PanRight (void);
  virtual void  PanUp (void);
  virtual void  PanDown (void);
*/
};

//
// External tower camera
//
// When selected, the eyepoint for this camera is placed a the nearest
//   airport tower location.
//
class CCameraTower : public CCamera {
public:
  // CCamera methods
  virtual void GetCameraOffset (SVector *v);
  virtual void GetCameraOrientation (SVector *v);

  virtual Tag   GetCameraType (void)
  {
    return CAMERA_TOWER;
  }

  virtual void  GetCameraName (char* name, int maxLength)
  {
    strncpy (name, "Tower Camera", maxLength);
  }

  virtual int   IsInteriorCamera (void)
  {
    return 0; // False for exterior camera
  }


/*
  virtual void  PanLeft (void);
  virtual void  PanRight (void);
  virtual void  PanUp (void);
  virtual void  PanDown (void);
*/
};


//
// Overhead camera
//
// When selected, the eyepoint for this camera is placed above the aircraft
//   looking down towards the ground.
//
class CCameraOverhead : public CCamera {
public:
  virtual void GetCameraOffset (SVector *v);
  virtual void GetCameraOrientation (SVector *v);

  virtual Tag   GetCameraType (void)
  {
    return CAMERA_OVERHEAD;
  }

  virtual void  GetCameraName (char* name, int maxLength)
  {
    strncpy (name, "Overhead Camera", maxLength);
  }

  virtual int   IsInteriorCamera (void)
  {
    return 0; // False for exterior camera
  }
};


#endif // CAMERAS_H_

Documentation generated by