SolImage.cpp

Go to the documentation of this file.

/*
 * SolImage.cpp
 *
 * Part of Fly! Legacy project
 *
 * The design and implementation of these classes is based heavily on the
 *   sky model of SimGear 0.3.3, by Curtis Olson.  Integration into the
 *   Fly! Legacy project necessitated a rewrite of the actual classes,
 *   but I am indebteded to Curt and other contributors to the SimGear and
 *   FlightGear teams for their prior work in this area.
 *
 * 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/Sky.h"
#include "../Include/Utility.h"


//
// Pre-draw callback for Sol orb
//
static int sol_orb_predraw (ssgEntity *e)
{
  ssgLeaf *f = (ssgLeaf*) e;
  if (f->hasState()) f->getState()->apply ();

  glPushAttrib (GL_DEPTH_BUFFER_BIT | GL_FOG_BIT);
  glDisable (GL_DEPTH_TEST);
  glDisable (GL_FOG);

  return true;
}


//
// Post-draw callback for Sol orb
//
static int sol_orb_postdraw (ssgEntity *e)
{
  glPopAttrib ();
  return true;
}


//
// Pre-draw callback for Sol halo
//
static int sol_halo_predraw (ssgEntity *e)
{
  ssgLeaf *f = (ssgLeaf*) e;
  if (f->hasState()) f->getState()->apply ();

  glPushAttrib (GL_DEPTH_BUFFER_BIT | GL_FOG_BIT);
  glDisable (GL_DEPTH_TEST);
  glDisable (GL_FOG);

  return true;
}


//
// Post-draw callback for Sol halo
//
static int sol_halo_postdraw (ssgEntity *e)
{
  glPopAttrib ();
  return true;
}


//
// Sun layering parameters
//
// In Fly! II, this data was represented by the file Data\sun.txt
//   Since there was never any customization done as far as I know,
//   there's no real need to support this file, so to save time the
//   implementation is just hard-coded to match the contents of the
//   default sun.txt shipped with Fly! II
//

typedef struct {
  char  filename[64];   // Texture filename
  int   w;          // Dimension (width)
  float offset;       // Layer y-offset
  float radius;       // Radius in pseudo-feet
  float u1, v1, u2, v2;   // Texture coordinates
} SSunLayer;


const int nSunLayers = 10;
SSunLayer sunLayers[] =
{
  {"sun06", 64,   0.500000, 43.000000,  8, 8, 248, 248},
  {"suncram", 256,  0.30000,  143.000000, 130, 130, 254, 254},
  {"sun07", 64,   0.100000, 11.000000,  8, 8, 248, 248},
  {"sun07", 64,   -0.271000,  27.000000,  8, 8, 248, 248},
  {"sun09", 64,   -0.416000,  80.000000,  8, 8, 248, 248},
  {"sun11", 64,   -0.475000,  41.000000,  8, 8, 248, 248},
  {"sun12", 64,   -0.643000,  61.000000,  8, 8, 248, 248},
  {"sun13", 64,   -0.674000,  60.000000,  8, 8, 248, 248},
  {"suncram", 256,  -1.000000,  213.000000, 130, 2, 254, 126},
  {"suncram", 256,  -1.333000,  410.000000, 2, 130, 126, 254}
};


class CSunTextureCache {
public:
  CSunTextureCache (void);
  ~CSunTextureCache (void);

public:
  char          filename[64];
  CSunRawImage  *raw;
  GLuint        tex;
};

CSunTextureCache::CSunTextureCache (void)
{
  strcpy (filename, "");
  raw = NULL;
  tex = 0;
}

CSunTextureCache::~CSunTextureCache(void)
{
  if (tex != 0) glDeleteTextures (1, &tex);
  if (raw != NULL) delete raw;
}


GLuint CSolImage::GetSunTexture (const char* filename, int w)
{
  GLuint rc = 0;
/*
  // Search if texture is already loaded
  int nTextures = textures.getNumEntities ();
  for (int i=0; i<nTextures; i++) {
    CSunTextureCache *cache = (CSunTextureCache *)textures.getEntity (i);

    if (stricmp (filename, cache->filename) == 0) {
      // Found a match
      rc = cache->tex;
      break;
    }
  }

  // Return code will be set if a match was found
  if (rc == 0) {
    // Create a new cache entry
    CSunTextureCache *cache = new CSunTextureCache;
    strcpy (cache->filename, filename);
    textures.addEntity (cache);

    // Load the RAW image
    char raw[64];
    sprintf (raw, "ART\\%s.RAW", filename);
    char act[64];
    sprintf (act, "ART\\%s.ACT", filename);
    cache->raw = new CSunRawImage (w, w, raw, act);

    rc = cache->tex = cache->raw->GetTexture (false);
  }
*/
  return rc;
}

//
// Instantiate the sun image SSG object.
//
CSolImage::CSolImage (double size)
{
  // Instantiate SSG entities
  top = new ssgTransform;
  top->setName ("Sol");

/*
 * Sun orb commented out 2005-Mar-6.
 *

  //
  // Create sun orb as a simple coloured sphere
  //
  ssgSimpleState *state = new ssgSimpleState ();
  state->setShadeModel (GL_SMOOTH);
  state->disable (GL_LIGHTING);
  state->disable (GL_CULL_FACE);
  state->disable (GL_TEXTURE_2D);
  state->enable (GL_COLOR_MATERIAL);
  state->setColourMaterial (GL_AMBIENT_AND_DIFFUSE);
  state->setMaterial (GL_EMISSION, 0, 0, 0, 1);
  state->setMaterial (GL_SPECULAR, 0, 0, 0, 1);
  state->disable (GL_BLEND);
  state->disable (GL_ALPHA_TEST);

  // Initialize colour array
  rgba = new ssgColourArray (1);
  sgVec4 default_colour;
  sgSetVec4 (default_colour, 1.0, 1.0, 1.0, 1.0);
  rgba->add (default_colour);

  ssgBranch *orb = ssgMakeSphere (state, rgba, size, 10, 10,
    sol_orb_predraw, sol_orb_postdraw);
  orb->setName ("Orb");
  top->addKid (orb);

  *
  */

/*
 * Sun halo - need to fix texturing and shading before adding to scene

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

//  GLint tex = GetSunTexture ("halo", 256);

  CRawImage *rawHalo = new CRawImage (256, 256, "Art\\Halo.RAW", "Art\\Halo.ACT");
  GLuint tex = rawHalo->GetTexture(false);
  state->setTexture (tex);
  delete rawHalo;

  // Create vertex array
  double halo_size = size * 10;
  ssgVertexArray *va = new ssgVertexArray (4);
  sgVec3 v;
//  sgSetVec3 (v, -halo_size, 0.0, -halo_size);
  sgSetVec3 (v, -halo_size, -halo_size, 0.0);
  va->add (v);
//  sgSetVec3 (v, -halo_size, 0.0,  halo_size);
  sgSetVec3 (v, -halo_size, halo_size, 0.0);
  va->add (v);
//  sgSetVec3 (v,  halo_size, 0.0,  halo_size);
  sgSetVec3 (v,  halo_size, halo_size, 0.0);
  va->add (v);
//  sgSetVec3 (v,  halo_size, 0.0, -halo_size);
  sgSetVec3 (v,  halo_size, -halo_size, 0.0);
  va->add (v);

  // Create texture array
  ssgTexCoordArray *ta = new ssgTexCoordArray (4);
  float u1 = (float)0.0;
  float u2 = (float)1.0;
  float v1 = (float)0.0;
  float v2 = (float)1.0;
  sgVec2 t;
  sgSetVec2 (t, u1, v1);
  ta->add (t);
  sgSetVec2 (t, u1, v2);
  ta->add (t);
  sgSetVec2 (t, u2, v2);
  ta->add (t);
  sgSetVec2 (t, u2, v1);
  ta->add (t);

  // Create vertex table object for the halo
  ssgVtxTable *vt = new ssgVtxTable (GL_POLYGON, va, NULL, ta, rgba);
  vt->setName ("Halo");
  vt->setState (state);
  vt->setCallback (SSG_CALLBACK_PREDRAW, sol_halo_predraw);
  vt->setCallback (SSG_CALLBACK_POSTDRAW, sol_halo_postdraw);

//  top->addKid (vt);
  delete vt;
*/

/*
  // Create cutout for layered sun
  orb_cutout = new ssgCutout (true);
  orb_cutout->setName ("Orb cutout");

  // Add various texturing layers to sun orb object
  for (int i=0; i<nSunLayers; i++) {
//  for (int i=2; i<3; i++) {
    SSunLayer *s = &sunLayers[i];

    // Create state for this layer
    ssgSimpleState *state = new ssgSimpleState ();
    state->setShadeModel (GL_SMOOTH);
    state->disable (GL_LIGHTING);
    state->disable (GL_CULL_FACE);
    state->enable (GL_TEXTURE_2D);
    state->enable (GL_COLOR_MATERIAL);
    state->enable (GL_BLEND);
    state->enable (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);

    GLint tex = GetSunTexture (s->filename, s->w);
    state->setTexture (tex);

    // Allocate arrays
    ssgColourArray *rgba = new ssgColourArray (1);
    ssgVertexArray *va = new ssgVertexArray (4);
    ssgNormalArray *na = new ssgNormalArray (4);
    ssgTexCoordArray *ta = new ssgTexCoordArray (4);

    // Initialize colour array
    sgVec4 default_colour;
    sgSetVec4 (default_colour, 1.0, 1.0, 1.0, 1.0);
    rgba->add (default_colour);

    // Initialize vertex array based on layer radius
    float r = (float)s->radius * 100;
    sgVec3 v;
    sgSetVec3 (v, -r, s->offset, -r);
    va->add (v);
    sgSetVec3 (v, -r, s->offset,  r);
    va->add (v);
    sgSetVec3 (v,  r, s->offset,  r);
    va->add (v);
    sgSetVec3 (v,  r, s->offset, -r);
    va->add (v);

    // Initialize normal array
    sgVec3 n;
    sgSetVec3 (n, 0.0, -1.0, 0.0);
    na->add (n);
    na->add (n);
    na->add (n);
    na->add (n);

    // Initialize texture array
    float u1 = (float)s->u1 / 256;
    float u2 = (float)s->u2 / 256;
    float v1 = (float)s->v1 / 256;
    float v2 = (float)s->v2 / 256;
    sgVec2 t;
    sgSetVec2 (t, u1, v1);
    ta->add (t);
    sgSetVec2 (t, u1, v2);
    ta->add (t);
    sgSetVec2 (t, u2, v2);
    ta->add (t);
    sgSetVec2 (t, u2, v1);
    ta->add (t);

    // Create vertex table object for this layer
    ssgVtxTable *vt = new ssgVtxTable (GL_TRIANGLE_STRIP, va, NULL, ta, rgba);
    char name[64];
    sprintf (name, "Layer %d", i);
    vt->setName (name);
    vt->setState (state);
    vt->setCallback (SSG_CALLBACK_PREDRAW, sol_orb_predraw);
    vt->setCallback (SSG_CALLBACK_POSTDRAW, sol_orb_postdraw);
    orb_cutout->addKid (vt);
  }
*/
//  top->addKid (orb_cutout);

  // Apply scaling transform to top-level
//  sgMat4 T;
//  sgMakeIdentMat4 (T);
//  sgScaleMat4 (T, T, size);
//  top->setTransform (T);

  Repaint (0);

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

CSolImage::~CSolImage (void)
{
//  int i, n;
/*
  n = textures.getNumEntities();
  for (i=0; i<n; i++) {
    CSunTextureCache *cache = (CSunTextureCache *)textures.getEntity (i);
    delete cache;
  }
  textures.removeAllEntities();
*/
}


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


void CSolImage::Repaint (double angle)
{
  static float prev_angle = 9999.0f;

  if (angle != prev_angle) {
    prev_angle = angle;

    // Compute power factor, clamped to [-1, +1]
    float factor = 4 * cos(angle);
    if (factor > 1.0f) factor = 1.0f;
    if (factor < -1.0f) factor = -1.0f;

    // Compute RGB colours for sun orb
    sgVec4 colour;
    colour[0] = pow (factor, 0.25);     // Red
    colour[1] = pow (factor, 0.50);     // Green
    colour[2] = pow (factor, 4.0);      // Blue
    colour[3] = 1.0;            // Alpha (opaque)

    // DEBUG
//    sgSetVec4 (colour, 1.0, 1.0, 1.0, 1.0);

    // Set orb colour
    float *p = rgba->get (0);
    sgCopyVec4 (p, colour);
  }
}

//
// Reposition the image of the sun in the sky
//
// Arguments:
//  pos     3D position of the eye (cartesian coordinates??)
//  lst     Local Sidereal Time, in degrees
//  ra      Right Ascension, in radians
//  dec     Declination, in radians
//  distance  Distance from the eye in world units
//
void CSolImage::Reposition (sgVec3 pos, double lst, double lat, double ra, double dec, double distance)
{
  sgMat4 LST, LAT, RA, DEC, D;
  sgVec3 axis;
  sgVec3 v;

  // 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);

  // Combine all transforms
  sgMat4 T;
  sgMakeIdentMat4 (T);
  sgPreMultMat4 (T, LAT);
  sgPreMultMat4 (T, LST);
  sgPreMultMat4 (T, RA);
  sgPreMultMat4 (T, DEC);
  sgPreMultMat4 (T, D);

  sgCoord skypos;
  sgSetCoord (&skypos, T);

  // Set up the sun light position
  sgVec3 sunlight;
  sgSetVec3 (sunlight, -skypos.xyz[0], -skypos.xyz[1], skypos.xyz[2]);
  ssgGetLight (0)->setPosition (sunlight);

  top->setTransform (T);
}

Documentation generated by