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