StarImages.cpp

Go to the documentation of this file.

/*
 * StarImages.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"

using namespace std;

//
// Pre-draw callback for star images
//
static int star_predraw (ssgEntity *e)
{
  ssgLeaf *f = (ssgLeaf*)e;
  if (f->hasState()) f->getState()->apply();

  glPushAttrib (GL_DEPTH_BUFFER_BIT | GL_FOG_BIT | GL_POINT_BIT);
  glDisable (GL_DEPTH_TEST);
  glDisable (GL_FOG);
  glEnable (GL_POINT_SMOOTH);
  glPointSize (2.0);

  return true;
}

//
// Post-draw callback for star images
//
static int star_postdraw (ssgEntity *e)
{
  glPopAttrib ();

  return true;
}

//
// This local function finds the next token in a tab-delimited record.  
static char* getToken (const char* s, char* token, int size)
{
  // Initialize token to null string
  strcpy (token, "");

  // Get pointer to next \t delimiter
  char *p = strchr (s, '\t');
  if (p != NULL) {
    int nChars = p - s;
    if (nChars > (size-1)) nChars = (size-1);
    strncpy (token, s, nChars);
    token[nChars] = '\0';

    // Increment p to point to start of next token
    p++;
  } else {
    // Delimiter not found, copy entire string to token
    strncpy (token, s, size);
  }
  
  return p;
}

//
// This function initializes the star database from a text database in the format
//   of the default Fly! II star database (DATA\\VISFK5.TXT in Startup.POD).
//
void CStarImages::LoadFlyDatabase (const char* dbFilename)
{
  // Clear existing star database
  stars.erase (stars.begin(), stars.end());

  // Open tab-delimited text database file
  PODFILE* p = popen (&globals->pfs, dbFilename);
  if (p) {
    char s[256];

    // Skip header line
    pgets (s, 256, p);

    while (!peof(p)) {
      // Read tab-delimited data
      pgets (s, 256, p);

      // Initialize to first token (index number)
      char dummy[64];
      char *t = getToken (s, dummy, 64);
      int hr = atoi (dummy);

      // Read common name
      char name[64];
      t = getToken (t, dummy, 64);
      strcpy (name, dummy);

      // Skip FK5 index number
      t = getToken (t, dummy, 64);

      // Read right ascension (in hours) and convert to radians
      t = getToken (t, dummy, 64);
      double ra = atof (dummy);
      ra = (ra / 24.0) * SGD_PI * 2.0;

      // Read declinatin (in degrees) and convert to radians
      t = getToken (t, dummy, 64);
      double dec = atof (dummy);
      dec = DegToRad (dec);

      // Read magnitude
      t = getToken (t, dummy, 64);
      float mv = atof (dummy);

      // Store attributes in new SStar struct and add to list
      SStarData* star = new SStarData;
      strcpy (star->name, name);
      star->ra = WrapTwoPi (ra - (SGD_PI / 2));
      star->dec = dec;
      star->mv = mv;
      star->hr = hr;
      stars.push_back(star);
    }
  } else {
    gtfo ("CStarImages : Could not open Fly! II star database %s", dbFilename);
  }
}

//
// This function initializes the star database from the 5th edition
//   of the Yale Bright Star Catalog.  This database contains approx.
//   9000 stars down to magnitude +6.5.  For efficiency, only those stars with
//   visual magnitudes above the specified limit will be loaded.
//
/*

  Format of the BSC catalog data is as follows:

   1-  4  I4     ---     HR       [1/9110]+ Harvard Revised Number
                                    = Bright Star Number
   5- 14  A10    ---     Name     Name, generally Bayer and/or Flamsteed name
  15- 25  A11    ---     DM       Durchmusterung Identification (zone in
                                    bytes 17-19)
  26- 31  I6     ---     HD       [1/225300]? Henry Draper Catalog Number
  32- 37  I6     ---     SAO      [1/258997]? SAO Catalog Number
  38- 41  I4     ---     FK5      ? FK5 star Number
      42  A1     ---     IRflag   [I] I if infrared source
      43  A1     ---   r_IRflag  *[ ':] Coded reference for infrared source
      44  A1     ---    Multiple *[AWDIRS] Double or multiple-star code
  45- 49  A5     ---     ADS      Aitken's Double Star Catalog (ADS) designation
  50- 51  A2     ---     ADScomp  ADS number components
  52- 60  A9     ---     VarID    Variable star identification
  61- 62  I2     h       RAh1900  ?Hours RA, equinox B1900, epoch 1900.0 (1)
  63- 64  I2     min     RAm1900  ?Minutes RA, equinox B1900, epoch 1900.0 (1)
  65- 68  F4.1   s       RAs1900  ?Seconds RA, equinox B1900, epoch 1900.0 (1)
      69  A1     ---     DE-1900  ?Sign Dec, equinox B1900, epoch 1900.0 (1)
  70- 71  I2     deg     DEd1900  ?Degrees Dec, equinox B1900, epoch 1900.0 (1)
  72- 73  I2     arcmin  DEm1900  ?Minutes Dec, equinox B1900, epoch 1900.0 (1)
  74- 75  I2     arcsec  DEs1900  ?Seconds Dec, equinox B1900, epoch 1900.0 (1)
  76- 77  I2     h       RAh      ?Hours RA, equinox J2000, epoch 2000.0 (1)
  78- 79  I2     min     RAm      ?Minutes RA, equinox J2000, epoch 2000.0 (1)
  80- 83  F4.1   s       RAs      ?Seconds RA, equinox J2000, epoch 2000.0 (1)
      84  A1     ---     DE-      ?Sign Dec, equinox J2000, epoch 2000.0 (1)
  85- 86  I2     deg     DEd      ?Degrees Dec, equinox J2000, epoch 2000.0 (1)
  87- 88  I2     arcmin  DEm      ?Minutes Dec, equinox J2000, epoch 2000.0 (1)
  89- 90  I2     arcsec  DEs      ?Seconds Dec, equinox J2000, epoch 2000.0 (1)
  91- 96  F6.2   deg     GLON     ?Galactic longitude (1)
  97-102  F6.2   deg     GLAT     ?Galactic latitude (1)
 103-107  F5.2   mag     Vmag     ?Visual magnitude (1)
     108  A1     ---   n_Vmag    *[ HR] Visual magnitude code
     109  A1     ---   u_Vmag     [ :?] Uncertainty flag on V
 110-114  F5.2   mag     B-V      ? B-V color in the UBV system
     115  A1     ---   u_B-V      [ :?] Uncertainty flag on B-V
 116-120  F5.2   mag     U-B      ? U-B color in the UBV system
     121  A1     ---   u_U-B      [ :?] Uncertainty flag on U-B
 122-126  F5.2   mag     R-I      ? R-I   in system specified by n_R-I
     127  A1     ---   n_R-I      [CE:?D] Code for R-I system (Cousin, Eggen)
 128-147  A20    ---     SpType   Spectral type
     148  A1     ---   n_SpType   [evt] Spectral type code
 149-154  F6.3 arcsec/yr pmRA     ?Annual proper motion in RA J2000, FK5 system
 155-160  F6.3 arcsec/yr pmDE     ?Annual proper motion in Dec J2000, FK5 system
     161  A1     ---   n_Parallax [D] D indicates a dynamical parallax,
                                    otherwise a trigonometric parallax
 162-166  F5.3   arcsec  Parallax ? Trigonometric parallax (unless n_Parallax)
 167-170  I4     km/s    RadVel   ? Heliocentric Radial Velocity
 171-174  A4     ---   n_RadVel  *[V?SB123O ] Radial velocity comments
 175-176  A2     ---   l_RotVel   [<=> ] Rotational velocity limit characters
 177-179  I3     km/s    RotVel   ? Rotational velocity, v sin i
     180  A1     ---   u_RotVel   [ :v] uncertainty and variability flag on
                                    RotVel
 181-184  F4.1   mag     Dmag     ? Magnitude difference of double,
                                    or brightest multiple
 185-190  F6.1   arcsec  Sep      ? Separation of components in Dmag
                                    if occultation binary.
 191-194  A4     ---     MultID   Identifications of components in Dmag
 195-196  I2     ---     MultCnt  ? Number of components assigned to a multiple
     197  A1     ---     NoteFlag [*] a star indicates that there is a note
                                    (see file notes)
*/
void CStarImages::LoadBSCDatabase (const char* bscFilename, float limit)
{
  // Clear existing star database
  stars.erase (stars.begin(), stars.end());

  // Open Bright Star Catalog file
  PODFILE* p = popen (&globals->pfs, bscFilename);
  if (p) {
    
    // Define a buffer for each BSC record.
    char rec[512];

    while (!peof(p)) {
      // Read record
      pgets (rec, 512, p);

      // Get HR index number
      char hrString[16];
      memset (hrString, 0, 16);
      strncpy (hrString, rec, 4);
      int hr = atoi (hrString);

      // Get common name
      char name[16];
      memset (name, 0, 16);
      strncpy (name, rec+4, 10);

      // Get J2000.0 right ascension values
      char raHrs[8], raMin[8], raSec[8];
      memset (raHrs, 0, 8);
      memset (raMin, 0, 8);
      memset (raSec, 0, 8);
      strncpy (raHrs, rec+75, 2);
      strncpy (raMin, rec+77, 2);
      strncpy (raSec, rec+79, 4);

      // Convert right ascension to radians
      float rah = atof (raHrs);
      float ram = atof (raMin);
      float ras = atof (raSec);
      float ra = rah + (ram / 60.0) + (ras / 3600.0);   // RA in hours
      ra = (ra / 24.0) * 2 * SGD_PI;            // RA in radians

      // Get J2000.0 declination values
      char decDeg[8], decMin[8], decSec[8];
      memset (decDeg, 0, 8);
      memset (decMin, 0, 8);
      memset (decSec, 0, 8);
      strncpy (decDeg, rec+83, 3);
      strncpy (decMin, rec+86, 2);
      strncpy (decSec, rec+88, 2);

      // Convert declination to radians
      float decd = atof (decDeg);
      float decm = atof (decMin);
      float decs = atof (decSec);
      float dec = decd + (decm / 60.0) + (decs / 3600.0); // Dec in degrees
      dec = DegToRad (dec);               // Dec in radians

      // Get magnitude
      char mvText[8];
      memset (mvText, 0, 8);
      strncpy (mvText, rec+102, 5);
      float mv = atof (mvText);

      // Get colour (BV)
      char bvText[8];
      memset (bvText, 0, 8);
      strncpy (bvText, rec+109, 5);
      float bv = atof (bvText);

      // Check against limiting magnitude, and store this star in the database
      if (mv <= limit) {
        SStarData* star = new SStarData;
        strcpy (star->name, name);
        star->ra = WrapTwoPi (ra - (SGD_PI / 2));
        star->dec = dec;
        star->mv = mv;
        star->bv = bv;
        star->hr = hr;
        stars.push_back (star);
      }
    }

    pclose (p);
  } else {
    gtfo ("CStarImages : Could not open BSC5 database %s", bscFilename);
  }
}


//
// Load constellation stick figures.  The figures consists of a set of line
//   segments between stars.  The format of the constellation line database
//   file is:
//      1-3   C   3   Constellation abbreviation
//      4-11  I   8   HR1, first line endpoint
//      12-19 I   8   HR2, second line endpoint
//
// Since the HR index number is included in both the Fly! and BSC databases,
//   constellation figures can be displayed regardless of which database is
//   used.
//
void CStarImages::LoadConstellations (const char* txtFilename)
{
  // Clear existing star database
  constellations.erase (constellations.begin(), constellations.end());

  // Open constellation data file
  PODFILE* p = popen (&globals->pfs, txtFilename);
  if (p) {
    // Define a buffer for each record.
    char rec[512];

    while (!peof(p)) {
      // Read record
      pgets (rec, 512, p);
      TrimTrailingWhitespace (rec);

      // Skip comments lines beginning with semicolon
      if ((rec[0] == ';') || (strlen(rec) == 0)) continue;

      // Get constellation name (abbreviated)
      char name[16];
      memset (name, 0, 16);
      strncpy (name, rec, 3);

      // Get HR index for first endpoint
      char hr1String[16];
      memset (hr1String, 0, 16);
      strncpy (hr1String, rec+3, 8);
      int hr1 = atoi (hr1String);

      // Get HR index for second endpoint
      char hr2String[16];
      memset (hr2String, 0, 16);
      strncpy (hr2String, rec+11, 8);
      int hr2 = atoi (hr2String);

      // Check that both endpoint stars are in the set of loaded stars
      int star1 = FindStarByHR (hr1);
      int star2 = FindStarByHR (hr2);
      if ((star1 != 1) && (star2!= -1)) {
        // Store in the constellation database
        SConstellationLine* line = new SConstellationLine;
        strcpy (line->name, name);
        line->star1 = star1;
        line->star2 = star2;
        constellations.push_back (line);
      }
    }

    pclose (p);

  } else {
    gtfo ("CStarImages : Could not open constellation database %s", txtFilename);
  }
}



//
// This function provides a simplified mapping of a star's B-V colour index
//   to an RGB colour triplet.  The data is taken from the web page,
//   "What color are the stars?" at:
//   http://www.vendian.org/mncharity/dir3/starcolor/details.html
//

typedef struct {
  unsigned char r;
  unsigned char g;
  unsigned char b;
} SBVToRGB;


SBVToRGB bvMapping[] =
{
  {0x9b,  0xb2, 0xff},    // -0.40
  {0x9e,  0xb5, 0xff},    // -0.35
  {0xa3,  0xb9, 0xff},    // -0.30
  {0xaa,  0xbf, 0xff},    // -0.25
  {0xb2,  0xc5, 0xff},    // -0.20
  {0xbb,  0xcc, 0xff},    // -0.15
  {0xc4,  0xd2, 0xff},    // -0.10
  {0xcc,  0xd8, 0xff},    // -0.05
  {0xd3,  0xdd, 0xff},    //  0.00
  {0xda,  0xe2, 0xff},    //  0.05
  {0xdf,  0xe5, 0xff},    //  0.10
  {0xe4,  0xe9, 0xff},    //  0.15
  {0xe9,  0xec, 0xff},    //  0.20
  {0xee,  0xef, 0xff},    //  0.25
  {0xf3,  0xf2, 0xff},    //  0.30
  {0xf8,  0xf6, 0xff},    //  0.35
  {0xfe,  0xf9, 0xff},    //  0.40
  {0xff,  0xf9, 0xfb},    //  0.45
  {0xff,  0xf7, 0xf5},    //  0.50
  {0xff,  0xf5, 0xef},    //  0.55
  {0xff,  0xf3, 0xea},    //  0.60
  {0xff,  0xf1, 0xe5},    //  0.65
  {0xff,  0xef, 0xe0},    //  0.70
  {0xff,  0xed, 0xdb},    //  0.75
  {0xff,  0xeb, 0xd6},    //  0.80
  {0xff,  0xe9, 0xd2},    //  0.85
  {0xff,  0xe8, 0xce},    //  0.90
  {0xff,  0xe6, 0xca},    //  0.95
  {0xff,  0xe5, 0xc6},    //  1.00
  {0xff,  0xe3, 0xc3},    //  1.05
  {0xff,  0xe2, 0xbf},    //  1.10
  {0xff,  0xe0, 0xbb},    //  1.15
  {0xff,  0xdf, 0xb8},    //  1.20
  {0xff,  0xdd, 0xb4},    //  1.25
  {0xff,  0xdb, 0xb0},    //  1.30
  {0xff,  0xda, 0xad},    //  1.35
  {0xff,  0xd8, 0xa9},    //  1.40
  {0xff,  0xd6, 0xa5},    //  1.45
  {0xff,  0xd5, 0xa1},    //  1.50
  {0xff,  0xd2, 0x9c},    //  1.55
  {0xff,  0xd0, 0x96},    //  1.60
  {0xff,  0xcc, 0x8f},    //  1.65
  {0xff,  0xc8, 0x85},    //  1.70
  {0xff,  0xc1, 0x78},    //  1.75
  {0xff,  0xb7, 0x65},    //  1.80
  {0xff,  0xa9, 0x4b},    //  1.85
  {0xff,  0x95, 0x23},    // 1.90
  {0xff,  0x7b, 0x00},    // 1.95
  {0xff,  0x52, 0x00}   // 2.00
};

const int nMappings = sizeof(bvMapping) / sizeof(SBVToRGB);

static void bv_to_rgb (float bv, float& r, float& g, float& b)
{
  // Convert B-V colour to table index
  int i = (int)(floor (bv + 0.40) * 20.0);

  // Clamp to table bounds
  if (i < 0) i = 0;
  if (i > nMappings) i = nMappings;

  // Extract char values from mapping table and convert to float
  SBVToRGB *p = &bvMapping[i];
  r = (float)(p->r) / 255.0;
  g = (float)(p->g) / 255.0;
  b = (float)(p->b) / 255.0;
}

//
// Find the index of a star with the given HR index number.  If the HR index
//   does not exist, the function returns -1.
//
int CStarImages::FindStarByHR (int hr)
{
  int rc = -1;

  vector<SStarData*>::iterator i;
  int count = 0;
  for (i=stars.begin(); i!=stars.end(); i++, count++) {
    SStarData *s = *i;
    if (s->hr == hr) {
      // Found a match
      rc = count;
      break;
    }
  }
  return rc;
}


CStarImages::CStarImages (double distance)
{
  int i;
  
  // Construct the top-level transform
  top = new ssgTransform;

  // Get INI setting to determine format of star database to use
  char dbType[64];
  strcpy (dbType, "");
  GetIniString ("Graphics", "starDatabaseType", dbType, 64);
  if (stricmp (dbType, "FLY") == 0) {
    // Fly! II star database
    char flyDbName[64];
    strcpy (flyDbName, "DATA\\VISFK5.TXT");
    GetIniString ("Graphics", "starDatabaseName", flyDbName, 64);
    LoadFlyDatabase (flyDbName);
  } else {
    // BSC (Bright Star Catalog) database
    char bscDbName[64];
    strcpy (bscDbName, "");
    GetIniString ("Graphics", "starDatabaseName", bscDbName, 64);
    if (strlen (bscDbName) == 0) {
      strcpy (bscDbName, "SYSTEM\\BSC5.CAT");
    }

    // Get INI setting for limiting magnitude
    float limit = 0;
    GetIniFloat ("Graphics", "starLimitingMagnitude", &limit);
    if (limit == 0) {
      limit = 6.5;
    }

    LoadBSCDatabase (bscDbName, limit);
  }

  //
  // Construct SSG leaf for stars as a set of points
  //

  // Construct SSG state for drawing stars
  ssgSimpleState *stars_state = new ssgSimpleState();
  stars_state->disable( GL_LIGHTING );
  stars_state->disable( GL_CULL_FACE );
  stars_state->disable( GL_TEXTURE_2D );
  stars_state->enable( GL_COLOR_MATERIAL );
  stars_state->setColourMaterial( GL_AMBIENT_AND_DIFFUSE );
  stars_state->setMaterial( GL_EMISSION, 0, 0, 0, 1 );
  stars_state->setMaterial( GL_SPECULAR, 0, 0, 0, 1 );
  stars_state->enable( GL_BLEND );
  stars_state->disable( GL_ALPHA_TEST );

  // Allocate vertex and colour arrays
  int nStars = stars.size();
  stars_va = new ssgVertexArray (nStars);
  stars_rgba = new ssgColourArray (nStars);

  // Build ssg structure
  sgVec3 v;
  sgVec4 c;
  for (i=0; i<nStars; i++) {
    // Vertex position
    SStarData *s = stars[i];
    sgSetVec3 (v,
               distance * cos (s->ra) * cos (s->dec),
               distance * sin (s->ra) * cos (s->dec),
               distance * sin (s->dec));
    stars_va->add (v);

    // Assign RGB colour based on B-V colour index
    float r, g, b;
    bv_to_rgb (s->bv, r, g, b);
    sgSetVec4 (c, r, g, b, 1.0 );
    stars_rgba->add (c);
  }

  // Construct the leaf object for the stars and set attributes
  ssgLeaf *stars_leaf =
      new ssgVtxTable ( GL_POINTS, stars_va, NULL, NULL, stars_rgba );
  stars_leaf->setState( stars_state );
  stars_leaf->setCallback( SSG_CALLBACK_PREDRAW, star_predraw );
  stars_leaf->setCallback( SSG_CALLBACK_POSTDRAW, star_postdraw );
  top->addKid (stars_leaf);

  // Check INI setting to see if constellation figures are to be drawn
  i = 0;
  GetIniVar ("Graphics", "starShowConstellations", &i);
  if (i != 0) {
    // Get filename of constellation figures fron INI settings
    char constDbName[64];
    strcpy (constDbName, "");
    GetIniString ("Graphics", "starConstellationsName", constDbName, 64);
    if (strlen (constDbName) == 0) {
      strcpy (constDbName, "SYSTEM\\DefaultConstL.txt");
    }
    
    // Load the constellation stick figures.  This will update the class
    //   member 'constellations', a vector of star endpoints.  Only those
    //   lines that can be drawn, given the set of stars that were loaded,
    //   will be added to the vector.
    LoadConstellations (constDbName);

    // Construct SSG state for drawing constellations
    ssgSimpleState *constellations_state = new ssgSimpleState();
    constellations_state->disable( GL_LIGHTING );
    constellations_state->disable( GL_CULL_FACE );
    constellations_state->disable( GL_TEXTURE_2D );
    constellations_state->enable( GL_COLOR_MATERIAL );
    constellations_state->setColourMaterial( GL_AMBIENT_AND_DIFFUSE );
    constellations_state->setMaterial( GL_EMISSION, 0, 0, 0, 1 );
    constellations_state->setMaterial( GL_SPECULAR, 0, 0, 0, 1 );
    constellations_state->enable( GL_BLEND );
    constellations_state->disable( GL_ALPHA_TEST );

    // Allocate vertex and colour arrays
    int nLines = constellations.size();
    constellations_va = new ssgVertexArray (nLines * 2);
    constellations_rgba = new ssgColourArray (1);

    // Default constellation line colour
    sgSetVec4 (c, 1.0, 1.0, 1.0, 0.5);
    constellations_rgba->add (c);

    // Build ssg structure
    vector<SConstellationLine*>::iterator i;
    for (i=constellations.begin(); i!=constellations.end(); i++) {
      SConstellationLine *s = *i;

      // Copy each star vertex into constellation endpoint list
      float *v1 = stars_va->get (s->star1);
      float *v2 = stars_va->get (s->star2);

      sgVec3 p1, p2;
      sgCopyVec3 (p1, v1);
      sgCopyVec3 (p2, v2);

      constellations_va->add (p1);
      constellations_va->add (p2);
    
      // Construct leaf object for constellations
      ssgLeaf *constellations_leaf =
        new ssgVtxTable (GL_LINES, constellations_va, NULL, NULL, constellations_rgba);
      constellations_leaf->setState( constellations_state );
      constellations_leaf->setCallback( SSG_CALLBACK_PREDRAW, star_predraw );
      constellations_leaf->setCallback( SSG_CALLBACK_POSTDRAW, star_postdraw );
      top->addKid (constellations_leaf);
    }
  }
}

CStarImages::~CStarImages (void)
{
  vector<SStarData*>::iterator i;
  for (i=stars.begin(); i!=stars.end(); i++) delete *i;

  vector<SConstellationLine*>::iterator j;
  for (j=constellations.begin(); j!=constellations.end(); j++) delete *j;
}

//
// Return the top-level SSG entity for the star images
//
ssgEntity* CStarImages::GetSSGEntity (void)
{
  return top;
}

void CStarImages::Repaint (float limit, float factor)
{
  int i;

  int nStars = stars.size();
  for (i=0; i<nStars; i++) {
    SStarData* star = stars[i];

    // Determine visual brightness of the star
    double mv = star->mv;
    double nmag, alpha;
    if (mv < limit) {
      // This star is brighter than the limiting magnitude
      nmag = (limit - mv) / limit;    // Scale brightness to 0.0..1.0
      alpha = (nmag * 0.85);        // Scale alpha to 0.0..0.85
      alpha += 0.25;            // Bias +25%
      alpha *= factor;          // Adjust alpha for ambient light
    } else {
      // Star is dimmer than the limiting magnitude
      alpha = 0.0;
    }

    // Clamp alpha to 0.0..1.0
    if (alpha > 1.0) { alpha = 1.0; }
    if (alpha < 0.0) { alpha = 0.0; }

    float* c = stars_rgba->get (i);
    c[3] = alpha;
  }
}

//
// Reposition the image of the stars in the sky
//
// Arguments:
//  pos     3D position of the eye (cartesian coordinates??)
//  lst     Local Sidereal Time, in degrees
//
void CStarImages::Reposition (sgVec3 pos, double lon, double lat, double lst)
{
  sgMat4 LAT, LST;
  sgVec3 axis;

  // Rotate for eye position latitude
  sgSetVec3 (axis, -1, 0, 0);
  sgMakeRotMat4 (LAT, 90 - lat, axis);

  // Rotation matrix for local sidereal time, converted from h to deg
  sgSetVec3 (axis, 0, 0, -1);
  sgMakeRotMat4 (LST, (lst * 15), axis);

  sgMat4 T;
  sgMakeIdentMat4 (T);
  sgPreMultMat4 (T, LAT);
  sgPreMultMat4 (T, LST);

  top->setTransform (T);
}

Documentation generated by