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.
 571             b = mt_rand(&seed) * stepv1;
 572           }
 573
 574           SGVec3f randomPoint = vorigin + a*v0 + b*v1;
 575           float rotation = mt_rand(&seed);
 576
 577           if (object_mask != NULL) {
 578             SGVec2f texCoord = torigin + a*t0 + b*t1;
 579             osg::Image* img = object_mask->getImage();
 580             int x = (int) (img->s() * texCoord.x()) % img->s();
 581             int y = (int) (img->t() * texCoord.y()) % img->t();
 582
 583             // In some degenerate cases x or y can be < 1, in which case the mod operand fails
 584             while (x < 0) x += img->s();
 585             while (y < 0) y += img->t();
 586
 587             if (mt_rand(&seed) < img->getColor(x, y).b()) {
 588               // Object passes mask. Rotation is taken from the red channel
 589               rotation = img->getColor(x,y).r();
 590             } else {
 591               // Fails mask test - try again.
 592               mask_dropped++;
 593               num -= 1.0;
 594               continue;
 595             }
 596           }
 597
 598           // Now create the building, so we have an idea of its footprint
 599           // and therefore appropriate spacing.
 600           SGBuildingBin::BuildingType buildingtype;
 601           float width;
 602           float depth;
 603           int floors;
 604           float height;
 605           bool pitched;
 606
 607           // Determine the building type, and hence dimensions.
 608           float type = mt_rand(&seed);
 609
 610           if (type < mat->get_building_small_fraction()) {
 611             // Small building
 612             buildingtype = SGBuildingBin::SMALL;
 613             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());
 614             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());
 615             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()));
 616             height = floors * (2.8 + mt_rand(&seed));
 617
 618             // Small buildings are never deeper than they are wide.
 619             if (depth > width) { depth = width; }
 620
 621             pitched = (mt_rand(&seed) < mat->get_building_small_pitch());
 622           } else if (type < (mat->get_building_small_fraction() + mat->get_building_medium_fraction())) {
 623             buildingtype = SGBuildingBin::MEDIUM;
 624             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());
 625             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());
 626             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()));
 627             height = floors * (2.8 + mt_rand(&seed));
 628
 629             while ((height > width) && (floors > mat->get_building_medium_min_floors())) {
 630               // Ensure that medium buildings aren't taller than they are wide
 631               floors--;
 632               height = floors * (2.8 + mt_rand(&seed));
 633             }
 634
 635             pitched = (mt_rand(&seed) < mat->get_building_medium_pitch());
 636           } else {
 637             buildingtype = SGBuildingBin::LARGE;
 638             width = mat->get_building_large_min_width() + mt_rand(&seed) * (mat->get_building_large_max_width() - mat->get_building_large_min_width());
 639             depth = mat->get_building_large_min_depth() + mt_rand(&seed) * (mat->get_building_large_max_depth() - mat->get_building_large_min_depth());
 640             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()));
 641             height = floors * (2.8 + mt_rand(&seed));
 642             pitched = (mt_rand(&seed) < mat->get_building_large_pitch());
 643           }
 644
 645           // Determine an appropriate minimum spacing for the object.  Note that the
 646           // origin of the building model is the center of the front face, hence we
 647           // consider the full depth.  We choose _not_ to use the diagonal distance
 648           // to one of the rear corners, as we assume that terrain masking will
 649           // make the buildings place in some sort of grid.
 650           float radius = std::max(depth, 0.5f*width);
 651
 652           // Check that the point is sufficiently far from
 653           // the edge of the triangle by measuring the distance
 654           // from the three lines that make up the triangle.
 655           SGVec3f p = randomPoint - vorigin;
 656
 657           if (((length(cross(p     , p - v0)) / length(v0))      < radius) ||
 658               ((length(cross(p - v0, p - v1)) / length(v1 - v0)) < radius) ||
 659               ((length(cross(p - v1, p     )) / length(v1))      < radius)   )
 660           {
 661             triangle_dropped++;
 662             num -= 1.0;
 663             continue;
 664           }
 665
 666           // Check against the generic random objects.  TODO - make this more efficient by
 667           // masking ahead of time objects outside of the triangle.
 668           bool too_close = false;
 669           for (unsigned int i = 0; i < randomModels.getNumModels(); ++i) {
 670             float min_dist = randomModels.getMatModel(i).model->get_spacing_m() + radius + min_spacing;
 671             min_dist = min_dist * min_dist;
 672
 673             if (distSqr(randomModels.getMatModel(i).position, randomPoint) < min_dist) {
 674               too_close = true;
 675               random_dropped++;
 676               continue;
 677             }
 678           }
 679
 680           if (too_close) {
 681             // Too close to a random model - drop and try again
 682             num -= 1.0;
 683             continue;
 684           }
 685
 686           SGBuildingBin::BuildingList::iterator l;
 687
 688           // Check that the building is sufficiently far from any other building within the triangle.
 689           for (l = triangle_buildings.begin(); l != triangle_buildings.end(); ++l) {
 690
 691             float min_dist = l->radius + radius + min_spacing;
 692             min_dist = min_dist * min_dist;
 693
 694             if (distSqr(randomPoint, l->position) < min_dist) {
 695               building_dropped++;
 696               too_close = true;
 697               continue;
 698             }
 699           }
 700
 701           if (too_close) {
 702             // Too close to another building - drop and try again
 703             num -= 1.0;
 704             continue;
 705           }
 706
 707           // If we've passed all of the above tests we have a valid
 708           // building, so create it!
 709           SGBuildingBin::Building building =
 710                     SGBuildingBin::Building(buildingtype,
 711                                             randomPoint,
 712                                             width,
 713                                             depth,
 714                                             height,
 715                                             floors,
 716                                             rotation,
 717                                             pitched);
 718           triangle_buildings.push_back(building);
 719
 720           num -= 1.0;
 721         }
 722
 723         // Add the buildings from this triangle to the overall list.
 724         SGBuildingBin::BuildingList::iterator l;
 725
 726         for (l = triangle_buildings.begin(); l != triangle_buildings.end(); ++l) {
 727           bin->insert(*l);
 728         }
 729
 730         triangle_buildings.clear();
 731       }
 732
 733       SG_LOG(SG_TERRAIN, SG_DEBUG, "Random Buildings: " << bin->getNumBuildings());
 734       SG_LOG(SG_TERRAIN, SG_DEBUG, "  Dropped due to mask: " << mask_dropped);
 735       SG_LOG(SG_TERRAIN, SG_DEBUG, "  Dropped due to triangle edge: " << triangle_dropped);
 736       SG_LOG(SG_TERRAIN, SG_DEBUG, "  Dropped due to random object: " << random_dropped);
 737       SG_LOG(SG_TERRAIN, SG_DEBUG, "  Dropped due to other building: " << building_dropped);
 738     }
 739   }
 740
 741   void computeRandomForest(SGMaterialLib* matlib, float vegetation_density)
 742   {
 743     SGMaterialTriangleMap::iterator i;
 744
 745     // generate a repeatable random seed
 746     mt seed;
 747
 748     mt_init(&seed, unsigned(586));
 749
 750     for (i = materialTriangleMap.begin(); i != materialTriangleMap.end(); ++i) {
 751       SGMaterial *mat = matlib->find(i->first);
 752       if (!mat)
 753         continue;
 754
 755       float wood_coverage = mat->get_wood_coverage();
 756       if (wood_coverage <= 0)
 757         continue;
 758
 759       // Attributes that don't vary by tree but do vary by material
 760       bool found = false;
 761       TreeBin* bin = NULL;
 762
 763       BOOST_FOREACH(bin, randomForest)
 764       {
 765         if ((bin->texture           == mat->get_tree_texture()  ) &&
 766             (bin->texture_varieties == mat->get_tree_varieties()) &&
 767             (bin->range             == mat->get_tree_range()    ) &&
 768             (bin->width             == mat->get_tree_width()    ) &&
 769             (bin->height            == mat->get_tree_height()   )   ) {
 770             found = true;
 771             break;
 772         }
 773       }
 774
 775       if (!found) {
 776         bin = new TreeBin();
 777         bin->texture = mat->get_tree_texture();
 778           SG_LOG(SG_INPUT, SG_DEBUG, "Tree texture " << bin->texture);
 779         bin->range   = mat->get_tree_range();
 780         bin->width   = mat->get_tree_width();
 781         bin->height  = mat->get_tree_height();
 782         bin->texture_varieties = mat->get_tree_varieties();
 783         randomForest.push_back(bin);
 784       }
 785
 786       std::vector<SGVec3f> randomPoints;
 787       i->second.addRandomTreePoints(wood_coverage,
 788                                     mat->get_object_mask(i->second),
 789                                     vegetation_density,
 790                                     randomPoints);
 791
 792       std::vector<SGVec3f>::iterator k;
 793       for (k = randomPoints.begin(); k != randomPoints.end(); ++k) {
 794         bin->insert(*k);
 795       }
 796     }
 797   }
 798
 799   void computeRandomObjects(SGMaterialLib* matlib)
 800   {
 801     SGMaterialTriangleMap::iterator i;
 802
 803     // generate a repeatable random seed
 804     mt seed;
 805     mt_init(&seed, unsigned(123));
 806
 807     for (i = materialTriangleMap.begin(); i != materialTriangleMap.end(); ++i) {
 808       SGMaterial *mat = matlib->find(i->first);
 809       if (!mat)
 810         continue;
 811
 812       int group_count = mat->get_object_group_count();
 813
 814       if (group_count > 0)
 815       {
 816         for (int j = 0; j < group_count; j++)
 817         {
 818           SGMatModelGroup *object_group =  mat->get_object_group(j);
 819           int nObjects = object_group->get_object_count();
 820
 821           if (nObjects > 0)
 822           {
 823             // For each of the random models in the group, determine an appropriate
 824             // number of random placements and insert them.
 825             for (int k = 0; k < nObjects; k++) {
 826               SGMatModel * object = object_group->get_object(k);
 827
 828               std::vector<std::pair<SGVec3f, float> > randomPoints;
 829
 830               i->second.addRandomPoints(object->get_coverage_m2(),
 831                                         object->get_spacing_m(),
 832                                         mat->get_object_mask(i->second),
 833                                         randomPoints);
 834
 835               std::vector<std::pair<SGVec3f, float> >::iterator l;
 836               for (l = randomPoints.begin(); l != randomPoints.end(); ++l) {
 837                 // Only add the model if it is sufficiently far from the
 838                 // other models
 839                 bool close = false;
 840
 841                 for (unsigned i = 0; i < randomModels.getNumModels(); i++) {
 842                   float spacing = randomModels.getMatModel(i).model->get_spacing_m() + object->get_spacing_m();
 843                   spacing = spacing * spacing;
 844
 845                   if (distSqr(randomModels.getMatModel(i).position, l->first) < spacing) {
 846                     close = true;
 847                     continue;
 848                   }
 849                 }
 850
 851                 if (!close) {
 852                   randomModels.insert(l->first, object, (int)object->get_randomized_range_m(&seed), l->second);
 853                 }
 854               }
 855             }
 856           }
 857         }
 858       }
 859     }
 860   }
 861
 862   bool insertBinObj(const SGBinObject& obj, SGMaterialLib* matlib)
 863   {
 864     if (!insertPtGeometry(obj, matlib))
 865       return false;
 866     if (!insertSurfaceGeometry(obj, matlib))
 867       return false;
 868     return true;
 869   }
 870 };
 871
 872 typedef std::pair<osg::Node*, int> ModelLOD;
 873 struct MakeQuadLeaf {
 874     osg::LOD* operator() () const { return new osg::LOD; }
 875 };
 876 struct AddModelLOD {
 877     void operator() (osg::LOD* leaf, ModelLOD& mlod) const
 878     {
 879         leaf->addChild(mlod.first, 0, mlod.second);
 880     }
 881 };
 882 struct GetModelLODCoord {
 883     GetModelLODCoord() {}
 884     GetModelLODCoord(const GetModelLODCoord& rhs)
 885     {}
 886     osg::Vec3 operator() (const ModelLOD& mlod) const
 887     {
 888         return mlod.first->getBound().center();
 889     }
 890 };
 891
 892 typedef QuadTreeBuilder<osg::LOD*, ModelLOD, MakeQuadLeaf, AddModelLOD,
 893                         GetModelLODCoord>  RandomObjectsQuadtree;
 894
 895 osg::Node*
 896 SGLoadBTG(const std::string& path, const simgear::SGReaderWriterOptions* options)
 897 {
 898   SGBinObject tile;
 899   if (!tile.read_bin(path))
 900     return NULL;
 901
 902   SGMaterialLib* matlib = 0;
 903   bool use_random_objects = false;
 904   bool use_random_vegetation = false;
 905   bool use_random_buildings = false;
 906   float vegetation_density = 1.0f;
 907   float building_density = 1.0f;
 908   if (options) {
 909     matlib = options->getMaterialLib();
 910     SGPropertyNode* propertyNode = options->getPropertyNode().get();
 911     if (propertyNode) {
 912         use_random_objects
 913             = propertyNode->getBoolValue("/sim/rendering/random-objects",
 914                                          use_random_objects);
 915         use_random_vegetation
 916             = propertyNode->getBoolValue("/sim/rendering/random-vegetation",
 917                                          use_random_vegetation);
 918         vegetation_density
 919             = propertyNode->getFloatValue("/sim/rendering/vegetation-density",
 920                                           vegetation_density);
 921         use_random_buildings
 922             = propertyNode->getBoolValue("/sim/rendering/random-buildings",
 923                                          use_random_buildings);
 924         building_density
 925             = propertyNode->getFloatValue("/sim/rendering/building-density",
 926                                           building_density);
 927     }
 928   }
 929
 930   SGVec3d center = tile.get_gbs_center();
 931   SGGeod geodPos = SGGeod::fromCart(center);
 932   SGQuatd hlOr = SGQuatd::fromLonLat(geodPos)*SGQuatd::fromEulerDeg(0, 0, 180);
 933
 934   // rotate the tiles so that the bounding boxes get nearly axis aligned.
 935   // this will help the collision tree's bounding boxes a bit ...
 936   std::vector<SGVec3d> nodes = tile.get_wgs84_nodes();
 937   for (unsigned i = 0; i < nodes.size(); ++i)
 938     nodes[i] = hlOr.transform(nodes[i]);
 939   tile.set_wgs84_nodes(nodes);
 940
 941   SGQuatf hlOrf(hlOr[0], hlOr[1], hlOr[2], hlOr[3]);
 942   std::vector<SGVec3f> normals = tile.get_normals();
 943   for (unsigned i = 0; i < normals.size(); ++i)
 944     normals[i] = hlOrf.transform(normals[i]);
 945   tile.set_normals(normals);
 946
 947   SGTileGeometryBin tileGeometryBin;
 948   if (!tileGeometryBin.insertBinObj(tile, matlib))
 949     return NULL;
 950
 951   SGVec3f up(0, 0, 1);
 952   GroundLightManager* lightManager = GroundLightManager::instance();
 953
 954   osg::ref_ptr<osg::Group> lightGroup = new SGOffsetTransform(0.94);
 955   osg::ref_ptr<osg::Group> randomObjects;
 956   osg::ref_ptr<osg::Group> forestNode;
 957   osg::ref_ptr<osg::Group> buildingNode;
 958   osg::Group* terrainGroup = new osg::Group;
 959
 960   osg::Node* node = tileGeometryBin.getSurfaceGeometry(matlib);
 961   if (node)
 962     terrainGroup->addChild(node);
 963
 964   if (use_random_objects && matlib) {
 965     tileGeometryBin.computeRandomObjects(matlib);
 966
 967     if (tileGeometryBin.randomModels.getNumModels() > 0) {
 968       // Generate a repeatable random seed
 969       mt seed;
 970       mt_init(&seed, unsigned(123));
 971
 972       std::vector<ModelLOD> models;
 973       for (unsigned int i = 0;
 974            i < tileGeometryBin.randomModels.getNumModels(); i++) {
 975         SGMatModelBin::MatModel obj
 976           = tileGeometryBin.randomModels.getMatModel(i);
 977
 978         SGPropertyNode* root = options->getPropertyNode()->getRootNode();
 979         osg::Node* node = obj.model->get_random_model(root, &seed);
 980
 981         // Create a matrix to place the object in the correct
 982         // location, and then apply the rotation matrix created
 983         // above, with an additional random (or taken from
 984         // the object mask) heading rotation if appropriate.
 985         osg::Matrix transformMat;
 986         transformMat = osg::Matrix::translate(toOsg(obj.position));
 987         if (obj.model->get_heading_type() == SGMatModel::HEADING_RANDOM) {
 988           // Rotate the object around the z axis.
 989           double hdg = mt_rand(&seed) * M_PI * 2;
 990           transformMat.preMult(osg::Matrix::rotate(hdg,
 991                                                    osg::Vec3d(0.0, 0.0, 1.0)));
 992         }
 993
 994         if (obj.model->get_heading_type() == SGMatModel::HEADING_MASK) {
 995           // Rotate the object around the z axis.
 996           double hdg =  - obj.rotation * M_PI * 2;
 997           transformMat.preMult(osg::Matrix::rotate(hdg,
 998                                                    osg::Vec3d(0.0, 0.0, 1.0)));
 999         }
1000
1001         osg::MatrixTransform* position =
1002           new osg::MatrixTransform(transformMat);
1003         position->addChild(node);
1004         models.push_back(ModelLOD(position, obj.lod));
1005       }
1006       RandomObjectsQuadtree quadtree((GetModelLODCoord()), (AddModelLOD()));
1007       quadtree.buildQuadTree(models.begin(), models.end());
1008       randomObjects = quadtree.getRoot();
1009       randomObjects->setName("random objects");
1010     }
1011   }
1012
1013   if (use_random_vegetation && matlib) {
1014     // Now add some random forest.
1015     tileGeometryBin.computeRandomForest(matlib, vegetation_density);
1016
1017     if (tileGeometryBin.randomForest.size() > 0) {
1018       forestNode = createForest(tileGeometryBin.randomForest, osg::Matrix::identity(),
1019                                 options);
1020       forestNode->setName("Random trees");
1021     }
1022   }
1023
1024   if (use_random_buildings && matlib) {
1025     tileGeometryBin.computeRandomBuildings(matlib, building_density);
1026     if (tileGeometryBin.randomBuildings.size() > 0) {
1027       buildingNode = createRandomBuildings(tileGeometryBin.randomBuildings, osg::Matrix::identity(),
1028                                   options);
1029       buildingNode->setName("Random buildings");
1030     }
1031   }
1032
1033   // FIXME: ugly, has a side effect
1034   if (matlib)
1035     tileGeometryBin.computeRandomSurfaceLights(matlib);
1036
1037   if (tileGeometryBin.tileLights.getNumLights() > 0
1038       || tileGeometryBin.randomTileLights.getNumLights() > 0) {
1039     osg::Group* groundLights0 = new osg::Group;
1040     groundLights0->setStateSet(lightManager->getGroundLightStateSet());
1041     groundLights0->setNodeMask(GROUNDLIGHTS0_BIT);
1042     osg::Geode* geode = new osg::Geode;
1043     geode->addDrawable(SGLightFactory::getLights(tileGeometryBin.tileLights));
1044     geode->addDrawable(SGLightFactory::getLights(tileGeometryBin.randomTileLights, 4, -0.3f));
1045     groundLights0->addChild(geode);
1046     lightGroup->addChild(groundLights0);
1047   }
1048
1049   if (tileGeometryBin.randomTileLights.getNumLights() > 0) {
1050     osg::Group* groundLights1 = new osg::Group;
1051     groundLights1->setStateSet(lightManager->getGroundLightStateSet());
1052     groundLights1->setNodeMask(GROUNDLIGHTS1_BIT);
1053     osg::Group* groundLights2 = new osg::Group;
1054     groundLights2->setStateSet(lightManager->getGroundLightStateSet());
1055     groundLights2->setNodeMask(GROUNDLIGHTS2_BIT);
1056     osg::Geode* geode = new osg::Geode;
1057     geode->addDrawable(SGLightFactory::getLights(tileGeometryBin.randomTileLights, 2, -0.15f));
1058     groundLights1->addChild(geode);
1059     lightGroup->addChild(groundLights1);
1060     geode = new osg::Geode;
1061     geode->addDrawable(SGLightFactory::getLights(tileGeometryBin.randomTileLights));
1062     groundLights2->addChild(geode);
1063     lightGroup->addChild(groundLights2);
1064   }
1065
1066   if (!tileGeometryBin.vasiLights.empty()) {
1067     EffectGeode* vasiGeode = new EffectGeode;
1068     Effect* vasiEffect
1069         = getLightEffect(24, osg::Vec3(1, 0.0001, 0.000001), 1, 24, true);
1070     vasiGeode->setEffect(vasiEffect);
1071     SGVec4f red(1, 0, 0, 1);
1072     SGMaterial* mat = 0;
1073     if (matlib)
1074       mat = matlib->find("RWY_RED_LIGHTS");
1075     if (mat)
1076       red = mat->get_light_color();
1077     SGVec4f white(1, 1, 1, 1);
1078     mat = 0;
1079     if (matlib)
1080       mat = matlib->find("RWY_WHITE_LIGHTS");
1081     if (mat)
1082       white = mat->get_light_color();
1083     SGDirectionalLightListBin::const_iterator i;
1084     for (i = tileGeometryBin.vasiLights.begin();
1085          i != tileGeometryBin.vasiLights.end(); ++i) {
1086       vasiGeode->addDrawable(SGLightFactory::getVasi(up, *i, red, white));
1087     }
1088     vasiGeode->setStateSet(lightManager->getRunwayLightStateSet());
1089     lightGroup->addChild(vasiGeode);
1090   }
1091
1092   Effect* runwayEffect = 0;
1093   if (tileGeometryBin.runwayLights.getNumLights() > 0
1094       || !tileGeometryBin.rabitLights.empty()
1095       || !tileGeometryBin.reilLights.empty()
1096       || !tileGeometryBin.odalLights.empty()
1097       || tileGeometryBin.taxiLights.getNumLights() > 0)
1098       runwayEffect = getLightEffect(16, osg::Vec3(1, 0.001, 0.0002), 1, 16, true);
1099   if (tileGeometryBin.runwayLights.getNumLights() > 0
1100       || !tileGeometryBin.rabitLights.empty()
1101       || !tileGeometryBin.reilLights.empty()
1102       || !tileGeometryBin.odalLights.empty()
1103       || !tileGeometryBin.holdshortLights.empty()) {
1104     osg::Group* rwyLights = new osg::Group;
1105     rwyLights->setStateSet(lightManager->getRunwayLightStateSet());
1106     rwyLights->setNodeMask(RUNWAYLIGHTS_BIT);
1107     if (tileGeometryBin.runwayLights.getNumLights() != 0) {
1108       EffectGeode* geode = new EffectGeode;
1109       geode->setEffect(runwayEffect);
1110       geode->addDrawable(SGLightFactory::getLights(tileGeometryBin
1111                                                    .runwayLights));
1112       rwyLights->addChild(geode);
1113     }
1114     SGDirectionalLightListBin::const_iterator i;
1115     for (i = tileGeometryBin.rabitLights.begin();
1116          i != tileGeometryBin.rabitLights.end(); ++i) {
1117       rwyLights->addChild(SGLightFactory::getSequenced(*i));
1118     }
1119     for (i = tileGeometryBin.reilLights.begin();
1120          i != tileGeometryBin.reilLights.end(); ++i) {
1121       rwyLights->addChild(SGLightFactory::getSequenced(*i));
1122     }
1123     for (i = tileGeometryBin.holdshortLights.begin();
1124          i != tileGeometryBin.holdshortLights.end(); ++i) {
1125       rwyLights->addChild(SGLightFactory::getHoldShort(*i));
1126     }
1127     SGLightListBin::const_iterator j;
1128     for (j = tileGeometryBin.odalLights.begin();
1129          j != tileGeometryBin.odalLights.end(); ++j) {
1130       rwyLights->addChild(SGLightFactory::getOdal(*j));
1131     }
1132     lightGroup->addChild(rwyLights);
1133   }
1134
1135   if (tileGeometryBin.taxiLights.getNumLights() > 0) {
1136     osg::Group* taxiLights = new osg::Group;
1137     taxiLights->setStateSet(lightManager->getTaxiLightStateSet());
1138     taxiLights->setNodeMask(RUNWAYLIGHTS_BIT);
1139     EffectGeode* geode = new EffectGeode;
1140     geode->setEffect(runwayEffect);
1141     geode->addDrawable(SGLightFactory::getLights(tileGeometryBin.taxiLights));
1142     taxiLights->addChild(geode);
1143     lightGroup->addChild(taxiLights);
1144   }
1145
1146   // The toplevel transform for that tile.
1147   osg::MatrixTransform* transform = new osg::MatrixTransform;
1148   transform->setName(path);
1149   transform->setMatrix(osg::Matrix::rotate(toOsg(hlOr))*
1150                        osg::Matrix::translate(toOsg(center)));
1151   transform->addChild(terrainGroup);
1152   if (lightGroup->getNumChildren() > 0) {
1153     osg::LOD* lightLOD = new osg::LOD;
1154     lightLOD->addChild(lightGroup.get(), 0, 30000);
1155     // VASI is always on, so doesn't use light bits.
1156     lightLOD->setNodeMask(LIGHTS_BITS | MODEL_BIT);
1157     transform->addChild(lightLOD);
1158   }
1159
1160   if (randomObjects.valid() || forestNode.valid() || buildingNode.valid()) {
1161
1162     // Add a LoD node, so we don't try to display anything when the tile center
1163     // is more than 20km away.
1164     osg::LOD* objectLOD = new osg::LOD;
1165
1166     if (randomObjects.valid()) objectLOD->addChild(randomObjects.get(), 0, 20000);
1167     if (forestNode.valid())  objectLOD->addChild(forestNode.get(), 0, 20000);
1168     if (buildingNode.valid()) objectLOD->addChild(buildingNode.get(), 0, 20000);
1169
1170     unsigned nodeMask = SG_NODEMASK_CASTSHADOW_BIT | SG_NODEMASK_RECIEVESHADOW_BIT | SG_NODEMASK_TERRAIN_BIT;
1171     objectLOD->setNodeMask(nodeMask);
1172     transform->addChild(objectLOD);
1173   }
1174
1175   return transform;
1176 }