Sky.h

Go to the documentation of this file.

/*
 * Sky.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 SKY_H
#define SKY_H

#include "FlyLegacy.h"
#include "Ephemeris.h"
#include "Ini.h"
#include "Utility.h"
#include <string>
#include <vector>
#include <map>


//
// CSkyLight class represents aspects of the sun and moon positions as they
//   relate to sky and terrain lighting effects.  This class is derived from
//   the FlightGear class fgLIGHT by Curt Olsen
//
class CSkyLight {
public:
  // Constructor
  CSkyLight (void);

  // CSkyLight methods
  void Init (void);
  void Update (void);

public:
  /*
   * Sun parameters
   */

  // Geocentric latitude/longitude
    double sun_gc_lon, sun_gc_lat;

  // Cartesian coordinates
  sgVec3  sunpos;

  // Sun angle, the angle between the sun and local horizontal (radians)
    double sun_angle;

  // Sun rotation, the angle between the sun's azimuth angle and due south
    double sun_rotation;

  /*
   * Moon parameters...TBD
   */

  
  /*
   * Derived lighting values
   */

  // Fog colour
  GLfloat fog_colour[4];

  // Clear sky colour
  GLfloat sky_colour[4];
};


//
// CSkyDomeImage class implements the visual model for the background sky colour.
//   The dome consists of a central vertex at the zenith and three concentric rings
//   of vertices progressively down towards the horizon.  Applications can specify
//   independent colours for the zenith, and for any azimuth point on the concentric
//   rings.
//

typedef struct {
  float A, B, C, D, E;
} SPerezCoefficients;

typedef struct {
  float A[2], B[2], C[2], D[2], E[2];
} SCoefficientParameters;

typedef struct {
  float   A, B, C, D;
} SLuminanceZenith;

typedef struct {
  float   t2[4];
  float   t1[4];
  float   t0[4];
} SChromaZenith;

typedef struct {
  char          name[64];
  SCoefficientParameters  Y_curve;
  SCoefficientParameters  x_curve;
  SCoefficientParameters  y_curve;
  SLuminanceZenith        Y_zenith;
  SChromaZenith           x_zenith;
  SChromaZenith           y_zenith;
} SPerezParameters;


#define SKYDOME_SLICES  64
#define SKYDOME_STACKS  32

class CSkyDomeImage {
public:
  CSkyDomeImage (double distance);
  ~CSkyDomeImage (void);

  // CSkyDome methods
  ssgEntity*    GetSSGEntity (void);
  void      Repaint (double solTheta, double solPhi);
  void      Reposition (double solPhi);
  void      Print (FILE *f);

protected:
//  void      InitPerezParameters (SPerezParameters* p,
//                     CIniFile *inisky,
//                     const char* name);
protected:
  // Top-level SSG entities
  ssgTransform    *top;

  // Raw vertices
  sgVec3 vtx_zenith;
  sgVec3 vtx_ring[SKYDOME_STACKS][SKYDOME_SLICES];

  // Sky dome colour buffer for use in Repaint() method
  sgVec3 rgb_zenith;
  sgVec3 rgb_dome[SKYDOME_STACKS][SKYDOME_SLICES];

  // Parameters for sky dome shading with Perez functions
  double                                  prevTheta;      // Solar zenith angle at last repaint
  SPerezParameters                        *perezCurrent;  // Current Perez parameter set
  std::map<std::string,SPerezParameters*> perez;          // Map of Perez parameter sets
};


//
// The following enum represents the various phases of darkness.
//
typedef enum {
  PHASE_INVALID     = -1,
  PHASE_DEEP_NIGHT    = 0,
  PHASE_NIGHT       = 1,
  PHASE_LATE_DUSK     = 2,
  PHASE_DUSK        = 3,
  PHASE_EARLY_DUSK    = 4,
  PHASE_LATE_TWILIGHT   = 5,
  PHASE_EARLY_TWILIGHT  = 6,
  PHASE_DAYLIGHT      = 7
} EDarkPhase;


typedef struct {
  char  name[64]; // Common name (optional)
  double  ra, dec;  // Celestial coordinates
  float mv;     // Visual magnitude
  float bv;     // B-V colour index
  int   hr;     // HR number, used to construct constellation figures
} SStarData;

typedef struct {
  char  name[64];     // Constellation name (abbreviation)
  int   star1, star2; // Line endpoints, indices into stars vector
} SConstellationLine;


//
// CStarImages class implements the visual model for all star-like objects
//   (including stars and planets) in the sky.  These are rendered as
//   single points (or small clusters of points for very bright objects)
//   with accurate colours.
//
class CStarImages {
public:
  CStarImages (double distance);
  ~CStarImages (void);

  // CStarImages methods
  ssgEntity*    GetSSGEntity (void);
  void      Repaint (float limit, float factor);
  void      Reposition (sgVec3 pos, double lon, double lat, double lst);

protected:
  void      LoadFlyDatabase (const char* dbFilename);
  void      LoadBSCDatabase (const char* bscFilename, float limit);
  void      LoadConstellations (const char* txtFilename);
  int       FindStarByHR (int hr);

protected:
  std::vector<SStarData*>          stars;          
  std::vector<SConstellationLine*> constellations; 

  // SSG tree
  ssgTransform  *top;

  ssgLeaf     *stars_leaf;
  ssgVertexArray  *stars_va;
  ssgColourArray  *stars_rgba;

  ssgLeaf     *constellations_leaf;
  ssgVertexArray  *constellations_va;
  ssgColourArray  *constellations_rgba;
};








//
// CMoonImage class implements the visual model for the moon
//
class CMoonImage {
public:
  CMoonImage (double size);
  ~CMoonImage (void);

  // CMoonImage methods
  ssgEntity*    GetSSGEntity (void);
  void      Repaint (double angle, float age);
  void      Reposition (sgVec3 p, double theta, double lst, double lat,
                double ra, double dec, double spin,
                double distance);

protected:
  // SSG tree
  ssgTransform  *top;
  ssgVtxTable   *orb;

  // Moon phase textures
  CRawImage*    texlist[17];
  int       phase;
};


//
// CSolImage class implements the visual model for Sol (our sun)
//
class CSolImage {
public:
  CSolImage (double size);
  ~CSolImage (void);

  // CSolImage methods
  GLuint  GetSunTexture (const char* filename, int w);
  void    Repaint (double angle);
  void    Reposition (sgVec3 pos, double lst, double lat, double ra, double dec, double distance);
  ssgEntity*  GetSSGEntity (void);

protected:
  // SSG tree
  ssgTransform    *top;
  ssgColourArray  *rgba;
  ssgLeaf         *orb;
  ssgLeaf         *halo;
//  ssgTransform  *orb_transform;
//  ssgState    *orb_state;

//  ssgEntity   *orb;
//  ssgColourArray  *rgba;

  // Texture layers
};


//
// CMercuryImage class implements the visual model for the planet Mercury
//
class CMercuryImage {
public:
  CMercuryImage (void);

  // CMercuryImage methods
  void    Repaint (float mv, float limit, float factor);
  void    Reposition (sgVec3 pos, double lst, double lat,
                        double ra, double dec, double distance);
  ssgEntity*  GetSSGEntity (void);

protected:
  // SSG tree
  ssgTransform  *top;

  ssgColourArray  *rgba;
  ssgVertexArray  *va;
};


//
// CVenusImage class implements the visual model for the planet Venus
//
class CVenusImage {
public:
  CVenusImage (void);

  // CVenusImage methods
  void    Repaint (float mv, float limit, float factor);
  void    Reposition (sgVec3 pos, double lst, double lat,
                        double ra, double dec, double distance);
  ssgEntity*  GetSSGEntity (void);

protected:
  // SSG tree
  ssgTransform  *top;

  ssgColourArray  *rgba;
  ssgVertexArray  *va;
};


//
// CMarsImage class implements the visual model for the planet Mars
//
class CMarsImage {
public:
  CMarsImage (void);

  // CMarsImage methods
  void    Repaint (float mv, float limit, float factor);
  void    Reposition (sgVec3 pos, double lst, double lat,
                        double ra, double dec, double distance);
  ssgEntity*  GetSSGEntity (void);

protected:
  // SSG tree
  ssgTransform  *top;

  ssgColourArray  *rgba;
  ssgVertexArray  *va;
};


//
// CJupiterImage class implements the visual model for the planet Jupiter
//
class CJupiterImage {
public:
  CJupiterImage (void);

  // CJupiterImage methods
  void    Repaint (float mv, float limit, float factor);
  void    Reposition (sgVec3 pos, double lst, double lat,
                        double ra, double dec, double distance);
  ssgEntity*  GetSSGEntity (void);

protected:
  // SSG tree
  ssgTransform  *top;

  ssgColourArray  *rgba;
  ssgVertexArray  *va;
};


//
// CSaturnImage class implements the visual model for the planet Saturn
//
class CSaturnImage {
public:
  CSaturnImage (void);

  // CSaturnImage methods
  void    Repaint (float mv, float limit, float factor);
  void    Reposition (sgVec3 pos, double lst, double lat,
                        double ra, double dec, double distance);
  ssgEntity*  GetSSGEntity (void);

protected:
  // SSG tree
  ssgTransform  *top;

  ssgColourArray  *rgba;
  ssgVertexArray  *va;
};


//
// The CSkyManager class pulls all of the previous classes together into
//   the top-level application interface to the sky visual model.
//
class CSkyManager {
public:
    CSkyManager (void);
    ~CSkyManager (void);

  // CSkyManager methods
  void      Update (float dT);
  void      SetCamera (SPosition pos, SVector orient);
  void      PreDraw (void);
  void      Print (FILE *f);

protected:
  // SSG tree
  ssgRoot     *pre_root;
  ssgSelector   *pre_selector;
  ssgTransform  *pre_transform;

  // Sky lighting model
  CSkyLight   *skylight;

  // Various sky object images
  CSkyDomeImage *domeimage;
  CStarImages   *starimage;
  CSolImage   *solimage;
  CMoonImage    *moonimage;
  CMercuryImage *mercuryimage;
  CVenusImage   *venusimage;
  CMarsImage    *marsimage;
  CJupiterImage *jupiterimage;
  CSaturnImage  *saturnimage;

  // Ephemeris calculators for the sun, moon and planets
  CSol      *sol;
  CMoon     *moon;
  CMercury    *mercury;
  CVenus      *venus;
  CMars     *mars;
  CJupiter    *jupiter;
  CSaturn     *saturn;

  // Darkness phase at last update
  EDarkPhase    old_phase;

  // Effective visibility, in feet
  float     effective_visibility;
  float     skyDistance;
};

#endif // SKY_H

Documentation generated by