X-Git-Url: https://git.mxchange.org/?a=blobdiff_plain;ds=sidebyside;f=simgear%2Fscene%2Fmaterial%2Fmat.hxx;h=9e2d06e432d58d7f490a85c4222040ab4f87ece2;hb=542124e90cf467e590c4493774210f1e025cdc96;hp=82772890c8e2cb7d2006c5cfc193bf10b6364011;hpb=f1021ab820a08ab97b6768426a14265c69b1ceee;p=simgear.git diff --git a/simgear/scene/material/mat.hxx b/simgear/scene/material/mat.hxx index 82772890..9e2d06e4 100644 --- a/simgear/scene/material/mat.hxx +++ b/simgear/scene/material/mat.hxx @@ -1,10 +1,10 @@ -// 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 @@ -18,30 +18,47 @@ // // 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 -#include STL_STRING // Standard C++ string library +#include // Standard C++ string library +#include +#include -#include -#include +#include +#include + +namespace osg +{ +class StateSet; +} + +#include #include -#include +#include +#include -SG_USING_STD(string); +#include "matmodel.hxx" +namespace simgear +{ +class Effect; +void reload_shaders(); +} + +class SGMaterialGlyph; /** * A material in the scene graph. @@ -52,173 +69,10 @@ SG_USING_STD(string); * defined in the $FG_ROOT/materials.xml file, and can be changed * at runtime. */ -class FGNewMat { +class SGMaterial : public SGReferenced { public: - - ////////////////////////////////////////////////////////////////////// - // 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 _paths; - mutable vector _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 _objects; - - }; - - - //////////////////////////////////////////////////////////////////// // Public Constructors. @@ -231,34 +85,14 @@ public: * 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 ); @@ -267,30 +101,26 @@ public: //////////////////////////////////////////////////////////////////// /** - * 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; } /** @@ -298,52 +128,134 @@ public: * * 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& 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: @@ -355,8 +267,21 @@ 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 effect; + std::vector > texture_paths; + bool effect_realized; + osg::ref_ptr options; + }; private: @@ -365,13 +290,11 @@ 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; @@ -380,40 +303,104 @@ private: 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 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 _names; + std::vector > object_groups; + // taxiway-/runway-sign texture elements + std::map > glyphs; + + // Tree texture, typically a strip of applicable tree textures + std::string tree_texture; //////////////////////////////////////////////////////////////////// // 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