-// newmat.cxx -- class to handle material properties
+// mat.cxx -- class to handle material properties
//
// Written by Curtis Olson, started May 1998.
//
#include <simgear/math/sg_random.h>
#include <simgear/misc/sg_path.hxx>
#include <simgear/misc/sgstream.hxx>
-#include <simgear/scene/model/loader.hxx>
+#include <simgear/scene/model/modellib.hxx>
#include "mat.hxx"
}
-\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 );
+ 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];
////////////////////////////////////////////////////////////////////////
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");
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]));
}
////////////////////////////////////////////////////////////////////////
void
-FGNewMat::init ()
+SGMaterial::init ()
{
texture_path = "";
- state = 0;
- textured = 0;
- nontextured = 0;
+ state = NULL;
xsize = 0;
ysize = 0;
wrapu = true;
}
bool
-FGNewMat::load_texture ()
+SGMaterial::load_texture ()
{
- if (texture_loaded) {
+ 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 );
+ state->setTexture( (char *)texture_path.c_str(), wrapu, wrapv, mipmap );
texture_loaded = true;
return true;
}
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 = new ssgSimpleState();
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 );
+ 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, " " << texture_path );
- textured->setTexture( (char *)texture_path.c_str(), wrapu, wrapv );
+ state->setTexture( (char *)texture_path.c_str(), wrapu, wrapv );
texture_loaded = true;
} else {
texture_loaded = false;
}
- textured->enable( GL_COLOR_MATERIAL );
+ state->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 );
+ state->setColourMaterial( GL_AMBIENT_AND_DIFFUSE );
+ state->setMaterial( GL_EMISSION, 0, 0, 0, 1 );
+ state->setMaterial( GL_SPECULAR, 0, 0, 0, 1 );
#else
- textured->setMaterial ( GL_AMBIENT,
+ state->setMaterial ( GL_AMBIENT,
ambient[0], ambient[1],
ambient[2], ambient[3] ) ;
- textured->setMaterial ( GL_DIFFUSE,
+ 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 );
+ state->setShininess ( shininess );
#endif
-
- // 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);
- }
}
-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 = s;
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);
- }
}
-// end of newmat.cxx
+// end of mat.cxx
projects / simgear.git / blobdiff