bool cGrCelestialBody::reposition( sgVec3 p, double angle, double rightAscension, double declination, double sol_dist )
{
sgMat4 T1, T2, GST, RA, DEC;
sgVec3 axis;
sgVec3 v;
sgMakeTransMat4( T1, p );
sgSetVec3( axis, 0.0, 0.0, -1.0 );
sgMakeRotMat4( GST, (float)angle, axis );
sgSetVec3( axis, 0.0, 0.0, 1.0 );
sgMakeRotMat4( RA, (float)((rightAscension * SGD_RADIANS_TO_DEGREES) - 90.0), axis );
sgSetVec3( axis, 1.0, 0.0, 0.0 );
sgMakeRotMat4( DEC, (float)(declination * SGD_RADIANS_TO_DEGREES), axis );
sgSetVec3( v, 0.0, (float)sol_dist, 0.0 );
sgMakeTransMat4( T2, v );
sgMat4 TRANSFORM;
sgCopyMat4( TRANSFORM, T1 );
sgPreMultMat4( TRANSFORM, GST );
sgPreMultMat4( TRANSFORM, RA );
sgPreMultMat4( TRANSFORM, DEC );
sgPreMultMat4( TRANSFORM, T2 );
sgCoord skypos;
sgSetCoord( &skypos, TRANSFORM );
transform->setTransform( &skypos );
return true;
}
bool cGrMoon::reposition(sgVec3 p, double angle, double moonrightAscension, double moondeclination, double moon_dist)
{
sgMat4 T1, T2, GST, RA, DEC;
sgVec3 axis;
sgVec3 v;
sgMakeTransMat4( T1, p );
sgSetVec3( axis, 0.0, 0.0, -1.0 );
sgMakeRotMat4( GST, angle, axis );
sgSetVec3( axis, 0.0, 0.0, 1.0 );
sgMakeRotMat4( RA, (moonrightAscension * SGD_RADIANS_TO_DEGREES) - 90.0, axis );
sgSetVec3( axis, 1.0, 0.0, 0.0 );
sgMakeRotMat4( DEC, moondeclination * SGD_RADIANS_TO_DEGREES, axis );
sgSetVec3( v, 0.0, moon_dist, 0.0 );
sgMakeTransMat4( T2, v );
sgMat4 TRANSFORM;
sgCopyMat4( TRANSFORM, T1 );
sgPreMultMat4( TRANSFORM, GST );
sgPreMultMat4( TRANSFORM, RA );
sgPreMultMat4( TRANSFORM, DEC );
sgPreMultMat4( TRANSFORM, T2 );
sgCoord skypos;
sgSetCoord( &skypos, TRANSFORM );
moon_transform->setTransform( &skypos );
return true;
}
bool cGrSkyDome::reposition( sgVec3 p, double lon, double lat, double spin )
{
sgMat4 T, LON, LAT, SPIN;
sgVec3 axis;
// Translate to view position
sgMakeTransMat4( T, p );
// Rotate to proper orientation
sgSetVec3( axis, 0.0, 0.0, 1.0 );
sgMakeRotMat4( LON, (float)(lon * SGD_RADIANS_TO_DEGREES), axis );
sgSetVec3( axis, 0.0, 1.0, 0.0 );
sgMakeRotMat4( LAT, (float)(90.0 - lat * SGD_RADIANS_TO_DEGREES), axis );
sgSetVec3( axis, 0.0, 0.0, 1.0 );
sgMakeRotMat4( SPIN, (float)(spin * SGD_RADIANS_TO_DEGREES), axis );
sgMat4 TRANSFORM;
sgCopyMat4( TRANSFORM, T );
sgPreMultMat4( TRANSFORM, LON );
sgPreMultMat4( TRANSFORM, LAT );
sgPreMultMat4( TRANSFORM, SPIN );
sgCoord skypos;
sgSetCoord( &skypos, TRANSFORM );
dome_transform->setTransform( &skypos );
asl = - skypos.xyz[2];
return true;
}
//
// Update the position of the moon image in the sky
//
void CMoonImage::Reposition (sgVec3 p, double theta, double lst, double lat,
double ra, double dec, double spin)
{
sgMat4 LST, LAT, RA, DEC, D, SCALE, ECLIPTIC, SPIN;
sgVec3 axis;
sgVec3 v;
// Create scaling matrix for moon illusion (appears larger near horizon)
float scale = 1.0f;
sgMakeIdentMat4 (SCALE);
float maxMagnification = 0.5f;
float minThreshold = DegToRad (80.0f);
float maxThreshold = DegToRad (95.0f);
float span = maxThreshold - minThreshold;
if ((theta >= minThreshold) && (theta <= maxThreshold)) {
sgMat4 I;
sgMakeIdentMat4 (I);
scale = 1.0f + (maxMagnification * (theta - minThreshold) / span);
sgScaleMat4 (SCALE, I, scale);
}
// Rotation matrix for latitude
sgSetVec3 (axis, -1.0f, 0, 0);
sgMakeRotMat4 (LAT, 90.0f-(float)lat, axis);
// Rotation matrix for local sidereal time, converted from h to deg
sgSetVec3 (axis, 0, 0, -1.0f);
sgMakeRotMat4 (LST, ((float)lst * 15), axis);
// Rotation matrix for right ascension
sgSetVec3 (axis, 0, 0, 1);
sgMakeRotMat4 (RA, RadToDeg ((float)ra), axis);
// Rotation matrix for declination
sgSetVec3 (axis, 1, 0, 0);
sgMakeRotMat4 (DEC, 90.0f - RadToDeg ((float)dec), axis);
// Translate moon distance
sgSetVec3 (v, 0, 0, distance);
sgMakeTransMat4 (D, v);
// Rotate to align moon equator with ecliptic
sgSetVec3 (axis, 1.0f, 0, 0);
sgMakeRotMat4 (ECLIPTIC, 90.0f, axis);
/// Rotate the moon image accurately towards the sun position
sgSetVec3 (axis, 0, 0, 1);
sgMakeRotMat4 (SPIN, spin, axis);
// Combine all transforms
sgMakeIdentMat4 (T);
sgPreMultMat4 (T, LAT);
sgPreMultMat4 (T, LST);
sgPreMultMat4 (T, RA);
sgPreMultMat4 (T, DEC);
sgPreMultMat4 (T, D);
sgPreMultMat4 (T, ECLIPTIC);
sgPreMultMat4 (T, SPIN);
}
/** \brief Create a rotation matrix
*
* This function creates a rotation matrix from the original
* OpenGL glRotatef commands in CRRCAirplaneLaRCSim::draw().
*
* \param m The matrix to be rotated
* \param phi Euler angle phi
* \param theta Euler angle theta
* \param psi Euler angle psi
*/
inline void makeOGLRotMat4(sgMat4 m, double phi, double theta, double psi)
{
sgMat4 temp;
sgVec3 rvec;
//~ sgSetVec3(rvec, 0.0, 1.0, 0.0);
//~ sgMakeRotMat4(temp, 90.0, rvec);
//~ sgPreMultMat4(m, temp);
sgSetVec3(rvec, 0.0, 1.0, 0.0);
sgMakeRotMat4(temp, 180.0f - (float)psi * SG_RADIANS_TO_DEGREES, rvec);
sgPreMultMat4(m, temp);
sgSetVec3(rvec, -1.0, 0.0, 0.0);
sgMakeRotMat4(temp, (float)theta * SG_RADIANS_TO_DEGREES, rvec);
sgPreMultMat4(m, temp);
sgSetVec3(rvec, 0.0, 0.0, 1.0);
sgMakeRotMat4(temp, (float)phi * SG_RADIANS_TO_DEGREES, rvec);
sgPreMultMat4(m, temp);
}
bool cGrStars::reposition( sgVec3 p, double angle )
{
sgMat4 T1, GST;
sgVec3 axis;
sgMakeTransMat4( T1, p );
sgSetVec3( axis, 0.0, 0.0, -1.0 );
sgMakeRotMat4( GST, (float)angle, axis );
sgMat4 TRANSFORM;
sgCopyMat4( TRANSFORM, T1 );
sgPreMultMat4( TRANSFORM, GST );
sgCoord skypos;
sgSetCoord( &skypos, TRANSFORM );
stars_transform->setTransform( &skypos );
return true;
}
/**
* \brief Tile the terrain
*
* This function recursively walks the scene graph and sorts all
* triangles into a grid of smaller graphs. This reduces the
* calculation effort: If the position of the plane and therefore
* the grid below it is known, only a small fraction of all
* triangles has to be tested.
*
* During the recursive walk down the tree, the function tracks
* all transformations. If a leaf node is encountered, the contained
* triangles are transformed by the tracked transformations to
* get the absolute position of each triangle. Then all triangles
* are sorted into the grid by their absolute position.
*
* \param e Pointer to the currently processed entity
* \param xform Reference to the current transformation
*/
void HD_TilingTerrain::tiling_terrain(ssgEntity * e, sgMat4 xform)
{
// only continue if HOT traversal is enabled for this entity
if ( e->getTraversalMask() & SSGTRAV_HOT )
{
if ( e->isAKindOf(ssgTypeBranch()) )
{
ssgBranch *br = (ssgBranch *) e ;
if ( e -> isA ( ssgTypeTransform() ) )
{
sgMat4 xform1;
((ssgTransform *)e)->getTransform ( xform1 ) ;
sgPreMultMat4 ( xform, xform1 ) ;//Pre or Post ???
/*
std::cout << "------tranform " << br<< std::endl;
std::cout << "-------------- " << xform[0][0]<<" "<< xform[0][1]<<" "<< xform[0][2]<<" "<< xform[0][3]<< std::endl;
std::cout << "-------------- " << xform[1][0]<<" "<< xform[1][1]<<" "<< xform[1][2]<<" "<< xform[1][3]<< std::endl;
std::cout << "-------------- " << xform[2][0]<<" "<< xform[2][1]<<" "<< xform[2][2]<<" "<< xform[2][3]<< std::endl;
std::cout << "-------------- " << xform[3][0]<<" "<< xform[3][1]<<" "<< xform[3][2]<<" "<< xform[3][3]<< std::endl;
*/
}
//else std::cout << "------branch " << br<< std::endl;
// Bug #16552: "xform" is actually passed by reference and
// not by value. Therefore we have to store it locally and
// restore it before recursing to the next child. Else all
// children receive an xform matrix that was modified by
// the previous child.
sgMat4 local_xform;
sgCopyMat4(local_xform, xform);
for ( int i = 0 ; i < br -> getNumKids () ; i++ )
{
tiling_terrain ( br -> getKid ( i ), xform);
// restore transformation matrix
sgCopyMat4(xform, local_xform);
}
}
else if ( e -> isAKindOf ( ssgTypeLeaf() ) )
{
//std::cout << "------leaf " << e<< std::endl;
ssgLeaf *leaf = (ssgLeaf *) e ;
int nt = leaf->getNumTriangles();
//std::cout << "------n triangles " << nt<< std::endl;
for ( int i = 0 ; i < nt ; i++ )//pour chaque triangle
{
short iv1,iv2,iv3;/*float *v1, *v2, *v3;*/
sgVec3 v1,v2,v3;
leaf->getTriangle ( i, &iv1, &iv2, &iv3 );
sgCopyVec3 (v1 , leaf->getVertex(iv1));
sgXformPnt3( v1, xform);
sgCopyVec3 (v2 , leaf->getVertex(iv2));
sgXformPnt3( v2, xform);
sgCopyVec3 (v3 , leaf->getVertex(iv3));
sgXformPnt3( v3, xform);
/*
std::cout << "------triangle " << std::endl;
std::cout << "-------------- " << v1[0]<<" "<< v1[1]<<" "<< v1[2]<<" "<< std::endl;
std::cout << "-------------- " << v2[0]<<" "<< v2[1]<<" "<< v2[2]<<" "<< std::endl;
std::cout << "-------------- " << v3[0]<<" "<< v3[1]<<" "<< v3[2]<<" "<< std::endl;
*/
//calcule cube englobant
sgBox box;
box.empty();
box.extend(v1);
box.extend(v2);
box.extend(v3);
//std::cout << "Min " << box.min[0]<<", "<<box.min[1]<<", "<<box.min[2]<<" Max"<<box.max[0]<<", "<<box.max[1]<<", "<<box.max[2]<< std::endl;
//ajoute dans cellules recouvertes
int save = 1;
int i1 = (int)(-0.1+box.min[0]/SIZE_CELL_GRID_PLANES) + SIZE_GRID_PLANES/2;
int i2 = (int)(0.1+box.max[0]/SIZE_CELL_GRID_PLANES) + SIZE_GRID_PLANES/2;
int j1 = (int)(-0.1+box.min[2]/SIZE_CELL_GRID_PLANES) + SIZE_GRID_PLANES/2;
int j2 = (int)(0.1+box.max[2]/SIZE_CELL_GRID_PLANES) + SIZE_GRID_PLANES/2;
if (((i1<0) && (i2<0)) ||((i1>SIZE_GRID_PLANES) && (i2>SIZE_GRID_PLANES)) )
{
save = 0;
}
if (((j1<0) && (j2<0)) ||((j1>SIZE_GRID_PLANES) && (j2>SIZE_GRID_PLANES)) )
{
save = 0;
}
if (i1<0)
i1=0;
if (i1>SIZE_GRID_PLANES)
i1 = SIZE_GRID_PLANES;
if (i2<0)
i2=0;
if (i2>SIZE_GRID_PLANES)
i2 = SIZE_GRID_PLANES;
if (j1<0)
j1=0;
if (j1>SIZE_GRID_PLANES)
j1 = SIZE_GRID_PLANES;
if (j2<0)
j2=0;
if (j2>SIZE_GRID_PLANES)
j2 = SIZE_GRID_PLANES;
//std::cout << "cellules i, j " << i1 <<", "<<i2<<", "<<j1<<","<<j2<< std::endl;
if (save)
{
for ( int i = i1 ; i <= i2; i++ )
{
for ( int j = j1 ; j <= j2; j++ )
{
//std::cout << "met dans cellule " << i <<", "<<j<< std::endl;
tile_table[i][j]->add(v1);
tile_table[i][j]->add(v2);
tile_table[i][j]->add(v3);
}
}
}
}
}
}
}
bool cGrCloudLayer::reposition( sgVec3 p, sgVec3 up, double lon, double lat, double alt, double dt )
{
sgMat4 T1, LON, LAT;
sgVec3 axis;
// combine p and asl (meters) to get translation offset
sgVec3 asl_offset;
sgCopyVec3( asl_offset, up );
sgNormalizeVec3( asl_offset );
if ( alt <= layer_asl )
{
sgScaleVec3( asl_offset, layer_asl );
}
else
{
sgScaleVec3( asl_offset, layer_asl + layer_thickness );
}
sgAddVec3( asl_offset, p );
// Translate to zero elevation
sgMakeTransMat4( T1, asl_offset );
// Rotate to proper orientation
sgSetVec3( axis, 0.0, 0.0, 1.0 );
sgMakeRotMat4( LON, (float)(lon * SGD_RADIANS_TO_DEGREES), axis );
sgSetVec3( axis, 0.0, 1.0, 0.0 );
sgMakeRotMat4( LAT, (float)(90.0 - lat * SGD_RADIANS_TO_DEGREES), axis );
sgMat4 TRANSFORM;
sgCopyMat4( TRANSFORM, T1 );
sgPreMultMat4( TRANSFORM, LON );
sgPreMultMat4( TRANSFORM, LAT );
sgCoord layerpos;
sgSetCoord( &layerpos, TRANSFORM );
layer_transform->setTransform( &layerpos );
// now calculate update texture coordinates
if ( last_lon < -900 )
{
last_lon = lon;
last_lat = lat;
}
double sp_dist = speed*dt;
if ( lon != last_lon || lat != last_lat || sp_dist != 0 )
{
double course = 0.0, dist = 0.0;
if ( lon != last_lon || lat != last_lat )
{
sgVec2 start, dest;
sgSetVec2(start, (float)last_lon, (float)last_lat);
sgSetVec2(dest, (float)lon, (float)lat);
calc_gc_course_dist( dest, start, &course, &dist );
}
// calculate cloud movement
double ax = 0.0, ay = 0.0, bx = 0.0, by = 0.0;
if (dist > 0.0)
{
ax = cos(course) * dist;
ay = sin(course) * dist;
}
if (sp_dist > 0)
{
bx = cos(-direction * SGD_DEGREES_TO_RADIANS) * sp_dist;
by = sin(-direction * SGD_DEGREES_TO_RADIANS) * sp_dist;
}
float xoff = (float)((ax + bx) / (2 * scale));
float yoff = (float)((ay + by) / (2 * scale));
const float layer_scale = layer_span / scale;
float *base, *tc;
base = tl[0]->get( 0 );
base[0] += xoff;
if ( base[0] > -10.0 && base[0] < 10.0 )
{
base[0] -= (int)base[0];
}
else
{
base[0] = 0.0;
ulSetError(UL_WARNING, "Warning: base1\n");
}
base[1] += yoff;
if ( base[1] > -10.0 && base[1] < 10.0 )
{
base[1] -= (int)base[1];
}
else
{
base[1] = 0.0;
ulSetError(UL_WARNING, "Warning: base2\n");
}
for (int i = 0; i < 4; i++)
{
tc = tl[i]->get( 0 );
sgSetVec2( tc, base[0] + layer_scale * i/4, base[1] );
for (int j = 0; j < 4; j++)
{
tc = tl[i]->get( j*2+1 );
sgSetVec2( tc, base[0] + layer_scale * (i+1)/4,
base[1] + layer_scale * j/4 );
tc = tl[i]->get( (j+1)*2 );
sgSetVec2( tc, base[0] + layer_scale * i/4,
base[1] + layer_scale * (j+1)/4 );
}
tc = tl[i]->get( 9 );
sgSetVec2( tc, base[0] + layer_scale * (i+1)/4,
base[1] + layer_scale );
}
last_lon = lon;
last_lat = lat;
}
return true;
}
//
// Update the position of the moon image in the sky
//
void CMoonImage::Reposition (sgVec3 p, double theta, double lst, double lat,
double ra, double dec, double spin)
{
sgMat4 LST, LAT, RA, DEC, D, SCALE, ECLIPTIC, SPIN;
sgVec3 axis;
sgVec3 v;
// Create scaling matrix for moon illusion (appears larger near horizon)
float scale = 1.0f;
sgMakeIdentMat4 (SCALE);
float maxMagnification = 0.5f;
float minThreshold = DegToRad (80.0f);
float maxThreshold = DegToRad (95.0f);
float span = maxThreshold - minThreshold;
if ((theta >= minThreshold) && (theta <= maxThreshold)) {
sgMat4 I;
sgMakeIdentMat4 (I);
scale = 1.0f + (maxMagnification * (theta - minThreshold) / span);
sgScaleMat4 (SCALE, I, scale);
}
// Rotation matrix for latitude
sgSetVec3 (axis, -1.0f, 0, 0);
sgMakeRotMat4 (LAT, 90.0f-(float)lat, axis);
// Rotation matrix for local sidereal time, converted from h to deg
sgSetVec3 (axis, 0, 0, -1.0f);
sgMakeRotMat4 (LST, ((float)lst * 15), axis);
// Rotation matrix for right ascension
sgSetVec3 (axis, 0, 0, 1);
sgMakeRotMat4 (RA, RadToDeg ((float)ra), axis);
// Rotation matrix for declination
sgSetVec3 (axis, 1, 0, 0);
sgMakeRotMat4 (DEC, 90.0f - RadToDeg ((float)dec), axis);
// Translate moon distance
sgSetVec3 (v, 0, 0, distance);
sgMakeTransMat4 (D, v);
// Rotate to align moon equator with ecliptic
sgSetVec3 (axis, 1.0f, 0, 0);
sgMakeRotMat4 (ECLIPTIC, 90.0f, axis);
/// Rotate the moon image accurately towards the sun position
sgSetVec3 (axis, 0, 0, 1);
sgMakeRotMat4 (SPIN, spin, axis);
// Combine all transforms
sgMakeIdentMat4 (T);
sgPreMultMat4 (T, LAT);
sgPreMultMat4 (T, LST);
sgPreMultMat4 (T, RA);
sgPreMultMat4 (T, DEC);
sgPreMultMat4 (T, D);
sgPreMultMat4 (T, ECLIPTIC);
sgPreMultMat4 (T, SPIN);
/*
char debug[256];
double jd = CTimeManager::Instance().GetJulianDate();
SDateTime dt = CTimeManager::Instance().GetLocalDateTime ();
sprintf (debug, "JD=%f D=%d/%d/%d T=%d:%d RA=%f Dec=%f", jd,
dt.date.year, dt.date.month, dt.date.day, dt.time.hour, dt.time.minute,
RadToDeg(ra), RadToDeg(dec));
DrawNoticeToUser (debug, 1);
*/
}
