]> git.mxchange.org Git - simgear.git/blobdiff - simgear/scene/material/mat.cxx
Use a round-robin scheme rather than returning a random textured state.
[simgear.git] / simgear / scene / material / mat.cxx
index bcf6df5a6fb2931773ed0cea1eff7f2be95a903f..3ae2d37dae455b0478c96733081617940946d1fd 100644 (file)
@@ -1,4 +1,4 @@
-// newmat.cxx -- class to handle material properties
+// mat.cxx -- class to handle material properties
 //
 // Written by Curtis Olson, started May 1998.
 //
 #include <map>
 SG_USING_STD(map);
 
-#include <simgear/compiler.h>
+#include <plib/ul.h>
 
 #ifdef SG_MATH_EXCEPTION_CLASH
 #  include <math.h>
 #endif
 
 #include <simgear/debug/logstream.hxx>
-#include <simgear/math/sg_random.h>
 #include <simgear/misc/sg_path.hxx>
 #include <simgear/misc/sgstream.hxx>
-#include <simgear/scene/model/loader.hxx>
 
 #include "mat.hxx"
 
-\f
-////////////////////////////////////////////////////////////////////////
-// Local static functions.
-////////////////////////////////////////////////////////////////////////
-
-/**
- * Internal method to test whether a file exists.
- *
- * TODO: this should be moved to a SimGear library of local file
- * functions.
- */
-static inline bool
-local_file_exists( const string& path ) {
-    sg_gzifstream in( path );
-    if ( ! in.is_open() ) {
-       return false;
-    } else {
-       return true;
-    }
-}
-
-
-\f
-////////////////////////////////////////////////////////////////////////
-// Implementation of FGNewMat::Object.
-////////////////////////////////////////////////////////////////////////
-
-FGNewMat::Object::Object (const SGPropertyNode * node, double range_m)
-  : _models_loaded(false),
-    _coverage_m2(node->getDoubleValue("coverage-m2", 1000000)),
-    _range_m(range_m)
-{
-                               // Sanity check
-  if (_coverage_m2 < 1000) {
-    SG_LOG(SG_INPUT, SG_ALERT, "Random object coverage " << _coverage_m2
-          << " is too small, forcing, to 1000");
-    _coverage_m2 = 1000;
-  }
-
-                               // Note all the model paths
-  vector <SGPropertyNode_ptr> path_nodes = node->getChildren("path");
-  for (unsigned int i = 0; i < path_nodes.size(); i++)
-    _paths.push_back(path_nodes[i]->getStringValue());
-
-                               // Note the heading type
-  string hdg = node->getStringValue("heading-type", "fixed");
-  if (hdg == "fixed") {
-    _heading_type = HEADING_FIXED;
-  } else if (hdg == "billboard") {
-    _heading_type = HEADING_BILLBOARD;
-  } else if (hdg == "random") {
-    _heading_type = HEADING_RANDOM;
-  } else {
-    _heading_type = HEADING_FIXED;
-    SG_LOG(SG_INPUT, SG_ALERT, "Unknown heading type: " << hdg
-          << "; using 'fixed' instead.");
-  }
-
-  // uncomment to preload models
-  // load_models();
-}
-
-FGNewMat::Object::~Object ()
-{
-  for (unsigned int i = 0; i < _models.size(); i++) {
-    if (_models[i] != 0) {
-      _models[i]->deRef();
-      _models[i] = 0;
-    }
-  }
-}
-
-int
-FGNewMat::Object::get_model_count( FGModelLoader *loader,
-                                   const string &fg_root,
-                                   SGPropertyNode *prop_root,
-                                   double sim_time_sec )
-{
-  load_models( loader, fg_root, prop_root, sim_time_sec );
-  return _models.size();
-}
-
-inline void
-FGNewMat::Object::load_models ( FGModelLoader *loader,
-                                const string &fg_root,
-                                SGPropertyNode *prop_root,
-                                double sim_time_sec )
-{
-                               // Load model only on demand
-  if (!_models_loaded) {
-    for (unsigned int i = 0; i < _paths.size(); i++) {
-      ssgEntity *entity = loader->load_model( fg_root, _paths[i],
-                                              prop_root, sim_time_sec );
-      if (entity != 0) {
-                                // FIXME: this stuff can be handled
-                                // in the XML wrapper as well (at least,
-                                // the billboarding should be handled
-                                // there).
-       float ranges[] = {0, _range_m};
-       ssgRangeSelector * lod = new ssgRangeSelector;
-        lod->ref();
-        lod->setRanges(ranges, 2);
-       if (_heading_type == HEADING_BILLBOARD) {
-         ssgCutout * cutout = new ssgCutout(false);
-         cutout->addKid(entity);
-         lod->addKid(cutout);
-       } else {
-         lod->addKid(entity);
-       }
-       _models.push_back(lod);
-      } else {
-       SG_LOG(SG_INPUT, SG_ALERT, "Failed to load object " << _paths[i]);
-      }
-    }
-  }
-  _models_loaded = true;
-}
-
-ssgEntity *
-FGNewMat::Object::get_model( int index,
-                             FGModelLoader *loader,
-                             const string &fg_root,
-                             SGPropertyNode *prop_root,
-                             double sim_time_sec )
-{
-  load_models( loader, fg_root, prop_root, sim_time_sec ); // comment this out if preloading models
-  return _models[index];
-}
-
-ssgEntity *
-FGNewMat::Object::get_random_model( FGModelLoader *loader,
-                                    const string &fg_root,
-                                    SGPropertyNode *prop_root,
-                                    double sim_time_sec )
-{
-  load_models( loader, fg_root, prop_root, sim_time_sec ); // comment this out if preloading models
-  int nModels = _models.size();
-  int index = int(sg_random() * nModels);
-  if (index >= nModels)
-    index = 0;
-  return _models[index];
-}
-
-double
-FGNewMat::Object::get_coverage_m2 () const
-{
-  return _coverage_m2;
-}
-
-FGNewMat::Object::HeadingType
-FGNewMat::Object::get_heading_type () const
-{
-  return _heading_type;
-}
-
-
-\f
-////////////////////////////////////////////////////////////////////////
-// Implementation of FGNewMat::ObjectGroup.
-////////////////////////////////////////////////////////////////////////
-
-FGNewMat::ObjectGroup::ObjectGroup (SGPropertyNode * node)
-  : _range_m(node->getDoubleValue("range-m", 2000))
-{
-                               // Load the object subnodes
-  vector<SGPropertyNode_ptr> object_nodes =
-    ((SGPropertyNode *)node)->getChildren("object");
-  for (unsigned int i = 0; i < object_nodes.size(); i++) {
-    const SGPropertyNode * object_node = object_nodes[i];
-    if (object_node->hasChild("path"))
-      _objects.push_back(new Object(object_node, _range_m));
-    else
-      SG_LOG(SG_INPUT, SG_ALERT, "No path supplied for object");
-  }
-}
-
-FGNewMat::ObjectGroup::~ObjectGroup ()
-{
-  for (unsigned int i = 0; i < _objects.size(); i++) {
-    delete _objects[i];
-    _objects[i] = 0;
-  }
-}
-
-double
-FGNewMat::ObjectGroup::get_range_m () const
-{
-  return _range_m;
-}
-
-int
-FGNewMat::ObjectGroup::get_object_count () const
-{
-  return _objects.size();
-}
-
-FGNewMat::Object *
-FGNewMat::ObjectGroup::get_object (int index) const
-{
-  return _objects[index];
-}
-
-
 \f
 ////////////////////////////////////////////////////////////////////////
 // Constructors and destructor.
 ////////////////////////////////////////////////////////////////////////
 
 
-FGNewMat::FGNewMat( const string &fg_root,
-                    const SGPropertyNode *props,
-                    bool smooth_shading,
-                    bool use_textures )
+SGMaterial::SGMaterial( const string &fg_root, const SGPropertyNode *props )
 {
     init();
     read_properties( fg_root, props );
-    build_ssg_state( false, smooth_shading, use_textures );
+    build_ssg_state( false );
 }
 
-FGNewMat::FGNewMat( const string &texpath,
-                    bool smooth_shading,
-                    bool use_textures )
+SGMaterial::SGMaterial( const string &texpath )
 {
     init();
-    texture_path = texpath;
-    build_ssg_state( true, smooth_shading, use_textures );
+
+    _internal_state st = { NULL, texpath, false };
+    _status.push_back( st );
+
+    build_ssg_state( true );
 }
 
-FGNewMat::FGNewMat( ssgSimpleState *s,
-                    bool smooth_shading,
-                    bool use_textures )
+SGMaterial::SGMaterial( ssgSimpleState *s )
 {
     init();
-    set_ssg_state( s, smooth_shading, use_textures );
+    set_ssg_state( s );
 }
 
-FGNewMat::~FGNewMat (void)
+SGMaterial::~SGMaterial (void)
 {
   for (unsigned int i = 0; i < object_groups.size(); i++) {
     delete object_groups[i];
@@ -295,19 +86,36 @@ FGNewMat::~FGNewMat (void)
 ////////////////////////////////////////////////////////////////////////
 
 void
-FGNewMat::read_properties( const string &fg_root, const SGPropertyNode * props )
+SGMaterial::read_properties( const string &fg_root, const SGPropertyNode * props )
 {
-                               // Get the path to the texture
-  string tname = props->getStringValue("texture", "unknown.rgb");
-  SGPath tpath( fg_root );
-  tpath.append("Textures.high");
-  tpath.append(tname);
-  if (!local_file_exists(tpath.str())) {
-    tpath = SGPath( fg_root );
+                               // Gather the path(s) to the texture(s)
+  vector<SGPropertyNode_ptr> textures = props->getChildren("texture");
+  for (int i = 0; i < textures.size(); i++)
+  {
+    string tname = textures[i]->getStringValue();
+    if (tname == "")
+        tname = "unknown.rgb";
+
+    SGPath tpath( fg_root );
+    tpath.append("Textures.high");
+    tpath.append(tname);
+    if (!ulFileExists(tpath.c_str())) {
+      tpath = SGPath( fg_root );
+      tpath.append("Textures");
+      tpath.append(tname);
+    }
+    _internal_state st = { NULL, tpath.str(), false };
+    _status.push_back( st );
+  }
+
+  if (textures.size() == 0) {
+    string tname = "unknown.rgb";
+    SGPath tpath( fg_root );
     tpath.append("Textures");
     tpath.append(tname);
+    _internal_state st = { NULL, tpath.str(), true };
+    _status.push_back( st );
   }
-  texture_path = tpath.str();
 
   xsize = props->getDoubleValue("xsize", 0.0);
   ysize = props->getDoubleValue("ysize", 0.0);
@@ -316,32 +124,33 @@ FGNewMat::read_properties( const string &fg_root, const SGPropertyNode * props )
   mipmap = props->getBoolValue("mipmap", true);
   light_coverage = props->getDoubleValue("light-coverage", 0.0);
 
-  ambient[0] = props->getDoubleValue("ambient/r", 0.0);
-  ambient[1] = props->getDoubleValue("ambient/g", 0.0);
-  ambient[2] = props->getDoubleValue("ambient/b", 0.0);
-  ambient[3] = props->getDoubleValue("ambient/a", 0.0);
+  // Taken from default values as used in ac3d
+  ambient[0] = props->getDoubleValue("ambient/r", 0.2);
+  ambient[1] = props->getDoubleValue("ambient/g", 0.2);
+  ambient[2] = props->getDoubleValue("ambient/b", 0.2);
+  ambient[3] = props->getDoubleValue("ambient/a", 1.0);
 
-  diffuse[0] = props->getDoubleValue("diffuse/r", 0.0);
-  diffuse[1] = props->getDoubleValue("diffuse/g", 0.0);
-  diffuse[2] = props->getDoubleValue("diffuse/b", 0.0);
-  diffuse[3] = props->getDoubleValue("diffuse/a", 0.0);
+  diffuse[0] = props->getDoubleValue("diffuse/r", 0.8);
+  diffuse[1] = props->getDoubleValue("diffuse/g", 0.8);
+  diffuse[2] = props->getDoubleValue("diffuse/b", 0.8);
+  diffuse[3] = props->getDoubleValue("diffuse/a", 1.0);
 
   specular[0] = props->getDoubleValue("specular/r", 0.0);
   specular[1] = props->getDoubleValue("specular/g", 0.0);
   specular[2] = props->getDoubleValue("specular/b", 0.0);
-  specular[3] = props->getDoubleValue("specular/a", 0.0);
+  specular[3] = props->getDoubleValue("specular/a", 1.0);
 
   emission[0] = props->getDoubleValue("emissive/r", 0.0);
   emission[1] = props->getDoubleValue("emissive/g", 0.0);
   emission[2] = props->getDoubleValue("emissive/b", 0.0);
-  emission[3] = props->getDoubleValue("emissive/a", 0.0);
+  emission[3] = props->getDoubleValue("emissive/a", 1.0);
 
-  shininess = props->getDoubleValue("shininess", 0.0);
+  shininess = props->getDoubleValue("shininess", 1.0);
 
   vector<SGPropertyNode_ptr> object_group_nodes =
     ((SGPropertyNode *)props)->getChildren("object-group");
   for (unsigned int i = 0; i < object_group_nodes.size(); i++)
-    object_groups.push_back(new ObjectGroup(object_group_nodes[i]));
+    object_groups.push_back(new SGMatModelGroup(object_group_nodes[i]));
 }
 
 
@@ -351,177 +160,114 @@ FGNewMat::read_properties( const string &fg_root, const SGPropertyNode * props )
 ////////////////////////////////////////////////////////////////////////
 
 void 
-FGNewMat::init ()
+SGMaterial::init ()
 {
-    texture_path = "";
-    state = 0;
-    textured = 0;
-    nontextured = 0;
+    _status.clear();
     xsize = 0;
     ysize = 0;
     wrapu = true;
     wrapv = true;
     mipmap = true;
     light_coverage = 0.0;
-    texture_loaded = false;
     refcount = 0;
-    shininess = 0.0;
+    shininess = 1.0;
     for (int i = 0; i < 4; i++) {
-        ambient[i] = diffuse[i] = specular[i] = emission[i] = 0.0;
+        ambient[i]  = (i < 3) ? 0.2 : 1.0;
+        specular[i] = (i < 3) ? 0.0 : 1.0;
+        diffuse[i]  = (i < 3) ? 0.8 : 1.0;
+        emission[i] = (i < 3) ? 0.0 : 1.0;
     }
 }
 
 bool
-FGNewMat::load_texture ()
+SGMaterial::load_texture ( int n )
 {
-    if (texture_loaded) {
-        return false;
-    } else {
-        SG_LOG( SG_GENERAL, SG_INFO, "Loading deferred texture "
-                << texture_path );
-        textured->setTexture( (char *)texture_path.c_str(),
-                              wrapu, wrapv, mipmap );
-        texture_loaded = true;
-        return true;
+    int i   = (n >= 0) ? n   : 0 ;
+    int end = (n >= 0) ? n+1 : _status.size();
+
+    for (; i < end; i++)
+    {
+        if ( !_status[i].texture_loaded ) {
+            SG_LOG( SG_GENERAL, SG_INFO, "Loading deferred texture "
+                                          << _status[i].texture_path );
+            _status[i].state->setTexture(
+                   (char *)_status[i].texture_path.c_str(),
+                   wrapu, wrapv, mipmap );
+            _status[i].texture_loaded = true;
+       }
     }
+    return true;
+}
+
+ssgSimpleState *
+SGMaterial::get_state (int n) const
+{
+    static unsigned current = 0;
+
+    if (_status.size() == 0) {
+        SG_LOG( SG_GENERAL, SG_WARN, "No state available.");
+        return NULL;
+    }
+
+    if ( ++current >= _status.size())
+        current = 0;
+
+    return (n >= 0) ? _status[n].state : _status[current].state;
 }
 
 
 void 
-FGNewMat::build_ssg_state( bool defer_tex_load,
-                           bool smooth_shading,
-                           bool use_textures )
+SGMaterial::build_ssg_state( bool defer_tex_load )
 {
-    GLenum shade_model = ( smooth_shading ? GL_SMOOTH : GL_FLAT);
+    GLenum shade_model = GL_SMOOTH;
     
-    state = new ssgStateSelector(2);
-    state->ref();
-
-    textured = new ssgSimpleState();
-    textured->ref();
-
-    nontextured = new ssgSimpleState();
-    nontextured->ref();
-
-    // Set up the textured state
-    textured->setShadeModel( shade_model );
-    textured->enable( GL_LIGHTING );
-    textured->enable ( GL_CULL_FACE ) ;
-    textured->enable( GL_TEXTURE_2D );
-    textured->disable( GL_BLEND );
-    textured->disable( GL_ALPHA_TEST );
-    if ( !defer_tex_load ) {
-        SG_LOG(SG_INPUT, SG_INFO, "    " << texture_path );
-       textured->setTexture( (char *)texture_path.c_str(), wrapu, wrapv );
-       texture_loaded = true;
-    } else {
-       texture_loaded = false;
-    }
-    textured->enable( GL_COLOR_MATERIAL );
-#if 0
-    textured->setColourMaterial( GL_AMBIENT_AND_DIFFUSE );
-    textured->setMaterial( GL_EMISSION, 0, 0, 0, 1 );
-    textured->setMaterial( GL_SPECULAR, 0, 0, 0, 1 );
-#else
-    textured->setMaterial ( GL_AMBIENT,
-                            ambient[0], ambient[1],
-                            ambient[2], ambient[3] ) ;
-    textured->setMaterial ( GL_DIFFUSE,
+    for (int i = 0; i < _status.size(); i++)
+    {
+        ssgSimpleState *state = new ssgSimpleState();
+        state->ref();
+
+        // Set up the textured state
+        state->setShadeModel( shade_model );
+        state->enable( GL_LIGHTING );
+        state->enable ( GL_CULL_FACE ) ;
+        state->enable( GL_TEXTURE_2D );
+        state->disable( GL_BLEND );
+        state->disable( GL_ALPHA_TEST );
+
+        if ( !defer_tex_load ) {
+            SG_LOG(SG_INPUT, SG_INFO, "    " << _status[i].texture_path );
+           state->setTexture( (char *)_status[i].texture_path.c_str(),
+                                wrapu, wrapv );
+            _status[i].texture_loaded = true;
+        } else {
+            _status[i].texture_loaded = false;
+        }
+
+        state->enable( GL_COLOR_MATERIAL );
+        state->setMaterial ( GL_AMBIENT,
+                             ambient[0], ambient[1],
+                             ambient[2], ambient[3] ) ;
+        state->setMaterial ( GL_DIFFUSE,
                             diffuse[0], diffuse[1],
                             diffuse[2], diffuse[3] ) ;
-    textured->setMaterial ( GL_SPECULAR,
+        state->setMaterial ( GL_SPECULAR,
                             specular[0], specular[1],
                             specular[2], specular[3] ) ;
-    textured->setMaterial ( GL_EMISSION,
+        state->setMaterial ( GL_EMISSION,
                             emission[0], emission[1],
                             emission[2], emission[3] ) ;
-    textured->setShininess ( shininess );
-#endif
+        state->setShininess ( shininess );
 
-    // Set up the coloured state
-    nontextured->enable( GL_LIGHTING );
-    nontextured->setShadeModel( shade_model );
-    nontextured->enable ( GL_CULL_FACE      ) ;
-    nontextured->disable( GL_TEXTURE_2D );
-    nontextured->disable( GL_BLEND );
-    nontextured->disable( GL_ALPHA_TEST );
-    nontextured->disable( GL_COLOR_MATERIAL );
-
-    nontextured->setMaterial ( GL_AMBIENT, 
-                              ambient[0], ambient[1], 
-                              ambient[2], ambient[3] ) ;
-    nontextured->setMaterial ( GL_DIFFUSE, 
-                              diffuse[0], diffuse[1], 
-                              diffuse[2], diffuse[3] ) ;
-    nontextured->setMaterial ( GL_SPECULAR, 
-                              specular[0], specular[1], 
-                              specular[2], specular[3] ) ;
-    nontextured->setMaterial ( GL_EMISSION, 
-                              emission[0], emission[1], 
-                              emission[2], emission[3] ) ;
-    nontextured->setShininess ( shininess );
-
-    state->setStep( 0, textured );    // textured
-    state->setStep( 1, nontextured ); // untextured
-
-    // Choose the appropriate starting state.
-    if ( use_textures ) {
-       state->selectStep(0);
-    } else {
-       state->selectStep(1);
+        _status[i].state = state;
     }
 }
 
 
-void FGNewMat::set_ssg_state( ssgSimpleState *s,
-                              bool smooth_shading, bool use_textures )
+void SGMaterial::set_ssg_state( ssgSimpleState *s )
 {
-    GLenum shade_model = ( smooth_shading ? GL_SMOOTH : GL_FLAT);
-
-    state = new ssgStateSelector(2);
-    state->ref();
-
-    textured = s;
-    texture_loaded = true;
-
-    nontextured = new ssgSimpleState();
-    nontextured->ref();
-
-    // Set up the textured state
-    textured->setShadeModel( shade_model );
-
-    // Set up the coloured state
-    nontextured->enable( GL_LIGHTING );
-    nontextured->setShadeModel( shade_model );
-    nontextured->enable ( GL_CULL_FACE      ) ;
-    nontextured->disable( GL_TEXTURE_2D );
-    nontextured->disable( GL_BLEND );
-    nontextured->disable( GL_ALPHA_TEST );
-    nontextured->disable( GL_COLOR_MATERIAL );
-
-    nontextured->setMaterial ( GL_AMBIENT, 
-                              ambient[0], ambient[1], 
-                              ambient[2], ambient[3] ) ;
-    nontextured->setMaterial ( GL_DIFFUSE, 
-                              diffuse[0], diffuse[1], 
-                              diffuse[2], diffuse[3] ) ;
-    nontextured->setMaterial ( GL_SPECULAR, 
-                              specular[0], specular[1], 
-                              specular[2], specular[3] ) ;
-    nontextured->setMaterial ( GL_EMISSION, 
-                              emission[0], emission[1], 
-                              emission[2], emission[3] ) ;
-    nontextured->setShininess ( shininess );
-
-    state->setStep( 0, textured );    // textured
-    state->setStep( 1, nontextured ); // untextured
-
-    // Choose the appropriate starting state.
-    if ( use_textures ) {
-       state->selectStep(0);
-    } else {
-       state->selectStep(1);
-    }
+    s->ref();
+    _internal_state st = { s, "", true };
+    _status.push_back( st );
 }
 
-// end of newmat.cxx
+// end of mat.cxx