MoonImage.cpp

Go to the documentation of this file.

/*
 * MoonImage.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
 *
 */

/*
 *
 * There are 17 textures representing the phases of the moon.  All are
 *   128x128 in size, in RAW/ACT format in the \Art folder:
 *
 *     moon0000.RAW   Full
 *     moon0001.RAW   Waxing Gibbous
 *     moon0002.RAW   Waxing Gibbous
 *     moon0003.RAW   Waxing Gibbous
 *     moon0004.RAW   First Quarter
 *     moon0005.RAW   Waxing Crescent
 *     moon0006.RAW   Waxing Crescent
 *     moon0007.RAW   New -> Waxing
 *     moon0008.RAW   New
 *     moon0009.RAW   Waning -> New
 *     moon0010.RAW   Waning Crescent
 *     moon0011.RAW   Waning Crescent
 *     moon0012.RAW   Waning Crescent
 *     moon0013.RAW   Third Quarter
 *     moon0014.RAW   Waning Gibbous
 *     moon0015.RAW   Waning Gibbous
 *     moon0016.RAW   Waning Gibbous
 */

#include "../Include/Sky.h"
#include "../Ssg/ssgLocal.h"
#include "../Include/Utility.h"
#include "../Include/Ui.h"
#include "../Include/Globals.h"

#include <plib/ssgAux.h>


static int moonimage_predraw (ssgEntity *e)
{
  ssgLeaf *f = (ssgLeaf*) e;
  if (f->hasState()) {
    ssgSimpleState* state = (ssgSimpleState*) f->getState();
    state->apply ();
  }

  glPushAttrib (GL_COLOR_BUFFER_BIT | GL_ENABLE_BIT);
  glDisable (GL_DEPTH_TEST);
  glDisable (GL_FOG);

  return true;
}


static int moonimage_postdraw (ssgEntity *e)
{
  glPopAttrib ();
  return true;
}


#define N_PHASES  17


CMoonImage::CMoonImage (double size)
{
  // Instantiate SSG entities
  top = new ssgTransform;
  top->setName ("Moon");

  // Load textures
  for (int i=0; i<N_PHASES; i++) {
    // Construct moon texture RAW, ACT and OPA filenames
    char base[64];
    sprintf (base, "MOON%04d", i);

    char rawFilename[64];
    char actFilename[64];
    char opaFilename[64];
    sprintf (rawFilename, "ART\\MOON%04d.RAW", i);
    sprintf (actFilename, "ART\\MOON%04d.ACT", i);
    sprintf (opaFilename, "ART\\MOON%04d.OPA", i);

    // Load the textures, non-mipmapped
    texlist[i] = new CRawImage (128, 128, rawFilename, actFilename, opaFilename);
    if (texlist[i] == NULL) {
      globals->logWarning->Write ("CMoonImage : Could not open texture %s", rawFilename);
    }
  }

  // Create leaf node for the orb
  ssgVertexArray *va = new ssgVertexArray (4);
  ssgColourArray *ca = new ssgColourArray (1);
  ssgNormalArray *na = new ssgNormalArray (1);
  ssgTexCoordArray *ta = new ssgTexCoordArray (4);

  sgVec3 v;
  sgSetVec3 (v,  size, size, 0);
  va->add (v);
  sgSetVec3 (v,  size, -size, 0);
  va->add (v);
  sgSetVec3 (v, -size, -size, 0);
  va->add (v);
  sgSetVec3 (v, -size, size, 0);
  va->add (v);

  sgVec3 n;
  sgSetVec3 (n, 0.0, 1.0, 0.0);
  na->add (n);

  sgVec4 c;
  sgSetVec4 (c, 1.0, 1.0, 1.0, 1.0);
  ca->add (c);

  sgVec2 t;
  sgSetVec2 (t, 0.0, 0.0);
  ta->add (t);
  sgSetVec2 (t, 0.0, 1.0);
  ta->add (t);
  sgSetVec2 (t, 1.0, 1.0);
  ta->add (t);
  sgSetVec2 (t, 1.0, 0.0);
  ta->add (t);

//  orb = new ssgVtxTable (GL_TRIANGLE_STRIP, va, na, ta, ca);
  orb = new ssgVtxTable (GL_POLYGON, va, na, ta, ca);
  orb->setName ("Orb");
  orb->setCallback (SSG_CALLBACK_PREDRAW, moonimage_predraw);
  orb->setCallback (SSG_CALLBACK_POSTDRAW, moonimage_postdraw);

  // Create state for the orb
  ssgSimpleState *state = new ssgSimpleState ();
  state->setShadeModel (GL_SMOOTH);
  state->disable (GL_LIGHTING);
//  state->disable (GL_CULL_FACE);
  state->enable (GL_CULL_FACE);
  state->enable (GL_TEXTURE_2D);
  state->enable (GL_COLOR_MATERIAL);
  state->enable (GL_BLEND);
  state->disable (GL_ALPHA_TEST);
  state->setColourMaterial (GL_AMBIENT_AND_DIFFUSE);
  state->setMaterial (GL_EMISSION, 0, 0, 0, 1);
  state->setMaterial (GL_SPECULAR, 0, 0, 0, 1);
  state->setAlphaClamp (0.01);
  phase = -1;
  orb->setState (state);

  // Add the cutout to the top-level transform
  top->addKid (orb);

//  FILE* f = fopen ("moonimage.txt", "w");
//  top->print (f);
//  fclose (f);
}

CMoonImage::~CMoonImage (void)
{
  // Delete moon texture images
  for (int i=0; i<N_PHASES; i++) {
    if (texlist[i] != NULL) delete texlist[i];
  }

  // Delete top-level SSG entity
  delete top;
}


ssgEntity*    CMoonImage::GetSSGEntity (void)
{
  return top;
}


// Repaint the moon image based on its relative angle in radians:
//    0  =   Transit (highest point in the sky)
//   PI/2 =  Rise/set
//    PI  =  Nadir
//
// Age is number of days into current lunation (0.0 = new moon, ~14.5 = full moon)
//
// Moon lighting algorithm adapted from SimGear 0.3.3

void CMoonImage::Repaint (double angle, float age)
{
  // Select appropriate phase based on lunar phase age.
  // ??? Is this correct or was another bug fixed to prevent the crash ???
  // Only change the texture
  //   if it is not already the current moon texture.  SSG will crash
  //   if the same texture is re-set as the actual texture.
  int new_phase = (int)(((LUNATION_DAYS - age) / LUNATION_DAYS) * N_PHASES + 0.5) + (N_PHASES / 2);
  while (new_phase < 0) { new_phase += N_PHASES; }
  while (new_phase >= N_PHASES) { new_phase -= N_PHASES; }
  if (new_phase != phase && (texlist[new_phase] != NULL)) {
    ssgSimpleState* state = (ssgSimpleState*) orb->getState();

    // Free old phase texture from video memory
    texlist[phase]->FreeTexture ();

    // Assign new phase texture
    GLint t = texlist[new_phase]->GetTexture(true);
    state->setTexture (t);
    state->force ();

    phase = new_phase;
  }

  // x_10 = moon_angle^10
  double x_2 = angle * angle;
  double x_10 = x_2 * x_2 * x_2 * x_2 * x_2;

  // Calculate ambient light caused by moon; clamped between 0.3 and 1.0
  float ambient = (float)(0.4 * pow (1.1, -x_10 / 30.0));
  if (ambient < 0.3) ambient = 0.3;
  if (ambient > 1.0) ambient = 1.0;

  // Compute moon colouring
  sgVec4 colour;
  sgSetVec4 (colour,
    (ambient * 6.0) - 1.0,
    (ambient * 11.0) - 3.0,
    (ambient * 12.0) - 3.6,
    0.5);

  // For testing, force colour to pure white
  sgSetVec4 (colour, 1.0, 1.0, 1.0, 1.0);

  // Clamp colour components to maximum 1.0
  if (colour[0] > 1.0) colour[0] = 1.0;
  if (colour[1] > 1.0) colour[1] = 1.0;
  if (colour[2] > 1.0) colour[2] = 1.0;

  // Update colour of moon leaf node
//  ssgVtxTable *vt = (ssgVtxTable*) orb_cutout->getKid(0);
  ssgVtxTable *vt = (ssgVtxTable*) top->getKid (0);
  float *ptr = vt->getColours()->get(0);
//  float *ptr = orb->getColours()->get(0);
  sgCopyVec4 (ptr, colour);

  // DEBUG
//  char debug[80];
//  sprintf (debug, "age=%7.3f   phase=%d", age, phase);
//  DrawNoticeToUser (debug, 1);
}


//
// Update the position of the moon image in the sky
//
void CMoonImage::Reposition (sgVec3 p, double theta, double lst, double lat,
               double ra, double dec, double spin,
               double distance)
{
  sgMat4 LST, LAT, RA, DEC, D, E, SCALE;
  sgVec3 axis;
  sgVec3 v;

  sgMakeIdentMat4 (SCALE);
  if (theta > (SGD_PI / 4)) {
    sgMat4 I;
    sgMakeIdentMat4 (I);
    float scale = 1.0 + fabs ((theta - (SGD_PI/4)) / (SGD_PI/4));
    sgScaleMat4 (SCALE, I, scale);

    // DEBUG
//    char debug[80];
//    sprintf (debug, "moon scale =%7.3f", scale);
//    DrawNoticeToUser (debug, 1);
  }

  // Rotation matrix for 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);

  // Rotation matrix for right ascension
  sgSetVec3 (axis, 0, 0, 1);
  sgMakeRotMat4 (RA, RadToDeg (ra), axis);

  // Rotation matrix for declination
  sgSetVec3 (axis, 1, 0, 0);
  sgMakeRotMat4 (DEC, 90 - RadToDeg (dec), axis);

  // Translate sun distance
  sgSetVec3 (v, 0, 0, distance);
  sgMakeTransMat4 (D, v);

  sgSetVec3 (axis, 0, 0, 1);
  sgMakeRotMat4 (E, 0, axis);

  // Combine all transforms
  sgMat4 T;
  sgMakeIdentMat4 (T);
  sgPreMultMat4 (T, LAT);
  sgPreMultMat4 (T, LST);
  sgPreMultMat4 (T, RA);
  sgPreMultMat4 (T, DEC);
  sgPreMultMat4 (T, D);
  sgPreMultMat4 (T, E);
  
  top->setTransform (T);
}

Documentation generated by