simgear/scene/material/Effect.hxx

   1 // Copyright (C) 2008 - 2009  Tim Moore timoore@redhat.com
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Library General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2 of the License, or (at your option) any later version.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Library General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU General Public License
  14 // along with this program; if not, write to the Free Software
  15 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  16
  17 #ifndef SIMGEAR_EFFECT_HXX
  18 #define SIMGEAR_EFFECT_HXX 1
  19
  20 #include <vector>
  21 #include <string>
  22 #include <boost/tr1/unordered_map.hpp>
  23
  24 #include <boost/functional/hash.hpp>
  25
  26 #include <osg/Object>
  27 #include <osgDB/ReaderWriter>
  28
  29 #include <simgear/props/props.hxx>
  30 #include <simgear/scene/util/UpdateOnceCallback.hxx>
  31
  32 namespace osg
  33 {
  34 class Drawable;
  35 class StateSet;
  36 class RenderInfo;
  37 }
  38
  39 namespace osgUtil
  40 {
  41 class CullVisitor;
  42 }
  43
  44 namespace simgear
  45 {
  46 class Technique;
  47 class Effect;
  48 class SGReaderWriterOptions;
  49
  50 /**
  51  * Object to be initialized at some point after an effect -- and its
  52  * containing effect geode -- are hooked into the scene graph. Some
  53  * things, like manipulations of the global property tree, are are
  54  * only safe in the update process.
  55  */
  56
  57 class InitializeWhenAdded
  58 {
  59 public:
  60     InitializeWhenAdded() : _initialized(false) {};
  61     virtual ~InitializeWhenAdded() {};
  62     void initOnAdd(Effect* effect, SGPropertyNode* propRoot)
  63     {
  64         if (!_initialized) {
  65             initOnAddImpl(effect, propRoot);
  66             _initialized = true;
  67         }
  68     }
  69     bool getInitialized() const { return _initialized; }
  70 private:
  71     virtual void initOnAddImpl(Effect* effect, SGPropertyNode* propRoot) = 0;
  72     bool _initialized;
  73 };
  74
  75 class Effect : public osg::Object
  76 {
  77 public:
  78     META_Object(simgear,Effect)
  79     Effect();
  80     Effect(const Effect& rhs,
  81            const osg::CopyOp& copyop = osg::CopyOp::SHALLOW_COPY);
  82     osg::StateSet* getDefaultStateSet();
  83
  84     enum Buffer
  85     {
  86         DEPTH_BUFFER,
  87         NORMAL_BUFFER,
  88         DIFFUSE_BUFFER,
  89         SPECULAR_BUFFER,
  90         EMISSION_BUFFER,
  91         LIGHTING_BUFFER,
  92         BLOOM_BUFFER
  93     };
  94
  95     // Define what needs to be generated for this effect
  96     enum Generator
  97     {
  98         NORMAL,
  99         TANGENT,
 100         BINORMAL
 101     };
 102     void setGenerator(Generator what, int where) { generator[what] = where; }
 103     int getGenerator(Generator what) const;  // Returns -1 if generator should not be used
 104     std::map<Generator, int> generator;  // What is generated into which attribute location
 105
 106     std::vector<osg::ref_ptr<Technique> > techniques;
 107     SGPropertyNode_ptr root;
 108     // Pointer to the parameters node, if it exists
 109     SGPropertyNode_ptr parametersProp;
 110     Technique* chooseTechnique(osg::RenderInfo* renderInfo);
 111     virtual void resizeGLObjectBuffers(unsigned int maxSize);
 112     virtual void releaseGLObjects(osg::State* state = 0) const;
 113     /**
 114      * Build the techniques from the effect properties.
 115      */
 116     bool realizeTechniques(const SGReaderWriterOptions* options = 0);
 117     /**
 118      * Updaters that should be derefed when the effect is
 119      * deleted. Updaters arrange to be run by listening on properties
 120      * or something.
 121      */
 122     struct Updater : public virtual SGReferenced
 123     {
 124         virtual ~Updater() {}
 125     };
 126     void addUpdater(Updater* data) { _extraData.push_back(data); }
 127     // Callback that is added to the effect geode to initialize the
 128     // effect.
 129     friend struct InitializeCallback;
 130     struct InitializeCallback : public UpdateOnceCallback
 131     {
 132         void doUpdate(osg::Node* node, osg::NodeVisitor* nv);
 133     };
 134 protected:
 135     std::vector<SGSharedPtr<Updater> > _extraData;
 136     ~Effect();
 137     // Support for a cache of effects that inherit from this one, so
 138     // Effect objects with the same parameters and techniques can be
 139     // shared.
 140     struct Key
 141     {
 142         Key() {}
 143         Key(SGPropertyNode* unmerged_, const osgDB::FilePathList& paths_)
 144             : unmerged(unmerged_), paths(paths_)
 145         {
 146         }
 147         Key& operator=(const Key& rhs)
 148         {
 149             unmerged = rhs.unmerged;
 150             paths = rhs.paths;
 151             return *this;
 152         }
 153         SGPropertyNode_ptr unmerged;
 154         osgDB::FilePathList paths;
 155         struct EqualTo
 156         {
 157             bool operator()(const Key& lhs, const Key& rhs) const;
 158         };
 159     };
 160     typedef std::tr1::unordered_map<Key, osg::ref_ptr<Effect>,
 161                                     boost::hash<Key>, Key::EqualTo> Cache;
 162     Cache* getCache()
 163     {
 164         if (!_cache)
 165             _cache = new Cache;
 166         return _cache;
 167     }
 168     Cache* _cache;
 169     friend size_t hash_value(const Key& key);
 170     friend Effect* makeEffect(SGPropertyNode* prop, bool realizeTechniques,
 171                               const SGReaderWriterOptions* options);
 172     bool _isRealized;
 173 };
 174 // Automatic support for boost hash function
 175 size_t hash_value(const Effect::Key&);
 176
 177
 178 Effect* makeEffect(const std::string& name,
 179                    bool realizeTechniques,
 180                    const SGReaderWriterOptions* options = 0);
 181
 182 Effect* makeEffect(SGPropertyNode* prop,
 183                    bool realizeTechniques,
 184                    const SGReaderWriterOptions* options = 0);
 185
 186 bool makeParametersFromStateSet(SGPropertyNode* paramRoot,
 187                                 const osg::StateSet* ss);
 188
 189 namespace effect
 190 {
 191 /**
 192  * The function that implements effect property tree inheritance.
 193  */
 194 void mergePropertyTrees(SGPropertyNode* resultNode,
 195                         const SGPropertyNode* left,
 196                         const SGPropertyNode* right);
 197 }
 198 }
 199 #endif