/ - Diff - spinframework - SAT[Métalab]

         virtual ~GeometryNode();
         virtual void callbackUpdate();
         void setStateSetFromFile(const char* filename);
         void setStateSet        (const char* s);
         const char *getStateSet () const { return stateset->s_name; }
         void updateStateSet        ();
         int getRenderBin() const { return renderBin_; }
         int getLighting() const { return (int)lightingEnabled_; }
         void setRenderBin(int i);
         void setLighting(int i);
         virtual void updateStateSet();
         void setNumVertices(int i);
         void setVertex(int index, float x, float y, float z);
-...
         virtual std::vector<lo_message> getState() const;
     private:
         osg::ref_ptr<osg::Geode> geode_;
         osg::ref_ptr<osg::Geometry> geometry_;
         unsigned int numVertices_;
         t_symbol *stateset;
         int renderBin_;
         bool lightingEnabled_;
         bool updateFlag_;
     };
     } // end of namespace spin

         };
         enum globalsReportMode { NONE, GLOBAL_6DOF, GLOBAL_ALL };
         enum velocityMode { TRANSLATE, MOVE };
         enum ComputationMode { SERVER_SIDE, CLIENT_SIDE };
         enum OrientationMode
+        {
             NORMAL,
-...
         		float x, float y, float z);
     	void setLock(const char* userString, int lock);
         /**
          * Print debug information about the node to standard out (when running in
          * console mode). It may be possible to redirect this to a text box for GUI
          * logs.
          */
         virtual void debug();
         /**
          * setStateSetFromFile guesses the type of stateset from the filename
          * extension, creates a new stateset of that type and assigns it to this
          * node
          */
         void setStateSetFromFile(const char* filename);
         /**
          * Assign an existing stateset to this node
          */
         void setStateSet(const char* s);
         t_symbol* getStateSetSymbol() const { return stateset_; }
         /**
          * This method actually applies the stateset to the subgraph, replacing any
          * existing stateset with this one. The setStateSet and setStateSetFromFile
          * methods just set the stateset_ symbol, while updateStateSet does the
          * actual work.
+         *
          * Override this method in subclasses in order to change how stateset should
          * be applied. For example, to which node in the subgraph it should be
          * attached, or whether it should be merged with the existing stateset
          * (rather than merged).
+         *
          * By default it is applied to the mainTransform.
          */
         virtual void updateStateSet();
         void setReportMode(globalsReportMode mode);
         void setInteractionMode(InteractionMode mode);
         void setComputationMode(ComputationMode mode);
         int getComputationMode() const { return (int)computationMode_; };
         /**
          * Set a clipping rectangle for the model so that geometry outside of the
          * region (+-x, +-y, +-z) will not be shown (or used in interactive events)
-...
         void drawManipulator();
         osg::ref_ptr<UserNode> owner;
         t_symbol *stateset_;
         //osg::ref_ptr<osg::PositionAttitudeTransform> mainTransform;
         osg::ref_ptr<osg::MatrixTransform> mainTransform;
-...
         osg::Vec3 _globalScale;
         float _globalRadius;
         bool computationMode_;
         enum OrientationMode orientationMode_;
         t_symbol* orientationTarget_;
         osg::Vec3 _orientation; // store the orientation as it comes in (in degrees)
-...
     private:
         osg::Timer_t lastTick;
     };

         ImageTexture(SceneManager *sceneManager, const char *initID);
         ~ImageTexture();
         /**
          * TO_BE_DONE
          */
         enum TextureMode { TEXTURE_2D, TEXTURE_RECTANGLE };
         virtual void debug();
-...
         void setPath (const char* newPath);
         const char *getPath() const { return _path.c_str(); }
         void setTextureMode(TextureMode mode);
         int getTextureMode() const { return (int)textureMode_; };
         // must reimplement
         virtual std::vector<lo_message> getState() const;
     protected:
         void draw();
     private:
         osg::ref_ptr<osg::Image> _image;
         std::string _path;
         bool _useTextureRectangle;
         TextureMode textureMode_;
     };
     } // end of namespace spin

b/include/ModelNode.h
184	184	* Note: for this to work, stateRegistration must be enabled.
185	185	*/
186	186	void setStateSet (int index, const char *replacement);
	187	void updateStateSet();
187	188
188	189	/**
189	190	* For each subclass of ReferencedNode, we override the getState() method to

          * \param alpha Opacity channel. Number in the range [0, 1]
          */
         void setColor            (float red, float green, float blue, float alpha);
         void setTextureFromFile    (const char* filename);
         void setRenderBin        (int i);
         void setLighting        (int i);
         void setStateSetFromFile(const char* filename);
         void setStateSet        (const char* s);
         const char *getStateSet () const { return stateset->s_name; }
         void updateStateSet        ();
         virtual void updateStateSet();
         int getShape() const { return (int)shape; }
         int getBillboard() const { return (int)billboard; }
-...
         int getRenderBin() const { return renderBin; }
         int getLighting() const { return (int)lightingEnabled; }
         //void addSharedVideoTexture(osg::Node *n, std::string shID);
         //void addVideoTexture(osg::Node *n, std::string texturePath);
         void addImageTexture(osg::Node *n, std::string texturePath);
         /**
          * For each subclass of ReferencedNode, we override the getState() method to
-...
         shapeType shape;
         t_symbol *stateset;
         billboardType billboard;
-...
         std::string texturePath;
         int renderBin;
         bool lightingEnabled;
         //osg::ref_ptr<osg::Image> textureImage; // store textureImage so we don't waste time in the callback
-...
     protected:
         virtual void drawShape();
         virtual void drawTexture();
     };

     	          Properties::VIRTUAL,
     	          __void__debug,
     	          "",
     	          "Debug print (to log/console) ");
     	          "Print debug information about the node to standard out (when running in console mode). It may be possible to redirect this to a text box for GUI logs. ");
     	I_Method1(void, setMass, IN, float, mass,
     	          Properties::NON_VIRTUAL,
     	          __void__setMass__float,

     	          __void__callbackUpdate,
     	          "",
     	          "For nodes that require regular programmatic control, there is a callback that is evaluated with every refresh. This function can thus be used for animations, or any other periodic updates.Note that changes to the scene graph structure (eg, moving/deleting nodes should NOT be done within this callback because traversals stacks will become corrupted. The technique is rather to enable a flag and then do the actual change in the SceneManager::updateGraph() method. ");
     	I_Method1(void, setStateSetFromFile, IN, const char *, filename,
     	          Properties::NON_VIRTUAL,
     	          __void__setStateSetFromFile__C5_char_P1,
     	          "",
     	          "");
     	I_Method1(void, setStateSet, IN, const char *, s,
     	          Properties::NON_VIRTUAL,
     	          __void__setStateSet__C5_char_P1,
     	          "",
     	          "");
     	I_Method0(const char *, getStateSet,
     	          Properties::NON_VIRTUAL,
     	          __C5_char_P1__getStateSet,
     	          "",
     	          "");
     	I_Method0(void, updateStateSet,
     	          Properties::VIRTUAL,
     	          __void__updateStateSet,
     	          "",
     	          "In derived classes, you can handle how a stateset gets applied to a node (eg, which part of the subgraph it is attached by overriding the updateStateSet method. ");
     	I_Method0(int, getRenderBin,
     	          Properties::NON_VIRTUAL,
     	          __int__getRenderBin,
     	          "",
     	          "");
     	I_Method0(int, getLighting,
     	          Properties::NON_VIRTUAL,
     	          __int__getLighting,
     	          "",
     	          "");
     	I_Method1(void, setRenderBin, IN, int, i,
     	          Properties::NON_VIRTUAL,
     	          __void__setRenderBin__int,
     	          "",
     	          "");
     	I_Method1(void, setLighting, IN, int, i,
     	          Properties::NON_VIRTUAL,
     	          __void__setLighting__int,
     	          "",
     	          "");
     	          "This method actually applies the stateset to the subgraph, replacing any existing stateset with this one. The setStateSet and setStateSetFromFile methods just set the stateset_ symbol, while updateStateSet does the actual work.Override this method in subclasses in order to change how stateset should be applied. For example, to which node in the subgraph it should be attached, or whether it should be merged with the existing stateset (rather than merged).By default it is applied to the mainTransform. ");
     	I_Method1(void, setNumVertices, IN, int, i,
     	          Properties::NON_VIRTUAL,
     	          __void__setNumVertices__int,
-...
     	          __std_vectorT1_lo_message___getState,
     	          "",
     	          "For each subclass of ReferencedNode, we override the getState() method to fill the vector with the correct set of methods for this particular node ");
     	I_SimpleProperty(int, Lighting,
     	                 __int__getLighting,
     	                 __void__setLighting__int);
     	I_SimpleProperty(int, NumVertices,
 ,
     	                 __void__setNumVertices__int);
     	I_SimpleProperty(int, RenderBin,
     	                 __int__getRenderBin,
     	                 __void__setRenderBin__int);
     	I_SimpleProperty(std::vector< lo_message >, State,
     	                 __std_vectorT1_lo_message___getState,
 );
     	I_SimpleProperty(const char *, StateSet,
     	                 __C5_char_P1__getStateSet,
     	                 __void__setStateSet__C5_char_P1);
     	I_SimpleProperty(const char *, StateSetFromFile,
 ,
     	                 __void__setStateSetFromFile__C5_char_P1);
     END_REFLECTOR

     #include <GroupNode.h>
     #include <SceneManager.h>
     #include <spinUtil.h>
     // Must undefine IN and OUT macros defined in Windows headers
     #ifdef IN
-...
     	I_EnumLabel(spin::GroupNode::MOVE);
     END_REFLECTOR
     BEGIN_ENUM_REFLECTOR(spin::GroupNode::ComputationMode)
     	I_DeclaringFile("GroupNode.h");
     	I_EnumLabel(spin::GroupNode::SERVER_SIDE);
     	I_EnumLabel(spin::GroupNode::CLIENT_SIDE);
     END_REFLECTOR
     BEGIN_ENUM_REFLECTOR(spin::GroupNode::OrientationMode)
     	I_DeclaringFile("GroupNode.h");
     	I_EnumLabel(spin::GroupNode::NORMAL);
-...
     	          Properties::VIRTUAL,
     	          __void__debug,
     	          "",
     	          "Debug print (to log/console) ");
     	          "Print debug information about the node to standard out (when running in console mode). It may be possible to redirect this to a text box for GUI logs. ");
     	I_Method1(void, setStateSetFromFile, IN, const char *, filename,
     	          Properties::NON_VIRTUAL,
     	          __void__setStateSetFromFile__C5_char_P1,
     	          "",
     	          "setStateSetFromFile guesses the type of stateset from the filename extension, creates a new stateset of that type and assigns it to this node ");
     	I_Method1(void, setStateSet, IN, const char *, s,
     	          Properties::NON_VIRTUAL,
     	          __void__setStateSet__C5_char_P1,
     	          "",
     	          "Assign an existing stateset to this node ");
     	I_Method0(spin::t_symbol *, getStateSetSymbol,
     	          Properties::NON_VIRTUAL,
     	          __t_symbol_P1__getStateSetSymbol,
     	          "",
     	          "");
     	I_Method0(void, updateStateSet,
     	          Properties::VIRTUAL,
     	          __void__updateStateSet,
     	          "",
     	          "This method actually applies the stateset to the subgraph, replacing any existing stateset with this one. The setStateSet and setStateSetFromFile methods just set the stateset_ symbol, while updateStateSet does the actual work.Override this method in subclasses in order to change how stateset should be applied. For example, to which node in the subgraph it should be attached, or whether it should be merged with the existing stateset (rather than merged).By default it is applied to the mainTransform. ");
     	I_Method1(void, setReportMode, IN, spin::GroupNode::globalsReportMode, mode,
     	          Properties::NON_VIRTUAL,
     	          __void__setReportMode__globalsReportMode,
-...
     	          __void__setInteractionMode__InteractionMode,
     	          "",
     	          "");
     	I_Method1(void, setComputationMode, IN, spin::GroupNode::ComputationMode, mode,
     	          Properties::NON_VIRTUAL,
     	          __void__setComputationMode__ComputationMode,
     	          "",
     	          "");
     	I_Method0(int, getComputationMode,
     	          Properties::NON_VIRTUAL,
     	          __int__getComputationMode,
     	          "",
     	          "");
     	I_Method3(void, setClipping, IN, float, x, IN, float, y, IN, float, z,
     	          Properties::NON_VIRTUAL,
     	          __void__setClipping__float__float__float,
-...
     	I_SimpleProperty(osg::Vec3, Clipping,
     	                 __osg_Vec3__getClipping,
 );
     	I_SimpleProperty(int, ComputationMode,
     	                 __int__getComputationMode,
 );
     	I_SimpleProperty(float, Damping,
     	                 __float__getDamping,
     	                 __void__setDamping__float);
-...
     	I_SimpleProperty(std::vector< lo_message >, State,
     	                 __std_vectorT1_lo_message___getState,
 );
     	I_SimpleProperty(const char *, StateSet,
 ,
     	                 __void__setStateSet__C5_char_P1);
     	I_SimpleProperty(const char *, StateSetFromFile,
 ,
     	                 __void__setStateSetFromFile__C5_char_P1);
     	I_SimpleProperty(spin::t_symbol *, StateSetSymbol,
     	                 __t_symbol_P1__getStateSetSymbol,
 );
     	I_SimpleProperty(osg::MatrixTransform *, Transform,
     	                 __osg_MatrixTransform_P1__getTransform,
 );

     #undef OUT
     #endif
     BEGIN_ENUM_REFLECTOR(spin::ImageTexture::TextureMode)
     	I_DeclaringFile("ImageTexture.h");
     	I_EnumLabel(spin::ImageTexture::TEXTURE_2D);
     	I_EnumLabel(spin::ImageTexture::TEXTURE_RECTANGLE);
     END_REFLECTOR
     BEGIN_OBJECT_REFLECTOR(spin::ImageTexture)
     	I_DeclaringFile("ImageTexture.h");
     	I_BaseType(spin::Shader);
-...
     	          Properties::VIRTUAL,
     	          __void__debug,
     	          "",
     	          "TO_BE_DONE ");
     	          "Print debug information to console. ");
     	I_Method0(bool, isValid,
     	          Properties::NON_VIRTUAL,
     	          __bool__isValid,
-...
     	          __C5_char_P1__getPath,
     	          "",
     	          "");
     	I_Method1(void, setTextureMode, IN, spin::ImageTexture::TextureMode, mode,
     	          Properties::NON_VIRTUAL,
     	          __void__setTextureMode__TextureMode,
     	          "",
     	          "");
     	I_Method0(int, getTextureMode,
     	          Properties::NON_VIRTUAL,
     	          __int__getTextureMode,
     	          "",
     	          "");
     	I_Method0(std::vector< lo_message >, getState,
     	          Properties::VIRTUAL,
     	          __std_vectorT1_lo_message___getState,
     	          "",
     	          "Just like a ReferencedNode, each subclass of ReferencedStateSet must override the getState() method to pass it's current state. ");
     	I_ProtectedMethod0(void, draw,
     	                   Properties::NON_VIRTUAL,
     	                   Properties::NON_CONST,
     	                   __void__draw,
     	                   "",
     	                   "");
     	I_SimpleProperty(const char *, Path,
     	                 __C5_char_P1__getPath,
     	                 __void__setPath__C5_char_P1);
     	I_SimpleProperty(std::vector< lo_message >, State,
     	                 __std_vectorT1_lo_message___getState,
 );
     	I_SimpleProperty(int, TextureMode,
     	                 __int__getTextureMode,
 );
     END_REFLECTOR

b/src/osgWrappers/introspection/Menu3D.cpp
172	172	0);
173	173	END_REFLECTOR
174	174
175		TYPE_NAME_ALIAS(std::vector< osg::observer_ptr< spin::TextNode > >, spin::MenuVector)
176
177		STD_VECTOR_REFLECTOR(std::vector< osg::observer_ptr< spin::TextNode > >)
178

     	          __void__setStateSet__int__C5_char_P1,
     	          "",
     	          "For statesets embedded in the model, it is possible to swap with some other (already existing) stateset.Note: for this to work, stateRegistration must be enabled. ");
     	I_Method0(void, updateStateSet,
     	          Properties::VIRTUAL,
     	          __void__updateStateSet,
     	          "",
     	          "This method actually applies the stateset to the subgraph, replacing any existing stateset with this one. The setStateSet and setStateSetFromFile methods just set the stateset_ symbol, while updateStateSet does the actual work.Override this method in subclasses in order to change how stateset should be applied. For example, to which node in the subgraph it should be attached, or whether it should be merged with the existing stateset (rather than merged).By default it is applied to the mainTransform. ");
     	I_Method0(std::vector< lo_message >, getState,
     	          Properties::VIRTUAL,
     	          __std_vectorT1_lo_message___getState,

     	          Properties::VIRTUAL,
     	          __void__debug,
     	          "",
     	          "Debug print (to log/console) ");
     	          "Print debug information about the node to standard out (when running in console mode). It may be possible to redirect this to a text box for GUI logs. ");
     	I_Method0(void, callbackUpdate,
     	          Properties::VIRTUAL,
     	          __void__callbackUpdate,

     	          __void__setUpdateRate__float,
     	          "",
     	          "Sets the update delay for the physics engine (in seconds). The default is 0.02 seconds (ie, 50hz). ");
     	I_Method2(void, detectCollision, IN, bool &, lastColState, IN, btCollisionWorld *, cw,
     	          Properties::NON_VIRTUAL,
     	          __void__detectCollision__bool_R1__btCollisionWorld_P1,
     	          "",
     	          "");
     	I_SimpleProperty(std::vector< std::string >, AllNodeTypes,
     	                 __std_vectorT1_std_string___getAllNodeTypes,
 );
-...
     	I_PublicMemberProperty(bool, graphicalMode);
     	I_PublicMemberProperty(osg::ref_ptr< spin::GroupNode >, globalObserver);
     	I_PublicMemberProperty(std::string, resourcesPath);
     	I_PublicMemberProperty(bool, lastColState);
     	I_PublicMemberProperty(btDynamicsWorld *, dynamicsWorld_);
     END_REFLECTOR
     TYPE_NAME_ALIAS(std::vector< osg::ref_ptr< spin::ReferencedNode > >, spin::nodeListType)

     	          __void__setColor__float__float__float__float,
     	          "",
     	          " param red Red channel. Number in the range [0, 1]  green Green channel. Number in the range [0, 1]  blue Blue channel. Number in the range [0, 1]  alpha Opacity channel. Number in the range [0, 1]  ");
     	I_Method1(void, setTextureFromFile, IN, const char *, filename,
     	          Properties::NON_VIRTUAL,
     	          __void__setTextureFromFile__C5_char_P1,
     	          "",
     	          "");
     	I_Method1(void, setRenderBin, IN, int, i,
     	          Properties::NON_VIRTUAL,
     	          __void__setRenderBin__int,
-...
     	          __void__setLighting__int,
     	          "",
     	          "");
     	I_Method1(void, setStateSetFromFile, IN, const char *, filename,
     	          Properties::NON_VIRTUAL,
     	          __void__setStateSetFromFile__C5_char_P1,
     	          "",
     	          "");
     	I_Method1(void, setStateSet, IN, const char *, s,
     	          Properties::NON_VIRTUAL,
     	          __void__setStateSet__C5_char_P1,
     	          "",
     	          "");
     	I_Method0(const char *, getStateSet,
     	          Properties::NON_VIRTUAL,
     	          __C5_char_P1__getStateSet,
     	          "",
     	          "");
     	I_Method0(void, updateStateSet,
     	          Properties::VIRTUAL,
     	          __void__updateStateSet,
     	          "",
     	          "In derived classes, you can handle how a stateset gets applied to a node (eg, which part of the subgraph it is attached by overriding the updateStateSet method. ");
     	          "This method actually applies the stateset to the subgraph, replacing any existing stateset with this one. The setStateSet and setStateSetFromFile methods just set the stateset_ symbol, while updateStateSet does the actual work.Override this method in subclasses in order to change how stateset should be applied. For example, to which node in the subgraph it should be attached, or whether it should be merged with the existing stateset (rather than merged).By default it is applied to the mainTransform. ");
     	I_Method0(int, getShape,
     	          Properties::NON_VIRTUAL,
     	          __int__getShape,
-...
     	          __int__getLighting,
     	          "",
     	          "");
     	I_Method2(void, addImageTexture, IN, osg::Node *, n, IN, std::string, texturePath,
     	          Properties::NON_VIRTUAL,
     	          __void__addImageTexture__osg_Node_P1__std_string,
     	          "",
     	          "");
     	I_Method0(std::vector< lo_message >, getState,
     	          Properties::VIRTUAL,
     	          __std_vectorT1_lo_message___getState,
-...
     	                   __void__drawShape,
     	                   "",
     	                   "");
     	I_ProtectedMethod0(void, drawTexture,
     	                   Properties::VIRTUAL,
     	                   Properties::NON_CONST,
     	                   __void__drawTexture,
     	                   "",
     	                   "");
     	I_SimpleProperty(int, Billboard,
     	                 __int__getBillboard,
 );
-...
     	I_SimpleProperty(std::vector< lo_message >, State,
     	                 __std_vectorT1_lo_message___getState,
 );
     	I_SimpleProperty(const char *, StateSet,
     	                 __C5_char_P1__getStateSet,
     	                 __void__setStateSet__C5_char_P1);
     	I_SimpleProperty(const char *, StateSetFromFile,
 ,
     	                 __void__setStateSetFromFile__C5_char_P1);
     	I_SimpleProperty(const char *, TextureFromFile,
 ,
     	                 __void__setTextureFromFile__C5_char_P1);
     	I_PublicMemberProperty(spin::ShapeNode::shapeType, shape);
     	I_PublicMemberProperty(spin::t_symbol *, stateset);
     	I_PublicMemberProperty(spin::ShapeNode::billboardType, billboard);
     	I_PublicMemberProperty(osg::Vec4, _color);
     	I_PublicMemberProperty(std::string, texturePath);

b/src/osgWrappers/introspection/spinApp.cpp
172	172	I_PublicMemberProperty(boost::python::object, _pyNamespace);
173	173	I_PublicMemberProperty(bool, _pyInitialized);
174	174	I_PublicMemberProperty(osg::ref_ptr< spin::UserNode >, userNode);
	175	I_PublicMemberProperty(spatosc::Scene *, audioScene);
175	176	I_PublicMemberProperty(bool, hasAudioRenderer);
176	177	I_PublicMemberProperty(spin::SceneManager *, sceneManager);
177	178	END_REFLECTOR

     	this->setName(string(id->s_name) + ".GeometryNode");
     	nodeType = "GeometryNode";
     	stateset = gensym("NULL");
     	renderBin_ = 11;
     	lightingEnabled_ = true;
         updateFlag_ = false;
         numVertices_ = 4;
         osg::Vec3Array *vertexArray_ = new osg::Vec3Array(numVertices_);
         osg::Vec4Array *colorArray_ = new osg::Vec4Array(numVertices_);
-...
     // -----------------------------------------------------------------------------
     void GeometryNode::setStateSetFromFile(const char* filename)
+    {
     	osg::ref_ptr<ReferencedStateSet> ss = sceneManager->createStateSet(filename);
     	if (ss.valid())
+    	{
     		if (ss->id == stateset) return; // we're already using that stateset
     		stateset = ss->id;
     		updateStateSet();
     		BROADCAST(this, "ss", "setStateSet", getStateSet());
+    	}
+    }
     void GeometryNode::setStateSet (const char* s)
+    {
     	if (gensym(s)==stateset) return;
     	osg::ref_ptr<ReferencedStateSet> ss = sceneManager->getStateSet(s);
     	if (ss.valid())
+    	{
     		stateset = ss->id;
     		updateStateSet();
     		BROADCAST(this, "ss", "setStateSet", getStateSet());
+    	}
+    }
     void GeometryNode::updateStateSet()
+    {
     	osg::ref_ptr<ReferencedStateSet> ss = dynamic_cast<ReferencedStateSet*>(stateset->s_thing);
     	osg::ref_ptr<ReferencedStateSet> ss = dynamic_cast<ReferencedStateSet*>(stateset_->s_thing);
     	if (geode_.valid() && ss.valid()) geode_->setStateSet( ss.get() );
+    }
     void GeometryNode::setRenderBin (int i)
+    {
     	if (renderBin_ == i) return;
     	renderBin_ = i;
     	if (geode_.valid())
+    	{
     		osg::StateSet *ss = geode_->getOrCreateStateSet();
     		ss->setRenderBinDetails( (int)renderBin_, "RenderBin");
     		//setStateSet( shapeStateSet );
+    	}
     	BROADCAST(this, "si", "setRenderBin", renderBin_);
+    }
     void GeometryNode::setLighting (int i)
+    {
     	if (lightingEnabled_==(bool)i) return;
     	lightingEnabled_ = (bool)i;
     	if (geode_.valid() && !stateset->s_thing)
+    	{
     		osg::StateSet *ss = geode_->getOrCreateStateSet();
     		if (lightingEnabled_) ss->setMode( GL_LIGHTING, osg::StateAttribute::ON );
     		else ss->setMode( GL_LIGHTING, osg::StateAttribute::OFF );
+    	}
     	BROADCAST(this, "si", "setLighting", getLighting());
+    }
     void GeometryNode::setNumVertices(int i)
+    {
         if (numVertices_ != i)
-...
     	osg::Vec3 v3;
     	osg::Vec4 v4;
     	msg = lo_message_new();
     	lo_message_add(msg,  "ss", "setStateSet", getStateSet());
     	ret.push_back(msg);
     	msg = lo_message_new();
     	lo_message_add(msg, "si", "setRenderBin", getRenderBin());
     	ret.push_back(msg);
     	msg = lo_message_new();
     	lo_message_add(msg, "si", "setLighting", getLighting());
     	ret.push_back(msg);
     	// put this one last:
     	/*
     	msg = lo_message_new();

         //mainTransform->setPosition(osg::Vec3(0.0,0.0,0.0));
         this->addChild(mainTransform.get());
         computationMode_ = SERVER_SIDE;
         stateset_ = gensym("NULL");
         clipNode = new osg::ClipNode();
         clipNode->setCullingActive(false);
-...
         // Now we need to update translation/orientation based on our velocity/spin.
         // We find out how many seconds passed since the last time this was called,
         // and move by _velocity*dt (ie, m/s) and rotate by _spin*dt (ie, deg/sec)
         if ( spinApp::Instance().getContext()->isServer() )
         if (spinApp::Instance().getContext()->isServer())
+        {
             if (computationMode_==SERVER_SIDE)
+            {
                 // update based on velocity and broadcast
+            }
             else
+            {
                 // don't broadcast any massages but keep the node's position up to date
+             }
+        }
         else
+        {
             // just call move(), translate(), etc.
+        }
         if (1)
+        {
             osg::Timer_t tick = osg::Timer::instance()->tick();
             float dt = osg::Timer::instance()->delta_s(lastTick,tick);
-...
+    }
     // ***********************************************************
     // ***********************************************************
     // -----------------------------------------------------------------------------
     /*
     void GroupNode::reportGlobals (int b)
     void GroupNode::setComputationMode (ComputationMode mode)
+    {
         if (this->_reportGlobals != (bool)b)
         if (this->computationMode_ != (int)mode)
+        {
             this->_reportGlobals = (bool) b;
             BROADCAST(this, "si", "reportGlobals", (int) this->_reportGlobals);
             this->computationMode_ = mode;
             BROADCAST(this, "si", "setComputationMode", getComputationMode());
+        }
+    }
     */
     void GroupNode::setReportMode (globalsReportMode mode)
+    {
-...
+        }
+    }
     // -----------------------------------------------------------------------------
     void GroupNode::setStateSetFromFile(const char* filename)
+    {
     	osg::ref_ptr<ReferencedStateSet> ss = sceneManager->createStateSet(filename);
     	if (ss.valid())
+    	{
     		if (ss->id == stateset_) return; // we're already using that stateset
     		stateset_ = ss->id;
     		updateStateSet();
     		BROADCAST(this, "ss", "setStateSet", getStateSetSymbol()->s_name);
+    	}
+    }
     void GroupNode::setStateSet (const char* s)
+    {
     	if (gensym(s)==stateset_) return;
     	osg::ref_ptr<ReferencedStateSet> ss = sceneManager->getStateSet(s);
     	if (ss.valid())
+    	{
     		stateset_ = ss->id;
     		updateStateSet();
     		BROADCAST(this, "ss", "setStateSet", getStateSetSymbol()->s_name);
+    	}
+    }
     void GroupNode::updateStateSet()
+    {
     	osg::ref_ptr<ReferencedStateSet> ss = dynamic_cast<ReferencedStateSet*>(stateset_->s_thing);
     	if (mainTransform.valid() && ss.valid()) mainTransform->setStateSet( ss.get() );
+    }
     // -----------------------------------------------------------------------------
     void GroupNode::setClipping(float x, float y, float z)
+    {
         _clipping = osg::Vec3d(x,y,z);
-...
         lo_message msg;
         osg::Vec3 v;
     	msg = lo_message_new();
     	lo_message_add(msg,  "ss", "setStateSet", getStateSetSymbol()->s_name);
     	ret.push_back(msg);
         msg = lo_message_new();
         lo_message_add(msg, "si", "setComputationMode", getComputationMode());
         ret.push_back(msg);
         msg = lo_message_new();
         lo_message_add(msg, "si", "setReportMode", getReportMode());

     	classType = "ImageTexture";
     	_path = "NULL";
     	_useTextureRectangle = false;
     	textureMode_ = TEXTURE_2D;
+    }
     // destructor
-...
     // *****************************************************************************
     void ImageTexture::setPath (const char* newPath)
+    {
     	// only do this if the id has changed:
     	if (_path == std::string(newPath)) return;
     	_path = std::string(newPath);
     	if (sceneManager->isGraphical())
+    	{
     		std::string fullPath = getAbsolutePath(_path);
     		std::cout << "Loading image: " << fullPath << std::endl;
     		//osg::setNotifyLevel(osg::DEBUG_FP);
     		osg::ref_ptr<osg::Image> test = osgDB::readImageFile(fullPath);
     		//osg::setNotifyLevel(osg::FATAL);
     		if (test.valid())
+    		{
     			this->setName("ImageTexture("+_path+")");
     			// create a texture object
     			osg::Texture *tex;
     			if (_useTextureRectangle)
+    			{
     				tex = new osg::TextureRectangle;
     			} else {
     				tex = new osg::Texture2D;
+    			}
     			tex->setResizeNonPowerOfTwoHint(false);
     			tex->setFilter(osg::Texture::MIN_FILTER,osg::Texture::LINEAR);
     			//tex->setFilter(osg::Texture::MAG_FILTER,osg::Texture::LINEAR);
     			//tex->setWrap(osg::Texture::WRAP_R, osg::Texture::REPEAT);
     			if (textureRepeatS_)
     				tex->setWrap(osg::Texture::WRAP_S, osg::Texture::REPEAT);
     			else
     				tex->setWrap(osg::Texture::WRAP_S, osg::Texture::CLAMP);
     			if (textureRepeatT_)
     				tex->setWrap(osg::Texture::WRAP_T, osg::Texture::REPEAT);
     			else
     				tex->setWrap(osg::Texture::WRAP_T, osg::Texture::CLAMP);
     			// set the image:
     			tex->setImage(0,test.get());
     			// set transparent border:
     			tex->setBorderColor(osg::Vec4(1.0f,1.0f,1.0f,0.0f));
     			// add texture to stateset:
     			this->setTextureAttributeAndModes(0, tex, osg::StateAttribute::ON | osg::StateAttribute::OVERRIDE );
     			// osg::TexEnv::REPLACE  osg::TexEnv::DECAL  osg::TexEnv::MODULATE osg::TexEnv::BLEND
     			osg::TexEnv* texenv = new osg::TexEnv();
     			texenv->setMode(textureBlend_);
     			this->setTextureAttribute(0, texenv, osg::StateAttribute::ON | osg::StateAttribute::OVERRIDE );
     			// set lighting:
     			if (lightingEnabled_) this->setMode( GL_LIGHTING, osg::StateAttribute::ON );
     			else this->setMode( GL_LIGHTING, osg::StateAttribute::OFF );
     			// set renderbin:
     			this->setRenderBinDetails( renderBin_, "RenderBin");
     			// if image has transparency, enable blending:
     			if (1)//(_imageStream->isImageTranslucent())
+    			{
     				this->setMode(GL_BLEND, osg::StateAttribute::ON);
     				this->setRenderingHint(osg::StateSet::TRANSPARENT_BIN);
     			} else
+                {
                     this->setMode(GL_BLEND, osg::StateAttribute::OFF);
     				this->setRenderingHint(osg::StateSet::DEFAULT_BIN);
+                }
+    		}
     	if (_path != std::string(newPath))
+        {
             _path = std::string(newPath);
             if (sceneManager->isGraphical()) this->draw();
             BROADCAST(this, "ss", "setPath", getPath());
+        }
+    }
     		else {
     			std::cout << "ImageTexture ERROR. Bad format?: " << _path << std::endl;
+    		}
+    	}
     void ImageTexture::setTextureMode(TextureMode mode)
+    {
         if (this->textureMode_ != (int)mode)
+        {
             this->textureMode_ = mode;
             if (sceneManager->isGraphical()) this->draw();
             BROADCAST(this, "si", "setTextureMode", (int) this->textureMode_);
+        }
+    }
     	BROADCAST(this, "ss", "setPath", getPath());
     void ImageTexture::draw()
+    {
         std::string fullPath = getAbsolutePath(_path);
         std::cout << "Loading image: " << fullPath << std::endl;
         //osg::setNotifyLevel(osg::DEBUG_FP);
         osg::ref_ptr<osg::Image> test = osgDB::readImageFile(fullPath);
         //osg::setNotifyLevel(osg::FATAL);
         if (test.valid())
+        {
             this->setName("ImageTexture("+_path+")");
             // create a texture object
             osg::Texture *tex;
             if (textureMode_==TEXTURE_RECTANGLE)
+            {
                 tex = new osg::TextureRectangle;
             } else {
                 tex = new osg::Texture2D;
+            }
             tex->setResizeNonPowerOfTwoHint(false);
             tex->setFilter(osg::Texture::MIN_FILTER,osg::Texture::LINEAR);
             //tex->setFilter(osg::Texture::MAG_FILTER,osg::Texture::LINEAR);
             //tex->setWrap(osg::Texture::WRAP_R, osg::Texture::REPEAT);
             if (textureRepeatS_)
                 tex->setWrap(osg::Texture::WRAP_S, osg::Texture::REPEAT);
             else
                 tex->setWrap(osg::Texture::WRAP_S, osg::Texture::CLAMP);
             if (textureRepeatT_)
                 tex->setWrap(osg::Texture::WRAP_T, osg::Texture::REPEAT);
             else
                 tex->setWrap(osg::Texture::WRAP_T, osg::Texture::CLAMP);
             // set the image:
             tex->setImage(0,test.get());
             // set transparent border:
             tex->setBorderColor(osg::Vec4(1.0f,1.0f,1.0f,0.0f));
             // add texture to stateset:
             this->setTextureAttributeAndModes(0, tex, osg::StateAttribute::ON | osg::StateAttribute::OVERRIDE );
             // osg::TexEnv::REPLACE  osg::TexEnv::DECAL  osg::TexEnv::MODULATE osg::TexEnv::BLEND
             osg::TexEnv* texenv = new osg::TexEnv();
             texenv->setMode(textureBlend_);
             this->setTextureAttribute(0, texenv, osg::StateAttribute::ON | osg::StateAttribute::OVERRIDE );
             // set lighting:
             if (lightingEnabled_) this->setMode( GL_LIGHTING, osg::StateAttribute::ON );
             else this->setMode( GL_LIGHTING, osg::StateAttribute::OFF );
             // set renderbin:
             this->setRenderBinDetails( renderBin_, "RenderBin");
             // if image has transparency, enable blending:
             if (1)//(_imageStream->isImageTranslucent())
+            {
                 this->setMode(GL_BLEND, osg::StateAttribute::ON);
                 this->setRenderingHint(osg::StateSet::TRANSPARENT_BIN);
             } else
+            {
                 this->setMode(GL_BLEND, osg::StateAttribute::OFF);
                 this->setRenderingHint(osg::StateSet::DEFAULT_BIN);
+            }
+        }
         else {
             std::cout << "ImageTexture ERROR. Bad format?: " << _path << std::endl;
+        }
+    }
-...
     	lo_message msg;
     	msg = lo_message_new();
     	lo_message_add(msg, "si", "setTextureMode", getTextureMode());
     	ret.push_back(msg);
     	msg = lo_message_new();
     	lo_message_add(msg, "ss", "setPath", getPath());
     	ret.push_back(msg);

         _attachCentroid = false;
         _registerStates = false;
     	_statesetList.clear();
         _statesetList.push_back(stateset_);
         _renderBin = 10;
         _lightingOverride = 0;
-...
     void ModelNode::setStateSet (int i, const char *replacement)
+    {
     	osg::ref_ptr<ReferencedStateSet> ssOrig, ssReplacement;
     	if ( i < (int)_statesetList.size() )
+    	{
     		ssOrig = dynamic_cast<ReferencedStateSet*>(_statesetList[i]->s_thing);
+    	}
     	ssReplacement = sceneManager->getStateSet(replacement);
     	if (ssOrig.valid() && ssReplacement.valid())
+    	{
     		// oops. this method might replace other model's stateset (if more than
     		// one model is currently using ssOrig:
     		/*
     		for (int j=0; j < ssOrig->getNumParents(); j++)
+    		{
     			// stateset can be shared by several parents within the model, but
     			// they must be either of type osg::Drawable or osg::Node
     			osg::Drawable *drawable = dynamic_cast<osg::Drawable*>(ssOrig->getParent(j));
     			osg::Node *node = dynamic_cast<osg::Node*>(ssOrig->getParent(j));
     			if (drawable) drawable->setStateSet(ssReplacement.get());
     			else if (node) node->setStateSet(ssReplacement.get());
     			else std::cout << "ERROR: setStateSet for model " << id->s_name << " had problems." << std::endl;
+    		}
     		*/
         osg::ref_ptr<ReferencedStateSet> ssReplacement = sceneManager->getStateSet(replacement);
         if (i==0)
+        {
             osg::ref_ptr<ReferencedStateSet> ss = dynamic_cast<ReferencedStateSet*>(stateset_->s_thing);
             if (mainTransform.valid() && ss.valid()) mainTransform->setStateSet( ss.get() );
+        }
         else if ((i>0) && (i<_statesetList.size()))
+        {
             osg::ref_ptr<ReferencedStateSet> ssOrig = dynamic_cast<ReferencedStateSet*>(_statesetList[i]->s_thing);
     		// We need to search through the drawables and nodes that originally had
     		// statesets and replace ssOrig with ssReplacement:
     		std::vector<osg::Drawable*>::iterator dItr;
     		for (dItr=_ssDrawableList.begin(); dItr!=_ssDrawableList.end(); ++dItr)
+    		{
     			if ((*dItr)->getStateSet() == ssOrig.get())
+    			{
     				(*dItr)->setStateSet(ssReplacement.get());
+    			}
+    		}
     		std::vector<osg::Node*>::iterator nItr;
     		for (nItr=_ssNodeList.begin(); nItr!=_ssNodeList.end(); ++nItr)
+    		{
     			if ((*nItr)->getStateSet() == ssOrig.get())
+    			{
     				(*nItr)->setStateSet(ssReplacement.get());
+    			}
+    		}
             if (ssOrig.valid() && ssReplacement.valid())
+            {
                 // We need to search through the drawables and nodes that originally had
                 // statesets and replace ssOrig with ssReplacement:
                 std::vector<osg::Drawable*>::iterator dItr;
                 for (dItr=_ssDrawableList.begin(); dItr!=_ssDrawableList.end(); ++dItr)
+                {
                     if ((*dItr)->getStateSet() == ssOrig.get())
+                    {
                         (*dItr)->setStateSet(ssReplacement.get());
+                    }
+                }
                 std::vector<osg::Node*>::iterator nItr;
                 for (nItr=_ssNodeList.begin(); nItr!=_ssNodeList.end(); ++nItr)
+                {
                     if ((*nItr)->getStateSet() == ssOrig.get())
+                    {
                         (*nItr)->setStateSet(ssReplacement.get());
+                    }
+                }
+            }
+        }
         if (ssReplacement.valid())
+        {
             _statesetList[i] = ssReplacement->id;
             BROADCAST(this, "sis", "setStateSet", i, _statesetList[i]->s_name);
+        }
+    }
     		_statesetList[i] = ssReplacement->id;
     		BROADCAST(this, "sis", "setStateSet", i, _statesetList[i]->s_name);
+    	}
     void ModelNode::updateStateSet()
+    {
         // updateStateSet should do nothing for ModelNode.
         this->setStateSet(0, stateset_->s_name);
+    }
     void ModelNode::setLighting(int i)
-...
     // ===================================================================
     void ModelNode::drawModel()
+    {
     	int i,j;
     	pthread_mutex_lock(&sceneMutex);
     	if (model.valid())
-...
             model = NULL;
             _centroid->setPosition(osg::Vec3(0.0,0.0,0.0));
     		_statesetList.clear();
             _statesetList.push_back(stateset_);
     		_ssDrawableList.clear();
     		_ssNodeList.clear();
     		//if (sceneManager->sharedStateManager.valid()) sceneManager->sharedStateManager->prune();
     		for (i=0; i<MODELNODE_NUM_ANIM_CONTROLS; i++)
     		for (int i=0; i<MODELNODE_NUM_ANIM_CONTROLS; i++)
+    		{
     			// re-initialize:
     			switcher[i] = NULL;
-...
     			SearchVisitor searchVisitor;
     			char buf[16];
     			for (i=0; i<MODELNODE_NUM_ANIM_CONTROLS; i++)
     			for (int i=0; i<MODELNODE_NUM_ANIM_CONTROLS; i++)
+    			{
     				sprintf( buf, "%02d", i );
-...
     					animationMode[i] = SWITCH;
     					// initialize so only first frame is visible:
     					switcher[i]->setValue(0, true);
     					for (j=1; j<switcher[i]->getNumChildren(); j++) switcher[i]->setValue(j, false);
     					for (int j=1; j<switcher[i]->getNumChildren(); j++) switcher[i]->setValue(j, false);
+    				}
-...
     							ss->replace((*itr).get());
     							this->_statesetList.push_back(ss->id);
     							std::cout << "  Replaced placeholder texture with " << ss->classType << ": " << ss->id->s_name << std::endl;
                                 //
                                 std::cout << "Now we have " << _statesetList.size() << " statesets:" << std::endl;
                                 for (int i=0; i<_statesetList.size(); i++)
+                                {
                                     std::cout << " - " << _statesetList[i]->s_name << std::endl;
+                                }
+    						}
     						// OLD:
     						/*
     						// check if the imagefile (minus extension) is a directory, and replace if necessary
     						if (osgDB::getDirectoryContents(osgDB::getNameLessExtension(imageFile)).size())
+    						{
     							osg::ref_ptr<VideoTexture> vid = dynamic_cast<VideoTexture*>(sceneManager->createStateSet(osgDB::getStrippedName(imageFile).c_str(), "VideoTexture"));
     							//osg::ref_ptr<VideoTexture> vid = dynamic_cast<VideoTexture*>(sceneManager->createStateSet((string(id->s_name)+"/"+osgDB::getStrippedName(imageFile)).c_str(), "VideoTexture"));
     							//osg::ref_ptr<VideoTexture> vid = new VideoTexture(sceneManager, (string(id->s_name)+"/"+osgDB::getStrippedName(imageFile)).c_str());
     							if (vid.valid())
+    							{
     								vid->setVideoPath(osgDB::getNameLessExtension(getRelativePath(imageFile)).c_str());
     								vid->replace((*itr).get());
     								//(*itr) = vid.get();
     								std::cout << "  Replaced placeholder texture with " << vid->classType << ": " << vid->id->s_name << std::endl;
+    							}
+    						}
     						// if filename contains "shared_video_texture", then replace
     						// current TextureAttribute with a SharedVideoTexture
     						if ((pos=imageFile.find("shared_video_texture01")) != string::npos)
+    						{
     							std::string shID = "shvid_"+imageFile.substr(pos+20, imageFile.rfind(".")-(pos+20));
     							osg::ref_ptr<SharedVideoTexture> shvid = dynamic_cast<SharedVideoTexture*>(sceneManager->createStateSet(shID.c_str(), "SharedVideoTexture"));
     							if (shvid.valid())
+    							{
     								shvid->setTextureID(shID.c_str());
     								(*itr)->removeAttribute(attr);
     								shvid->replace((*itr).get());
     								std::cout << "  Replaced placeholder texture with " << shvid->classType << ": " << shvid->id->s_name << std::endl;
+    							}
+    						}
     						// Check if filename (minus extension) is a movie format:
     						//
     						// ... the idea is that the model was created with using
     						// a placeholder image with a name like: texture.avi.jpg
     						//
     						// ... we look for a video file in the same path, but with
     						// the image extension stripped off: eg, texture.avi
     						//
     						// We replace the image with an ImageStream, and all YUV
     						// texture mapping will remain (assuming the image and video
     						// have identical resolutions.
     						else if (isVideoPath(imageFileLessExtension))
+    						{
     							std::string vidPath;
     							if (imageFileLessExtension.substr(1)=="/")
+    							{
     								// absolute path, so don't change it
     								vidPath = imageFileLessExtension;
+    							}
     							else {
     								// relative path:
     								vidPath = osgDB::concatPaths(osgDB::getFilePath(getAbsolutePath(modelPath)), imageFileLessExtension);
+    							}
     							std::cout << "... imageFileLessExtension: " << imageFileLessExtension << std::endl;
     							std::cout << "... vidPath: " << vidPath << std::endl;
     							std::cout << "--> " << (string(id->s_name)+"/"+osgDB::getStrippedName(imageFileLessExtension)).c_str() << std::endl;
     							osg::ref_ptr<VideoTexture> vid = dynamic_cast<VideoTexture*>(sceneManager->createStateSet(osgDB::getStrippedName(imageFileLessExtension).c_str(), "VideoTexture"));
     							//osg::ref_ptr<VideoTexture> vid = dynamic_cast<VideoTexture*>(sceneManager->createStateSet((string(id->s_name)+"/"+osgDB::getStrippedName(imageFile)).c_str(), "VideoTexture"));
     							//osg::ref_ptr<VideoTexture> vid = new VideoTexture(sceneManager, (string(id->s_name)+"/"+osgDB::getStrippedName(imageFile)).c_str());
     							if (vid.valid())
+    							{
     								vid->setVideoPath(vidPath.c_str());
     								vid->replace((*itr).get());
     								//(*itr) = vid.get();
+    							}
+    						}
     						*/
     					} // if texture attribute
     				} // stateset iterator
     			} // if _registerStates
-...
         lo_message_add(msg, "si", "setLighting", getLighting());
         ret.push_back(msg);
     	msg = lo_message_new();
     	lo_message_add(msg, "si", "setRenderBin", getRenderBin());
     	ret.push_back(msg);
     	for (i=0; i<MODELNODE_NUM_ANIM_CONTROLS; i++)
+    	{
     		if (switcher[i].valid() || sequencer[i].valid())
-...
     	lo_message_add(msg, "si", "setRenderBin", getRenderBin());
     	ret.push_back(msg);
     	for (i=0; i<_statesetList.size(); i++)
     	for (i=1; i<_statesetList.size(); i++)
+    	{
     		msg = lo_message_new();
             lo_message_add(msg, "sis", "setStateSet", i, _statesetList[i]->s_name);

     		statesetsToSave = getSavableStateSets(*childIter, withUsers);
+    	}
     	// the only subgraphs which can have statesets are:
     	// oops this doesn't work on the server (isGraphical==false) because it
     	// doesn't actually add the statesets to the nodes
     	/*
     	if ((n->nodeType=="ShapeNode") || (n->nodeType=="ModelNode"))
+    	{
     		std::cout << "getting statesets for shape/model: " << n->id->s_name <<  std::endl;
     		// to actually find the stateset, we use the TextureStateSetFinder
     		// node visitor
     		StateSetList statesets;
     		TextureStateSetFinder f(statesets);
     		n->accept(f);
     		// these statesets could be regular osg statesets, but we keep only
     		// those which can be cast as ReferencedStateSet
     		for (StateSetList::iterator itr=statesets.begin(); itr!=statesets.end(); ++itr)
+    		{
     			std::cout << "found one ... testing if referenced stateset" <<  std::endl;
     			ReferencedStateSet *refStateSet = dynamic_cast<ReferencedStateSet*>((*itr).get());
     			if (refStateSet) statesetsToSave.push_back(refStateSet);
+    		}
+    	}
     	*/
     	if (n->nodeType == "ShapeNode")
+    	{
     		ShapeNode *shp = dynamic_cast<ShapeNode*>(n);
     		if (shp)
+    		{
     			statesetsToSave.push_back(shp->stateset);
+    		}
+    	}
     	else if (n->nodeType == "ModelNode")
     	if (n->nodeType == "ModelNode")
+    	{
     		ModelNode *mdl = dynamic_cast<ModelNode*>(n);
     		if (mdl)
+    		{
     			statesetsToSave.insert( statesetsToSave.begin(), mdl->_statesetList.begin(), mdl->_statesetList.end());
+    		}
+    	}
+    	}
         else
+        {
             GroupNode *grp = dynamic_cast<GroupNode*>(n);
     		if (grp)
+    		{
                 t_symbol *ss = grp->getStateSetSymbol();
                 if (ss->s_thing)
                     statesetsToSave.push_back(ss);
+    		}
+        }
     	return statesetsToSave;
+    }

     	shape = BOX;
     	billboard = RELATIVE; // ie, no billboard
     	texturePath = "NULL";
     	stateset = gensym("NULL");
     	renderBin = 11;
     	lightingEnabled = true;
-...
+    }
     // ===================================================================
     void ShapeNode::setTextureFromFile (const char* s)
+    {
     	string path = getRelativePath(string(s));
     	// don't do anything if the current texture is already loaded:
     	if (path==texturePath) return;
     	else texturePath=path;
     	//drawTexture();
     	BROADCAST(this, "ss", "setTextureFromFile", texturePath.c_str());
+    }
     void ShapeNode::setStateSetFromFile(const char* filename)
+    {
     	osg::ref_ptr<ReferencedStateSet> ss = sceneManager->createStateSet(filename);
     	if (ss.valid())
+    	{
     		if (ss->id == stateset) return; // we're already using that stateset
     		stateset = ss->id;
     		updateStateSet();
     		BROADCAST(this, "ss", "setStateSet", getStateSet());
+    	}
+    }
     void ShapeNode::setStateSet (const char* s)
+    {
     	if (gensym(s)==stateset) return;
     	osg::ref_ptr<ReferencedStateSet> ss = sceneManager->getStateSet(s);
     	if (ss.valid())
+    	{
     		stateset = ss->id;
     		updateStateSet();
     		BROADCAST(this, "ss", "setStateSet", getStateSet());
+    	}
+    }
     void ShapeNode::updateStateSet()
+    {
     	osg::ref_ptr<ReferencedStateSet> ss = dynamic_cast<ReferencedStateSet*>(stateset->s_thing);
     	osg::ref_ptr<ReferencedStateSet> ss = dynamic_cast<ReferencedStateSet*>(stateset_->s_thing);
     	if (shapeGeode.valid() && ss.valid()) shapeGeode->setStateSet( ss.get() );
+    }
-...
     	if (lightingEnabled==(bool)i) return;
     	lightingEnabled = (bool)i;
     	if (shapeGeode.valid() && !stateset->s_thing)
     	if (shapeGeode.valid() && !stateset_->s_thing)

spinframework

Revision c38d81dd