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