Sky.cpp

Go to the documentation of this file.

/*
 * Sky.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/Sky.h"
#include "../Include/Utility.h"
#include "../Include/Ui.h"
#include "../Include/TimeManager.h"
#include "../Include/Situation.h"


//
// Calculate zenith angle and azimuth for a celestial body
//
// Inputs:
//    ra    Right Ascension in radians
//    dec   Declination in radians
//    lat   Latitude, in degrees north/south of Equator
//    lon   Longitude, in degrees east of Prime Meridian
//
// Outputs:
//    za    Zenith angle, in radians
//    azm   Azimuth angle, in radians west of south
//
static void calc_zenith_azimuth_angles (double ra, double dec,
                    double lat, double lon,
                    double *theta, double *phi)
{
  // Get local sidereal time in decimal hours, convert to radians
  double lst = globals->timemgr->GetLocalSiderealTime (lon * 3600);
  lst = SGD_TWO * SGD_PI * lst / 24.0;

  // Calculate local hour angle in radians
  double lha = lst - ra;

  // Convert latitude to radians
  double latrad = DegToRad (lat);

  // Calculate zenith angle theta
  double thetaFactor1 = sin(latrad)*sin(dec);
  double thetaFactor2 = cos(latrad)*cos(dec)*cos(lha);
  double thetaArg = thetaFactor1 + thetaFactor2;
  *theta = WrapTwoPi ((SGD_PI / 2.0) - asin (thetaArg));

  double phiArgY = -cos(dec)*sin(lha);
  double phiArgX = cos(latrad)*sin(dec) - sin(latrad)*cos(dec)*cos(lha);
  *phi = WrapTwoPi (atan2 (phiArgY, phiArgX));
}




CSkyManager::CSkyManager (void)
{
  // Initialize darkness phase
  old_phase = PHASE_INVALID;

  // Instantiate SSG tree entities
  pre_root = new ssgRoot;
  pre_root->setName ("Sky Predraw Root");

  pre_transform = new ssgTransform;
  pre_transform->setName ("Top Transform");

  // Instantiate and initialize sky lighting model
  skylight = new CSkyLight ();
  skylight->Init ();

  // Initialize effective visibility to 60 miles
  effective_visibility = 60.0 * 5280.0;

  // Instantiate ephemeris classes for sun, moon and planets
  moon = new CMoon ();
  sol = new CSol ();
  mercury = new CMercury ();
  venus = new CVenus ();
  mars = new CMars ();
  jupiter = new CJupiter ();
  saturn = new CSaturn ();

//  skyDistance = 1.0E+6;
  skyDistance = effective_visibility;

  // Instantiate sky dome
  domeimage = new CSkyDomeImage (skyDistance);
  domeimage->Repaint (0.0, 0.0);
  pre_transform->addKid (domeimage->GetSSGEntity ());

  // Instantiate star images
  starimage = new CStarImages (skyDistance);
  pre_transform->addKid (starimage->GetSSGEntity ());

  // Instantiate Mercury image
  mercuryimage = new CMercuryImage ();
  pre_transform->addKid (mercuryimage->GetSSGEntity ());

  // Instantiate Venus image
  venusimage = new CVenusImage ();
  pre_transform->addKid (venusimage->GetSSGEntity ());

  // Instantiate Mars image
  marsimage = new CMarsImage ();
  pre_transform->addKid (marsimage->GetSSGEntity ());

  // Instantiate Jupiter image
  jupiterimage = new CJupiterImage ();
  pre_transform->addKid (jupiterimage->GetSSGEntity ());

  // Instantiate Saturn image
  saturnimage = new CSaturnImage ();
  pre_transform->addKid (saturnimage->GetSSGEntity ());

  // Instantiate moon image.  Image "size" and "distance" are tweaked to adjust
  //   the size of the moon orb in the sky
  moonimage = new CMoonImage (skyDistance);
  moonimage->Repaint (PI/2, 0.0);
//  pre_transform->addKid (moonimage->GetSSGEntity ());

/*
 * Sol image removed from sky scene 2005-Mar-6.

  // Instantiate Sol image.  Image "size" and "distance" are tweaked to adjust
  //   the size of the sun in the sky
  char *tag3 = new char[32];
  strcpy (tag3, "solimage start");
  solimage = new CSolImage (skyDistance);
  solimage->Repaint (PI/2);
  pre_transform->addKid (solimage->GetSSGEntity ());
  char *tag4 = new char[32];
  strcpy (tag4, "solimage End");

  *
  */

  // Link everything up to the root node
  pre_root->addKid (pre_transform);
}

CSkyManager::~CSkyManager (void)
{
  pre_root->removeAllKids();
  delete pre_root;

  delete skylight;
  delete domeimage;
  delete starimage;
  delete mercuryimage;
  delete venusimage;
  delete marsimage;
  delete jupiterimage;
  delete saturnimage;
  delete moonimage;
//  delete solimage;

  delete moon;
  delete sol;
  delete mercury;
  delete venus;
  delete mars;
  delete jupiter;
  delete saturn;
}


//
// This function returns the limiting visual magnitude based on the sun's elevation.
//
static EDarkPhase limitingMagnitude (double solTheta, float *limit, float *factor)
{
  
  EDarkPhase phase = PHASE_DEEP_NIGHT;

  // Calculate phase of darkness based on sun elevation
  double solElevation = 90 - RadToDeg (solTheta);
/*
  if (solElevation < -18.0) {
    // Deep night
    phase = PHASE_DEEP_NIGHT;
        *factor = 1.0;
        *limit = 6.5;
  } else if (solElevation < -12.0) {
    // Night
    phase = PHASE_NIGHT;
        *factor = 1.0;
        *limit = 5.5;
  } else if (solElevation <  -6.0) {
    // Late Dusk
    phase = PHASE_LATE_DUSK;
        *factor = 0.95;
        *limit = 3.5;
  } else if (solElevation < -3.0) {
    // Dusk
    phase = PHASE_DUSK;
        *factor = 0.9;
        *limit = 2.0;
  } else if (solElevation < -1.5) {
    // Early Dusk
    phase = PHASE_EARLY_DUSK;
        *factor = 0.85;
        *limit = 1.0;
  } else if (solElevation < 0.0) {
    // Late Twilight
    phase = PHASE_LATE_TWILIGHT;
        *factor = 0.8;
        *limit = 0.5;
  } else if (solElevation < 0.5) {
    // Early Twilight
    phase = PHASE_EARLY_TWILIGHT;
        *factor = 0.75;
    *limit = 0.2;
  } else {
    // Daylight
    phase = PHASE_DAYLIGHT;
        *factor = 0.7;
    *limit = 0.0;
  }
*/

  // Experimental star limit/factor
  if (solElevation > 0) {
    // Sun is above horizon
    float f = (90.0 - solElevation) / 90.0;
    *limit = -10 + (10.5 * f);
    *factor = 0.7 * f;
  } else if (solElevation > -18.0) {
    // Twilight
    *limit = 0.5 + (-solElevation / 3.0);
    *factor = 0.7 + (0.3 * (-solElevation / 18.0));
  } else {
    // Astronomical night
    *limit = 6.5;
    *factor = 1.0;
  }


  // DEBUG
//  char debug[80];
//  sprintf (debug, "elevation=%7.3f  factor=%5.3f  limit=%5.3f", 
//    solElevation, *factor, *limit);
//  DrawNoticeToUser (debug, 1);
  
  return phase;
}


void CSkyManager::Update (float dT)
{
  SPosition eyePos = globals->sit->GetUserVehicle()->GetPosition ();
  double mjd = globals->timemgr->GetModifiedJulianDate ();
  double lst = globals->timemgr->GetLocalSiderealTime(eyePos.lon);

  // Convert camera eye position to cartesian coordinates
  SVector v;
  v = GeodToCartesian (eyePos);
  sgVec3 p;
  sgSetVec3 (p, v.x, v.y, v.z);

  // Make translation matrix for eye altitude
  sgVec3 t;
  sgSetVec3 (t, 0, 0, -eyePos.alt);
  sgMat4 TRANSLATE;
  sgMakeTransMat4 (TRANSLATE, t);
  pre_transform->setTransform (TRANSLATE);

  // Convert latitude and longitude to degrees for sky object repositioning
  double lat = eyePos.lat / 3600;
  double lon = eyePos.lon / 3600;

  // Update sky lighting model
  skylight->Update ();


  // Update ephemeris calculations for sun.  This needs to be done first since
  //   the sun elevation is needed to update the other celestial objects
  sol->UpdatePosition (mjd);

  // Update ephemeris calculations for other celestial objects
  moon->UpdatePosition (mjd, lst, lat, sol);

  mercury->UpdatePosition (mjd, sol);
  venus->UpdatePosition (mjd, sol);
  mars->UpdatePosition (mjd, sol);
  jupiter->UpdatePosition (mjd, sol);
  saturn->UpdatePosition (mjd, sol);

  // Get solar zenith and azimuth angles
  double solTheta, solPhi;
  calc_zenith_azimuth_angles (sol->GetRightAscension(), sol->GetDeclination(),
                              lat, lon,
                              &solTheta, &solPhi);

  double moonTheta, moonPhi;
  calc_zenith_azimuth_angles (moon->GetRightAscension(), moon->GetDeclination(),
                              lat, lon,
                              &moonTheta, &moonPhi);

  // DEBUG
//  char debug[80];
//  sprintf (debug, "solTheta=%7.3f deg, solPhi=%7.3f deg",
//    RadToDeg (solTheta), RadToDeg (solPhi));
//  DrawNoticeToUser (debug, 1);

  // Update appearance and position of sky dome
  domeimage->Repaint (solTheta, solPhi);
  domeimage->Reposition (solPhi);

  // Update appearance and position of Sol
//  solimage->Repaint (solTheta);
//  solimage->Reposition (p, lst, lat,
//                      sol->GetRightAscension(), sol->GetDeclination(),
//                      skyDistance);

  // Update appearance and position of the Moon
  moonimage->Repaint (moonTheta, moon->GetAge ());
  moonimage->Reposition (p, moonTheta, lst, lat,
                       moon->GetRightAscension(), moon->GetDeclination(), 0,
                       skyDistance);

  // Determine limiting magnitude and ambient light factor for night sky objects
  float limit, factor;
  float limitLastUpdate = 10.0;
//  EDarkPhase phase = limitingMagnitude (solTheta, &limit, &factor);
  limitingMagnitude (solTheta, &limit, &factor);

  // If the limiting magnitude has changed by more than the preset value, repaint
  //   the stars and planets
//  if (phase != old_phase) {
  if (fabs (limitLastUpdate - limit) > 0.1) {
    limitLastUpdate = limit;
    // Update appearance for all planets
    mercuryimage->Repaint (mercury->GetMagnitude (), limit, factor);
    venusimage->Repaint (venus->GetMagnitude(), limit, factor);
    marsimage->Repaint (mars->GetMagnitude(), limit, factor);
    jupiterimage->Repaint (jupiter->GetMagnitude(), limit, factor);
    saturnimage->Repaint (saturn->GetMagnitude(), limit, factor);

    // Update appearance for all stars
    starimage->Repaint (limit, factor);
  }

  // Update positions of all planets
  mercuryimage->Reposition (p, lst, lat,
                            mercury->GetRightAscension(), mercury->GetDeclination(),
                            skyDistance);
  venusimage->Reposition (p, lst, lat,
                          venus->GetRightAscension(), venus->GetDeclination(),
                          skyDistance);
  marsimage->Reposition (p, lst, lat,
                         mars->GetRightAscension(), mars->GetDeclination(),
                         skyDistance);
  jupiterimage->Reposition (p, lst, lat,
                            jupiter->GetRightAscension(), jupiter->GetDeclination(),
                            skyDistance);
  saturnimage->Reposition (p, lst, lat,
                           saturn->GetRightAscension(), saturn->GetDeclination(),
                           skyDistance);

  // Update positions of stars
  starimage->Reposition (p, lon, lat, lst);
}

void CSkyManager::SetCamera (SPosition pos, SVector orient)
{
  sgVec3 eye, lookat, up;
  sgSetVec3 (eye, 0, 0, 0);

  float x_lookat = sin(-orient.h) * cos(orient.p);
  float y_lookat = cos (-orient.h) * cos(orient.p);
  float z_lookat = -sin(orient.p);
  sgSetVec3 (lookat, x_lookat, y_lookat, z_lookat);

  float x_up = 0;
  float y_up = 0;
  float z_up = 1;
  sgSetVec3 (up, x_up, y_up, z_up);

  // DEBUG
//  char debug[80];
//  sprintf (debug, "x=%7.3f y=%7.3f z=%7.3f  up x=%7.3f y=%7.3f z=%7.3f",
//    x_lookat, y_lookat, z_lookat, x_up, y_up, z_up);
//  DrawNoticeToUser (debug, 1);

  ssgSetCameraLookAt (eye, lookat, up);

  // Set field of view and near/far clipping planes
  ssgSetNearFar (1.0E+5, 1.0E+9);
}

void CSkyManager::PreDraw (void)
{
  // Special skay drawing GL commands
  glPushAttrib (GL_ENABLE_BIT);
  glDisable (GL_DEPTH_TEST);

  // Draw sky root
  ssgCullAndDraw (pre_root);

  glPopAttrib ();
}


//
// Dump the contents of the CSkyManager class to a file for debugging
//
void CSkyManager::Print (FILE *f)
{
  //
  // Sky dome shading parameter sets
  //
  domeimage->Print (f);

  //
  // Ephemeris data for the sun moon and planes
  //
  fprintf (f, "Ephemeris Data:\n");

  double mjd = globals->timemgr->GetModifiedJulianDate ();
  fprintf (f, "MJD      : %f\n", mjd);

  SDateTime dt = globals->timemgr->GetUTCDateTime ();
  fprintf (f, "UTC Date : %04d/%02d/%02d \n", dt.date.year + 1900, dt.date.month, dt.date.day);
  fprintf (f, "UTC Time : %02d:%02d:%02d.%03d\n",
    dt.time.hour, dt.time.minute, dt.time.second, dt.time.msecs);

  fprintf (f, "                  RA               Dec\n");
  char radec[64];
  FormatRADec (sol->GetRightAscension(), sol->GetDeclination(), radec);
  fprintf (f, "Sun:      %s\n", radec);

  FormatRADec (moon->GetRightAscension(), moon->GetDeclination(), radec);
  fprintf (f, "Moon:     %s\n", radec);

  FormatRADec (mercury->GetRightAscension(), mercury->GetDeclination(), radec);
  fprintf (f, "Mercury:  %s\n", radec);

  FormatRADec (venus->GetRightAscension(), venus->GetDeclination(), radec);
  fprintf (f, "Venus:    %s\n", radec);

  FormatRADec (mars->GetRightAscension(), mars->GetDeclination(), radec);
  fprintf (f, "Mars:     %s\n", radec);

  FormatRADec (jupiter->GetRightAscension(), jupiter->GetDeclination(), radec);
  fprintf (f, "Jupiter:  %s\n", radec);

  FormatRADec (saturn->GetRightAscension(), saturn->GetDeclination(), radec);
  fprintf (f, "Saturn:   %8s\n", radec);

  //
  // SSG tree
  //
  fprintf (f, "\n");
  fprintf (f, "Sky SSG Tree:\n");
  pre_root->print (f, " ", 4);
  fprintf (f, "\n");
}

Documentation generated by