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