X-Git-Url: https://git.mxchange.org/?a=blobdiff_plain;f=src%2FObjects%2Fobj.cxx;h=a33178ae44783b18b51ce93a0cafa334d5e00983;hb=ab381e5c013292935c598dbe80bdd092bcbdd3ff;hp=2f7cef034e3c53ab4655e2ccf45183b0702ec221;hpb=655ce0e20dbe1c8d902d753baee27f77b61fdaf2;p=flightgear.git

diff --git a/src/Objects/obj.cxx b/src/Objects/obj.cxx
index 2f7cef034..a33178ae4 100644
--- a/src/Objects/obj.cxx
+++ b/src/Objects/obj.cxx
@@ -25,19 +25,15 @@
 #  include <config.h>
 #endif
 
-#ifdef FG_MATH_EXCEPTION_CLASH
+#ifdef SG_MATH_EXCEPTION_CLASH
 #  include <math.h>
 #endif
 
 #include <stdio.h>
 #include <string.h>
 
-// #if defined ( __sun__ )
-// extern "C" void *memmove(void *, const void *, size_t);
-// extern "C" void *memset(void *, int, size_t);
-// #endif
-
 #include <simgear/compiler.h>
+#include <simgear/io/sg_binobj.hxx>
 
 #include STL_STRING
 #include <map>			// STL
@@ -46,22 +42,23 @@
 
 #include <simgear/constants.h>
 #include <simgear/debug/logstream.hxx>
-#include <simgear/math/fg_geodesy.hxx>
-#include <simgear/math/fg_random.h>
 #include <simgear/math/point3d.hxx>
 #include <simgear/math/polar3d.hxx>
-#include <simgear/misc/fgstream.hxx>
+#include <simgear/math/sg_geodesy.hxx>
+#include <simgear/math/sg_random.h>
+#include <simgear/misc/sgstream.hxx>
 #include <simgear/misc/stopwatch.hxx>
 #include <simgear/misc/texcoord.hxx>
 
-#include <Main/options.hxx>
+#include <Main/globals.hxx>
+#include <Main/fg_props.hxx>
 #include <Scenery/tileentry.hxx>
 
 #include "matlib.hxx"
 #include "obj.hxx"
 
-FG_USING_STD(string);
-FG_USING_STD(vector);
+SG_USING_STD(string);
+SG_USING_STD(vector);
 
 
 typedef vector < int > int_list;
@@ -73,25 +70,6 @@ static double normals[FG_MAX_NODES][3];
 static double tex_coords[FG_MAX_NODES*3][3];
 
 
-#if 0
-// given three points defining a triangle, calculate the normal
-static void calc_normal(Point3D p1, Point3D p2, 
-			Point3D p3, sgVec3 normal)
-{
-    sgVec3 v1, v2;
-
-    v1[0] = p2[0] - p1[0]; v1[1] = p2[1] - p1[1]; v1[2] = p2[2] - p1[2];
-    v2[0] = p3[0] - p1[0]; v2[1] = p3[1] - p1[1]; v2[2] = p3[2] - p1[2];
-
-    sgVectorProductVec3( normal, v1, v2 );
-    sgNormalizeVec3( normal );
-
-    // fgPrintf( FG_TERRAIN, FG_DEBUG, "  Normal = %.2f %.2f %.2f\n", 
-    //           normal[0], normal[1], normal[2]);
-}
-#endif
-
-
 #define FG_TEX_CONSTANT 69.0
 
 // Calculate texture coordinates for a given point.
@@ -107,14 +85,14 @@ static Point3D local_calc_tex_coords(const Point3D& node, const Point3D& ref) {
 		  node[1] + ref.y(),
 		  node[2] + ref.z() );
 
-    pp = fgCartToPolar3d(cp);
+    pp = sgCartToPolar3d(cp);
 
-    // tmplon = pp.lon() * RAD_TO_DEG;
-    // tmplat = pp.lat() * RAD_TO_DEG;
+    // tmplon = pp.lon() * SGD_RADIANS_TO_DEGREES;
+    // tmplat = pp.lat() * SGD_RADIANS_TO_DEGREES;
     // cout << tmplon << " " << tmplat << endl;
 
-    pp.setx( fmod(RAD_TO_DEG * FG_TEX_CONSTANT * pp.x(), 11.0) );
-    pp.sety( fmod(RAD_TO_DEG * FG_TEX_CONSTANT * pp.y(), 11.0) );
+    pp.setx( fmod(SGD_RADIANS_TO_DEGREES * FG_TEX_CONSTANT * pp.x(), 11.0) );
+    pp.sety( fmod(SGD_RADIANS_TO_DEGREES * FG_TEX_CONSTANT * pp.y(), 11.0) );
 
     if ( pp.x() < 0.0 ) {
 	pp.setx( pp.x() + 11.0 );
@@ -137,6 +115,11 @@ ssgBranch *fgGenTile( const string& path, FGTileEntry *t) {
     ssgSimpleState *state = NULL;
 
     ssgBranch *tile = new ssgBranch () ;
+    if ( !tile ) {
+        SG_LOG( SG_TERRAIN, SG_ALERT, "fgGenTile(): NO MEMORY" );
+        return NULL;
+    }
+
     tile -> setName ( (char *)path.c_str() ) ;
 
     double tex_width = 1000.0;
@@ -153,19 +136,19 @@ ssgBranch *fgGenTile( const string& path, FGTileEntry *t) {
 	// set ssgState
 	state = newmat->get_state();
     } else {
-	FG_LOG( FG_TERRAIN, FG_ALERT, 
+	SG_LOG( SG_TERRAIN, SG_ALERT, 
 		"Ack! unknown usemtl name = " << "Ocean" 
 		<< " in " << path );
     }
 
     // Calculate center point
-    FGBucket b = t->tile_bucket;
+    SGBucket b = t->tile_bucket;
     double clon = b.get_center_lon();
     double clat = b.get_center_lat();
     double height = b.get_height();
     double width = b.get_width();
 
-    Point3D center = fgGeodToCart(Point3D(clon*DEG_TO_RAD,clat*DEG_TO_RAD,0.0));
+    Point3D center = sgGeodToCart(Point3D(clon*SGD_DEGREES_TO_RADIANS,clat*SGD_DEGREES_TO_RADIANS,0.0));
     t->center = center;
     // cout << "center = " << center << endl;;
     
@@ -179,14 +162,15 @@ ssgBranch *fgGenTile( const string& path, FGTileEntry *t) {
     Point3D rad[4];
     int i;
     for ( i = 0; i < 4; ++i ) {
-	rad[i] = Point3D( geod[i].x() * DEG_TO_RAD, geod[i].y() * DEG_TO_RAD,
-			  geod[i].z() );
+        rad[i] = Point3D( geod[i].x() * SGD_DEGREES_TO_RADIANS,
+                          geod[i].y() * SGD_DEGREES_TO_RADIANS,
+                          geod[i].z() );
     }
 
     Point3D cart[4], rel[4];
     t->nodes.clear();
     for ( i = 0; i < 4; ++i ) {
-	cart[i] = fgGeodToCart(rad[i]);
+	cart[i] = sgGeodToCart(rad[i]);
 	rel[i] = cart[i] - center;
 	t->nodes.push_back( rel[i] );
 	// cout << "corner " << i << " = " << cart[i] << endl;
@@ -201,21 +185,18 @@ ssgBranch *fgGenTile( const string& path, FGTileEntry *t) {
     // Calculate normals
     Point3D normals[4];
     for ( i = 0; i < 4; ++i ) {
-	normals[i] = cart[i];
-	double length = normals[i].distance3D( Point3D(0.0) );
-	normals[i] /= length;
+	double length = cart[i].distance3D( Point3D(0.0) );
+	normals[i] = cart[i] / length;
 	// cout << "normal = " << normals[i] << endl;
     }
 
     // Calculate texture coordinates
     point_list geod_nodes;
     geod_nodes.clear();
-    for ( i = 0; i < 4; ++i ) {
-	geod_nodes.push_back( geod[i] );
-    }
     int_list rectangle;
     rectangle.clear();
     for ( i = 0; i < 4; ++i ) {
+	geod_nodes.push_back( geod[i] );
 	rectangle.push_back( i );
     }
     point_list texs = calc_tex_coords( b, geod_nodes, rectangle, 
@@ -259,17 +240,82 @@ ssgBranch *fgGenTile( const string& path, FGTileEntry *t) {
     leaf->setState( state );
 
     tile->addKid( leaf );
-    // if ( current_options.get_clouds() ) {
-    //    fgGenCloudTile(path, t, tile);
-    // }
 
     return tile;
 }
 
 
-// Load a .obj file
-ssgBranch *fgObjLoad( const string& path, FGTileEntry *t, const bool is_base) {
-    FGNewMat *newmat;
+static void random_pt_inside_tri( float *res,
+				  float *n1, float *n2, float *n3 )
+{
+    sgVec3 p1, p2, p3;
+
+    double a = sg_random();
+    double b = sg_random();
+    if ( a + b > 1.0 ) {
+	a = 1.0 - a;
+	b = 1.0 - b;
+    }
+    double c = 1 - a - b;
+
+    sgScaleVec3( p1, n1, a );
+    sgScaleVec3( p2, n2, b );
+    sgScaleVec3( p3, n3, c );
+
+    sgAddVec3( res, p1, p2 );
+    sgAddVec3( res, p3 );
+}
+
+
+static void gen_random_surface_points( ssgLeaf *leaf, ssgVertexArray *lights,
+				       double factor ) {
+    int num = leaf->getNumTriangles();
+    if ( num > 0 ) {
+	short int n1, n2, n3;
+	float *p1, *p2, *p3;
+	sgVec3 result;
+
+	// generate a repeatable random seed
+	p1 = leaf->getVertex( 0 );
+	unsigned int seed = (unsigned int)p1[0];
+	sg_srandom( seed );
+
+	for ( int i = 0; i < num; ++i ) {
+	    leaf->getTriangle( i, &n1, &n2, &n3 );
+	    p1 = leaf->getVertex(n1);
+	    p2 = leaf->getVertex(n2);
+	    p3 = leaf->getVertex(n3);
+	    double area = sgTriArea( p1, p2, p3 );
+	    double num = area / factor;
+
+	    // generate a light point for each unit of area
+	    while ( num > 1.0 ) {
+		random_pt_inside_tri( result, p1, p2, p3 );
+		lights->add( result );
+		num -= 1.0;
+	    }
+	    // for partial units of area, use a zombie door method to
+	    // create the proper random chance of a light being created
+	    // for this triangle
+	    if ( num > 0.0 ) {
+		if ( sg_random() <= num ) {
+		    // a zombie made it through our door
+		    random_pt_inside_tri( result, p1, p2, p3 );
+		    lights->add( result );
+		}
+	    }
+	}
+    }
+}
+
+
+// Load an Ascii obj file
+ssgBranch *fgAsciiObjLoad( const string& path, FGTileEntry *t,
+				  ssgVertexArray *lights, const bool is_base)
+{
+    FGNewMat *newmat = NULL;
+    string material;
+    float coverage = -1;
     Point3D pp;
     // sgVec3 approx_normal;
     // double normal[3], scale = 0.0;
@@ -301,15 +347,17 @@ ssgBranch *fgObjLoad( const string& path, FGTileEntry *t, const bool is_base) {
     tile -> setName ( (char *)path.c_str() ) ;
 
     // Attempt to open "path.gz" or "path"
-    fg_gzifstream in( path );
+    sg_gzifstream in( path );
     if ( ! in.is_open() ) {
-	FG_LOG( FG_TERRAIN, FG_ALERT, "Cannot open file: " << path );
-	FG_LOG( FG_TERRAIN, FG_ALERT, "default to ocean tile: " << path );
+	SG_LOG( SG_TERRAIN, SG_DEBUG, "Cannot open file: " << path );
+	SG_LOG( SG_TERRAIN, SG_DEBUG, "default to ocean tile: " << path );
+
+        delete tile;
 
-	return fgGenTile( path, t );
+	return NULL;
     }
 
-    shading = current_options.get_shading();
+    shading = fgGetBool("/sim/rendering/shading");
 
     if ( is_base ) {
 	t->ncount = 0;
@@ -321,8 +369,8 @@ ssgBranch *fgObjLoad( const string& path, FGTileEntry *t, const bool is_base) {
     }
     center = t->center;
 
-    StopWatch stopwatch;
-    stopwatch.start();
+    // StopWatch stopwatch;
+    // stopwatch.start();
 
     // ignore initial comments and blank lines. (priming the pump)
     // in >> skipcomment;
@@ -338,11 +386,7 @@ ssgBranch *fgObjLoad( const string& path, FGTileEntry *t, const bool is_base) {
     while ( ! in.eof() ) {
 #endif
 
-#if defined( macintosh )
 	in >> ::skipws;
-#else
-	in >> skipws;
-#endif
 
 	if ( in.get( c ) && c == '#' ) {
 	    // process a comment line
@@ -356,6 +400,16 @@ ssgBranch *fgObjLoad( const string& path, FGTileEntry *t, const bool is_base) {
 		// read scenery versions number
 		in >> scenery_version;
 		// cout << "scenery_version = " << scenery_version << endl;
+		if ( scenery_version > 0.4 ) {
+		    SG_LOG( SG_TERRAIN, SG_ALERT, 
+			    "\nYou are attempting to load a tile format that\n"
+			    << "is newer than this version of flightgear can\n"
+			    << "handle.  You should upgrade your copy of\n"
+			    << "FlightGear to the newest version.  For\n"
+			    << "details, please see:\n"
+			    << "\n    http://www.flightgear.org\n" );
+		    exit(-1);
+		}
 	    } else if ( token == "gbs" ) {
 		// reference point (center offset)
 		if ( is_base ) {
@@ -382,8 +436,9 @@ ssgBranch *fgObjLoad( const string& path, FGTileEntry *t, const bool is_base) {
 		if ( ! shared_done ) {
 		    // sanity check
 		    if ( (int)nodes.size() != vncount ) {
-			FG_LOG( FG_TERRAIN, FG_ALERT, 
-				"Tile has mismatched nodes and normals: " 
+			SG_LOG( SG_TERRAIN, SG_ALERT, 
+				"Tile has mismatched nodes = " << nodes.size()
+				<< " and normals = " << vncount << " : " 
 				<< path );
 			// exit(-1);
 		    }
@@ -419,7 +474,6 @@ ssgBranch *fgObjLoad( const string& path, FGTileEntry *t, const bool is_base) {
 		in_faces = false;
 
 		// scan the material line
-		string material;
 		in >> material;
 		
 		// find this material in the properties list
@@ -435,14 +489,14 @@ ssgBranch *fgObjLoad( const string& path, FGTileEntry *t, const bool is_base) {
 		    file += material;
 		    cout << "current file = " << file << endl;
 		    if ( ! material_lib.add_item( file ) ) {
-			FG_LOG( FG_TERRAIN, FG_ALERT, 
+			SG_LOG( SG_TERRAIN, SG_ALERT, 
 				"Ack! unknown usemtl name = " << material 
 				<< " in " << path );
 		    } else {
 			// locate our newly created material
 			newmat = material_lib.find( material );
 			if ( newmat == NULL ) {
-			    FG_LOG( FG_TERRAIN, FG_ALERT, 
+			    SG_LOG( SG_TERRAIN, SG_ALERT, 
 				    "Ack! bad on the fly materia create = "
 				    << material << " in " << path );
 			}
@@ -455,11 +509,14 @@ ssgBranch *fgObjLoad( const string& path, FGTileEntry *t, const bool is_base) {
 		    tex_width = newmat->get_xsize();
 		    tex_height = newmat->get_ysize();
 		    state = newmat->get_state();
+		    coverage = newmat->get_light_coverage();
 		    // cout << "(w) = " << tex_width << " (h) = " 
 		    //      << tex_width << endl;
+		} else {
+		    coverage = -1;
 		}
 	    } else {
-		// unknown comment, just gobble the input untill the
+		// unknown comment, just gobble the input until the
 		// end of line
 
 		in >> skipeol;
@@ -479,7 +536,7 @@ ssgBranch *fgObjLoad( const string& path, FGTileEntry *t, const bool is_base) {
 		       >> normals[vncount][2];
 		    vncount++;
 		} else {
-		    FG_LOG( FG_TERRAIN, FG_ALERT, 
+		    SG_LOG( SG_TERRAIN, SG_ALERT, 
 			    "Read too many vertex normals in " << path 
 			    << " ... dying :-(" );
 		    exit(-1);
@@ -491,7 +548,7 @@ ssgBranch *fgObjLoad( const string& path, FGTileEntry *t, const bool is_base) {
 		       >> tex_coords[vtcount][1];
 		    vtcount++;
 		} else {
-		    FG_LOG( FG_TERRAIN, FG_ALERT, 
+		    SG_LOG( SG_TERRAIN, SG_ALERT, 
 			    "Read too many vertex texture coords in " << path
 			    << " ... dying :-("
 			    );
@@ -509,14 +566,14 @@ ssgBranch *fgObjLoad( const string& path, FGTileEntry *t, const bool is_base) {
 			t->ncount++;
 		    }
 		} else {
-		    FG_LOG( FG_TERRAIN, FG_ALERT, 
+		    SG_LOG( SG_TERRAIN, SG_ALERT, 
 			    "Read too many nodes in " << path 
 			    << " ... dying :-(");
 		    exit(-1);
 		}
 	    } else if ( (token == "tf") || (token == "ts") || (token == "f") ) {
 		// triangle fan, strip, or individual face
-		// FG_LOG( FG_TERRAIN, FG_INFO, "new fan or strip");
+		// SG_LOG( SG_TERRAIN, SG_INFO, "new fan or strip");
 
 		fan_vertices.clear();
 		fan_tex_coords.clear();
@@ -572,11 +629,7 @@ ssgBranch *fgObjLoad( const string& path, FGTileEntry *t, const bool is_base) {
 		
 		// read all subsequent numbers until next thing isn't a number
 		while ( true ) {
-#if defined( macintosh )
 		    in >> ::skipws;
-#else
-		    in >> skipws;
-#endif
 
 		    char c;
 		    in.get(c);
@@ -666,18 +719,25 @@ ssgBranch *fgObjLoad( const string& path, FGTileEntry *t, const bool is_base) {
 		leaf->setState( state );
 
 		tile->addKid( leaf );
+
+		if ( is_base ) {
+		    if ( coverage > 0.0 ) {
+			if ( coverage < 10000.0 ) {
+			    SG_LOG(SG_INPUT, SG_ALERT, "Light coverage is "
+				   << coverage << ", pushing up to 10000");
+			    coverage = 10000;
+			}
+			gen_random_surface_points(leaf, lights, coverage);
+		    }
+		}
 	    } else {
-		FG_LOG( FG_TERRAIN, FG_WARN, "Unknown token in " 
+		SG_LOG( SG_TERRAIN, SG_WARN, "Unknown token in " 
 			<< path << " = " << token );
 	    }
 
 	    // eat white space before start of while loop so if we are
 	    // done with useful input it is noticed before hand.
-#if defined( macintosh )
 	    in >> ::skipws;
-#else
-	    in >> skipws;
-#endif
 	}
     }
 
@@ -685,16 +745,263 @@ ssgBranch *fgObjLoad( const string& path, FGTileEntry *t, const bool is_base) {
 	t->nodes = nodes;
     }
 
-    stopwatch.stop();
-    FG_LOG( FG_TERRAIN, FG_DEBUG, 
-	    "Loaded " << path << " in " 
-	    << stopwatch.elapsedSeconds() << " seconds" );
+    // stopwatch.stop();
+    // SG_LOG( SG_TERRAIN, SG_DEBUG, 
+    //     "Loaded " << path << " in " 
+    //     << stopwatch.elapsedSeconds() << " seconds" );
 
-    // Generate a cloud layer above the tiles
-    // if ( current_options.get_clouds() ) {
-    //  	fgGenCloudTile(path, t, tile);
-    // }
     return tile;
 }
 
 
+ssgLeaf *gen_leaf( const string& path,
+		   const GLenum ty, const string& material,
+		   const point_list& nodes, const point_list& normals,
+		   const point_list& texcoords,
+		   const int_list node_index,
+		   const int_list& tex_index,
+		   const bool calc_lights, ssgVertexArray *lights )
+{
+    double tex_width = 1000.0, tex_height = 1000.0;
+    ssgSimpleState *state = NULL;
+    float coverage = -1;
+
+    FGNewMat *newmat = material_lib.find( material );
+    if ( newmat == NULL ) {
+	// see if this is an on the fly texture
+	string file = path;
+	int pos = file.rfind( "/" );
+	file = file.substr( 0, pos );
+	cout << "current file = " << file << endl;
+	file += "/";
+	file += material;
+	cout << "current file = " << file << endl;
+	if ( ! material_lib.add_item( file ) ) {
+	    SG_LOG( SG_TERRAIN, SG_ALERT, 
+		    "Ack! unknown usemtl name = " << material 
+		    << " in " << path );
+	} else {
+	    // locate our newly created material
+	    newmat = material_lib.find( material );
+	    if ( newmat == NULL ) {
+		SG_LOG( SG_TERRAIN, SG_ALERT, 
+			"Ack! bad on the fly material create = "
+			<< material << " in " << path );
+	    }
+	}
+    }
+
+    if ( newmat != NULL ) {
+	// set the texture width and height values for this
+	// material
+	tex_width = newmat->get_xsize();
+	tex_height = newmat->get_ysize();
+	state = newmat->get_state();
+	coverage = newmat->get_light_coverage();
+	// cout << "(w) = " << tex_width << " (h) = " 
+	//      << tex_width << endl;
+    } else {
+	coverage = -1;
+    }
+
+    // cout << "before list allocs" << endl;
+
+    // cout << "before vl, size = " << size << endl;
+    // cout << "before nl" << endl;
+    // cout << "before tl" << endl;
+    // cout << "before cl" << endl;
+
+    sgVec2 tmp2;
+    sgVec3 tmp3;
+    sgVec4 tmp4;
+    int i;
+
+    // vertices
+    int size = node_index.size();
+    if ( size < 1 ) {
+	SG_LOG( SG_TERRAIN, SG_ALERT, "Woh! node list size < 1" );
+	exit(-1);
+    }
+    ssgVertexArray *vl = new ssgVertexArray( size );
+    Point3D node;
+    for ( i = 0; i < size; ++i ) {
+	node = nodes[ node_index[i] ];
+	sgSetVec3( tmp3, node[0], node[1], node[2] );
+	vl -> add( tmp3 );
+    }
+
+    // colors
+    ssgColourArray *cl = new ssgColourArray( 1 );
+    sgSetVec4( tmp4, 1.0, 1.0, 1.0, 1.0 );
+    cl->add( tmp4 );
+
+    // normals
+    Point3D normal;
+    ssgNormalArray *nl = new ssgNormalArray( size );
+    if ( normals.size() == 1 ) {
+        normal = normals[ 0 ];
+        sgSetVec3( tmp3, normal[0], normal[1], normal[2] );
+        nl -> add( tmp3 );
+    } else if ( normals.size() > 1 ) {
+        for ( i = 0; i < size; ++i ) {
+            normal = normals[ node_index[i] ];
+            sgSetVec3( tmp3, normal[0], normal[1], normal[2] );
+            nl -> add( tmp3 );
+        }
+    }
+
+    // texture coordinates
+    size = tex_index.size();
+    Point3D texcoord;
+    ssgTexCoordArray *tl = new ssgTexCoordArray( size );
+    if ( size == 1 ) {
+        texcoord = texcoords[ tex_index[0] ];
+	sgSetVec2( tmp2, texcoord[0], texcoord[1] );
+	sgSetVec2( tmp2, texcoord[0], texcoord[1] );
+	if ( tex_width > 0 ) {
+	    tmp2[0] *= (1000.0 / tex_width);
+	}
+	if ( tex_height > 0 ) {
+	    tmp2[1] *= (1000.0 / tex_height);
+	}
+	tl -> add( tmp2 );
+    } else if ( size > 1 ) {
+        for ( i = 0; i < size; ++i ) {
+            texcoord = texcoords[ tex_index[i] ];
+            sgSetVec2( tmp2, texcoord[0], texcoord[1] );
+            if ( tex_width > 0 ) {
+                tmp2[0] *= (1000.0 / tex_width);
+            }
+            if ( tex_height > 0 ) {
+                tmp2[1] *= (1000.0 / tex_height);
+            }
+            tl -> add( tmp2 );
+        }
+    }
+
+    // cout << "before leaf create" << endl;
+    ssgLeaf *leaf = new ssgVtxTable ( ty, vl, nl, tl, cl );
+    // cout << "after leaf create" << endl;
+
+    // lookup the state record
+    // cout << "looking up material = " << endl;
+    // cout << material << endl;
+    // cout << "'" << endl;
+
+    leaf->setState( state );
+
+    if ( calc_lights ) {
+	if ( coverage > 0.0 ) {
+	    if ( coverage < 10000.0 ) {
+		SG_LOG(SG_INPUT, SG_ALERT, "Light coverage is "
+		       << coverage << ", pushing up to 10000");
+		coverage = 10000;
+	    }
+	    gen_random_surface_points(leaf, lights, coverage);
+	}
+    }
+
+    return leaf;
+}
+
+
+// Load an Binary obj file
+ssgBranch *fgBinObjLoad( const string& path, FGTileEntry *t,
+                         ssgVertexArray *lights, const bool is_base)
+{
+    int i;
+
+    SGBinObject obj;
+    bool result = obj.read_bin( path );
+
+    if ( !result ) {
+	return NULL;
+    }
+
+    // cout << "fans size = " << obj.get_fans_v().size()
+    //      << " fan_mats size = " << obj.get_fan_materials().size() << endl;
+
+    ssgBranch *object = new ssgBranch();
+    object->setName( (char *)path.c_str() );
+   
+    if ( is_base && t != NULL ) {
+	// reference point (center offset/bounding sphere)
+	t->center = obj.get_gbs_center();
+	t->bounding_radius = obj.get_gbs_radius();
+    }
+
+    point_list nodes = obj.get_wgs84_nodes();
+    point_list colors = obj.get_colors();
+    point_list normals = obj.get_normals();
+    point_list texcoords = obj.get_texcoords();
+
+    string material;
+    int_list vertex_index;
+    int_list tex_index;
+
+    // generate points
+    string_list pt_materials = obj.get_pt_materials();
+    group_list pts_v = obj.get_pts_v();
+    for ( i = 0; i < (int)pts_v.size(); ++i ) {
+        cout << "pts_v.size() = " << pts_v.size() << endl;
+	material = pt_materials[i];
+	vertex_index = pts_v[i];
+	tex_index.clear();
+	ssgLeaf *leaf = gen_leaf( path, GL_POINTS, material,
+				  nodes, normals, texcoords,
+				  vertex_index, tex_index,
+				  false, lights );
+
+	object->addKid( leaf );
+    }
+
+    // generate triangles
+    string_list tri_materials = obj.get_tri_materials();
+    group_list tris_v = obj.get_tris_v();
+    group_list tris_tc = obj.get_tris_tc();
+    for ( i = 0; i < (int)tris_v.size(); ++i ) {
+	material = tri_materials[i];
+	vertex_index = tris_v[i];
+	tex_index = tris_tc[i];
+	ssgLeaf *leaf = gen_leaf( path, GL_TRIANGLES, material,
+				  nodes, normals, texcoords,
+				  vertex_index, tex_index,
+				  is_base, lights );
+
+	object->addKid( leaf );
+    }
+
+    // generate strips
+    string_list strip_materials = obj.get_strip_materials();
+    group_list strips_v = obj.get_strips_v();
+    group_list strips_tc = obj.get_strips_tc();
+    for ( i = 0; i < (int)strips_v.size(); ++i ) {
+	material = strip_materials[i];
+	vertex_index = strips_v[i];
+	tex_index = strips_tc[i];
+	ssgLeaf *leaf = gen_leaf( path, GL_TRIANGLE_STRIP, material,
+				  nodes, normals, texcoords,
+				  vertex_index, tex_index,
+				  is_base, lights );
+
+	object->addKid( leaf );
+    }
+
+    // generate fans
+    string_list fan_materials = obj.get_fan_materials();
+    group_list fans_v = obj.get_fans_v();
+    group_list fans_tc = obj.get_fans_tc();
+    for ( i = 0; i < (int)fans_v.size(); ++i ) {
+	material = fan_materials[i];
+	vertex_index = fans_v[i];
+	tex_index = fans_tc[i];
+	ssgLeaf *leaf = gen_leaf( path, GL_TRIANGLE_FAN, material,
+				  nodes, normals, texcoords,
+				  vertex_index, tex_index,
+				  is_base, lights );
+
+	object->addKid( leaf );
+    }
+
+    return object;
+}