simgear/scene/material/matmodel.hxx

   1 // matmodel.hxx -- class to handle models tied to a material property
   2 //
   3 // Written by David Megginson, December 2001
   4 //
   5 // Copyright (C) 1998 - 2003  Curtis L. Olson  - http://www.flightgear.org/~curt
   6 //
   7 // This program is free software; you can redistribute it and/or
   8 // modify it under the terms of the GNU General Public License as
   9 // published by the Free Software Foundation; either version 2 of the
  10 // License, or (at your option) any later version.
  11 //
  12 // This program is distributed in the hope that it will be useful, but
  13 // WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15 // General Public License for more details.
  16 //
  17 // You should have received a copy of the GNU General Public License
  18 // along with this program; if not, write to the Free Software
  19 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  20 //
  21 // $Id$
  22
  23
  24 #ifndef _SG_MAT_MODEL_HXX
  25 #define _SG_MAT_MODEL_HXX
  26
  27 #ifndef __cplusplus
  28 # error This library requires C++
  29 #endif
  30
  31 #include <simgear/compiler.h>
  32
  33 #include <string>      // Standard C++ string library
  34 #include <vector>
  35
  36 #include <osg/ref_ptr>
  37 #include <osg/Node>
  38 #include <osg/NodeVisitor>
  39 #include <osg/Billboard>
  40
  41 #include <simgear/structure/SGReferenced.hxx>
  42 #include <simgear/structure/SGSharedPtr.hxx>
  43 #include <simgear/props/props.hxx>
  44 #include <simgear/math/sg_random.h>
  45
  46
  47 class SGMatModelGroup;
  48
  49
  50 /**
  51  * A randomly-placeable object.
  52  *
  53  * SGMaterial uses this class to keep track of the model(s) and
  54  * parameters for a single instance of a randomly-placeable object.
  55  * The object can have more than one variant model (i.e. slightly
  56  * different shapes of trees), but they are considered equivalent
  57  * and interchangeable.
  58  */
  59 class SGMatModel : public SGReferenced {
  60
  61 public:
  62
  63     /**
  64      * The heading type for a randomly-placed object.
  65      */
  66     enum HeadingType {
  67         HEADING_FIXED,
  68         HEADING_BILLBOARD,
  69         HEADING_RANDOM,
  70         HEADING_MASK
  71     };
  72
  73     /**
  74      * Get the number of variant models available for the object.
  75      *
  76      * @return The number of variant models.
  77      */
  78     int get_model_count( SGPropertyNode *prop_root );
  79
  80
  81     /**
  82      * Get a randomly-selected variant model for the object.
  83      *
  84      * @return A randomly select model from the variants.
  85      */
  86     osg::Node *get_random_model( SGPropertyNode *prop_root, mt *seed );
  87
  88
  89     /**
  90      * Get the average number of meters^2 occupied by each instance.
  91      *
  92      * @return The coverage in meters^2.
  93      */
  94     double get_coverage_m2 () const;
  95
  96     /**
  97      * Get the visual range of the object in meters.
  98      *
  99      * @return The visual range.
 100      */
 101     double get_range_m () const;
 102
 103     /**
 104      * Get the minimum spacing between this and any
 105      * other objects in m
 106      *
 107      * @return The spacing in m.
 108      */
 109     double get_spacing_m () const;
 110
 111
 112     /**
 113      * Get a randomized visual range
 114      *
 115      * @return a randomized visual range
 116      */
 117     double get_randomized_range_m(mt* seed) const;
 118
 119     /**
 120      * Get the heading type for the object.
 121      *
 122      * @return The heading type.
 123      */
 124     HeadingType get_heading_type () const;
 125
 126     virtual ~SGMatModel ();
 127
 128
 129 protected:
 130
 131     friend class SGMatModelGroup;
 132
 133     SGMatModel (const SGPropertyNode * node, double range_m);
 134
 135 private:
 136
 137     /**
 138      * Actually load the models.
 139      *
 140      * This class uses lazy loading so that models won't be held
 141      * in memory for materials that are never referenced.
 142      */
 143     void load_models( SGPropertyNode *prop_root );
 144
 145     std::vector<std::string> _paths;
 146     mutable std::vector<osg::ref_ptr<osg::Node> > _models;
 147     mutable bool _models_loaded;
 148     double _coverage_m2;
 149     double _spacing_m;
 150     double _range_m;
 151     HeadingType _heading_type;
 152 };
 153
 154
 155 /**
 156  * A collection of related objects with the same visual range.
 157  *
 158  * Grouping objects with the same range together significantly
 159  * reduces the memory requirements of randomly-placed objects.
 160  * Each SGMaterial instance keeps a (possibly-empty) list of
 161  * object groups for placing randomly on the scenery.
 162  */
 163 class SGMatModelGroup : public SGReferenced {
 164
 165 public:
 166
 167     virtual ~SGMatModelGroup ();
 168
 169
 170     /**
 171      * Get the visual range of the object in meters.
 172      *
 173      * @return The visual range.
 174      */
 175     double get_range_m () const;
 176
 177
 178     /**
 179      * Get the number of objects in the group.
 180      *
 181      * @return The number of objects.
 182      */
 183     int get_object_count () const;
 184
 185
 186     /**
 187      * Get a specific object.
 188      *
 189      * @param index The object's index, zero-based.
 190      * @return The object selected.
 191      */
 192     SGMatModel * get_object (int index) const;
 193
 194 protected:
 195
 196     friend class SGMaterial;
 197
 198     SGMatModelGroup (SGPropertyNode * node);
 199
 200 private:
 201
 202     double _range_m;
 203     std::vector<SGSharedPtr<SGMatModel> > _objects;
 204 };
 205
 206 #endif // _SG_MAT_MODEL_HXX