simgear/scene/tgdb/obj.cxx

   1 // obj.cxx -- routines to handle loading scenery and building the plib
   2 //            scene graph.
   3 //
   4 // Written by Curtis Olson, started October 1997.
   5 //
   6 // Copyright (C) 1997  Curtis L. Olson  - http://www.flightgear.org/~curt
   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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  21 //
  22 // $Id$
  23
  24
  25 #ifdef HAVE_CONFIG_H
  26 #  include <simgear_config.h>
  27 #endif
  28
  29 #include "obj.hxx"
  30
  31 #include <simgear/compiler.h>
  32
  33 #include <osg/Fog>
  34 #include <osg/Geode>
  35 #include <osg/Geometry>
  36 #include <osg/Group>
  37 #include <osg/LOD>
  38 #include <osg/MatrixTransform>
  39 #include <osg/Point>
  40 #include <osg/StateSet>
  41 #include <osg/Switch>
  42
  43 #include <boost/foreach.hpp>
  44
  45 #include <algorithm>
  46
  47 #include <simgear/debug/logstream.hxx>
  48 #include <simgear/io/sg_binobj.hxx>
  49 #include <simgear/math/sg_geodesy.hxx>
  50 #include <simgear/math/sg_random.h>
  51 #include <simgear/math/SGMisc.hxx>
  52 #include <simgear/scene/material/Effect.hxx>
  53 #include <simgear/scene/material/EffectGeode.hxx>
  54 #include <simgear/scene/material/mat.hxx>
  55 #include <simgear/scene/material/matlib.hxx>
  56 #include <simgear/scene/model/SGOffsetTransform.hxx>
  57 #include <simgear/scene/util/SGUpdateVisitor.hxx>
  58 #include <simgear/scene/util/SGNodeMasks.hxx>
  59 #include <simgear/scene/util/QuadTreeBuilder.hxx>
  60
  61 #include "SGTexturedTriangleBin.hxx"
  62 #include "SGLightBin.hxx"
  63 #include "SGModelBin.hxx"
  64 #include "SGBuildingBin.hxx"
  65 #include "TreeBin.hxx"
  66 #include "SGDirectionalLightBin.hxx"
  67 #include "GroundLightManager.hxx"
  68
  69
  70 #include "pt_lights.hxx"
  71
  72 using namespace simgear;
  73
  74 typedef std::map<std::string,SGTexturedTriangleBin> SGMaterialTriangleMap;
  75 typedef std::list<SGLightBin> SGLightListBin;
  76 typedef std::list<SGDirectionalLightBin> SGDirectionalLightListBin;
  77
  78 struct SGTileGeometryBin {
  79   SGMaterialTriangleMap materialTriangleMap;
  80   SGLightBin tileLights;
  81   SGLightBin randomTileLights;
  82   SGTreeBinList randomForest;
  83   SGDirectionalLightBin runwayLights;
  84   SGDirectionalLightBin taxiLights;
  85   SGDirectionalLightListBin vasiLights;
  86   SGDirectionalLightListBin rabitLights;
  87   SGLightListBin odalLights;
  88   SGDirectionalLightListBin holdshortLights;
  89   SGDirectionalLightListBin reilLights;
  90   SGMatModelBin randomModels;
  91   SGBuildingBinList randomBuildings;
  92
  93   static SGVec4f
  94   getMaterialLightColor(const SGMaterial* material)
  95   {
  96     if (!material)
  97       return SGVec4f(1, 1, 1, 0.8);
  98     return material->get_light_color();
  99   }
 100
 101   static void
 102   addPointGeometry(SGLightBin& lights,
 103                    const std::vector<SGVec3d>& vertices,
 104                    const SGVec4f& color,
 105                    const int_list& pts_v)
 106   {
 107     for (unsigned i = 0; i < pts_v.size(); ++i)
 108       lights.insert(toVec3f(vertices[pts_v[i]]), color);
 109   }
 110
 111   static void
 112   addPointGeometry(SGDirectionalLightBin& lights,
 113                    const std::vector<SGVec3d>& vertices,
 114                    const std::vector<SGVec3f>& normals,
 115                    const SGVec4f& color,
 116                    const int_list& pts_v,
 117                    const int_list& pts_n)
 118   {
 119     // If the normal indices match the vertex indices, use seperate
 120     // normal indices. Else reuse the vertex indices for the normals.
 121     if (pts_v.size() == pts_n.size()) {
 122       for (unsigned i = 0; i < pts_v.size(); ++i)
 123         lights.insert(toVec3f(vertices[pts_v[i]]), normals[pts_n[i]], color);
 124     } else {
 125       for (unsigned i = 0; i < pts_v.size(); ++i)
 126         lights.insert(toVec3f(vertices[pts_v[i]]), normals[pts_v[i]], color);
 127     }
 128   }
 129
 130   bool
 131   insertPtGeometry(const SGBinObject& obj, SGMaterialLib* matlib)
 132   {
 133     if (obj.get_pts_v().size() != obj.get_pts_n().size()) {
 134       SG_LOG(SG_TERRAIN, SG_ALERT,
 135              "Group list sizes for points do not match!");
 136       return false;
 137     }
 138
 139     for (unsigned grp = 0; grp < obj.get_pts_v().size(); ++grp) {
 140       std::string materialName = obj.get_pt_materials()[grp];
 141       SGMaterial* material = 0;
 142       if (matlib)
 143           material = matlib->find(materialName);
 144       SGVec4f color = getMaterialLightColor(material);
 145
 146       if (3 <= materialName.size() && materialName.substr(0, 3) != "RWY") {
 147         // Just plain lights. Not something for the runway.
 148         addPointGeometry(tileLights, obj.get_wgs84_nodes(), color,
 149                          obj.get_pts_v()[grp]);
 150       } else if (materialName == "RWY_BLUE_TAXIWAY_LIGHTS"
 151                  || materialName == "RWY_GREEN_TAXIWAY_LIGHTS") {
 152         addPointGeometry(taxiLights, obj.get_wgs84_nodes(), obj.get_normals(),
 153                          color, obj.get_pts_v()[grp], obj.get_pts_n()[grp]);
 154       } else if (materialName == "RWY_VASI_LIGHTS") {
 155         vasiLights.push_back(SGDirectionalLightBin());
 156         addPointGeometry(vasiLights.back(), obj.get_wgs84_nodes(),
 157                          obj.get_normals(), color, obj.get_pts_v()[grp],
 158                          obj.get_pts_n()[grp]);
 159       } else if (materialName == "RWY_SEQUENCED_LIGHTS") {
 160         rabitLights.push_back(SGDirectionalLightBin());
 161         addPointGeometry(rabitLights.back(), obj.get_wgs84_nodes(),
 162                          obj.get_normals(), color, obj.get_pts_v()[grp],
 163                          obj.get_pts_n()[grp]);
 164       } else if (materialName == "RWY_ODALS_LIGHTS") {
 165         odalLights.push_back(SGLightBin());
 166         addPointGeometry(odalLights.back(), obj.get_wgs84_nodes(),
 167                          color, obj.get_pts_v()[grp]);
 168       } else if (materialName == "RWY_YELLOW_PULSE_LIGHTS") {
 169         holdshortLights.push_back(SGDirectionalLightBin());
 170         addPointGeometry(holdshortLights.back(), obj.get_wgs84_nodes(),
 171                          obj.get_normals(), color, obj.get_pts_v()[grp],
 172                          obj.get_pts_n()[grp]);
 173       } else if (materialName == "RWY_REIL_LIGHTS") {
 174         reilLights.push_back(SGDirectionalLightBin());
 175         addPointGeometry(reilLights.back(), obj.get_wgs84_nodes(),
 176                          obj.get_normals(), color, obj.get_pts_v()[grp],
 177                          obj.get_pts_n()[grp]);
 178       } else {
 179         // what is left must be runway lights
 180         addPointGeometry(runwayLights, obj.get_wgs84_nodes(),
 181                          obj.get_normals(), color, obj.get_pts_v()[grp],
 182                          obj.get_pts_n()[grp]);
 183       }
 184     }
 185
 186     return true;
 187   }
 188
 189
 190   static SGVec2f
 191   getTexCoord(const std::vector<SGVec2f>& texCoords, const int_list& tc,
 192               const SGVec2f& tcScale, unsigned i)
 193   {
 194     if (tc.empty())
 195       return tcScale;
 196     else if (tc.size() == 1)
 197       return mult(texCoords[tc[0]], tcScale);
 198     else
 199       return mult(texCoords[tc[i]], tcScale);
 200   }
 201
 202   static void
 203   addTriangleGeometry(SGTexturedTriangleBin& triangles,
 204                       const std::vector<SGVec3d>& vertices,
 205                       const std::vector<SGVec3f>& normals,
 206                       const std::vector<SGVec2f>& texCoords,
 207                       const int_list& tris_v,
 208                       const int_list& tris_n,
 209                       const int_list& tris_tc,
 210                       const SGVec2f& tcScale)
 211   {
 212     if (tris_v.size() != tris_n.size()) {
 213       // If the normal indices do not match, they should be inmplicitly
 214       // the same than the vertex indices. So just call ourselves again
 215       // with the matching index vector.
 216       addTriangleGeometry(triangles, vertices, normals, texCoords,
 217                           tris_v, tris_v, tris_tc, tcScale);
 218       return;
 219     }
 220
 221     for (unsigned i = 2; i < tris_v.size(); i += 3) {
 222       SGVertNormTex v0;
 223       v0.vertex = toVec3f(vertices[tris_v[i-2]]);
 224       v0.normal = normals[tris_n[i-2]];
 225       v0.texCoord = getTexCoord(texCoords, tris_tc, tcScale, i-2);
 226       SGVertNormTex v1;
 227       v1.vertex = toVec3f(vertices[tris_v[i-1]]);
 228       v1.normal = normals[tris_n[i-1]];
 229       v1.texCoord = getTexCoord(texCoords, tris_tc, tcScale, i-1);
 230       SGVertNormTex v2;
 231       v2.vertex = toVec3f(vertices[tris_v[i]]);
 232       v2.normal = normals[tris_n[i]];
 233       v2.texCoord = getTexCoord(texCoords, tris_tc, tcScale, i);
 234       triangles.insert(v0, v1, v2);
 235     }
 236   }
 237
 238   static void
 239   addStripGeometry(SGTexturedTriangleBin& triangles,
 240                    const std::vector<SGVec3d>& vertices,
 241                    const std::vector<SGVec3f>& normals,
 242                    const std::vector<SGVec2f>& texCoords,
 243                    const int_list& strips_v,
 244                    const int_list& strips_n,
 245                    const int_list& strips_tc,
 246                    const SGVec2f& tcScale)
 247   {
 248     if (strips_v.size() != strips_n.size()) {
 249       // If the normal indices do not match, they should be inmplicitly
 250       // the same than the vertex indices. So just call ourselves again
 251       // with the matching index vector.
 252       addStripGeometry(triangles, vertices, normals, texCoords,
 253                        strips_v, strips_v, strips_tc, tcScale);
 254       return;
 255     }
 256
 257     for (unsigned i = 2; i < strips_v.size(); ++i) {
 258       SGVertNormTex v0;
 259       v0.vertex = toVec3f(vertices[strips_v[i-2]]);
 260       v0.normal = normals[strips_n[i-2]];
 261       v0.texCoord = getTexCoord(texCoords, strips_tc, tcScale, i-2);
 262       SGVertNormTex v1;
 263       v1.vertex = toVec3f(vertices[strips_v[i-1]]);
 264       v1.normal = normals[strips_n[i-1]];
 265       v1.texCoord = getTexCoord(texCoords, strips_tc, tcScale, i-1);
 266       SGVertNormTex v2;
 267       v2.vertex = toVec3f(vertices[strips_v[i]]);
 268       v2.normal = normals[strips_n[i]];
 269       v2.texCoord = getTexCoord(texCoords, strips_tc, tcScale, i);
 270       if (i%2)
 271         triangles.insert(v1, v0, v2);
 272       else
 273         triangles.insert(v0, v1, v2);
 274     }
 275   }
 276
 277   static void
 278   addFanGeometry(SGTexturedTriangleBin& triangles,
 279                  const std::vector<SGVec3d>& vertices,
 280                  const std::vector<SGVec3f>& normals,
 281                  const std::vector<SGVec2f>& texCoords,
 282                  const int_list& fans_v,
 283                  const int_list& fans_n,
 284                  const int_list& fans_tc,
 285                  const SGVec2f& tcScale)
 286   {
 287     if (fans_v.size() != fans_n.size()) {
 288       // If the normal indices do not match, they should be implicitly
 289       // the same than the vertex indices. So just call ourselves again
 290       // with the matching index vector.
 291       addFanGeometry(triangles, vertices, normals, texCoords,
 292                      fans_v, fans_v, fans_tc, tcScale);
 293       return;
 294     }
 295
 296     SGVertNormTex v0;
 297     v0.vertex = toVec3f(vertices[fans_v[0]]);
 298     v0.normal = normals[fans_n[0]];
 299     v0.texCoord = getTexCoord(texCoords, fans_tc, tcScale, 0);
 300     SGVertNormTex v1;
 301     v1.vertex = toVec3f(vertices[fans_v[1]]);
 302     v1.normal = normals[fans_n[1]];
 303     v1.texCoord = getTexCoord(texCoords, fans_tc, tcScale, 1);
 304     for (unsigned i = 2; i < fans_v.size(); ++i) {
 305       SGVertNormTex v2;
 306       v2.vertex = toVec3f(vertices[fans_v[i]]);
 307       v2.normal = normals[fans_n[i]];
 308       v2.texCoord = getTexCoord(texCoords, fans_tc, tcScale, i);
 309       triangles.insert(v0, v1, v2);
 310       v1 = v2;
 311     }
 312   }
 313
 314   SGVec2f getTexCoordScale(const std::string& name, SGMaterialLib* matlib)
 315   {
 316     if (!matlib)
 317       return SGVec2f(1, 1);
 318     SGMaterial* material = matlib->find(name);
 319     if (!material)
 320       return SGVec2f(1, 1);
 321
 322     return material->get_tex_coord_scale();
 323   }
 324
 325   bool
 326   insertSurfaceGeometry(const SGBinObject& obj, SGMaterialLib* matlib)
 327   {
 328     if (obj.get_tris_n().size() < obj.get_tris_v().size() ||
 329         obj.get_tris_tc().size() < obj.get_tris_v().size()) {
 330       SG_LOG(SG_TERRAIN, SG_ALERT,
 331              "Group list sizes for triangles do not match!");
 332       return false;
 333     }
 334
 335     for (unsigned grp = 0; grp < obj.get_tris_v().size(); ++grp) {
 336       std::string materialName = obj.get_tri_materials()[grp];
 337       SGVec2f tcScale = getTexCoordScale(materialName, matlib);
 338       addTriangleGeometry(materialTriangleMap[materialName],
 339                           obj.get_wgs84_nodes(), obj.get_normals(),
 340                           obj.get_texcoords(), obj.get_tris_v()[grp],
 341                           obj.get_tris_n()[grp], obj.get_tris_tc()[grp],
 342                           tcScale);
 343     }
 344
 345     if (obj.get_strips_n().size() < obj.get_strips_v().size() ||
 346         obj.get_strips_tc().size() < obj.get_strips_v().size()) {
 347       SG_LOG(SG_TERRAIN, SG_ALERT,
 348              "Group list sizes for strips do not match!");
 349       return false;
 350     }
 351     for (unsigned grp = 0; grp < obj.get_strips_v().size(); ++grp) {
 352       std::string materialName = obj.get_strip_materials()[grp];
 353       SGVec2f tcScale = getTexCoordScale(materialName, matlib);
 354       addStripGeometry(materialTriangleMap[materialName],
 355                        obj.get_wgs84_nodes(), obj.get_normals(),
 356                        obj.get_texcoords(), obj.get_strips_v()[grp],
 357                        obj.get_strips_n()[grp], obj.get_strips_tc()[grp],
 358                        tcScale);
 359     }
 360
 361     if (obj.get_fans_n().size() < obj.get_fans_v().size() ||
 362         obj.get_fans_tc().size() < obj.get_fans_v().size()) {
 363       SG_LOG(SG_TERRAIN, SG_ALERT,
 364              "Group list sizes for fans do not match!");
 365       return false;
 366     }
 367     for (unsigned grp = 0; grp < obj.get_fans_v().size(); ++grp) {
 368       std::string materialName = obj.get_fan_materials()[grp];
 369       SGVec2f tcScale = getTexCoordScale(materialName, matlib);
 370       addFanGeometry(materialTriangleMap[materialName],
 371                      obj.get_wgs84_nodes(), obj.get_normals(),
 372                      obj.get_texcoords(), obj.get_fans_v()[grp],
 373                      obj.get_fans_n()[grp], obj.get_fans_tc()[grp],
 374                      tcScale);
 375     }
 376     return true;
 377   }
 378
 379   osg::Node* getSurfaceGeometry(SGMaterialLib* matlib) const
 380   {
 381     if (materialTriangleMap.empty())
 382       return 0;
 383
 384     EffectGeode* eg = 0;
 385     osg::Group* group = (materialTriangleMap.size() > 1 ? new osg::Group : 0);
 386     //osg::Geode* geode = new osg::Geode;
 387     SGMaterialTriangleMap::const_iterator i;
 388     for (i = materialTriangleMap.begin(); i != materialTriangleMap.end(); ++i) {
 389       osg::Geometry* geometry = i->second.buildGeometry();
 390       SGMaterial *mat = 0;
 391       if (matlib)
 392         mat = matlib->find(i->first);
 393       eg = new EffectGeode;
 394       if (mat)
 395         eg->setEffect(mat->get_effect(i->second));
 396       eg->addDrawable(geometry);
 397       eg->runGenerators(geometry);  // Generate extra data needed by effect
 398       if (group)
 399         group->addChild(eg);
 400     }
 401     if (group)
 402         return group;
 403     else
 404         return eg;
 405   }
 406
 407   void computeRandomSurfaceLights(SGMaterialLib* matlib)
 408   {
 409     SGMaterialTriangleMap::iterator i;
 410
 411     // generate a repeatable random seed
 412     mt seed;
 413     mt_init(&seed, unsigned(123));
 414
 415     for (i = materialTriangleMap.begin(); i != materialTriangleMap.end(); ++i) {
 416       SGMaterial *mat = matlib->find(i->first);
 417       if (!mat)
 418         continue;
 419
 420       float coverage = mat->get_light_coverage();
 421       if (coverage <= 0)
 422         continue;
 423       if (coverage < 10000.0) {
 424         SG_LOG(SG_INPUT, SG_ALERT, "Light coverage is "
 425                << coverage << ", pushing up to 10000");
 426         coverage = 10000;
 427       }
 428
 429       std::vector<SGVec3f> randomPoints;
 430       i->second.addRandomSurfacePoints(coverage, 3, mat->get_object_mask(i->second), randomPoints);
 431       std::vector<SGVec3f>::iterator j;
 432       for (j = randomPoints.begin(); j != randomPoints.end(); ++j) {
 433         float zombie = mt_rand(&seed);
 434         // factor = sg_random() ^ 2, range = 0 .. 1 concentrated towards 0
 435         float factor = mt_rand(&seed);
 436         factor *= factor;
 437
 438         float bright = 1;
 439         SGVec4f color;
 440         if ( zombie > 0.5 ) {
 441           // 50% chance of yellowish
 442           color = SGVec4f(0.9f, 0.9f, 0.3f, bright - factor * 0.2f);
 443         } else if (zombie > 0.15f) {
 444           // 35% chance of whitish
 445           color = SGVec4f(0.9, 0.9f, 0.8f, bright - factor * 0.2f);
 446         } else if (zombie > 0.05f) {
 447           // 10% chance of orangish
 448           color = SGVec4f(0.9f, 0.6f, 0.2f, bright - factor * 0.2f);
 449         } else {
 450           // 5% chance of redish
 451           color = SGVec4f(0.9f, 0.2f, 0.2f, bright - factor * 0.2f);
 452         }
 453         randomTileLights.insert(*j, color);
 454       }
 455     }
 456   }
 457
 458   void computeRandomBuildings(SGMaterialLib* matlib, float building_density)
 459   {
 460     SGMaterialTriangleMap::iterator i;
 461
 462     // generate a repeatable random seed
 463     mt seed;
 464     mt_init(&seed, unsigned(123));
 465
 466     for (i = materialTriangleMap.begin(); i != materialTriangleMap.end(); ++i) {
 467       SGMaterial *mat = matlib->find(i->first);
 468       SGTexturedTriangleBin triangleBin = i->second;
 469
 470       if (!mat)
 471         continue;
 472
 473       osg::Texture2D* object_mask = mat->get_object_mask(triangleBin);
 474
 475       float coverage = mat->get_building_coverage();
 476
 477       // Minimum spacing needs to include the maximum footprint of a building.
 478       // As the 0,0,0 point is the center of the front of the building, we need
 479       // to consider the full depth, but only half the possible width.
 480       float min_spacing = mat->get_building_spacing();
 481
 482       if (coverage <= 0)
 483         continue;
 484
 485       bool found = false;
 486       SGBuildingBin* bin = NULL;
 487
 488       BOOST_FOREACH(bin, randomBuildings)
 489       {
 490         if (bin->texture == mat->get_building_texture()) {
 491             found = true;
 492             break;
 493         }
 494       }
 495
 496       if (!found) {
 497         bin = new SGBuildingBin();
 498         bin->texture = mat->get_building_texture();
 499         bin->lightMap = mat->get_building_lightmap();
 500         SG_LOG(SG_INPUT, SG_DEBUG, "Building texture " << bin->texture);
 501         randomBuildings.push_back(bin);
 502       }
 503
 504       std::vector<std::pair<SGVec3f, float> > randomPoints;
 505
 506       unsigned num = i->second.getNumTriangles();
 507       int triangle_dropped = 0;
 508       int building_dropped = 0;
 509       int random_dropped = 0;
 510       int mask_dropped = 0;
 511
 512       for (unsigned i = 0; i < num; ++i) {
 513         SGBuildingBin::BuildingList triangle_buildings;
 514         SGTexturedTriangleBin::triangle_ref triangleRef = triangleBin.getTriangleRef(i);
 515
 516         SGVec3f vorigin = triangleBin.getVertex(triangleRef[0]).vertex;
 517         SGVec3f v0 = triangleBin.getVertex(triangleRef[1]).vertex - vorigin;
 518         SGVec3f v1 = triangleBin.getVertex(triangleRef[2]).vertex - vorigin;
 519         SGVec2f torigin = triangleBin.getVertex(triangleRef[0]).texCoord;
 520         SGVec2f t0 = triangleBin.getVertex(triangleRef[1]).texCoord - torigin;
 521         SGVec2f t1 = triangleBin.getVertex(triangleRef[2]).texCoord - torigin;
 522         SGVec3f normal = cross(v0, v1);
 523
 524         // Compute the area
 525         float area = 0.5f*length(normal);
 526         if (area <= SGLimitsf::min())
 527           continue;
 528
 529         // for partial units of area, use a zombie door method to
 530         // create the proper random chance of an object being created
 531         // for this triangle.
 532         double num = area / coverage + mt_rand(&seed);
 533         if (num < 1.0f) {
 534           continue;
 535         }
 536
 537         // Apply density, which is linear, while we're dealing in areas
 538         num = num * building_density * building_density;
 539
 540         // Cosine of the angle between the two vectors.
 541         float cosine = (dot(v0, v1) / (length(v0) * length(v1)));
 542
 543         // Determine a grid spacing in each vector such that the correct
 544         // coverage will result.
 545         float stepv0 = (sqrtf(coverage) / building_density) / length(v0) / sqrtf(1 - cosine * cosine);
 546         float stepv1 = (sqrtf(coverage) / building_density) / length(v1);
 547
 548         stepv0 = std::min(stepv0, 1.0f);
 549         stepv1 = std::min(stepv1, 1.0f);
 550
 551         // Start at a random point. a will be immediately incremented below.
 552         float a = -mt_rand(&seed) * stepv0;
 553         float b = mt_rand(&seed) * stepv1;
 554
 555         // Place an object each unit of area
 556         while (num > 1.0) {
 557
 558           // Set the next location to place a building
 559           a += stepv0;
 560
 561           if ((a + b) > 1.0f) {
 562             // Reached the end of the scan-line on v0. Reset and increment
 563             // scan-line on v1
 564             a = mt_rand(&seed) * stepv0;
 565             b += stepv1;
 566           }
 567
 568           if (b > 1.0f) {
 569             // In a degenerate case of a single point, we might be outside the
 570             // scanline.  Note that we need to still ensure that a+b < 1.
 571             b = mt_rand(&seed) * stepv1 * (1.0f - a);
 572           }
 573
 574           if ((a + b) > 1.0f ) {
 575             // Truly degenerate case - simply choose a random point guaranteed
 576             // to fulfil the constraing of a+b < 1.
 577             a = mt_rand(&seed);
 578             b = mt_rand(&seed) * (1.0f - a);
 579           }
 580
 581           SGVec3f randomPoint = vorigin + a*v0 + b*v1;
 582           float rotation = mt_rand(&seed);
 583
 584           if (object_mask != NULL) {
 585             SGVec2f texCoord = torigin + a*t0 + b*t1;
 586             osg::Image* img = object_mask->getImage();
 587             int x = (int) (img->s() * texCoord.x()) % img->s();
 588             int y = (int) (img->t() * texCoord.y()) % img->t();
 589
 590             // In some degenerate cases x or y can be < 1, in which case the mod operand fails
 591             while (x < 0) x += img->s();
 592             while (y < 0) y += img->t();
 593
 594             if (mt_rand(&seed) < img->getColor(x, y).b()) {
 595               // Object passes mask. Rotation is taken from the red channel
 596               rotation = img->getColor(x,y).r();
 597             } else {
 598               // Fails mask test - try again.
 599               mask_dropped++;
 600               num -= 1.0;
 601               continue;
 602             }
 603           }
 604
 605           // Now create the building, so we have an idea of its footprint
 606           // and therefore appropriate spacing.
 607           SGBuildingBin::BuildingType buildingtype;
 608           float width;
 609           float depth;
 610           int floors;
 611           float height;
 612           bool pitched;
 613
 614           // Determine the building type, and hence dimensions.
 615           float type = mt_rand(&seed);
 616
 617           if (type < mat->get_building_small_fraction()) {
 618             // Small building
 619             buildingtype = SGBuildingBin::SMALL;
 620             width = mat->get_building_small_min_width() + mt_rand(&seed) * mt_rand(&seed) * (mat->get_building_small_max_width() - mat->get_building_small_min_width());
 621             depth = mat->get_building_small_min_depth() + mt_rand(&seed) * mt_rand(&seed) * (mat->get_building_small_max_depth() - mat->get_building_small_min_depth());
 622             floors = SGMisc<double>::round(mat->get_building_small_min_floors() + mt_rand(&seed) * (mat->get_building_small_max_floors() - mat->get_building_small_min_floors()));
 623             height = floors * (2.8 + mt_rand(&seed));
 624
 625             // Small buildings are never deeper than they are wide.
 626             if (depth > width) { depth = width; }
 627
 628             pitched = (mt_rand(&seed) < mat->get_building_small_pitch());
 629           } else if (type < (mat->get_building_small_fraction() + mat->get_building_medium_fraction())) {
 630             buildingtype = SGBuildingBin::MEDIUM;
 631             width = mat->get_building_medium_min_width() + mt_rand(&seed) * mt_rand(&seed) * (mat->get_building_medium_max_width() - mat->get_building_medium_min_width());
 632             depth = mat->get_building_medium_min_depth() + mt_rand(&seed) * mt_rand(&seed) * (mat->get_building_medium_max_depth() - mat->get_building_medium_min_depth());
 633             floors = SGMisc<double>::round(mat->get_building_medium_min_floors() + mt_rand(&seed) * (mat->get_building_medium_max_floors() - mat->get_building_medium_min_floors()));
 634             height = floors * (2.8 + mt_rand(&seed));
 635
 636             while ((height > width) && (floors > mat->get_building_medium_min_floors())) {
 637               // Ensure that medium buildings aren't taller than they are wide
 638               floors--;
 639               height = floors * (2.8 + mt_rand(&seed));
 640             }
 641
 642             pitched = (mt_rand(&seed) < mat->get_building_medium_pitch());
 643           } else {
 644             buildingtype = SGBuildingBin::LARGE;
 645             width = mat->get_building_large_min_width() + mt_rand(&seed) * (mat->get_building_large_max_width() - mat->get_building_large_min_width());
 646             depth = mat->get_building_large_min_depth() + mt_rand(&seed) * (mat->get_building_large_max_depth() - mat->get_building_large_min_depth());
 647             floors = SGMisc<double>::round(mat->get_building_large_min_floors() + mt_rand(&seed) * (mat->get_building_large_max_floors() - mat->get_building_large_min_floors()));
 648             height = floors * (2.8 + mt_rand(&seed));
 649             pitched = (mt_rand(&seed) < mat->get_building_large_pitch());
 650           }
 651
 652           // Determine an appropriate minimum spacing for the object.  Note that the
 653           // origin of the building model is the center of the front face, hence we
 654           // consider the full depth.  We choose _not_ to use the diagonal distance
 655           // to one of the rear corners, as we assume that terrain masking will
 656           // make the buildings place in some sort of grid.
 657           float radius = std::max(depth, 0.5f*width);
 658
 659           // Check that the point is sufficiently far from
 660           // the edge of the triangle by measuring the distance
 661           // from the three lines that make up the triangle.
 662           SGVec3f p = randomPoint - vorigin;
 663
 664           if (((length(cross(p     , p - v0)) / length(v0))      < radius) ||
 665               ((length(cross(p - v0, p - v1)) / length(v1 - v0)) < radius) ||
 666               ((length(cross(p - v1, p     )) / length(v1))      < radius)   )
 667           {
 668             triangle_dropped++;
 669             num -= 1.0;
 670             continue;
 671           }
 672
 673           // Check against the generic random objects.  TODO - make this more efficient by
 674           // masking ahead of time objects outside of the triangle.
 675           bool too_close = false;
 676           for (unsigned int i = 0; i < randomModels.getNumModels(); ++i) {
 677             float min_dist = randomModels.getMatModel(i).model->get_spacing_m() + radius + min_spacing;
 678             min_dist = min_dist * min_dist;
 679
 680             if (distSqr(randomModels.getMatModel(i).position, randomPoint) < min_dist) {
 681               too_close = true;
 682               random_dropped++;
 683               continue;
 684             }
 685           }
 686
 687           if (too_close) {
 688             // Too close to a random model - drop and try again
 689             num -= 1.0;
 690             continue;
 691           }
 692
 693           SGBuildingBin::BuildingList::iterator l;
 694
 695           // Check that the building is sufficiently far from any other building within the triangle.
 696           for (l = triangle_buildings.begin(); l != triangle_buildings.end(); ++l) {
 697
 698             float min_dist = l->radius + radius + min_spacing;
 699             min_dist = min_dist * min_dist;
 700
 701             if (distSqr(randomPoint, l->position) < min_dist) {
 702               building_dropped++;
 703               too_close = true;
 704               continue;
 705             }
 706           }
 707
 708           if (too_close) {
 709             // Too close to another building - drop and try again
 710             num -= 1.0;
 711             continue;
 712           }
 713
 714           // If we've passed all of the above tests we have a valid
 715           // building, so create it!
 716           SGBuildingBin::Building building =
 717                     SGBuildingBin::Building(buildingtype,
 718                                             randomPoint,
 719                                             width,
 720                                             depth,
 721                                             height,
 722                                             floors,
 723                                             rotation,
 724                                             pitched);
 725           triangle_buildings.push_back(building);
 726
 727           num -= 1.0;
 728         }
 729
 730         // Add the buildings from this triangle to the overall list.
 731         SGBuildingBin::BuildingList::iterator l;
 732
 733         for (l = triangle_buildings.begin(); l != triangle_buildings.end(); ++l) {
 734           bin->insert(*l);
 735         }
 736
 737         triangle_buildings.clear();
 738       }
 739
 740       SG_LOG(SG_TERRAIN, SG_DEBUG, "Random Buildings: " << bin->getNumBuildings());
 741       SG_LOG(SG_TERRAIN, SG_DEBUG, "  Dropped due to mask: " << mask_dropped);
 742       SG_LOG(SG_TERRAIN, SG_DEBUG, "  Dropped due to triangle edge: " << triangle_dropped);
 743       SG_LOG(SG_TERRAIN, SG_DEBUG, "  Dropped due to random object: " << random_dropped);
 744       SG_LOG(SG_TERRAIN, SG_DEBUG, "  Dropped due to other building: " << building_dropped);
 745     }
 746   }
 747
 748   void computeRandomForest(SGMaterialLib* matlib, float vegetation_density)
 749   {
 750     SGMaterialTriangleMap::iterator i;
 751
 752     // generate a repeatable random seed
 753     mt seed;
 754
 755     mt_init(&seed, unsigned(586));
 756
 757     for (i = materialTriangleMap.begin(); i != materialTriangleMap.end(); ++i) {
 758       SGMaterial *mat = matlib->find(i->first);
 759       if (!mat)
 760         continue;
 761
 762       float wood_coverage = mat->get_wood_coverage();
 763       if (wood_coverage <= 0)
 764         continue;
 765
 766       // Attributes that don't vary by tree but do vary by material
 767       bool found = false;
 768       TreeBin* bin = NULL;
 769
 770       BOOST_FOREACH(bin, randomForest)
 771       {
 772         if ((bin->texture           == mat->get_tree_texture()  ) &&
 773             (bin->texture_varieties == mat->get_tree_varieties()) &&
 774             (bin->range             == mat->get_tree_range()    ) &&
 775             (bin->width             == mat->get_tree_width()    ) &&
 776             (bin->height            == mat->get_tree_height()   )   ) {
 777             found = true;
 778             break;
 779         }
 780       }
 781
 782       if (!found) {
 783         bin = new TreeBin();
 784         bin->texture = mat->get_tree_texture();
 785           SG_LOG(SG_INPUT, SG_DEBUG, "Tree texture " << bin->texture);
 786         bin->range   = mat->get_tree_range();
 787         bin->width   = mat->get_tree_width();
 788         bin->height  = mat->get_tree_height();
 789         bin->texture_varieties = mat->get_tree_varieties();
 790         randomForest.push_back(bin);
 791       }
 792
 793       std::vector<SGVec3f> randomPoints;
 794       i->second.addRandomTreePoints(wood_coverage,
 795                                     mat->get_object_mask(i->second),
 796                                     vegetation_density,
 797                                     randomPoints);
 798
 799       std::vector<SGVec3f>::iterator k;
 800       for (k = randomPoints.begin(); k != randomPoints.end(); ++k) {
 801         bin->insert(*k);
 802       }
 803     }
 804   }
 805
 806   void computeRandomObjects(SGMaterialLib* matlib)
 807   {
 808     SGMaterialTriangleMap::iterator i;
 809
 810     // generate a repeatable random seed
 811     mt seed;
 812     mt_init(&seed, unsigned(123));
 813
 814     for (i = materialTriangleMap.begin(); i != materialTriangleMap.end(); ++i) {
 815       SGMaterial *mat = matlib->find(i->first);
 816       if (!mat)
 817         continue;
 818
 819       int group_count = mat->get_object_group_count();
 820
 821       if (group_count > 0)
 822       {
 823         for (int j = 0; j < group_count; j++)
 824         {
 825           SGMatModelGroup *object_group =  mat->get_object_group(j);
 826           int nObjects = object_group->get_object_count();
 827
 828           if (nObjects > 0)
 829           {
 830             // For each of the random models in the group, determine an appropriate
 831             // number of random placements and insert them.
 832             for (int k = 0; k < nObjects; k++) {
 833               SGMatModel * object = object_group->get_object(k);
 834
 835               std::vector<std::pair<SGVec3f, float> > randomPoints;
 836
 837               i->second.addRandomPoints(object->get_coverage_m2(),
 838                                         object->get_spacing_m(),
 839                                         mat->get_object_mask(i->second),
 840                                         randomPoints);
 841
 842               std::vector<std::pair<SGVec3f, float> >::iterator l;
 843               for (l = randomPoints.begin(); l != randomPoints.end(); ++l) {
 844                 // Only add the model if it is sufficiently far from the
 845                 // other models
 846                 bool close = false;
 847
 848                 for (unsigned i = 0; i < randomModels.getNumModels(); i++) {
 849                   float spacing = randomModels.getMatModel(i).model->get_spacing_m() + object->get_spacing_m();
 850                   spacing = spacing * spacing;
 851
 852                   if (distSqr(randomModels.getMatModel(i).position, l->first) < spacing) {
 853                     close = true;
 854                     continue;
 855                   }
 856                 }
 857
 858                 if (!close) {
 859                   randomModels.insert(l->first, object, (int)object->get_randomized_range_m(&seed), l->second);
 860                 }
 861               }
 862             }
 863           }
 864         }
 865       }
 866     }
 867   }
 868
 869   bool insertBinObj(const SGBinObject& obj, SGMaterialLib* matlib)
 870   {
 871     if (!insertPtGeometry(obj, matlib))
 872       return false;
 873     if (!insertSurfaceGeometry(obj, matlib))
 874       return false;
 875     return true;
 876   }
 877 };
 878
 879 typedef std::pair<osg::Node*, int> ModelLOD;
 880 struct MakeQuadLeaf {
 881     osg::LOD* operator() () const { return new osg::LOD; }
 882 };
 883 struct AddModelLOD {
 884     void operator() (osg::LOD* leaf, ModelLOD& mlod) const
 885     {
 886         leaf->addChild(mlod.first, 0, mlod.second);
 887     }
 888 };
 889 struct GetModelLODCoord {
 890     GetModelLODCoord() {}
 891     GetModelLODCoord(const GetModelLODCoord& rhs)
 892     {}
 893     osg::Vec3 operator() (const ModelLOD& mlod) const
 894     {
 895         return mlod.first->getBound().center();
 896     }
 897 };
 898
 899 typedef QuadTreeBuilder<osg::LOD*, ModelLOD, MakeQuadLeaf, AddModelLOD,
 900                         GetModelLODCoord>  RandomObjectsQuadtree;
 901
 902 osg::Node*
 903 SGLoadBTG(const std::string& path, const simgear::SGReaderWriterOptions* options)
 904 {
 905   SGBinObject tile;
 906   if (!tile.read_bin(path))
 907     return NULL;
 908
 909   SGMaterialLib* matlib = 0;
 910   bool use_random_objects = false;
 911   bool use_random_vegetation = false;
 912   bool use_random_buildings = false;
 913   float vegetation_density = 1.0f;
 914   float building_density = 1.0f;
 915   if (options) {
 916     matlib = options->getMaterialLib();
 917     SGPropertyNode* propertyNode = options->getPropertyNode().get();
 918     if (propertyNode) {
 919         use_random_objects
 920             = propertyNode->getBoolValue("/sim/rendering/random-objects",
 921                                          use_random_objects);
 922         use_random_vegetation
 923             = propertyNode->getBoolValue("/sim/rendering/random-vegetation",
 924                                          use_random_vegetation);
 925         vegetation_density
 926             = propertyNode->getFloatValue("/sim/rendering/vegetation-density",
 927                                           vegetation_density);
 928         use_random_buildings
 929             = propertyNode->getBoolValue("/sim/rendering/random-buildings",
 930                                          use_random_buildings);
 931         building_density
 932             = propertyNode->getFloatValue("/sim/rendering/building-density",
 933                                           building_density);
 934     }
 935   }
 936
 937   SGVec3d center = tile.get_gbs_center();
 938   SGGeod geodPos = SGGeod::fromCart(center);
 939   SGQuatd hlOr = SGQuatd::fromLonLat(geodPos)*SGQuatd::fromEulerDeg(0, 0, 180);
 940
 941   // rotate the tiles so that the bounding boxes get nearly axis aligned.
 942   // this will help the collision tree's bounding boxes a bit ...
 943   std::vector<SGVec3d> nodes = tile.get_wgs84_nodes();
 944   for (unsigned i = 0; i < nodes.size(); ++i)
 945     nodes[i] = hlOr.transform(nodes[i]);
 946   tile.set_wgs84_nodes(nodes);
 947
 948   SGQuatf hlOrf(hlOr[0], hlOr[1], hlOr[2], hlOr[3]);
 949   std::vector<SGVec3f> normals = tile.get_normals();
 950   for (unsigned i = 0; i < normals.size(); ++i)
 951     normals[i] = hlOrf.transform(normals[i]);
 952   tile.set_normals(normals);
 953
 954   SGTileGeometryBin tileGeometryBin;
 955   if (!tileGeometryBin.insertBinObj(tile, matlib))
 956     return NULL;
 957
 958   SGVec3f up(0, 0, 1);
 959   GroundLightManager* lightManager = GroundLightManager::instance();
 960
 961   osg::ref_ptr<osg::Group> lightGroup = new SGOffsetTransform(0.94);
 962   osg::ref_ptr<osg::Group> randomObjects;
 963   osg::ref_ptr<osg::Group> forestNode;
 964   osg::ref_ptr<osg::Group> buildingNode;
 965   osg::Group* terrainGroup = new osg::Group;
 966
 967   osg::Node* node = tileGeometryBin.getSurfaceGeometry(matlib);
 968   if (node)
 969     terrainGroup->addChild(node);
 970
 971   if (use_random_objects && matlib) {
 972     tileGeometryBin.computeRandomObjects(matlib);
 973
 974     if (tileGeometryBin.randomModels.getNumModels() > 0) {
 975       // Generate a repeatable random seed
 976       mt seed;
 977       mt_init(&seed, unsigned(123));
 978
 979       std::vector<ModelLOD> models;
 980       for (unsigned int i = 0;
 981            i < tileGeometryBin.randomModels.getNumModels(); i++) {
 982         SGMatModelBin::MatModel obj
 983           = tileGeometryBin.randomModels.getMatModel(i);
 984
 985         SGPropertyNode* root = options->getPropertyNode()->getRootNode();
 986         osg::Node* node = obj.model->get_random_model(root, &seed);
 987
 988         // Create a matrix to place the object in the correct
 989         // location, and then apply the rotation matrix created
 990         // above, with an additional random (or taken from
 991         // the object mask) heading rotation if appropriate.
 992         osg::Matrix transformMat;
 993         transformMat = osg::Matrix::translate(toOsg(obj.position));
 994         if (obj.model->get_heading_type() == SGMatModel::HEADING_RANDOM) {
 995           // Rotate the object around the z axis.
 996           double hdg = mt_rand(&seed) * M_PI * 2;
 997           transformMat.preMult(osg::Matrix::rotate(hdg,
 998                                                    osg::Vec3d(0.0, 0.0, 1.0)));
 999         }
1000
1001         if (obj.model->get_heading_type() == SGMatModel::HEADING_MASK) {
1002           // Rotate the object around the z axis.
1003           double hdg =  - obj.rotation * M_PI * 2;
1004           transformMat.preMult(osg::Matrix::rotate(hdg,
1005                                                    osg::Vec3d(0.0, 0.0, 1.0)));
1006         }
1007
1008         osg::MatrixTransform* position =
1009           new osg::MatrixTransform(transformMat);
1010         position->addChild(node);
1011         models.push_back(ModelLOD(position, obj.lod));
1012       }
1013       RandomObjectsQuadtree quadtree((GetModelLODCoord()), (AddModelLOD()));
1014       quadtree.buildQuadTree(models.begin(), models.end());
1015       randomObjects = quadtree.getRoot();
1016       randomObjects->setName("random objects");
1017     }
1018   }
1019
1020   if (use_random_vegetation && matlib) {
1021     // Now add some random forest.
1022     tileGeometryBin.computeRandomForest(matlib, vegetation_density);
1023
1024     if (tileGeometryBin.randomForest.size() > 0) {
1025       forestNode = createForest(tileGeometryBin.randomForest, osg::Matrix::identity(),
1026                                 options);
1027       forestNode->setName("Random trees");
1028     }
1029   }
1030
1031   if (use_random_buildings && matlib) {
1032     tileGeometryBin.computeRandomBuildings(matlib, building_density);
1033     if (tileGeometryBin.randomBuildings.size() > 0) {
1034       buildingNode = createRandomBuildings(tileGeometryBin.randomBuildings, osg::Matrix::identity(),
1035                                   options);
1036       buildingNode->setName("Random buildings");
1037     }
1038   }
1039
1040   // FIXME: ugly, has a side effect
1041   if (matlib)
1042     tileGeometryBin.computeRandomSurfaceLights(matlib);
1043
1044   if (tileGeometryBin.tileLights.getNumLights() > 0
1045       || tileGeometryBin.randomTileLights.getNumLights() > 0) {
1046     osg::Group* groundLights0 = new osg::Group;
1047     groundLights0->setStateSet(lightManager->getGroundLightStateSet());
1048     groundLights0->setNodeMask(GROUNDLIGHTS0_BIT);
1049     osg::Geode* geode = new osg::Geode;
1050     geode->addDrawable(SGLightFactory::getLights(tileGeometryBin.tileLights));
1051     geode->addDrawable(SGLightFactory::getLights(tileGeometryBin.randomTileLights, 4, -0.3f));
1052     groundLights0->addChild(geode);
1053     lightGroup->addChild(groundLights0);
1054   }
1055
1056   if (tileGeometryBin.randomTileLights.getNumLights() > 0) {
1057     osg::Group* groundLights1 = new osg::Group;
1058     groundLights1->setStateSet(lightManager->getGroundLightStateSet());
1059     groundLights1->setNodeMask(GROUNDLIGHTS1_BIT);
1060     osg::Group* groundLights2 = new osg::Group;
1061     groundLights2->setStateSet(lightManager->getGroundLightStateSet());
1062     groundLights2->setNodeMask(GROUNDLIGHTS2_BIT);
1063     osg::Geode* geode = new osg::Geode;
1064     geode->addDrawable(SGLightFactory::getLights(tileGeometryBin.randomTileLights, 2, -0.15f));
1065     groundLights1->addChild(geode);
1066     lightGroup->addChild(groundLights1);
1067     geode = new osg::Geode;
1068     geode->addDrawable(SGLightFactory::getLights(tileGeometryBin.randomTileLights));
1069     groundLights2->addChild(geode);
1070     lightGroup->addChild(groundLights2);
1071   }
1072
1073   if (!tileGeometryBin.vasiLights.empty()) {
1074     EffectGeode* vasiGeode = new EffectGeode;
1075     Effect* vasiEffect
1076         = getLightEffect(24, osg::Vec3(1, 0.0001, 0.000001), 1, 24, true);
1077     vasiGeode->setEffect(vasiEffect);
1078     SGVec4f red(1, 0, 0, 1);
1079     SGMaterial* mat = 0;
1080     if (matlib)
1081       mat = matlib->find("RWY_RED_LIGHTS");
1082     if (mat)
1083       red = mat->get_light_color();
1084     SGVec4f white(1, 1, 1, 1);
1085     mat = 0;
1086     if (matlib)
1087       mat = matlib->find("RWY_WHITE_LIGHTS");
1088     if (mat)
1089       white = mat->get_light_color();
1090     SGDirectionalLightListBin::const_iterator i;
1091     for (i = tileGeometryBin.vasiLights.begin();
1092          i != tileGeometryBin.vasiLights.end(); ++i) {
1093       vasiGeode->addDrawable(SGLightFactory::getVasi(up, *i, red, white));
1094     }
1095     vasiGeode->setStateSet(lightManager->getRunwayLightStateSet());
1096     lightGroup->addChild(vasiGeode);
1097   }
1098
1099   Effect* runwayEffect = 0;
1100   if (tileGeometryBin.runwayLights.getNumLights() > 0
1101       || !tileGeometryBin.rabitLights.empty()
1102       || !tileGeometryBin.reilLights.empty()
1103       || !tileGeometryBin.odalLights.empty()
1104       || tileGeometryBin.taxiLights.getNumLights() > 0)
1105       runwayEffect = getLightEffect(16, osg::Vec3(1, 0.001, 0.0002), 1, 16, true);
1106   if (tileGeometryBin.runwayLights.getNumLights() > 0
1107       || !tileGeometryBin.rabitLights.empty()
1108       || !tileGeometryBin.reilLights.empty()
1109       || !tileGeometryBin.odalLights.empty()
1110       || !tileGeometryBin.holdshortLights.empty()) {
1111     osg::Group* rwyLights = new osg::Group;
1112     rwyLights->setStateSet(lightManager->getRunwayLightStateSet());
1113     rwyLights->setNodeMask(RUNWAYLIGHTS_BIT);
1114     if (tileGeometryBin.runwayLights.getNumLights() != 0) {
1115       EffectGeode* geode = new EffectGeode;
1116       geode->setEffect(runwayEffect);
1117       geode->addDrawable(SGLightFactory::getLights(tileGeometryBin
1118                                                    .runwayLights));
1119       rwyLights->addChild(geode);
1120     }
1121     SGDirectionalLightListBin::const_iterator i;
1122     for (i = tileGeometryBin.rabitLights.begin();
1123          i != tileGeometryBin.rabitLights.end(); ++i) {
1124       rwyLights->addChild(SGLightFactory::getSequenced(*i));
1125     }
1126     for (i = tileGeometryBin.reilLights.begin();
1127          i != tileGeometryBin.reilLights.end(); ++i) {
1128       rwyLights->addChild(SGLightFactory::getSequenced(*i));
1129     }
1130     for (i = tileGeometryBin.holdshortLights.begin();
1131          i != tileGeometryBin.holdshortLights.end(); ++i) {
1132       rwyLights->addChild(SGLightFactory::getHoldShort(*i));
1133     }
1134     SGLightListBin::const_iterator j;
1135     for (j = tileGeometryBin.odalLights.begin();
1136          j != tileGeometryBin.odalLights.end(); ++j) {
1137       rwyLights->addChild(SGLightFactory::getOdal(*j));
1138     }
1139     lightGroup->addChild(rwyLights);
1140   }
1141
1142   if (tileGeometryBin.taxiLights.getNumLights() > 0) {
1143     osg::Group* taxiLights = new osg::Group;
1144     taxiLights->setStateSet(lightManager->getTaxiLightStateSet());
1145     taxiLights->setNodeMask(RUNWAYLIGHTS_BIT);
1146     EffectGeode* geode = new EffectGeode;
1147     geode->setEffect(runwayEffect);
1148     geode->addDrawable(SGLightFactory::getLights(tileGeometryBin.taxiLights));
1149     taxiLights->addChild(geode);
1150     lightGroup->addChild(taxiLights);
1151   }
1152
1153   // The toplevel transform for that tile.
1154   osg::MatrixTransform* transform = new osg::MatrixTransform;
1155   transform->setName(path);
1156   transform->setMatrix(osg::Matrix::rotate(toOsg(hlOr))*
1157                        osg::Matrix::translate(toOsg(center)));
1158   transform->addChild(terrainGroup);
1159   if (lightGroup->getNumChildren() > 0) {
1160     osg::LOD* lightLOD = new osg::LOD;
1161     lightLOD->addChild(lightGroup.get(), 0, 30000);
1162     // VASI is always on, so doesn't use light bits.
1163     lightLOD->setNodeMask(LIGHTS_BITS | MODEL_BIT | PERMANENTLIGHT_BIT);
1164     transform->addChild(lightLOD);
1165   }
1166
1167   if (randomObjects.valid() || forestNode.valid() || buildingNode.valid()) {
1168
1169     // Add a LoD node, so we don't try to display anything when the tile center
1170     // is more than 20km away.
1171     osg::LOD* objectLOD = new osg::LOD;
1172
1173     if (randomObjects.valid()) objectLOD->addChild(randomObjects.get(), 0, 20000);
1174     if (forestNode.valid())  objectLOD->addChild(forestNode.get(), 0, 20000);
1175     if (buildingNode.valid()) objectLOD->addChild(buildingNode.get(), 0, 20000);
1176
1177     unsigned nodeMask = SG_NODEMASK_CASTSHADOW_BIT | SG_NODEMASK_RECEIVESHADOW_BIT | SG_NODEMASK_TERRAIN_BIT;
1178     objectLOD->setNodeMask(nodeMask);
1179     transform->addChild(objectLOD);
1180   }
1181   transform->setNodeMask( ~simgear::MODELLIGHT_BIT );
1182
1183   return transform;
1184 }