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