Airports/genapt.cxx

   1 //
   2 // getapt.cxx -- generate airport scenery from the given definition file
   3 //
   4 // Written by Curtis Olson, started September 1998.
   5 //
   6 // Copyright (C) 1998  Curtis L. Olson  - curt@me.umn.edu
   7 //
   8 // This program is free software; you can redistribute it and/or
   9 // modify it under the terms of the GNU General Public License as
  10 // published by the Free Software Foundation; either version 2 of the
  11 // License, or (at your option) any later version.
  12 //
  13 // This program is distributed in the hope that it will be useful, but
  14 // WITHOUT ANY WARRANTY; without even the implied warranty of
  15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16 // General Public License for more details.
  17 //
  18 // You should have received a copy of the GNU General Public License
  19 // along with this program; if not, write to the Free Software
  20 // Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 //
  22 // $Id$
  23 // (Log is kept at end of this file)
  24
  25
  26 #include <string>        // Standard C++ string library
  27 #include <vector>
  28 #include "Include/fg_stl_config.h"
  29
  30 #ifdef NEEDNAMESPACESTD
  31 using namespace std;
  32 #endif
  33
  34 #include <Debug/fg_debug.h>
  35 #include <Include/fg_types.h>
  36 #include <Math/fg_geodesy.h>
  37 #include <Math/mat3.h>
  38 #include <Math/polar3d.hxx>
  39 #include <Misc/fgstream.hxx>
  40 #include <Objects/material.hxx>
  41
  42 // #include <gpc/gpc.h>
  43
  44 #include "genapt.hxx"
  45
  46
  47 typedef vector < fgPoint3d > container;
  48 typedef container::iterator iterator;
  49 typedef container::const_iterator const_iterator;
  50
  51
  52 // Calculate distance between to fgPoint3d's
  53 static double calc_dist(const fgPoint3d& p1, const fgPoint3d& p2) {
  54     double x, y, z;
  55     x = p1.x - p2.x;
  56     y = p1.y - p2.y;
  57     z = p1.z - p2.z;
  58     return sqrt(x*x + y*y + z*z);
  59 }
  60
  61
  62 // convert a geodetic point lon(degrees), lat(degrees), elev(meter) to a
  63 // cartesian point
  64 static fgPoint3d geod_to_cart(fgPoint3d geod) {
  65     fgPoint3d cart;
  66     fgPoint3d geoc;
  67     double sl_radius;
  68
  69     // printf("A geodetic point is (%.2f, %.2f, %.2f)\n", geod[0],
  70     //        geod[1], geod[2]);
  71
  72     geoc.lon = geod.lon*DEG_TO_RAD;
  73     fgGeodToGeoc(geod.lat*DEG_TO_RAD, geod.radius, &sl_radius, &geoc.lat);
  74
  75     // printf("A geocentric point is (%.2f, %.2f, %.2f)\n", gc_lon,
  76     //        gc_lat, sl_radius+geod[2]); */
  77
  78     geoc.radius = sl_radius + geod.radius;
  79     cart = fgPolarToCart3d(geoc);
  80
  81     // printf("A cart point is (%.8f, %.8f, %.8f)\n", cp.x, cp.y, cp.z);
  82
  83     return cart;
  84 }
  85
  86
  87 #define FG_APT_BASE_TEX_CONSTANT 2000.0
  88
  89 // Calculate texture coordinates for a given point.
  90 static fgPoint3d
  91 calc_tex_coords(const fgPoint3d& p) {
  92     fgPoint3d tex;
  93
  94     cout << "Texture coordinates = " <<
  95         FG_APT_BASE_TEX_CONSTANT * p.lon << "  " <<
  96         FG_APT_BASE_TEX_CONSTANT * p.lat << "\n";
  97
  98     tex.x = fmod(FG_APT_BASE_TEX_CONSTANT * p.lon, 10.0);
  99     tex.y = fmod(FG_APT_BASE_TEX_CONSTANT * p.lat, 10.0);
 100
 101     if ( tex.x < 0.0 ) {
 102         tex.x += 10.0;
 103     }
 104
 105     if ( tex.y < 0.0 ) {
 106         tex.y += 10.0;
 107     }
 108
 109     cout << "Texture coordinates = " << tex.x << "  " << tex.y << "\n";
 110
 111     return tex;
 112 }
 113
 114
 115 // generate the actual base area for the airport
 116 static void
 117 gen_base( const fgPoint3d& average, const container& perimeter, fgTILE *t)
 118 {
 119     GLint display_list;
 120     fgPoint3d ave_cart, cart, cart_trans, tex;
 121     MAT3vec normal;
 122     double dist, max_dist, temp;
 123     int center_num, i;
 124
 125     fgFRAGMENT fragment;
 126
 127     max_dist = 0.0;
 128
 129     cout << "generating airport base for size = " << perimeter.size() << "\n";
 130
 131     fragment.init();
 132     fragment.tile_ptr = t;
 133
 134     // find airport base material in the properties list
 135     if ( ! material_mgr.find( APT_BASE_MATERIAL, fragment.material_ptr )) {
 136         fgPrintf( FG_TERRAIN, FG_ALERT,
 137                   "Ack! unknown material name = %s in fgAptGenerat()\n",
 138                   APT_BASE_MATERIAL );
 139     }
 140
 141     ave_cart = geod_to_cart( average );
 142     printf(" tile center = %.2f %.2f %.2f\n",
 143            t->center.x, t->center.y, t->center.z);
 144     printf(" airport center = %.2f %.2f %.2f\n",
 145            average.x, average.y, average.z);
 146     printf(" airport center = %.2f %.2f %.2f\n",
 147            ave_cart.x, ave_cart.y, ave_cart.z);
 148     fragment.center.x = ave_cart.x;
 149     fragment.center.y = ave_cart.y;
 150     fragment.center.z = ave_cart.z;
 151
 152     normal[0] = ave_cart.x;
 153     normal[1] = ave_cart.y;
 154     normal[2] = ave_cart.z;
 155     MAT3_NORMALIZE_VEC(normal, temp);
 156
 157     display_list = xglGenLists(1);
 158     xglNewList(display_list, GL_COMPILE);
 159     xglBegin(GL_TRIANGLE_FAN);
 160
 161     // center of fan
 162     cart_trans.x = ave_cart.x - t->center.x;
 163     cart_trans.y = ave_cart.y - t->center.y;
 164     cart_trans.z = ave_cart.z - t->center.z;
 165     t->nodes[t->ncount][0] = cart_trans.x;
 166     t->nodes[t->ncount][1] = cart_trans.y;
 167     t->nodes[t->ncount][2] = cart_trans.z;
 168     t->ncount++;
 169
 170     tex = calc_tex_coords( average );
 171     xglTexCoord2f(tex.x, tex.y);
 172     xglNormal3dv(normal);
 173     xglVertex3d(cart_trans.x, cart_trans.y, cart_trans.z);
 174
 175     // first point (center of fan)
 176     iterator current = perimeter.begin();
 177     cart = geod_to_cart( *current );
 178     cart_trans.x = cart.x - t->center.x;
 179     cart_trans.y = cart.y - t->center.y;
 180     cart_trans.z = cart.z - t->center.z;
 181     center_num = t->ncount;
 182     t->nodes[t->ncount][0] = cart_trans.x;
 183     t->nodes[t->ncount][1] = cart_trans.y;
 184     t->nodes[t->ncount][2] = cart_trans.z;
 185     t->ncount++;
 186
 187     tex = calc_tex_coords( *current );
 188     dist = calc_dist(ave_cart, cart);
 189     if ( dist > max_dist ) {
 190         max_dist = dist;
 191     }
 192     xglTexCoord2f(tex.x, tex.y);
 193     xglVertex3d(cart_trans.x, cart_trans.y, cart_trans.z);
 194
 195     const_iterator last = perimeter.end();
 196     for ( ; current != last; ++current ) {
 197         cart = geod_to_cart( *current );
 198         cart_trans.x = cart.x - t->center.x;
 199         cart_trans.y = cart.y - t->center.y;
 200         cart_trans.z = cart.z - t->center.z;
 201         t->nodes[t->ncount][0] = cart_trans.x;
 202         t->nodes[t->ncount][1] = cart_trans.y;
 203         t->nodes[t->ncount][2] = cart_trans.z;
 204         t->ncount++;
 205         fragment.add_face(center_num, t->ncount - 2, t->ncount - 1);
 206
 207         tex = calc_tex_coords( *current );
 208         dist = calc_dist(ave_cart, cart);
 209         if ( dist > max_dist ) {
 210             max_dist = dist;
 211         }
 212         xglTexCoord2f(tex.x, tex.y);
 213         xglVertex3d(cart_trans.x, cart_trans.y, cart_trans.z);
 214     }
 215
 216     // last point (first point in perimeter list)
 217     current = perimeter.begin();
 218     cart = geod_to_cart( *current );
 219     cart_trans.x = cart.x - t->center.x;
 220     cart_trans.y = cart.y - t->center.y;
 221     cart_trans.z = cart.z - t->center.z;
 222     fragment.add_face(center_num, t->ncount - 1, center_num + 1);
 223
 224     tex = calc_tex_coords( *current );
 225     xglTexCoord2f(tex.x, tex.y);
 226     xglVertex3d(cart_trans.x, cart_trans.y, cart_trans.z);
 227
 228     xglEnd();
 229     xglEndList();
 230
 231     fragment.bounding_radius = max_dist;
 232     fragment.display_list = display_list;
 233
 234     t->fragment_list.push_back(fragment);
 235 }
 236
 237
 238 // Load a .apt file and register the GL fragments with the
 239 // corresponding tile
 240 int
 241 fgAptGenerate(const string& path, fgTILE *tile)
 242 {
 243     string token;
 244     string apt_id, apt_name;
 245     char c;
 246
 247     // face list (this indexes into the master tile vertex list)
 248     container perimeter;
 249     fgPoint3d p, average;
 250     int size;
 251
 252     // gpc_vertex p_2d, list_2d[MAX_PERIMETER];
 253     // gpc_vertex_list perimeter_2d;
 254
 255     fg_gzifstream in( path );
 256     if ( !in ) {
 257         // exit immediately assuming an airport file for this tile
 258         // doesn't exist.
 259         return 0;
 260     }
 261
 262     apt_id = "";
 263
 264     // read in each line of the file
 265     in.eat_comments();
 266     while ( ! in.eof() )
 267     {
 268         in.stream() >> token;
 269
 270         if ( token == "a" ) {
 271             // airport info record (start of airport)
 272
 273             if ( apt_id != "" ) {
 274                 // we have just finished reading and airport record.
 275                 // process the info
 276                 gen_base(average, perimeter, tile);
 277             }
 278
 279             cout << "Reading airport record\n";
 280             in.stream() >> apt_id;
 281             apt_name = "";
 282             average.lon = average.lat = average.radius = 0.0;
 283             perimeter.erase( perimeter.begin(), perimeter.end() );
 284             // skip to end of line.
 285             while ( in.get(c) && c != '\n' ) {
 286                 apt_name += c;
 287             }
 288             cout << "\tID = " + apt_id + "  Name = " + apt_name + "\n";
 289         } else if ( token == "p" ) {
 290             // airport area bounding polygon coordinate.  These
 291             // specify a convex hull that should already have been cut
 292             // out of the base terrain.  The points are given in
 293             // counter clockwise order and are specified in lon/lat
 294             // degrees.
 295             in.stream() >> p.lon >> p.lat >> p.radius;
 296             average.lon += p.lon;
 297             average.lat += p.lat;
 298             average.radius += p.radius;
 299             perimeter.push_back(p);
 300         } else if ( token == "r" ) {
 301             // runway record
 302             // skip for now
 303             while ( in.get(c) && c != '\n' );
 304         }
 305
 306         // airports.insert(a);
 307         in.eat_comments();
 308     }
 309
 310     if ( apt_id != "" ) {
 311         // we have just finished reading and airport record.
 312         // process the info
 313         size = perimeter.size();
 314         average.lon /= (double)size;
 315         average.lat /= (double)size;
 316         average.radius /= (double)size;
 317
 318         gen_base(average, perimeter, tile);
 319     }
 320
 321     return 1;
 322 }
 323
 324
 325 // $Log$
 326 // Revision 1.1  1998/09/14 02:14:01  curt
 327 // Initial revision of genapt.[ch]xx for generating airport scenery.
 328 //
 329 //
 330