-// newmat.hxx -- a material in the scene graph.
+// mat.hxx -- a material in the scene graph.
// TODO: this class needs to be renamed.
//
// Written by Curtis Olson, started May 1998.
// Overhauled by David Megginson, December 2001
//
-// Copyright (C) 1998 - 2000 Curtis L. Olson - curt@flightgear.org
+// Copyright (C) 1998 - 2000 Curtis L. Olson - http://www.flightgear.org/~curt
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License as
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
-// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
//
// $Id$
-#ifndef _NEWMAT_HXX
-#define _NEWMAT_HXX
+#ifndef _SG_MAT_HXX
+#define _SG_MAT_HXX
-#ifndef __cplusplus
+#ifndef __cplusplus
# error This library requires C++
-#endif
+#endif
#include <simgear/compiler.h>
-#include STL_STRING // Standard C++ string library
+#include <string> // Standard C++ string library
+#include <vector>
+#include <map>
-#include <plib/sg.h>
-#include <plib/ssg.h>
+#include <simgear/math/SGMath.hxx>
+#include <osg/ref_ptr>
+
+namespace osg
+{
+class StateSet;
+}
+
+#include <simgear/scene/model/SGReaderWriterXMLOptions.hxx>
#include <simgear/props/props.hxx>
-#include <simgear/scene/model/loader.hxx>
+#include <simgear/structure/SGSharedPtr.hxx>
+#include <simgear/scene/util/SGSceneFeatures.hxx>
-SG_USING_STD(string);
+#include "matmodel.hxx"
+namespace simgear
+{
+class Effect;
+void reload_shaders();
+}
+
+class SGMaterialGlyph;
/**
* A material in the scene graph.
* defined in the $FG_ROOT/materials.xml file, and can be changed
* at runtime.
*/
-class FGNewMat {
+class SGMaterial : public SGReferenced {
public:
-\f
- //////////////////////////////////////////////////////////////////////
- // Inner classes.
- //////////////////////////////////////////////////////////////////////
-
- class ObjectGroup;
-
- /**
- * A randomly-placeable object.
- *
- * FGNewMat uses this class to keep track of the model(s) and
- * parameters for a single instance of a randomly-placeable object.
- * The object can have more than one variant model (i.e. slightly
- * different shapes of trees), but they are considered equivalent
- * and interchangeable.
- */
- class Object
- {
- public:
-
- /**
- * The heading type for a randomly-placed object.
- */
- enum HeadingType {
- HEADING_FIXED,
- HEADING_BILLBOARD,
- HEADING_RANDOM
- };
-
-
- /**
- * Get the number of variant models available for the object.
- *
- * @return The number of variant models.
- */
- int get_model_count( FGModelLoader *loader,
- const string &fg_root,
- SGPropertyNode *prop_root,
- double sim_time_sec );
-
-
- /**
- * Get a specific variant model for the object.
- *
- * @param index The index of the model.
- * @return The model.
- */
- ssgEntity *get_model( int index,
- FGModelLoader *loader,
- const string &fg_root,
- SGPropertyNode *prop_root,
- double sim_time_sec );
-
-
- /**
- * Get a randomly-selected variant model for the object.
- *
- * @return A randomly select model from the variants.
- */
- ssgEntity *get_random_model( FGModelLoader *loader,
- const string &fg_root,
- SGPropertyNode *prop_root,
- double sim_time_sec );
-
-
- /**
- * Get the average number of meters^2 occupied by each instance.
- *
- * @return The coverage in meters^2.
- */
- double get_coverage_m2 () const;
-
-
- /**
- * Get the heading type for the object.
- *
- * @return The heading type.
- */
- HeadingType get_heading_type () const;
-
- protected:
-
- friend class ObjectGroup;
-
- Object (const SGPropertyNode * node, double range_m);
-
- virtual ~Object ();
-
- private:
-
- /**
- * Actually load the models.
- *
- * This class uses lazy loading so that models won't be held
- * in memory for materials that are never referenced.
- */
- void load_models( FGModelLoader *loader,
- const string &fg_root,
- SGPropertyNode *prop_root,
- double sim_time_sec );
-
- vector<string> _paths;
- mutable vector<ssgEntity *> _models;
- mutable bool _models_loaded;
- double _coverage_m2;
- double _range_m;
- HeadingType _heading_type;
- };
-
-
- /**
- * A collection of related objects with the same visual range.
- *
- * Grouping objects with the same range together significantly
- * reduces the memory requirements of randomly-placed objects.
- * Each FGNewMat instance keeps a (possibly-empty) list of
- * object groups for placing randomly on the scenery.
- */
- class ObjectGroup
- {
- public:
- virtual ~ObjectGroup ();
-
-
- /**
- * Get the visual range of the object in meters.
- *
- * @return The visual range.
- */
- double get_range_m () const;
-
-
- /**
- * Get the number of objects in the group.
- *
- * @return The number of objects.
- */
- int get_object_count () const;
-
-
- /**
- * Get a specific object.
- *
- * @param index The object's index, zero-based.
- * @return The object selected.
- */
- Object * get_object (int index) const;
-
- protected:
-
- friend class FGNewMat;
-
- ObjectGroup (SGPropertyNode * node);
-
- private:
-
- double _range_m;
- vector<Object *> _objects;
-
- };
-
-
-
\f
////////////////////////////////////////////////////////////////////
// Public Constructors.
* state information for the material. This node is usually
* loaded from the $FG_ROOT/materials.xml file.
*/
- FGNewMat( const string &fg_root, const SGPropertyNode *props,
- bool smooth_shading, bool use_textures );
-
-
- /**
- * Construct a material from an absolute texture path.
- *
- * @param texture_path A string containing an absolute path
- * to a texture file (usually RGB).
- */
- FGNewMat( const string &texpath, bool smooth_shading, bool use_textures );
-
-
- /**
- * Construct a material around an existing SSG state.
- *
- * This constructor allows the application to create a custom,
- * low-level state for the scene graph and wrap a material around
- * it. Note: the pointer ownership is transferred to the material.
- *
- * @param s The SSG state for this material.
- */
- FGNewMat( ssgSimpleState *s, bool smooth_shading, bool use_textures );
+ SGMaterial( const osgDB::ReaderWriter::Options*, const SGPropertyNode *props);
+ SGMaterial(const simgear::SGReaderWriterXMLOptions*,
+ const SGPropertyNode *props);
/**
* Destructor.
*/
- virtual ~FGNewMat( void );
+ ~SGMaterial( void );
\f
////////////////////////////////////////////////////////////////////
/**
- * Force the texture to load if it hasn't already.
- *
- * @return true if the texture loaded, false if it was loaded
- * already.
+ * Get the textured state.
*/
- virtual bool load_texture ();
-
+ simgear::Effect *get_effect(int n = -1);
/**
- * Get the textured state.
+ * Get the number of textures assigned to this material.
*/
- virtual inline ssgSimpleState *get_textured () { return textured; }
+ inline int get_num() const { return _status.size(); }
/**
* Get the xsize of the texture, in meters.
*/
- virtual inline double get_xsize() const { return xsize; }
+ inline double get_xsize() const { return xsize; }
/**
* Get the ysize of the texture, in meters.
*/
- virtual inline double get_ysize() const { return ysize; }
+ inline double get_ysize() const { return ysize; }
/**
*
* A smaller number means more generated night lighting.
*
- * @return The area (m^2?) covered by each light.
+ * @return The area (m^2) covered by each light.
*/
- virtual inline double get_light_coverage () const { return light_coverage; }
+ inline double get_light_coverage () const { return light_coverage; }
+ /**
+ * Get the wood coverage.
+ *
+ * A smaller number means more generated woods within the forest.
+ *
+ * @return The area (m^2) covered by each wood.
+ */
+ inline double get_wood_coverage () const { return wood_coverage; }
/**
- * Get the number of randomly-placed objects defined for this material.
+ * Get the density of the wood
+ *
+ * @return The area (m^2) covered by each tree in the wood.
+ */
+ inline double get_tree_density () const { return tree_density; }
+
+ /**
+ * Get the size of each wood
+ *
+ * @return the average area (m^2) of each wood
+ */
+ inline double get_wood_size () const { return wood_size; }
+
+ /**
+ * Get the tree height.
+ *
+ * @return The average height of the trees.
+ */
+ inline double get_tree_height () const { return tree_height; }
+
+ /**
+ * Get the tree width.
+ *
+ * @return The average width of the trees.
*/
- virtual int get_object_group_count () const { return object_groups.size(); }
+ inline double get_tree_width () const { return tree_width; }
+ /**
+ * Get the forest LoD range.
+ *
+ * @return The LoD range for the trees.
+ */
+ inline double get_tree_range () const { return tree_range; }
+
+ /**
+ * Get the number of tree varieties available
+ *
+ * @return the number of different trees defined in the texture strip
+ */
+ inline int get_tree_varieties () const { return tree_varieties; }
+
+ /**
+ * Get the texture strip to use for trees
+ *
+ * @return the texture to use for trees.
+ */
+ inline std::string get_tree_texture () const { return tree_texture; }
/**
- * Get a randomly-placed object for this material.
+ * Return if the surface material is solid, if it is not solid, a fluid
+ * can be assumed, that is usually water.
*/
- virtual ObjectGroup * get_object_group (int index) const {
- return object_groups[index];
- }
+ bool get_solid () const { return solid; }
+ /**
+ * Get the friction factor for that material
+ */
+ double get_friction_factor () const { return friction_factor; }
/**
- * Get the current state.
+ * Get the rolling friction for that material
*/
- virtual inline ssgStateSelector *get_state () const { return state; }
+ double get_rolling_friction () const { return rolling_friction; }
+ /**
+ * Get the bumpines for that material
+ */
+ double get_bumpiness () const { return bumpiness; }
/**
- * Increment the reference count for this material.
- *
- * A material with 0 references may be deleted by the
- * material library.
+ * Get the load resistance
*/
- virtual inline void ref () { refcount++; }
+ double get_load_resistance () const { return load_resistance; }
+ /**
+ * Get the list of names for this material
+ */
+ const std::vector<std::string>& get_names() const { return _names; }
/**
- * Decrement the reference count for this material.
+ * add the given name to the list of names this material is known
*/
- virtual inline void deRef () { refcount--; }
+ void add_name(const std::string& name) { _names.push_back(name); }
+ /**
+ * Get the number of randomly-placed objects defined for this material.
+ */
+ int get_object_group_count () const { return object_groups.size(); }
/**
- * Get the reference count for this material.
- *
- * @return The number of references (0 if none).
+ * Get a randomly-placed object for this material.
*/
- virtual inline int getRef () const { return refcount; }
+ SGMatModelGroup * get_object_group (int index) const {
+ return object_groups[index];
+ }
+
+ /**
+ * Return pointer to glyph class, or 0 if it doesn't exist.
+ */
+ SGMaterialGlyph * get_glyph (const std::string& name) const;
+
+ void set_light_color(const SGVec4f& color)
+ { emission = color; }
+ const SGVec4f& get_light_color() const
+ { return emission; }
+
+ SGVec2f get_tex_coord_scale() const
+ {
+ float tex_width = get_xsize();
+ float tex_height = get_ysize();
+
+ return SGVec2f((0 < tex_width) ? 1000.0f/tex_width : 1.0f,
+ (0 < tex_height) ? 1000.0f/tex_height : 1.0f);
+ }
protected:
/**
* Initialization method, invoked by all public constructors.
*/
- virtual void init();
+ void init();
+protected:
+
+ struct _internal_state {
+ _internal_state(simgear::Effect *e, bool l,
+ const simgear::SGReaderWriterXMLOptions *o);
+ _internal_state(simgear::Effect *e, const std::string &t, bool l,
+ const simgear::SGReaderWriterXMLOptions *o);
+ void add_texture(const std::string &t, int i);
+ osg::ref_ptr<simgear::Effect> effect;
+ std::vector<std::pair<std::string,int> > texture_paths;
+ bool effect_realized;
+ osg::ref_ptr<const simgear::SGReaderWriterXMLOptions> options;
+ };
private:
// Internal state.
////////////////////////////////////////////////////////////////////
- // names
- string texture_path;
+ // texture status
+ std::vector<_internal_state> _status;
- // pointers to ssg states
- ssgStateSelector *state;
- ssgSimpleState *textured;
- ssgSimpleState *nontextured;
+ // Round-robin counter
+ mutable unsigned int _current_ptr;
// texture size
double xsize, ysize;
bool wrapu, wrapv;
// use mipmapping?
- int mipmap;
+ bool mipmap;
// coverage of night lighting.
double light_coverage;
+
+ // coverage of woods
+ double wood_coverage;
+
+ // The size of each wood
+ double wood_size;
+
+ // Tree density within the wood
+ double tree_density;
+
+ // Range at which trees become visible
+ double tree_range;
+
+ // Height of the tree
+ double tree_height;
+
+ // Width of the tree
+ double tree_width;
+
+ // Number of varieties of tree texture
+ int tree_varieties;
+
+ // True if the material is solid, false if it is a fluid
+ bool solid;
+
+ // the friction factor of that surface material
+ double friction_factor;
+
+ // the rolling friction of that surface material
+ double rolling_friction;
+
+ // the bumpiness of that surface material
+ double bumpiness;
+
+ // the load resistance of that surface material
+ double load_resistance;
// material properties
- sgVec4 ambient, diffuse, specular, emission;
+ SGVec4f ambient, diffuse, specular, emission;
double shininess;
- // true if texture loading deferred, and not yet loaded
- bool texture_loaded;
-
- vector<ObjectGroup *> object_groups;
+ // effect for this material
+ std::string effect;
- // ref count so we can properly delete if we have multiple
- // pointers to this record
- int refcount;
+ // the list of names for this material. May be empty.
+ std::vector<std::string> _names;
+ std::vector<SGSharedPtr<SGMatModelGroup> > object_groups;
+ // taxiway-/runway-sign texture elements
+ std::map<std::string, SGSharedPtr<SGMaterialGlyph> > glyphs;
+
+ // Tree texture, typically a strip of applicable tree textures
+ std::string tree_texture;
\f
////////////////////////////////////////////////////////////////////
// Internal constructors and methods.
////////////////////////////////////////////////////////////////////
- FGNewMat( const string &fg_root, const FGNewMat &mat ); // unimplemented
+ void read_properties(const simgear::SGReaderWriterXMLOptions* options,
+ const SGPropertyNode *props);
+ void buildEffectProperties(const simgear::SGReaderWriterXMLOptions* options);
+};
- void read_properties( const string &fg_root, const SGPropertyNode *props );
- void build_ssg_state( bool defer_tex_load,
- bool smooth_shading,
- bool use_textures );
- void set_ssg_state( ssgSimpleState *s,
- bool smooth_shading, bool use_textures );
+class SGMaterialGlyph : public SGReferenced {
+public:
+ SGMaterialGlyph(SGPropertyNode *);
+ inline double get_left() const { return _left; }
+ inline double get_right() const { return _right; }
+ inline double get_width() const { return _right - _left; }
+protected:
+ double _left;
+ double _right;
};
-#endif // _NEWMAT_HXX
+class SGMaterialUserData : public osg::Referenced {
+public:
+ SGMaterialUserData(const SGMaterial* material) :
+ mMaterial(material)
+ {}
+ const SGMaterial* getMaterial() const
+ { return mMaterial; }
+private:
+ // this cannot be an SGSharedPtr since that would create a cicrular reference
+ // making it impossible to ever free the space needed by SGMaterial
+ const SGMaterial* mMaterial;
+};
+
+void
+SGSetTextureFilter( int max);
+
+int
+SGGetTextureFilter();
+
+#endif // _SG_MAT_HXX
projects / simgear.git / blobdiff