simgear/sky/dome.cxx

   1 // dome.cxx -- model sky with an upside down "bowl"
   2 //
   3 // Written by Curtis Olson, started December 1997.
   4 // SSG-ified by Curtis Olson, February 2000.
   5 //
   6 // Copyright (C) 1997-2000  Curtis L. Olson  - curt@flightgear.org
   7 //
   8 // This program is free software; you can redistribute it and/or
   9 // modify it under the terms of the GNU General Public License as
  10 // published by the Free Software Foundation; either version 2 of the
  11 // License, or (at your option) any later version.
  12 //
  13 // This program is distributed in the hope that it will be useful, but
  14 // WITHOUT ANY WARRANTY; without even the implied warranty of
  15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16 // General Public License for more details.
  17 //
  18 // You should have received a copy of the GNU General Public License
  19 // along with this program; if not, write to the Free Software
  20 // Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 //
  22 // $Id$
  23
  24
  25 #ifdef HAVE_CONFIG_H
  26 #  include <config.h>
  27 #endif
  28
  29 #ifdef HAVE_WINDOWS_H
  30 #  include <windows.h>
  31 #endif
  32
  33 #include <math.h>
  34
  35 #include <GL/glut.h>
  36 #include <simgear/xgl/xgl.h>
  37
  38 #include <simgear/constants.h>
  39 #include <simgear/debug/logstream.hxx>
  40 #include <simgear/math/fg_random.h>
  41
  42 #include "dome.hxx"
  43
  44
  45 #ifdef __MWERKS__
  46 #  pragma global_optimizer off
  47 #endif
  48
  49
  50 // in meters of course
  51 #define CENTER_ELEV   25000.0
  52
  53 #define UPPER_RADIUS  50000.0
  54 #define UPPER_ELEV    20000.0
  55
  56 #define MIDDLE_RADIUS 70000.0
  57 #define MIDDLE_ELEV    8000.0
  58
  59 #define LOWER_RADIUS  80000.0
  60 #define LOWER_ELEV        0.0
  61
  62 #define BOTTOM_RADIUS 50000.0
  63 #define BOTTOM_ELEV   -2000.0
  64
  65
  66 // Set up dome rendering callbacks
  67 static int sgSkyDomePreDraw( ssgEntity *e ) {
  68     /* cout << endl << "Dome Pre Draw" << endl << "----------------"
  69          << endl << endl; */
  70     glDisable( GL_DEPTH_TEST );
  71     glDisable( GL_FOG );
  72
  73     return true;
  74 }
  75
  76 static int sgSkyDomePostDraw( ssgEntity *e ) {
  77     /* cout << endl << "Dome Post Draw" << endl << "----------------"
  78          << endl << endl; */
  79     glEnable( GL_DEPTH_TEST );
  80     glEnable( GL_FOG );
  81
  82     return true;
  83 }
  84
  85
  86 // Constructor
  87 SGSkyDome::SGSkyDome( void ) {
  88 }
  89
  90
  91 // Destructor
  92 SGSkyDome::~SGSkyDome( void ) {
  93 }
  94
  95
  96 // initialize the sky object and connect it into our scene graph
  97 ssgBranch * SGSkyDome::build( ) {
  98     sgVec4 color;
  99
 100     float theta;
 101     int i;
 102
 103     // set up the state
 104     dome_state = new ssgSimpleState();
 105     dome_state->setShadeModel( GL_SMOOTH );
 106     dome_state->disable( GL_LIGHTING );
 107     dome_state->disable( GL_CULL_FACE );
 108     dome_state->disable( GL_TEXTURE_2D );
 109     dome_state->enable( GL_COLOR_MATERIAL );
 110     dome_state->setColourMaterial( GL_AMBIENT_AND_DIFFUSE );
 111     dome_state->setMaterial( GL_EMISSION, 0, 0, 0, 1 );
 112     dome_state->setMaterial( GL_SPECULAR, 0, 0, 0, 1 );
 113     dome_state->disable( GL_BLEND );
 114     dome_state->disable( GL_ALPHA_TEST );
 115
 116     // initialize arrays
 117     center_disk_vl = new ssgVertexArray( 14 );
 118     center_disk_cl = new ssgColourArray( 14 );
 119
 120     upper_ring_vl = new ssgVertexArray( 26 );
 121     upper_ring_cl = new ssgColourArray( 26 );
 122
 123     middle_ring_vl = new ssgVertexArray( 26 );
 124     middle_ring_cl = new ssgColourArray( 26 );
 125
 126     lower_ring_vl = new ssgVertexArray( 26 );
 127     lower_ring_cl = new ssgColourArray( 26 );
 128
 129     // initially seed to all blue
 130     sgSetVec4( color, 0.0, 0.0, 1.0, 1.0 );
 131
 132     // generate the raw vertex data
 133     sgVec3 center_vertex;
 134     sgVec3 upper_vertex[12];
 135     sgVec3 middle_vertex[12];
 136     sgVec3 lower_vertex[12];
 137     sgVec3 bottom_vertex[12];
 138
 139     sgSetVec3( center_vertex, 0.0, 0.0, CENTER_ELEV );
 140
 141     for ( i = 0; i < 12; i++ ) {
 142         theta = (i * 30.0) * DEG_TO_RAD;
 143
 144         sgSetVec3( upper_vertex[i],
 145                    cos(theta) * UPPER_RADIUS,
 146                    sin(theta) * UPPER_RADIUS,
 147                    UPPER_ELEV );
 148
 149         sgSetVec3( middle_vertex[i],
 150                    cos((double)theta) * MIDDLE_RADIUS,
 151                    sin((double)theta) * MIDDLE_RADIUS,
 152                    MIDDLE_ELEV );
 153
 154         sgSetVec3( lower_vertex[i],
 155                    cos((double)theta) * LOWER_RADIUS,
 156                    sin((double)theta) * LOWER_RADIUS,
 157                    LOWER_ELEV );
 158
 159         sgSetVec3( bottom_vertex[i],
 160                    cos((double)theta) * BOTTOM_RADIUS,
 161                    sin((double)theta) * BOTTOM_RADIUS,
 162                    BOTTOM_ELEV );
 163     }
 164
 165     // generate the center disk vertex/color arrays
 166     center_disk_vl->add( center_vertex );
 167     center_disk_cl->add( color );
 168     for ( i = 11; i >= 0; i-- ) {
 169         center_disk_vl->add( upper_vertex[i] );
 170         center_disk_cl->add( color );
 171     }
 172     center_disk_vl->add( upper_vertex[11] );
 173     center_disk_cl->add( color );
 174
 175     // generate the upper ring
 176     for ( i = 0; i < 12; i++ ) {
 177         upper_ring_vl->add( middle_vertex[i] );
 178         upper_ring_cl->add( color );
 179
 180         upper_ring_vl->add( upper_vertex[i] );
 181         upper_ring_cl->add( color );
 182     }
 183     upper_ring_vl->add( middle_vertex[0] );
 184     upper_ring_cl->add( color );
 185
 186     upper_ring_vl->add( upper_vertex[0] );
 187     upper_ring_cl->add( color );
 188
 189     // generate middle ring
 190     for ( i = 0; i < 12; i++ ) {
 191         middle_ring_vl->add( lower_vertex[i] );
 192         middle_ring_cl->add( color );
 193
 194         middle_ring_vl->add( middle_vertex[i] );
 195         middle_ring_cl->add( color );
 196     }
 197     middle_ring_vl->add( lower_vertex[0] );
 198     middle_ring_cl->add( color );
 199
 200     middle_ring_vl->add( middle_vertex[0] );
 201     middle_ring_cl->add( color );
 202
 203     // generate lower ring
 204     for ( i = 0; i < 12; i++ ) {
 205         lower_ring_vl->add( bottom_vertex[i] );
 206         lower_ring_cl->add( color );
 207
 208         lower_ring_vl->add( lower_vertex[i] );
 209         lower_ring_cl->add( color );
 210     }
 211     lower_ring_vl->add( bottom_vertex[0] );
 212     lower_ring_cl->add( color );
 213
 214     lower_ring_vl->add( lower_vertex[0] );
 215     lower_ring_cl->add( color );
 216
 217     // force a repaint of the sky colors with ugly defaults
 218     sgVec3 fog_color;
 219     sgSetVec3( fog_color, 1.0, 1.0, 1.0 );
 220     repaint( color, fog_color, 0.0 );
 221
 222     // build the ssg scene graph sub tree for the sky and connected
 223     // into the provide scene graph branch
 224     ssgVtxTable *center_disk, *upper_ring, *middle_ring, *lower_ring;
 225
 226     center_disk = new ssgVtxTable( GL_TRIANGLE_FAN,
 227                                    center_disk_vl, NULL, NULL, center_disk_cl );
 228
 229     upper_ring = new ssgVtxTable( GL_TRIANGLE_STRIP,
 230                                   upper_ring_vl, NULL, NULL, upper_ring_cl );
 231
 232     middle_ring = new ssgVtxTable( GL_TRIANGLE_STRIP,
 233                                    middle_ring_vl, NULL, NULL, middle_ring_cl );
 234
 235     lower_ring = new ssgVtxTable( GL_TRIANGLE_STRIP,
 236                                   lower_ring_vl, NULL, NULL, lower_ring_cl );
 237
 238     center_disk->setState( dome_state );
 239     upper_ring->setState( dome_state );
 240     middle_ring->setState( dome_state );
 241     lower_ring->setState( dome_state );
 242
 243     dome_transform = new ssgTransform;
 244     dome_transform->addKid( center_disk );
 245     dome_transform->addKid( upper_ring );
 246     dome_transform->addKid( middle_ring );
 247     dome_transform->addKid( lower_ring );
 248
 249     // not entirely satisfying.  We are depending here that the first
 250     // thing we add to a parent is the first drawn
 251     center_disk->setCallback( SSG_CALLBACK_PREDRAW, sgSkyDomePreDraw );
 252     center_disk->setCallback( SSG_CALLBACK_POSTDRAW, sgSkyDomePostDraw );
 253
 254     upper_ring->setCallback( SSG_CALLBACK_PREDRAW, sgSkyDomePreDraw );
 255     upper_ring->setCallback( SSG_CALLBACK_POSTDRAW, sgSkyDomePostDraw );
 256
 257     middle_ring->setCallback( SSG_CALLBACK_PREDRAW, sgSkyDomePreDraw );
 258     middle_ring->setCallback( SSG_CALLBACK_POSTDRAW, sgSkyDomePostDraw );
 259
 260     lower_ring->setCallback( SSG_CALLBACK_PREDRAW, sgSkyDomePreDraw );
 261     lower_ring->setCallback( SSG_CALLBACK_POSTDRAW, sgSkyDomePostDraw );
 262
 263     return dome_transform;
 264 }
 265
 266
 267 // repaint the sky colors based on current value of sun_angle, sky,
 268 // and fog colors.  This updates the color arrays for ssgVtxTable.
 269 // sun angle in degrees relative to verticle
 270 // 0 degrees = high noon
 271 // 90 degrees = sun rise/set
 272 // 180 degrees = darkest midnight
 273 bool SGSkyDome::repaint( sgVec4 sky_color, sgVec4 fog_color, double sun_angle )
 274 {
 275     double diff;
 276     sgVec3 outer_param, outer_amt, outer_diff;
 277     sgVec3 middle_param, middle_amt, middle_diff;
 278     int i, j;
 279
 280     // Check for sunrise/sunset condition
 281     if ( (sun_angle > 80.0) && (sun_angle < 100.0) ) {
 282         // 0.0 - 0.4
 283         sgSetVec3( outer_param,
 284                    (10.0 - fabs(90.0 - sun_angle)) / 20.0,
 285                    (10.0 - fabs(90.0 - sun_angle)) / 40.0,
 286                    -(10.0 - fabs(90.0 - sun_angle)) / 30.0 );
 287
 288         sgSetVec3( middle_param,
 289                    (10.0 - fabs(90.0 - sun_angle)) / 40.0,
 290                    (10.0 - fabs(90.0 - sun_angle)) / 80.0,
 291                    0.0 );
 292
 293         sgScaleVec3( outer_diff, outer_param, 1.0 / 6.0 );
 294
 295         sgScaleVec3( middle_diff, middle_param, 1.0 / 6.0 );
 296     } else {
 297         sgSetVec3( outer_param, 0.0, 0.0, 0.0 );
 298         sgSetVec3( middle_param, 0.0, 0.0, 0.0 );
 299
 300         sgSetVec3( outer_diff, 0.0, 0.0, 0.0 );
 301         sgSetVec3( middle_diff, 0.0, 0.0, 0.0 );
 302     }
 303     // printf("  outer_red_param = %.2f  outer_red_diff = %.2f\n",
 304     //        outer_red_param, outer_red_diff);
 305
 306     // calculate transition colors between sky and fog
 307     sgCopyVec3( outer_amt, outer_param );
 308     sgCopyVec3( middle_amt, middle_param );
 309
 310     //
 311     // First, recalulate the basic colors
 312     //
 313
 314     sgVec4 upper_color[12];
 315     sgVec4 middle_color[12];
 316     sgVec4 lower_color[12];
 317     sgVec4 bottom_color[12];
 318
 319     for ( i = 0; i < 6; i++ ) {
 320         for ( j = 0; j < 3; j++ ) {
 321             diff = sky_color[j] - fog_color[j];
 322
 323             // printf("sky = %.2f  fog = %.2f  diff = %.2f\n",
 324             //        l->sky_color[j], l->fog_color[j], diff);
 325
 326             upper_color[i][j] = sky_color[j] - diff * 0.3;
 327             middle_color[i][j] = sky_color[j] - diff * 0.9 + middle_amt[j];
 328             lower_color[i][j] = fog_color[j] + outer_amt[j];
 329
 330             if ( upper_color[i][j] > 1.0 ) { upper_color[i][j] = 1.0; }
 331             if ( upper_color[i][j] < 0.1 ) { upper_color[i][j] = 0.1; }
 332             if ( middle_color[i][j] > 1.0 ) { middle_color[i][j] = 1.0; }
 333             if ( middle_color[i][j] < 0.1 ) { middle_color[i][j] = 0.1; }
 334             if ( lower_color[i][j] > 1.0 ) { lower_color[i][j] = 1.0; }
 335             if ( lower_color[i][j] < 0.1 ) { lower_color[i][j] = 0.1; }
 336         }
 337         upper_color[i][3] = middle_color[i][3] = lower_color[i][3] = 1.0;
 338
 339         for ( j = 0; j < 3; j++ ) {
 340             outer_amt[j] -= outer_diff[j];
 341             middle_amt[j] -= middle_diff[j];
 342         }
 343
 344         /*
 345         printf("upper_color[%d] = %.2f %.2f %.2f %.2f\n", i, upper_color[i][0],
 346                upper_color[i][1], upper_color[i][2], upper_color[i][3]);
 347         printf("middle_color[%d] = %.2f %.2f %.2f %.2f\n", i,
 348                middle_color[i][0], middle_color[i][1], middle_color[i][2],
 349                middle_color[i][3]);
 350         printf("lower_color[%d] = %.2f %.2f %.2f %.2f\n", i,
 351                lower_color[i][0], lower_color[i][1], lower_color[i][2],
 352                lower_color[i][3]);
 353         */
 354     }
 355
 356     sgSetVec3( outer_amt, 0.0, 0.0, 0.0 );
 357     sgSetVec3( middle_amt, 0.0, 0.0, 0.0 );
 358
 359     for ( i = 6; i < 12; i++ ) {
 360         for ( j = 0; j < 3; j++ ) {
 361             diff = sky_color[j] - fog_color[j];
 362
 363             // printf("sky = %.2f  fog = %.2f  diff = %.2f\n",
 364             //        sky_color[j], fog_color[j], diff);
 365
 366             upper_color[i][j] = sky_color[j] - diff * 0.3;
 367             middle_color[i][j] = sky_color[j] - diff * 0.9 + middle_amt[j];
 368             lower_color[i][j] = fog_color[j] + outer_amt[j];
 369
 370             if ( upper_color[i][j] > 1.0 ) { upper_color[i][j] = 1.0; }
 371             if ( upper_color[i][j] < 0.1 ) { upper_color[i][j] = 0.1; }
 372             if ( middle_color[i][j] > 1.0 ) { middle_color[i][j] = 1.0; }
 373             if ( middle_color[i][j] < 0.1 ) { middle_color[i][j] = 0.1; }
 374             if ( lower_color[i][j] > 1.0 ) { lower_color[i][j] = 1.0; }
 375             if ( lower_color[i][j] < 0.1 ) { lower_color[i][j] = 0.1; }
 376         }
 377         upper_color[i][3] = middle_color[i][3] = lower_color[i][3] = 1.0;
 378
 379         for ( j = 0; j < 3; j++ ) {
 380             outer_amt[j] += outer_diff[j];
 381             middle_amt[j] += middle_diff[j];
 382         }
 383
 384         /*
 385         printf("upper_color[%d] = %.2f %.2f %.2f %.2f\n", i, upper_color[i][0],
 386                upper_color[i][1], upper_color[i][2], upper_color[i][3]);
 387         printf("middle_color[%d] = %.2f %.2f %.2f %.2f\n", i,
 388                middle_color[i][0], middle_color[i][1], middle_color[i][2],
 389                middle_color[i][3]);
 390         printf("lower_color[%d] = %.2f %.2f %.2f %.2f\n", i,
 391                lower_color[i][0], lower_color[i][1], lower_color[i][2],
 392                lower_color[i][3]);
 393         */
 394     }
 395
 396     for ( i = 0; i < 12; i++ ) {
 397         sgCopyVec4( bottom_color[i], fog_color );
 398     }
 399
 400     //
 401     // Second, assign the basic colors to the object color arrays
 402     //
 403
 404     float *slot;
 405     int counter;
 406
 407     // update the center disk color arrays
 408     counter = 0;
 409     slot = center_disk_cl->get( counter++ );
 410     // sgVec4 red;
 411     // sgSetVec4( red, 1.0, 0.0, 0.0, 1.0 );
 412     sgCopyVec4( slot, sky_color );
 413     for ( i = 11; i >= 0; i-- ) {
 414         slot = center_disk_cl->get( counter++ );
 415         sgCopyVec4( slot, upper_color[i] );
 416     }
 417     slot = center_disk_cl->get( counter++ );
 418     sgCopyVec4( slot, upper_color[11] );
 419
 420     // generate the upper ring
 421     counter = 0;
 422     for ( i = 0; i < 12; i++ ) {
 423         slot = upper_ring_cl->get( counter++ );
 424         sgCopyVec4( slot, middle_color[i] );
 425
 426         slot = upper_ring_cl->get( counter++ );
 427         sgCopyVec4( slot, upper_color[i] );
 428     }
 429     slot = upper_ring_cl->get( counter++ );
 430     sgCopyVec4( slot, middle_color[0] );
 431
 432     slot = upper_ring_cl->get( counter++ );
 433     sgCopyVec4( slot, upper_color[0] );
 434
 435     // generate middle ring
 436     counter = 0;
 437     for ( i = 0; i < 12; i++ ) {
 438         slot = middle_ring_cl->get( counter++ );
 439         sgCopyVec4( slot, lower_color[i] );
 440
 441         slot = middle_ring_cl->get( counter++ );
 442         sgCopyVec4( slot, middle_color[i] );
 443     }
 444     slot = middle_ring_cl->get( counter++ );
 445     sgCopyVec4( slot, lower_color[0] );
 446
 447     slot = middle_ring_cl->get( counter++ );
 448     sgCopyVec4( slot, middle_color[0] );
 449
 450     // generate lower ring
 451     counter = 0;
 452     for ( i = 0; i < 12; i++ ) {
 453         slot = lower_ring_cl->get( counter++ );
 454         sgCopyVec4( slot, bottom_color[i] );
 455
 456         slot = lower_ring_cl->get( counter++ );
 457         sgCopyVec4( slot, lower_color[i] );
 458     }
 459     slot = lower_ring_cl->get( counter++ );
 460     sgCopyVec4( slot, bottom_color[0] );
 461
 462     slot = lower_ring_cl->get( counter++ );
 463     sgCopyVec4( slot, lower_color[0] );
 464
 465     return true;
 466 }
 467
 468
 469 // reposition the sky at the specified origin and orientation
 470 // lon specifies a rotation about the Z axis
 471 // lat specifies a rotation about the new Y axis
 472 // spin specifies a rotation about the new Z axis (and orients the
 473 // sunrise/set effects
 474 bool SGSkyDome::reposition( sgVec3 p, double lon, double lat, double spin ) {
 475     sgMat4 T, LON, LAT, SPIN;
 476     sgVec3 axis;
 477
 478     // Translate to view position
 479     // Point3D zero_elev = current_view.get_cur_zero_elev();
 480     // xglTranslatef( zero_elev.x(), zero_elev.y(), zero_elev.z() );
 481     sgMakeTransMat4( T, p );
 482
 483     // printf("  Translated to %.2f %.2f %.2f\n",
 484     //        zero_elev.x, zero_elev.y, zero_elev.z );
 485
 486     // Rotate to proper orientation
 487     // printf("  lon = %.2f  lat = %.2f\n", FG_Longitude * RAD_TO_DEG,
 488     //        FG_Latitude * RAD_TO_DEG);
 489     // xglRotatef( f->get_Longitude() * RAD_TO_DEG, 0.0, 0.0, 1.0 );
 490     sgSetVec3( axis, 0.0, 0.0, 1.0 );
 491     sgMakeRotMat4( LON, lon * RAD_TO_DEG, axis );
 492
 493     // xglRotatef( 90.0 - f->get_Latitude() * RAD_TO_DEG, 0.0, 1.0, 0.0 );
 494     sgSetVec3( axis, 0.0, 1.0, 0.0 );
 495     sgMakeRotMat4( LAT, 90.0 - lat * RAD_TO_DEG, axis );
 496
 497     // xglRotatef( l->sun_rotation * RAD_TO_DEG, 0.0, 0.0, 1.0 );
 498     sgSetVec3( axis, 0.0, 0.0, 1.0 );
 499     sgMakeRotMat4( SPIN, spin * RAD_TO_DEG, axis );
 500
 501     sgMat4 TRANSFORM;
 502
 503     sgCopyMat4( TRANSFORM, T );
 504     sgPreMultMat4( TRANSFORM, LON );
 505     sgPreMultMat4( TRANSFORM, LAT );
 506     sgPreMultMat4( TRANSFORM, SPIN );
 507
 508     sgCoord skypos;
 509     sgSetCoord( &skypos, TRANSFORM );
 510
 511     dome_transform->setTransform( &skypos );
 512
 513     return true;
 514 }