Updates to osgFX, from Marco Jez, to map Effect across to being derived

from osg::Group rather than from osg::Node.

examples/osgfxbrowser/osgfxbrowser.cpp

@@ -180,7 +180,8 @@ protected:
 				root_->removeChild(0, root_->getNumChildren());
 				osg::ref_ptr<osgFX::Effect> effect = effects_[selected_fx_].get();
 				effect->setEnabled(fxen_);
-				effect->setChild(scene_.get());
+				effect->removeChild(0, effect->getNumChildren());
+				effect->addChild(scene_.get());
 				effect->setUpDemo();
 				root_->addChild(effect.get());
 			}

include/osgFX/BumpMapping

@@ -25,11 +25,11 @@ namespace osgFX
 {
 
 	/**
-     This effect makes surfaces appear bumpy. The child node must use two textures, 
+     This effect makes surfaces appear bumpy. Children nodes must use two textures, 
      one for diffuse color and one for the normal map (which can be created 
      from a height map with tools like nVIDIA's normal map generator). Furthermore, 
      tangent-space basis vectors must be created and assigned to each Geometry; this 
-     can be done quickly by calling BumpMapping::prepareChild(). Note that both 
+     can be done quickly by calling BumpMapping::prepareChildren(). Note that both 
      diffuse and normal map textures must have corresponding UV maps defined in 
      Geometry objects.
      This effect defines a preferred technique which uses ARB vertex & fragment 
@@ -46,11 +46,11 @@ namespace osgFX
         
             "Bump Mapping", 
             
-            "This effect makes surfaces appear bumpy. The child node must use two textures, "
+            "This effect makes surfaces appear bumpy. Children nodes must use two textures, "
             "one for diffuse color and one for the normal map (which can be created "
             "from a height map with tools like nVIDIA's normal map generator). Furthermore, "
             "tangent-space basis vectors must be created and assigned to each Geometry; this "
-            "can be done quickly by calling BumpMapping::prepareChild(). Note that both "
+            "can be done quickly by calling BumpMapping::prepareChildren(). Note that both "
             "diffuse and normal map textures must have corresponding UV maps defined in "
             "Geometry objects.\n"
             "This effect defines a preferred technique which uses ARB vertex & fragment "
@@ -79,22 +79,22 @@ namespace osgFX
         /** set the texture unit that contains normal map texture. Default is 0 */
         inline void setNormalMapTextureUnit(int n);
         
-        /** get the diffuse color texture that overrides the child's texture */
+        /** get the diffuse color texture that overrides children's texture */
         inline osg::Texture2D *getOverrideDiffuseTexture();
         
-        /** get the const diffuse color texture that overrides the child's texture */
+        /** get the const diffuse color texture that overrides children's texture */
         inline const osg::Texture2D *getOverrideDiffuseTexture() const;
         
-        /** set the diffuse color texture that overrides the child's texture */
+        /** set the diffuse color texture that overrides children's texture */
         inline void setOverrideDiffuseTexture(osg::Texture2D *texture);
         
-        /** get the normal map texture that overrides the child's texture */
+        /** get the normal map texture that overrides children's texture */
         inline osg::Texture2D *getOverrideNormalMapTexture();
         
-        /** get the const normal map texture that overrides the child's texture */
+        /** get the const normal map texture that overrides children's texture */
         inline const osg::Texture2D *getOverrideNormalMapTexture() const;
 
-        /** set the normal map texture that overrides the child's texture */
+        /** set the normal map texture that overrides children's texture */
         inline void setOverrideNormalMapTexture(osg::Texture2D *texture);
         
         /**
@@ -106,8 +106,8 @@ namespace osgFX
         /** prepare a Node for bump lighting, calling prepareGeometry() for each Geometry */
         void prepareNode(osg::Node *node);
         
-        /** prepare the current child for bump lighting. Actually calls prepareNode(getChild()) */
+        /** prepare children for bump lighting. Actually calls prepareNode() for each child */
-        void prepareChild();
+        void prepareChildren();
         
         /** set up a demo environment with predefined diffuse and normal maps, as well as texture coordinates */
         void setUpDemo();

include/osgFX/Effect

@@ -52,10 +52,9 @@ namespace osgFX
      selected either manually, with selectTechnique(), or automatically, in which
      case the first technique that is supported by all active rendering contexts 
      is chosen.
-     If you are an Effect user, then simply use it as a single-child group.
+     If you are an Effect user, then simply use it as a node group. Create an 
-     Create an instance of your desired effect, add it to your scene graph (it
+     instance of your desired effect, add it to your scene graph and call its 
-     is a Node) and call its setChild() method to set its child node as you 
+     addChild() method to add a child node as you would do with a Group.
-     would do with a Group.
      If you are an Effect developer, you will have to implement the method
      define_techniques() to define the different techniques that can be used
      for obtaining the desired effect. In define_techniques() you will usually
@@ -64,7 +63,7 @@ namespace osgFX
      techniques added first will have higher priority and will be used first as
      soon as all rendering contexts support it.
      */
-    class OSGFX_EXPORT Effect: public osg::Node {
+    class OSGFX_EXPORT Effect: public osg::Group {
     public:
         Effect();
         Effect(const Effect &copy, const osg::CopyOp &copyop = osg::CopyOp::SHALLOW_COPY);
@@ -95,15 +94,6 @@ namespace osgFX
         */
         inline virtual void setUpDemo()   {}
 
-        /** get the const child node */
-        inline const osg::Node *getChild() const;
-
-        /** get the child node */
-        inline osg::Node *getChild();
-
-        /** set the child node */
-        inline void setChild(osg::Node *child);
-
         /** get the number of techniques defined for this effect */
         inline int getNumTechniques() const;
         
@@ -123,13 +113,15 @@ namespace osgFX
         /** select a technique or enable automatic detection */
         inline void selectTechnique(int i = AUTO_DETECT);
 
+		/** custom traversal */
         virtual void traverse(osg::NodeVisitor &nv);        
 
-    protected:
+        /** default traversal */
-        virtual ~Effect() {}
+        inline void inherited_traverse(osg::NodeVisitor &nv);
-        Effect &operator=(const Effect &) { return *this; }
 
-        virtual bool computeBound() const;
+    protected:
+        virtual ~Effect();
+        Effect &operator=(const Effect &) { return *this; }
        
         /** force rebuilding of techniques on next traversal */
         inline void dirtyTechniques();
@@ -157,11 +149,11 @@ namespace osgFX
 
         // use int instead of bool to avoid errors
         mutable osg::buffered_value<int> tech_selected_;
+        
         int global_sel_tech_;
 
         bool techs_defined_;
 
-        osg::ref_ptr<osg::Node> child_;
         osg::ref_ptr<osg::Geode> dummy_for_validation_;
         
         void build_dummy_node();
@@ -179,33 +171,6 @@ namespace osgFX
         enabled_ = v;
     }
     
-    inline const osg::Node *Effect::getChild() const
-    {
-        return child_.get();
-    }
-
-    inline osg::Node *Effect::getChild()
-    {
-        return child_.get();
-    }
-
-    inline void Effect::setChild(osg::Node *child)
-    {
-        child_ = child;
-        setNumChildrenRequiringUpdateTraversal(0);
-        setNumChildrenWithCullingDisabled(0);
-        setNumChildrenWithOccluderNodes(0);
-        if (child) {
-            if (child->getNumChildrenRequiringUpdateTraversal() > 0 || child->getUpdateCallback())
-                setNumChildrenRequiringUpdateTraversal(1);
-            if (child->getNumChildrenWithCullingDisabled() > 0 || !child->getCullingActive())
-                setNumChildrenWithCullingDisabled(1);
-            if (child->getNumChildrenWithOccluderNodes() > 0 || dynamic_cast<osg::OccluderNode *>(child))
-                setNumChildrenWithOccluderNodes(1);
-        }
-        dirtyBound();
-    }
-
     inline int Effect::getNumTechniques() const
     {
         return static_cast<int>(techs_.size());
@@ -241,6 +206,12 @@ namespace osgFX
         techs_defined_ = false;
     }
     
+    inline void Effect::inherited_traverse(osg::NodeVisitor &nv)
+    {
+		typedef osg::Group inherited;
+		inherited::traverse(nv);
+    }
+
 }
 
 #endif

include/osgFX/Technique

@@ -37,6 +37,8 @@
 namespace osgFX
 {
 
+	class Effect;
+
     /**
      This is the base class for effect techniques. A technique represents one
      of the possible ways to implement a special effect. This base class is
@@ -79,12 +81,6 @@ namespace osgFX
         /** get the number of rendering passes defined in this technique */
         inline int getNumPasses() const;
 
-        /** get the Group object associated to the i-th pass */
-        inline osg::Group *getPassGroup(int i);
-
-        /** get the const Group object associated to the i-th pass */
-        inline const osg::Group *getPassGroup(int i) const;
-
         /** get the StateSet object associated to the i-th pass */
         inline osg::StateSet *getPassStateSet(int i);
 
@@ -92,10 +88,12 @@ namespace osgFX
         inline const osg::StateSet *getPassStateSet(int i) const;
 
         /** 
-         traverses the child nodes with multipass if necessary.
+         traverse children with multipass if necessary. By default this method
+         simply calls the protected method traverse_implementation(); you can
+         override it to change the default behavior.
          Don't call this method directly as it is called by osgFX::Effect
          */
-        virtual void accept(osg::NodeVisitor &nv, osg::Node *child);
+        inline virtual void traverse(osg::NodeVisitor &nv, Effect *fx);
         
     protected:
         Technique(const Technique &): osg::Referenced() {}    // copying is nonsense ;)
@@ -105,28 +103,11 @@ namespace osgFX
         /** force rebuilding of pass nodes on next traversal */
         inline void dirtyPasses();
 
-        /** optional: return a node that overrides the child node on a specified pass */
-        inline virtual osg::Node *getOverrideChild(int)  { return 0; }
-
         /** create a new pass node, add it to the technique and associate a StateSet */
         void addPass(osg::StateSet *ss = 0);
         
-        /**
+        /** optional: return a node that overrides the child node on a specified pass */
-         add a new pass to the technique specifying an user-defined pass node.
+        inline virtual osg::Node *getOverrideChild(int)  { return 0; }
-         You should call this version of addPass() only when you need to gain direct
-         control over the pass node (i.e. for setting up a cull callback); otherwise
-         please use addPass(StateSet*) and let the class create the pass node for you.
-        */
-        void addPass(osg::Group *pass);
-
-        /**
-         get the control node which holds the user's subgraph.
-         You may want to do something on it like applying a cull callback.
-         */
-        inline osg::Group *getControlNode();
-
-        /** get the const control node which holds the user's subgraph */
-        inline const osg::Group *getControlNode() const;
 
         /**
          define the rendering passes that make up this technique. You must
@@ -134,53 +115,42 @@ namespace osgFX
          */
         virtual void define_passes() = 0;
         
-    private:
+		/**
-        bool passes_defined_;
+		 traverse children with multipass if necessary. Don't call this method
+		 directly unless you are in a customized version of traverse().
+		 */
+        void traverse_implementation(osg::NodeVisitor &nv, Effect *fx);
 
-        osg::ref_ptr<osg::Group> control_node_;
+    private:
-        osg::ref_ptr<osg::Node> prev_child_;
+        typedef std::vector<osg::ref_ptr<osg::StateSet> > Pass_list;
+        Pass_list passes_;
     };
 
     // INLINE METHODS
 
     inline int Technique::getNumPasses() const
     {
-        return static_cast<int>(control_node_->getNumChildren());
+        return static_cast<int>(passes_.size());
-    }
-
-    inline osg::Group *Technique::getPassGroup(int i)
-    {
-        return static_cast<osg::Group *>(control_node_->getChild(i));
-    }
-
-    inline const osg::Group *Technique::getPassGroup(int i) const
-    {
-        return static_cast<const osg::Group *>(control_node_->getChild(i));
     }
 
     inline osg::StateSet *Technique::getPassStateSet(int i)
     {
-        return control_node_->getChild(i)->getStateSet();
+        return passes_[i].get();
     }
 
     inline const osg::StateSet *Technique::getPassStateSet(int i) const
     {
-        return control_node_->getChild(i)->getStateSet();
+        return passes_[i].get();
-    }
-    
-    inline osg::Group *Technique::getControlNode()
-    {
-        return control_node_.get();
-    }
-
-    inline const osg::Group *Technique::getControlNode() const
-    {
-        return control_node_.get();
     }
       
     inline void Technique::dirtyPasses()
     {
-        passes_defined_ = false;
+        passes_.clear();
+    }
+    
+    inline void Technique::traverse(osg::NodeVisitor &nv, Effect *fx)
+    {
+		traverse_implementation(nv, fx);
     }
 
 }

include/osgFX/Validator

@@ -34,22 +34,28 @@ namespace osgFX
      */
     class OSGFX_EXPORT Validator: public osg::StateAttribute {
     public:
+		enum {
+			VALIDATOR = 0x56616C69
+		};
+		
         Validator();
         Validator(Effect *effect);
         Validator(const Validator &copy, const osg::CopyOp &copyop = osg::CopyOp::SHALLOW_COPY);
 
-        META_StateAttribute(osgFX, Validator, 0x56616C69);
+        META_StateAttribute(osgFX, Validator, VALIDATOR);
 
         void apply(osg::State &state) const;
 
         inline int compare(const osg::StateAttribute &sa) const;
         
+        inline void disable() { effect_ = 0; }
+
     protected:
         virtual ~Validator() {}
         Validator &operator=(const Validator &) { return *this; }
 
     private:
-        mutable osg::ref_ptr<Effect> effect_;
+        mutable Effect *effect_;
     };
 
     // INLINE METHODS
@@ -59,8 +65,8 @@ namespace osgFX
         const Validator *v = dynamic_cast<const Validator *>(&sa);
         if (!v) return -1;
 
-        if (effect_.get() < v->effect_.get()) return -1;
+        if (effect_ < v->effect_) return -1;
-        if (effect_.get() > v->effect_.get()) return 1;
+        if (effect_ > v->effect_) return 1;
 
         return 0;
     }

src/osgFX/BumpMapping.cpp

@@ -599,22 +599,23 @@ void BumpMapping::prepareNode(osg::Node *node)
     node->accept(tv);
 }
 
-void BumpMapping::prepareChild()
+void BumpMapping::prepareChildren()
 {
-    if (getChild())
+	for (unsigned i=0; i<getNumChildren(); ++i)
-        prepareNode(getChild());
+		prepareNode(getChild(i));
 }
 
 void BumpMapping::setUpDemo()
 {
     // generate texture coordinates
     TexCoordGenerator tcg(diffuseunit_, normalunit_);
-    getChild()->accept(tcg);
+    for (unsigned i=0; i<getNumChildren(); ++i)
+		getChild(i)->accept(tcg);
 
     // set up diffuse texture
     if (!diffuse_tex_.valid()) {
         diffuse_tex_ = new osg::Texture2D;
-        diffuse_tex_->setImage(osgDB::readImageFile("whitemetal_diffuse.jpg"));
+        diffuse_tex_->setImage(osgDB::readImageFile("Images/whitemetal_diffuse.jpg"));
         diffuse_tex_->setFilter(osg::Texture::MIN_FILTER, osg::Texture::LINEAR_MIPMAP_LINEAR);
         diffuse_tex_->setFilter(osg::Texture::MAG_FILTER, osg::Texture::LINEAR);
         diffuse_tex_->setWrap(osg::Texture::WRAP_S, osg::Texture::REPEAT);
@@ -625,7 +626,7 @@ void BumpMapping::setUpDemo()
     // set up normal map texture
     if (!normal_tex_.valid()) {
         normal_tex_ = new osg::Texture2D;
-        normal_tex_->setImage(osgDB::readImageFile("whitemetal_normal.jpg"));
+        normal_tex_->setImage(osgDB::readImageFile("Images/whitemetal_normal.jpg"));
         normal_tex_->setFilter(osg::Texture::MIN_FILTER, osg::Texture::LINEAR_MIPMAP_LINEAR);
         normal_tex_->setFilter(osg::Texture::MAG_FILTER, osg::Texture::LINEAR);
         normal_tex_->setWrap(osg::Texture::WRAP_S, osg::Texture::REPEAT);
@@ -634,7 +635,7 @@ void BumpMapping::setUpDemo()
     }
 
     // generate tangent-space basis vector
-    prepareChild();
+    prepareChildren();
 
     // recreate techniques on next step
     dirtyTechniques();

src/osgFX/Effect.cpp

@@ -6,10 +6,12 @@
 #include <osg/StateAttribute>
 #include <osg/Geometry>
 
+#include <osgUtil/CullVisitor>
+
 using namespace osgFX;
 
 Effect::Effect()
-:    osg::Node(),
+:	osg::Group(),
     enabled_(true),
     global_sel_tech_(AUTO_DETECT),
     techs_defined_(false)
@@ -18,56 +20,59 @@ Effect::Effect()
 }
 
 Effect::Effect(const Effect &copy, const osg::CopyOp &copyop)
-:    osg::Node(copy, copyop),
+:	osg::Group(copy, copyop),
     enabled_(copy.enabled_),
     global_sel_tech_(copy.global_sel_tech_),
-    techs_defined_(false),
+    techs_defined_(false)
-    child_(static_cast<osg::Node *>(copyop(copy.child_.get())))
 {
     build_dummy_node();
 }
 
-bool Effect::computeBound() const
+Effect::~Effect()
 {
-    _bsphere.init();
+	// disable the validator for safety, so it won't try to access us
-    _bsphere_computed = true;
+	// even if it stays alive for some reason
-
+	if (dummy_for_validation_.valid()) {
-    if (child_.valid()) {
+		osg::StateSet *ss = dummy_for_validation_->getStateSet();
-        _bsphere.expandBy(child_->getBound());
+		if (ss) {
-    }
+			Validator *validator = dynamic_cast<Validator *>(ss->getAttribute(Validator::VALIDATOR));
-
+			if (validator) {
-    return _bsphere.valid();
+				validator->disable();
+			}
+		}
+	}
 }
 
 void Effect::traverse(osg::NodeVisitor &nv)
 {
-    typedef osg::Node Inherited;
+	// if this effect is not enabled, then go for default traversal
-
-    if (!child_.valid()) return;
-
-    // we are not a Group, so children will not notify us when their
-    // bounding box has changed. We need to recompute it at each traversal... :(
-    dirtyBound();
-
     if (!enabled_) {
-        child_->accept(nv);
+        inherited_traverse(nv);
-        Inherited::traverse(nv);
         return;
     }
 
+	// ensure that at least one technique is defined
     if (!techs_defined_) {
 
-        // clear existing techniques if necessary
+        // clear existing techniques
         techs_.clear();
+
+		// clear technique selection indices
         sel_tech_.clear();
+
+		// clear technique selection flags
         tech_selected_.clear();
 
         // define new techniques
         techs_defined_ = define_techniques();
+
+		// check for errors, return on failure
         if (!techs_defined_) {
             osg::notify(osg::WARN) << "Warning: osgFX::Effect: could not define techniques for effect " << className() << std::endl;
             return;
         }
+
+		// ensure that at least one technique has been defined
         if (techs_.empty()) {
             osg::notify(osg::WARN) << "Warning: osgFX::Effect: no techniques defined for effect " << className() << std::endl;
             return;
@@ -76,7 +81,11 @@ void Effect::traverse(osg::NodeVisitor &nv)
 
     Technique *tech = 0;
 
-    if (global_sel_tech_ == AUTO_DETECT) {
+    // if the selection mode is set to AUTO_DETECT then we have to
+	// choose the active technique!
+	if (global_sel_tech_ == AUTO_DETECT) {
+
+		// test whether at least one technique has been selected
         bool none_selected = true;
         for (unsigned i=0; i<tech_selected_.size(); ++i) {
             if (tech_selected_[i] != 0) {
@@ -85,11 +94,15 @@ void Effect::traverse(osg::NodeVisitor &nv)
             }
         }
 
+		// no techniques selected, traverse a dummy node that
+		// contains the Validator (it will select a technique)
         if (none_selected) {
             dummy_for_validation_->accept(nv);
         }
 
-        int max_index = -1;
+        // find the highest priority technique that could be validated
+		// in all active rendering contexts
+		int max_index = -1;
         for (unsigned j=0; j<sel_tech_.size(); ++j) {
             if (tech_selected_[j] != 0) {
                 if (sel_tech_[j] > max_index) {
@@ -98,21 +111,23 @@ void Effect::traverse(osg::NodeVisitor &nv)
             }
         }
 
-        if (max_index >= 0) {
+        // found a valid technique?
+		if (max_index >= 0) {
             tech = techs_[max_index].get();
         }
 
     } else {
+
+		// the active technique was selected manually
         tech = techs_[global_sel_tech_].get();
     }
 
-    if (tech) {
+    // if we could find an active technique, then continue with traversal
-        tech->accept(nv, child_.get());
+	if (tech) {
-    } else {
+		tech->traverse(nv, this);
-        child_->accept(nv);
+	}
-    }
 
-    Inherited::traverse(nv);
+	// wow, we're finished! :)
 }
 
 void Effect::build_dummy_node()

src/osgFX/Technique.cpp

@@ -1,32 +1,25 @@
 #include <osgFX/Technique>
+#include <osgFX/Effect>
 
 #include <osg/GLExtensions>
 
+#include <osgUtil/CullVisitor>
+
 using namespace osgFX;
 
 Technique::Technique()
-:    osg::Referenced(),
+:	osg::Referenced()
-    passes_defined_(false),
-    control_node_(new osg::Group)
 {
 }
 
 void Technique::addPass(osg::StateSet *ss)
 {
-    osg::ref_ptr<osg::Group> pass = new osg::Group;
+	if (ss) {
-    control_node_->addChild(pass.get());
+        passes_.push_back(ss);
-
+		ss->setRenderBinDetails(static_cast<int>(passes_.size()), "RenderBin");
-    if (ss) {
-        ss->setRenderBinDetails(static_cast<int>(control_node_->getNumChildren()), "RenderBin");
-        pass->setStateSet(ss);
     }
 }
 
-void Technique::addPass(osg::Group *pass)
-{
-    control_node_->addChild(pass);
-}
-
 bool Technique::validate(osg::State &) const
 {
     typedef std::vector<std::string> String_list;
@@ -41,39 +34,36 @@ bool Technique::validate(osg::State &) const
     return true;
 }
 
-void Technique::accept(osg::NodeVisitor &nv, osg::Node *child)
+void Technique::traverse_implementation(osg::NodeVisitor &nv, Effect *fx)
 {
     // define passes if necessary
-    if (!passes_defined_) {
+    if (passes_.empty()) {
-
-        // clear existing pass nodes
-        if (control_node_->getNumChildren() > 0) {
-            control_node_->removeChild(0, control_node_->getNumChildren());
-        }
-
         define_passes();
-        passes_defined_ = true;
     }
 
-    // update pass children if necessary
+	// special actions must be taken if the node visitor is actually a CullVisitor
-    if (child != prev_child_.get()) {
+	osgUtil::CullVisitor *cv = dynamic_cast<osgUtil::CullVisitor *>(&nv);
-        for (unsigned i=0; i<control_node_->getNumChildren(); ++i) {
-            osg::Group *pass = dynamic_cast<osg::Group *>(control_node_->getChild(i));
-            if (pass) {
-                if (pass->getNumChildren() > 0) {
-                    pass->removeChild(0, pass->getNumChildren());
-                }
-                osg::Node *oc = getOverrideChild(i);
-                if (oc) {
-                    pass->addChild(oc); 
-                } else {
-                    pass->addChild(child);
-                }
-            }
-        }
-        prev_child_ = child;
-    }
 
-    // traverse the control node
+	// traverse all passes
-    control_node_->accept(nv);
+	for (int i=0; i<getNumPasses(); ++i) {
+
+		// push the i-th pass' StateSet if necessary
+		if (cv) {
+			cv->pushStateSet(passes_[i].get());
+		}
+
+		// traverse the override node if defined, otherwise
+		// traverse children as a Group would do
+		osg::Node *override = getOverrideChild(i);
+		if (override) {
+			override->accept(nv);
+		} else {
+			fx->inherited_traverse(nv);
+		}
+
+		// pop the StateSet if necessary
+		if (cv) {
+			cv->popStateSet();
+		}
+	}        
 }

src/osgFX/Validator.cpp

@@ -6,7 +6,8 @@
 using namespace osgFX;
 
 Validator::Validator()
-:    osg::StateAttribute()
+:    osg::StateAttribute(),
+	effect_(0)
 {
 }
 
@@ -18,13 +19,13 @@ Validator::Validator(Effect *effect)
 
 Validator::Validator(const Validator &copy, const osg::CopyOp &copyop)
 :    osg::StateAttribute(copy, copyop),
-    effect_(static_cast<Effect *>(copyop(copy.effect_.get())))
+    effect_(static_cast<Effect *>(copyop(copy.effect_)))
 {
 }
 
 void Validator::apply(osg::State &state) const
 {
-    if (!effect_.valid()) return;
+    if (!effect_) return;
 
     if (effect_->tech_selected_[state.getContextID()] == 0) {
         Effect::Technique_list::iterator i;

src/osgPlugins/osgFX/IO_AnisotropicLighting.cpp

@@ -11,7 +11,7 @@ osgDB::RegisterDotOsgWrapperProxy AnisotropicLighting_Proxy
 (
 	new osgFX::AnisotropicLighting,
 	"osgFX::AnisotropicLighting",
-	"Object Node osgFX::Effect osgFX::AnisotropicLighting",
+	"Object Node Group osgFX::Effect osgFX::AnisotropicLighting",
     AnisotropicLighting_readLocalData,
     AnisotropicLighting_writeLocalData
 );

src/osgPlugins/osgFX/IO_BumpMapping.cpp

@@ -11,7 +11,7 @@ osgDB::RegisterDotOsgWrapperProxy BumpMapping_Proxy
 (
 	new osgFX::BumpMapping,
 	"osgFX::BumpMapping",
-	"Object Node osgFX::Effect osgFX::BumpMapping",
+	"Object Node Group osgFX::Effect osgFX::BumpMapping",
     BumpMapping_readLocalData,
     BumpMapping_writeLocalData
 );

src/osgPlugins/osgFX/IO_Cartoon.cpp

@@ -11,7 +11,7 @@ osgDB::RegisterDotOsgWrapperProxy Cartoon_Proxy
 (
 	new osgFX::Cartoon,
     "osgFX::Cartoon",
-	"Object Node osgFX::Effect osgFX::Cartoon",
+	"Object Node Group osgFX::Effect osgFX::Cartoon",
     Cartoon_readLocalData,
     Cartoon_writeLocalData
 );

src/osgPlugins/osgFX/IO_Effect.cpp

@@ -11,7 +11,7 @@ osgDB::RegisterDotOsgWrapperProxy Effect_Proxy
 (
 	0,
     "osgFX::Effect",
-	"Object Node osgFX::Effect",
+	"Object Node Group osgFX::Effect",
     Effect_readLocalData,
     Effect_writeLocalData
 );
@@ -46,11 +46,6 @@ bool Effect_readLocalData(osg::Object &obj, osgDB::Input &fr)
 		}
 	}
 
-	osg::ref_ptr<osg::Node> node = static_cast<osg::Node *>(fr.readObjectOfType(osgDB::type_wrapper<osg::Node>()));
-	if (node.valid()) {
-		myobj.setChild(node.get());
-	}
-
 	return itAdvanced;
 }
 
@@ -65,7 +60,6 @@ bool Effect_writeLocalData(const osg::Object &obj, osgDB::Output &fw)
 	} else {
 		fw << myobj.getSelectedTechnique() << "\n";
 	}
-	fw.writeObject(*myobj.getChild());
 
     return true;
 }

src/osgPlugins/osgFX/IO_Scribe.cpp

@@ -11,7 +11,7 @@ osgDB::RegisterDotOsgWrapperProxy Scribe_Proxy
 (
 	new osgFX::Scribe,
     "osgFX::Scribe",
-	"Object Node osgFX::Effect osgFX::Scribe",
+	"Object Node Group osgFX::Effect osgFX::Scribe",
     Scribe_readLocalData,
     Scribe_writeLocalData
 );

src/osgPlugins/osgFX/IO_SpecularHighlights.cpp

@@ -11,7 +11,7 @@ osgDB::RegisterDotOsgWrapperProxy SpecularHighlights_Proxy
 (
 	new osgFX::SpecularHighlights,
     "osgFX::SpecularHighlights",
-	"Object Node osgFX::Effect osgFX::SpecularHighlights",
+	"Object Node Group osgFX::Effect osgFX::SpecularHighlights",
     SpecularHighlights_readLocalData,
     SpecularHighlights_writeLocalData
 );