src/Scenery/scenery.cxx

   1 // scenery.cxx -- data structures and routines for managing scenery.
   2 //
   3 // Written by Curtis Olson, started May 1997.
   4 //
   5 // Copyright (C) 1997  Curtis L. Olson  - http://www.flightgear.org/~curt
   6 //
   7 // This program is free software; you can redistribute it and/or
   8 // modify it under the terms of the GNU General Public License as
   9 // published by the Free Software Foundation; either version 2 of the
  10 // License, or (at your option) any later version.
  11 //
  12 // This program is distributed in the hope that it will be useful, but
  13 // WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15 // General Public License for more details.
  16 //
  17 // You should have received a copy of the GNU General Public License
  18 // along with this program; if not, write to the Free Software
  19 // Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 //
  21 // $Id$
  22
  23
  24 #ifdef HAVE_CONFIG_H
  25 #  include <config.h>
  26 #endif
  27
  28 #include <stdio.h>
  29 #include <string.h>
  30
  31 #include <simgear/debug/logstream.hxx>
  32 #include <simgear/scene/tgdb/userdata.hxx>
  33 #include <simgear/math/sg_geodesy.hxx>
  34 #include <simgear/scene/model/placementtrans.hxx>
  35
  36 #include <Main/fg_props.hxx>
  37
  38 #include "hitlist.hxx"
  39 #include "scenery.hxx"
  40
  41
  42 // Scenery Management system
  43 FGScenery::FGScenery() {
  44     SG_LOG( SG_TERRAIN, SG_INFO, "Initializing scenery subsystem" );
  45
  46     center = Point3D(0.0);
  47 }
  48
  49
  50 // Initialize the Scenery Management system
  51 FGScenery::~FGScenery() {
  52 }
  53
  54
  55 void FGScenery::init() {
  56     // Scene graph root
  57     scene_graph = new ssgRoot;
  58     scene_graph->setName( "Scene" );
  59
  60     // Terrain branch
  61     terrain_branch = new ssgBranch;
  62     terrain_branch->setName( "Terrain" );
  63     scene_graph->addKid( terrain_branch );
  64
  65     models_branch = new ssgBranch;
  66     models_branch->setName( "Models" );
  67     scene_graph->addKid( models_branch );
  68
  69     aircraft_branch = new ssgBranch;
  70     aircraft_branch->setName( "Aircraft" );
  71     scene_graph->addKid( aircraft_branch );
  72
  73     // Lighting
  74     gnd_lights_root = new ssgRoot;
  75     gnd_lights_root->setName( "Ground Lighting Root" );
  76
  77     vasi_lights_root = new ssgRoot;
  78     vasi_lights_root->setName( "VASI/PAPI Lighting Root" );
  79
  80     rwy_lights_root = new ssgRoot;
  81     rwy_lights_root->setName( "Runway Lighting Root" );
  82
  83     taxi_lights_root = new ssgRoot;
  84     taxi_lights_root->setName( "Taxi Lighting Root" );
  85
  86     // Initials values needed by the draw-time object loader
  87     sgUserDataInit( globals->get_model_lib(), globals->get_fg_root(),
  88                     globals->get_props(), globals->get_sim_time_sec() );
  89 }
  90
  91
  92 void FGScenery::update(double dt) {
  93 }
  94
  95
  96 void FGScenery::bind() {
  97 }
  98
  99
 100 void FGScenery::unbind() {
 101 }
 102
 103 void FGScenery::set_center( const Point3D& p ) {
 104     center = p;
 105     sgdVec3 c;
 106     sgdSetVec3(c, p.x(), p.y(), p.z());
 107     placement_list_type::iterator it = _placement_list.begin();
 108     while (it != _placement_list.end()) {
 109         (*it)->setSceneryCenter(c);
 110         ++it;
 111     }
 112 }
 113
 114 void FGScenery::register_placement_transform(ssgPlacementTransform *trans) {
 115     trans->ref();
 116     _placement_list.push_back(trans);
 117     sgdVec3 c;
 118     sgdSetVec3(c, center.x(), center.y(), center.z());
 119     trans->setSceneryCenter(c);
 120 }
 121
 122 void FGScenery::unregister_placement_transform(ssgPlacementTransform *trans) {
 123     placement_list_type::iterator it = _placement_list.begin();
 124     while (it != _placement_list.end()) {
 125         if ((*it) == trans) {
 126             it = _placement_list.erase(it);
 127             ssgDeRefDelete(trans);
 128         } else
 129             ++it;
 130     }
 131 }
 132
 133 bool
 134 FGScenery::get_elevation_m(double lat, double lon, double max_alt,
 135                            double& alt, bool exact)
 136 {
 137 //   std::cout << __PRETTY_FUNCTION__ << " "
 138 //             << lat << " "
 139 //             << lon << " "
 140 //             << max_alt
 141 //             << std::endl;
 142   sgdVec3 pos;
 143   sgGeodToCart(lat*SG_DEGREES_TO_RADIANS, lon*SG_DEGREES_TO_RADIANS,
 144                max_alt, pos);
 145   return get_cart_elevation_m(pos, 0, alt, exact);
 146 }
 147
 148 bool
 149 FGScenery::get_cart_elevation_m(const sgdVec3& pos, double max_altoff,
 150                                 double& alt, bool exact)
 151 {
 152   Point3D saved_center = center;
 153   bool replaced_center = false;
 154   if (exact) {
 155     Point3D ppos(pos[0], pos[1], pos[2]);
 156     if (30.0*30.0 < ppos.distance3Dsquared(center)) {
 157       set_center( ppos );
 158       replaced_center = false;
 159     }
 160   }
 161
 162   // overridden with actual values if a terrain intersection is
 163   // found
 164   double hit_radius = 0.0;
 165   sgdVec3 hit_normal = { 0.0, 0.0, 0.0 };
 166
 167   bool hit = false;
 168   if ( fabs(pos[0]) > 1.0 || fabs(pos[1]) > 1.0 || fabs(pos[2]) > 1.0 ) {
 169     sgdVec3 sc;
 170     sgdSetVec3(sc, center[0], center[1], center[2]);
 171
 172     sgdVec3 ncpos;
 173     sgdCopyVec3(ncpos, pos);
 174
 175     FGHitList hit_list;
 176
 177     // scenery center has been properly defined so any hit should
 178     // be valid (and not just luck)
 179     hit = fgCurrentElev(ncpos, max_altoff+sgdLengthVec3(pos),
 180                         sc, (ssgTransform*)get_scene_graph(),
 181                         &hit_list, &alt, &hit_radius, hit_normal);
 182   }
 183
 184   if (replaced_center)
 185     set_center( saved_center );
 186
 187   return hit;
 188 }
 189
 190
 191 bool
 192 FGScenery::get_cart_ground_intersection(const sgdVec3& pos,
 193                                         const sgdVec3& dir,
 194                                         sgdVec3& nearestHit, bool exact)
 195 {
 196   // We assume that starting positions in the center of the earth are invalid
 197   if ( fabs(pos[0]) < 1.0 && fabs(pos[1]) < 1.0 && fabs(pos[2]) < 1.0 )
 198     return false;
 199
 200   // Well that 'exactness' is somehow problematic, but makes at least sure
 201   // that we don't compute that with a cenery center at the other side of
 202   // the world ...
 203   Point3D saved_center = center;
 204   bool replaced_center = false;
 205   if (exact) {
 206     Point3D ppos(pos[0], pos[1], pos[2]);
 207     if (30.0*30.0 < ppos.distance3Dsquared(center)) {
 208       set_center( ppos );
 209       replaced_center = true;
 210     }
 211   }
 212
 213   // Not yet found any hit ...
 214   bool result = false;
 215
 216   // Make really sure the direction is normalized, is really cheap compared to
 217   // computation of ground intersection.
 218   sgdVec3 normalizedDir;
 219   sgdCopyVec3(normalizedDir, dir);
 220   sgdNormaliseVec3(normalizedDir);
 221
 222   sgdVec3 sceneryCenter;
 223   sgdSetVec3(sceneryCenter, center[0], center[1], center[2]);
 224   sgdVec3 relativePos;
 225   sgdSubVec3(relativePos, pos, sceneryCenter);
 226
 227   // At the moment only intersection with the terrain?
 228   FGHitList hit_list;
 229   hit_list.Intersect(globals->get_scenery()->get_terrain_branch(),
 230                      relativePos, normalizedDir);
 231
 232   double dist = DBL_MAX;
 233   int hitcount = hit_list.num_hits();
 234   for (int i = 0; i < hitcount; ++i) {
 235     // Check for the nearest hit
 236     sgdVec3 diff;
 237     sgdSubVec3(diff, hit_list.get_point(i), relativePos);
 238
 239     // We only want hits in front of us ...
 240     if (sgdScalarProductVec3(normalizedDir, diff) < 0)
 241       continue;
 242
 243     // find the nearest hit
 244     double nDist = sgdScalarProductVec3(diff, diff);
 245     if (dist < nDist)
 246       continue;
 247
 248     // Store the hit point
 249     dist = nDist;
 250     sgdAddVec3(nearestHit, hit_list.get_point(i), sceneryCenter);
 251     result = true;
 252   }
 253
 254   if (replaced_center)
 255     set_center( saved_center );
 256
 257   return result;
 258 }
 259