Cleaning up.

include/RegionGeometry.h

@@ -31,6 +31,9 @@ namespace Ogre
 		RegionGeometry(){};
 
 		bool m_bIsEmpty;
+		bool m_bContainsSingleMaterialPatch;
+		bool m_bContainsMultiMaterialPatch;
+
 		UIntVector3 m_v3dRegionPosition;
 		IndexedSurfacePatch* m_patchSingleMaterial;
 		IndexedSurfacePatch* m_patchMultiMaterial;

include/SurfacePatchRenderable.h

@@ -18,7 +18,7 @@ namespace Ogre
 	class SurfacePatchRenderable : public SimpleRenderable
 	{
 	public:
-	   SurfacePatchRenderable(IndexedSurfacePatch* patchToRender, const String& material = "BaseWhiteNoLighting");
+	   SurfacePatchRenderable(const String& name, IndexedSurfacePatch* patchToRender, const String& material = "BaseWhiteNoLighting");
 	   ~SurfacePatchRenderable(void);
 
 	   void updateWithNewSurfacePatch(IndexedSurfacePatch* patchToRender);
@@ -26,11 +26,29 @@ namespace Ogre
 
 	   Real getSquaredViewDepth(const Camera *cam) const;
 	   Real getBoundingRadius(void) const;
+
+	   virtual const String& getMovableType(void) const;
 	protected:
 	   //void getWorldTransforms(Matrix4 *xform) const;
 	   const Quaternion &getWorldOrientation(void) const;
 	   const Vector3 &getWorldPosition(void) const;
-	};	
+	};
+
+	/** Factory object for creating Light instances */
+	/*class _OgreExport SimplePatchRenderableFactory : public MovableObjectFactory
+	{
+	protected:
+		MovableObject* createInstanceImpl( const String& name, const NameValuePairList* params);
+	public:
+		SimplePatchRenderableFactory() {}
+		~SimplePatchRenderableFactory() {}
+
+		static String FACTORY_TYPE_NAME;
+
+		const String& getType(void) const;
+		void destroyInstance( MovableObject* obj);  
+
+	};*/
 }
 
 #endif /* __SurfacePatchRenderable_H__ */

source/PolyVoxSceneManager.cpp

@@ -118,56 +118,100 @@ namespace Ogre
 
 			for(std::list<RegionGeometry>::iterator iterRegionGeometry = listChangedRegionGeometry.begin(); iterRegionGeometry != listChangedRegionGeometry.end(); iterRegionGeometry++)
 			{
-				std::string location("");
+				std::stringstream location;
-				location = location + "(" + iterRegionGeometry->m_v3dRegionPosition.x + "," + iterRegionGeometry->m_v3dRegionPosition.y + "," + iterRegionGeometry->m_v3dRegionPosition.z + ")";
+				location << "(" << iterRegionGeometry->m_v3dRegionPosition.x << "," << iterRegionGeometry->m_v3dRegionPosition.y << "," << iterRegionGeometry->m_v3dRegionPosition.z << ")";
+
+				std::stringstream singleMaterialNode;
+				singleMaterialNode << "Single Material Node: " << location.str();
+
+				std::stringstream multiMaterialNode;
+				multiMaterialNode << "Multi Material Node: " << location.str();
+
+				//LogManager::getSingleton().logMessage(location.str());
+				//LogManager::getSingleton().logMessage(singleMaterialNode.str());
+				//LogManager::getSingleton().logMessage(multiMaterialNode.str());
+				//LogManager::getSingleton().logMessage("/n");
 
 				if(iterRegionGeometry->m_bIsEmpty)
 				{
-					try
+					if(hasSceneNode(location.str()))
-					{
-						getRootSceneNode()->removeAndDestroyChild(location);
-					}
-					catch(...)
 					{
+						getRootSceneNode()->removeAndDestroyChild(location.str());
 					}
 				}
 				else
 				{
-
 					//If a SceneNode doesn't exist in this position then create one.
 					SceneNode* sceneNode;
-					try
+					if(hasSceneNode(location.str()))
 					{
-						sceneNode = dynamic_cast<SceneNode*>(getRootSceneNode()->getChild(location));
+						sceneNode = dynamic_cast<SceneNode*>(getRootSceneNode()->getChild(location.str()));
-					}
-					catch(...)
-					{
-						sceneNode = 0;
-					}
-
-					if(sceneNode == 0)
-					{
-						sceneNode = getRootSceneNode()->createChildSceneNode(location, Vector3(iterRegionGeometry->m_v3dRegionPosition.x*OGRE_REGION_SIDE_LENGTH,iterRegionGeometry->m_v3dRegionPosition.y*OGRE_REGION_SIDE_LENGTH,iterRegionGeometry->m_v3dRegionPosition.z*OGRE_REGION_SIDE_LENGTH));
-
-						SurfacePatchRenderable*singleMaterialSurfacePatchRenderable = new SurfacePatchRenderable(iterRegionGeometry->m_patchSingleMaterial,materialMap->getMaterialAtIndex(1));
-						SurfacePatchRenderable*multiMaterialSurfacePatchRenderable = new SurfacePatchRenderable(iterRegionGeometry->m_patchMultiMaterial,materialMap->getMaterialAtIndex(2));
-
-						multiMaterialSurfacePatchRenderable->setRenderQueueGroup(RENDER_QUEUE_3);
-						singleMaterialSurfacePatchRenderable->setRenderQueueGroup(RENDER_QUEUE_4);
-
-						sceneNode->attachObject(singleMaterialSurfacePatchRenderable);
-
-						sceneNode->attachObject(multiMaterialSurfacePatchRenderable);
 					}
 					else
 					{
+						sceneNode = getRootSceneNode()->createChildSceneNode(location.str(), Vector3(iterRegionGeometry->m_v3dRegionPosition.x*OGRE_REGION_SIDE_LENGTH,iterRegionGeometry->m_v3dRegionPosition.y*OGRE_REGION_SIDE_LENGTH,iterRegionGeometry->m_v3dRegionPosition.z*OGRE_REGION_SIDE_LENGTH));
+					}
 
-						SurfacePatchRenderable* singleMaterialSurfacePatchRenderable = dynamic_cast<SurfacePatchRenderable*>(sceneNode->getAttachedObject(0));
+					if(iterRegionGeometry->m_bContainsSingleMaterialPatch)
-						SurfacePatchRenderable* multiMaterialSurfacePatchRenderable = dynamic_cast<SurfacePatchRenderable*>(sceneNode->getAttachedObject(1));
+					{
+						SurfacePatchRenderable* singleMaterialSurfacePatchRenderable;
+						try
+						//if(hasMovableObject(singleMaterialNode.str(),"SimpleRenderable") )
+						{
+							LogManager::getSingleton().logMessage("FOUND IT!!!!!!!!!!!!!!!!!!!!!!!!!!");
+							singleMaterialSurfacePatchRenderable = dynamic_cast<SurfacePatchRenderable*>(sceneNode->getAttachedObject(singleMaterialNode.str()));
+							//singleMaterialSurfacePatchRenderable = dynamic_cast<SurfacePatchRenderable*>(getMovableObject(singleMaterialNode.str(), "SurfacePatchRenderable"));
+							singleMaterialSurfacePatchRenderable->updateWithNewSurfacePatch(iterRegionGeometry->m_patchSingleMaterial);
+						}
+						catch(Ogre::ItemIdentityException)
+						//else
+						{
+							singleMaterialSurfacePatchRenderable = new SurfacePatchRenderable(singleMaterialNode.str(), iterRegionGeometry->m_patchSingleMaterial,materialMap->getMaterialAtIndex(1));
+							singleMaterialSurfacePatchRenderable->setRenderQueueGroup(RENDER_QUEUE_4);
+							sceneNode->attachObject(singleMaterialSurfacePatchRenderable);
+						}
+					}
+					else
+					{
+						try
+						{
+							sceneNode->detachObject(singleMaterialNode.str());
+						}
+						catch(...)
+						{}
+					}
 
-						singleMaterialSurfacePatchRenderable->updateWithNewSurfacePatch(iterRegionGeometry->m_patchSingleMaterial);
+					if(iterRegionGeometry->m_bContainsMultiMaterialPatch)
-
+					{
-						multiMaterialSurfacePatchRenderable->updateWithNewSurfacePatch(iterRegionGeometry->m_patchMultiMaterial);
+						//If a SceneNode doesn't exist in this position then create one.
+						SurfacePatchRenderable* multiMaterialSurfacePatchRenderable;
+						try
+						{
+							multiMaterialSurfacePatchRenderable = dynamic_cast<SurfacePatchRenderable*>(sceneNode->getAttachedObject(multiMaterialNode.str()));
+						}
+						catch(...)
+						{
+							multiMaterialSurfacePatchRenderable = 0;
+						}
+						if(multiMaterialSurfacePatchRenderable == 0)
+						{
+							SurfacePatchRenderable* multiMaterialSurfacePatchRenderable = new SurfacePatchRenderable(multiMaterialNode.str(), iterRegionGeometry->m_patchMultiMaterial,materialMap->getMaterialAtIndex(2));
+							multiMaterialSurfacePatchRenderable->setRenderQueueGroup(RENDER_QUEUE_3);
+							sceneNode->attachObject(multiMaterialSurfacePatchRenderable);
+						}
+						else
+						{
+							multiMaterialSurfacePatchRenderable->updateWithNewSurfacePatch(iterRegionGeometry->m_patchMultiMaterial);
+						}
+					}
+					else
+					{
+						try
+						{
+							sceneNode->detachObject(multiMaterialNode.str());
+						}
+						catch(...)
+						{}
 					}
 				}
 			}
@@ -210,6 +254,8 @@ namespace Ogre
 
 						generateMeshDataForRegion(regionX,regionY,regionZ, regionGeometry.m_patchSingleMaterial, regionGeometry.m_patchMultiMaterial);
 
+						regionGeometry.m_bContainsSingleMaterialPatch = regionGeometry.m_patchSingleMaterial->m_vecVertices.size() > 0;
+						regionGeometry.m_bContainsMultiMaterialPatch = regionGeometry.m_patchMultiMaterial->m_vecVertices.size() > 0;
 						regionGeometry.m_bIsEmpty = ((regionGeometry.m_patchSingleMaterial->m_vecVertices.size() == 0) && (regionGeometry.m_patchMultiMaterial->m_vecTriangleIndices.size() == 0));
 
 						listChangedRegionGeometry.push_back(regionGeometry);

source/SurfacePatchRenderable.cpp

@@ -8,7 +8,8 @@
 
 namespace Ogre
 {
-	SurfacePatchRenderable::SurfacePatchRenderable(IndexedSurfacePatch* patchToRender, const String& material)
+	SurfacePatchRenderable::SurfacePatchRenderable(const String& name, IndexedSurfacePatch* patchToRender, const String& material)
+		:SimpleRenderable(name)
 	{
 		//Set up what we can of the vertex data
 		mRenderOp.vertexData = new VertexData();
@@ -164,4 +165,31 @@ namespace Ogre
 	{
 		return Vector3::ZERO;
 	}
+
+	const String& SurfacePatchRenderable::getMovableType(void) const
+    {
+        static String movType = "SurfacePatchRenderable";
+        return movType;
+    }
+
+	//-----------------------------------------------------------------------
+	/*String LightFactory::FACTORY_TYPE_NAME = "SurfacePatchRenderable";
+	//-----------------------------------------------------------------------
+	const String& SimplePatchRenderableFactory::getType(void) const
+	{
+		return FACTORY_TYPE_NAME;
+	}
+	//-----------------------------------------------------------------------
+	MovableObject* SimplePatchRenderableFactory::createInstanceImpl( const String& name, 
+		const NameValuePairList* params)
+	{
+
+		return new SurfacePatchRenderable(name);
+
+	}
+	//-----------------------------------------------------------------------
+	void SimplePatchRenderableFactory::destroyInstance( MovableObject* obj)
+	{
+		delete obj;
+	}*/
 }