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