Utility.h

Go to the documentation of this file.

/*
 * Utility.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 UTILITY_H
#define UTILITY_H

#include "FlyLegacy.h"


//
// Various constants
//
#define MILES_PER_NM      (1.151)
#define KM_PER_NM         (1.852)
#define METRES_PER_FOOT   (0.3048)
#define FEET_PER_NM       (6076.0)
#define PI                (3.1415926)
#define DEG2RAD           (PI / 180.0)
#define RAD2DEG           (180.0 / PI)
#define FEET_PER_MILE     (5280.0)
#define FEET_PER_METRE    (3.2808399)

// Assume polar circumference of 24,818 statue miles
#define POLAR_CIRCUMFERENCE       (double)(1.3104211E+08)
#define FEET_PER_LAT_ARCSEC       (double)(1.0111274E+02)

// Assume equator circumference of 24,900 statue miles
#define EQUATORIAL_CIRCUMFERENCE    (double)(1.3147339E+08)

// Artificial "mean" circumference of 21,600 nautical miles
#define MEAN_CIRCUMFERENCE          (FEET_PER_NM * 21600)



/*
 * Utility\Geodesy.cpp functions
 */

//
// Convert an SPosition from geocentric to (WGS84) geodetic systems
//
SPosition GeocToGeod (SPosition);

//
// Convert an SPosition from WGS84 geodetic to geocentric systems
//
SPosition GeodToGeoc (SPosition);

//
// Convert a geocentric SPosition (lat,lon,alt) to cartesian coordinates
//   in an SVector struct
//
SVector GeocToCartesian (SPosition);

//
// Convert cartesian coordinates to a geocentric SPosition
//
SPosition CartesianToGeoc (SVector);

//
// Convert a geodetic SPosition (lat,lon,alt) to cartesian coordinates
//   in an SVector struct
//
SVector GeodToCartesian (SPosition);

//
// Convert cartesian coordinates to a geodetic SPosition
//
SPosition CartesianToGeod (SVector);



void test_geodesy (void);



//
// Calculate great circle distance between two positions based on spherical
//   geocentric coordinates
//

//
// Calculate great circle distance between two positions based on WGS84
//   geodetic coordinates
//
float GreatCircleDistance(SPosition *from, SPosition *to);


//
// Calculate a WGS84 geodetic position based on a starting position (also
//   in WGS84 geodetic coordinates, and an azimuth/range specified in
//   the SVector argument.  The 'h' heading (radians, 0 = true north)
//   and 'r' range (in feet) are the only fields used
//
SPosition GreatCirclePosition(SPosition *from, SVector *polar);


//
// Calculate the azimuth bearing (in radians, 0 = true north) and
//   range (in feet) between two positions in WGS84 geodetic coordinates
SVector GreatCirclePolar(SPosition *from, SPosition *to);


//
// Simple vector addition
//
SVector VectorSum (SVector v1, SVector v2);

//
// Simple vector subtraction
//
SVector VectorDifference (SVector v1, SVector v2);

//
// Utility\Math.cpp functions
//
double  WrapTwoPi (double rad);
double  WrapPi (double rad);
double  Wrap360 (double deg);
int     Wrap360 (int deg);
double  Wrap180 (double deg);
float Wrap24 (float hrs);
float Wrap60 (float min);
double FeetPerLonArcsec (double lat);

//
// AddVector computes a new global position based on a starting position (lat/lon/alt)
//   and an offset vector.  This function uses a fast, simple approximation and
//   should only be used for relatively short distances (less than a couple of miles).
//   For long distances, use the GreatCircle... functions.
//
//    x = East/West offset in feet, East is positive
//    y = Altitude offset in feet, Up is positive
//    z = North/South offset in feet, North is positive
//

SPosition AddVector(SPosition &from, SVector &v);

//
// SubtractVector computes a new global position based on a starting position
//   and an offset vector.  This is essentially the same as AddVector except
//   the distances are inverted (i.e. an argument to AddVector of +20 feet
//   is equivalent to the same argument to SubtractVector of -20 feet).
//
SPosition SubtractVector(SPosition &from, SVector &v);

//
// SubtractPosition computes the vector offset between two globe positions.
//   See "AddVector" for details on the result.
//
SVector SubtractPosition(SPosition &from, SPosition &to);


float NmToMi (float nm);
float MiToNm (float mi);
float FeetToNm (float feet);
float NmToFeet (float nm);
float FpsToKt (float fps);

double  FeetToMetres (double ft);
double  MetresToFeet (double m);
float KmToNm (float km);
float NmToKm (float nm);

float RadToDeg (float rad);
double  RadToDeg (double rad);
float DegToRad (float deg);
double  DegToRad (double deg);

char *TagString (char* s, Tag tag);
Tag   StringToTag (const char* s);
void  TagToString (char* s, Tag tag);

void FormatPosition (SPosition pos, char* s);
void FormatRADec (double ra, double dec, char* s);
void FormatSiderealTime (double st, char *s);

void TrimTrailingWhitespace (char* s);


//
// Utility\Messaging.cpp
//
EMessageResult SendMessage (SMessage *msg);


//
// Utility\Scenery.cpp functions
//

//
// The following struct is used to represent CIE chrominance/luminance data
//   triplets, either Yxy or XYZ forms
//
typedef struct {
  union {
    struct {
      float Y;
      float x;
      float y;
    } Yxy;
    struct {
      float X;
      float Y;
      float Z;
    } XYZ;
  };
} SCIE;


//
// Convert CIE Yxy triplet to CIE XYZ
//
// Input parameters:
//  Y CIE Yxy luminance Y value   [0..100]
//  x CIE Yxy chrominance x value   [0..1]
//  y CIE Yxy chrominance y value   [0..1]
//
void CIE_Yxy_to_XYZ (SCIE in, SCIE &out);

//
// Convert CIE XYZ triplet to RGB colour using the D65 white point.
//
void CIE_XYZ_to_RGB_D65 (SCIE XYZ, sgdVec3 &RGB);


//
// Convert lat/lon into globe tile
//
// Arguments:
//  latArg
//    Latitude is specified as decimal value in the range [-90.0, +90.0]
//      as degrees North (+) or South (-) of the Equator.  The Fly! scenery
//      system does not model extreme latitudes north or south of approx.
//      85 degrees.
//
//  lonArg
//    Longitude is specified as decimal value in the range [-180.0, 180.0]
//      as degrees East (+) or West (-) of the Prime Meridian.  Some sample
//      (approximate) longitude values:
//
//  iLatGlobe, iLonGlobe
//    Globe tile indexes
//
// Return code:
//  bool
//    Indicates success or failure of the conversion.  If the function
//    returns false then the contents of the tile argument are undefined.
//
void init_globe_tile_table ();
void lat_lon_to_qgt (double latArg, double lonArg, int &x, int &z);
void lat_lon_to_globe_tile (double latArg, double lonArg, int &x, int &z);

void qgt_lon_bounds (int x, double &w, double &e);
void qgt_lat_bounds (int z, double &s, double &n);
void globe_tile_lon_bounds (int x, double &w, double &e);
void globe_tile_lat_bounds (int z, double &s, double &n);

void qgt_position (SPosition pos, int &qx, int &qz, double &x, double &z);
void delta_qgt (SPosition pos, int rx, int rz, double &x, double &z);

float TerrainScale (SPosition pos);
float GlobeTileDistance (void);
SVector PosToFlatCartesian (SPosition pos, int gx, int gz);
SVector PosToFlatCartesian (SPosition pos);
SVector PosToScaledFlatCartesian (SPosition pos);
SVector PosToFlatCartesianQgt (SPosition pos, int x, int z);
SVector PosToFlatCartesianQgt (SPosition pos);
SVector PosToScaledFlatCartesianQgt (SPosition pos);

//
// CImageTIFF
//
// Implemented in Utility/ImageTIFF.cpp
//
class CImageTIFF {
public:
  // Constructor/Destructor
  CImageTIFF (const char* tifFilename);
  ~CImageTIFF (void);

  // CImageTIFF methods
  int         GetWidth (void);
  int         GetHeight (void);
  GLuint      CreateTexture (bool mipmap);

protected:
  char      name[64];
  int       width, height, depth;
  GLubyte   *image;
  GLuint    texid;
};


//
// CMaskImage
//
// Implemented in Utility\RawImage.cpp
//
class CMaskImage {
public:
  // Constructor/Destructor
  CMaskImage (int width, int height);
  CMaskImage (int width, int height, const GLubyte *data);
  CMaskImage (int width, int height, const char* rawFilename);
  CMaskImage (const CMaskImage &src);
  ~CMaskImage (void);

  // CMaskImage methods
  int     GetWidth (void);
  int     GetHeight (void);

  // void   MaskPoint (int x, int y);
  // void   MaskLine (int x1, int y1, int x2, int y2);
  // void   MaskPolygon (int nPoints, int* data);

public:
  char      name[64];
  int       width, height;
  GLubyte   *rawdata;
};


//
// CRawImage
//
// Implemented in RawImage.cpp
//
class CRawImage {
public:
  // Constructor/Destructor
  CRawImage (const char* rawFilename,
             const char* actFilename = NULL,
             const char* opaFilename = NULL);
  CRawImage (int width,
             int height,
             const char* rawFilename,
             const char* actFilename = NULL,
             const char* opaFilename = NULL);
  CRawImage (const CRawImage &src);
  ~CRawImage (void);

  // CRawImage methods
  void      Init (void);
  void      Load (const char* rawFilename,
                  const char* actFilename,
                  const char* opaFilename = NULL);
  int       GetWidth (void);
  int       GetHeight (void);
  void      SetName (const char* name);
  void      CreateTransferMaps (void);
  GLubyte*  GetRGBImageData (void);
  GLubyte*  GetRGBAImageData (void);

  void      Copy (const CRawImage &src);
  void      CopyMasked (const CRawImage *src, const CMaskImage *mask);
  void      Merge (const CRawImage *raw, const CMaskImage *mask, int actOffset);
  void      MergeTransitions (const CRawImage *bRaw, const CMaskImage *bMask,
                  const CRawImage *xRaw, const CMaskImage *xMask,
                  const CRawImage *yRaw, const CMaskImage *yMask);
  GLuint    GetTexture (bool mipmap);
  void      FreeTexture (void);

protected:
  char    name[64];
  int     width, height;
  GLubyte   *actdata;
  GLubyte   *rawdata;
  GLubyte   *opadata;
  GLuint    texid;

  GLfloat   *xferRed;
  GLfloat   *xferGreen;
  GLfloat   *xferBlue;
  GLfloat   *xferAlpha;
};


class CSunRawImage : public CRawImage {
public:
  CSunRawImage (int width,
              int height,
          const char* rawFilename,
          const char* actFilename);
};


//
// CModelBIN
//
// Implemented in Utility/ModelBIN.cpp
//
class CModelBIN {
public:
  // Constructors / Destructor
  CModelBIN (const char* binFilename);
  ~CModelBIN ();

  // CModelACM methods
  ssgEntity *GetSSGEntity (void);

protected:
  ssgBranch       *top;           // Top-level branch for entire model
  CRawImage       *rawtexture;    // Texture image (RAW/ACT file)
};


//
// CModelSMF
//
// Implemented in Utility/ModelSMF.cpp
//
class CModelSMF {
public:
  // Constructors / Destructor
  CModelSMF (const char* smfFilename);
  ~CModelSMF ();

  // CModelACM methods
  ssgEntity *GetSSGEntity (void);

protected:
  ssgTransform    *top;           // Top-level transform branch for entire model
};


//
// CModelACM
//
// Implemented in Utility/ModelACM.cpp
//
class CModelACM {
public:
  // Constructors / Destructor
  CModelACM (const char* acmFilename);
  ~CModelACM ();

  // CModelACM methods
  ssgEntity *GetSSGEntity (void);

protected:
  ssgTransform    *top;           // Top-level transform branch for entire model
  CImageTIFF      *tifftexture;   // TIFF texture image
};


//
// Surface and Bitmap utilities
//
// Implemented in Utility/Bitmaps.cpp
//
SSurface*     CreateSurface(int width, int height);
void          FreeSurface(SSurface *surface);
void          EraseSurface(SSurface *surface);
void          EraseSurfaceRGB(SSurface *surface, unsigned int rgb);
void          EraseSurfaceRGBA(SSurface *surface, unsigned int rgba);
void          DrawDot(SSurface *surface, int x, int y, unsigned int rgbColor);
void          DrawLine(SSurface *surface, int x1, int y1, int x2, int y2, unsigned int rgbColor);
void          DrawRect(SSurface *surface, int x1, int y1, int x2, int y2, unsigned int rgbColor);
void          FillRect(SSurface *surface, int x1, int y1, int x2, int y2, unsigned int rgbColor);
void          DrawCircle(SSurface *surface, int xCenter, int yCenter, int radius, unsigned int rgbColor);
unsigned int  MakeRGB(unsigned int r, unsigned int g, unsigned int b);
unsigned int  MakeRGBA(unsigned int r, unsigned int g, unsigned int b, unsigned int a);
void          UnmakeRGB (unsigned int rgb, unsigned int *r, unsigned int *g, unsigned int *b);
void          Blit (SSurface *surface);
void          BlitTransparent (SSurface *surface, unsigned int rgbTransparentColor);
GLuint        TextureFromSurface (SSurface *s, bool mipmap);

int           LoadBitmap(SBitmap *bm);
void          DrawBitmap(SSurface *surface, SBitmap *bm, int x, int y, int frame);
void          DrawBitmapPartial (SSurface *surface, SBitmap *bm, int dx, int dy, int sx1, int sy1, int sx2, int sy2, int frame);
void          GetBitmapSize(SBitmap *bm, int *xSize, int *ySize);
int           NumBitmapFrames(SBitmap *bm);
void          FreeBitmap(SBitmap *bm);


//
// Font utilities
//
// Implemented in Utility/Fonts.cpp
//
int LoadFont (SFont *font);
void FreeFont (SFont *font);
void DrawChar (SSurface *surface, SFont *font,
               int x, int y, unsigned int rgbColour,
               char ascii);
void DrawText (SSurface *surface, SFont *font,
               int x, int y, unsigned int rgbColour,
               const char* text);
void DrawTextC (SSurface *surface, SFont *font,
                int x, int y, unsigned int rgbColour,
                const char* text);
void DrawTextR (SSurface *surface, SFont *font,
                int x, int y, unsigned int rgbColour,
                const char* text);
int TextHeight(SFont *font, const char *text);
int TextWidth(SFont *font, const char *text);
int CharHeight(SFont *font, char c);
int CharWidth(SFont *font, char c);
int MaxCharHeight(SFont *font);
int MaxCharWidth(SFont *font);


//
// CDataMap
//
// Data mappings are common objects in stream files.  They use one of a number
//   of techniques to map one float value (x) to another (y).
//
// Implemented in BaseObjects.cpp


class CDataLookup {
public:
  virtual float Lookup (float x) = 0;
};

class CDataMap : public CDataLookup, public CStreamObject {
public:
  // Constructors / destructor
  CDataMap (void);

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

  // CDataLookup methods
  float Lookup (float x);

protected:
  CDataLookup     *dataSource;
};


#endif // UTILITY_H

Documentation generated by