Merge pull request #97 from andrewkaufman/ropLinkControl

ForceObjects parameter for SceneCache ROP

Author: ldmoser

include/IECoreHoudini/HoudiniScene.h

@@ -93,6 +93,9 @@ class HoudiniScene : public IECore::SceneInterface
 		virtual IECore::SceneInterfacePtr scene( const Path &path, MissingBehaviour missingBehaviour = SceneInterface::ThrowIfMissing );
 		virtual IECore::ConstSceneInterfacePtr scene( const Path &path, MissingBehaviour missingBehaviour = SceneInterface::ThrowIfMissing ) const;
 
+		/// Convenience method to access the Houdini node this scene refers to
+		const OP_Node *node() const;
+		
 		typedef boost::function<bool (const OP_Node *)> HasFn;
 		typedef boost::function<IECore::ConstObjectPtr (const OP_Node *)> ReadFn;
 		typedef boost::function<bool (const OP_Node *, const Name &)> HasTagFn;

include/IECoreHoudini/ROP_SceneCacheWriter.h

@@ -56,9 +56,11 @@ class ROP_SceneCacheWriter : public ROP_Node
 
 		static PRM_Name pFile;
 		static PRM_Name pRootObject;
+		static PRM_Name pForceObjects;
 
 		static PRM_Default fileDefault;
 		static PRM_Default rootObjectDefault;
+		static PRM_SpareData forceObjectsSpareData;
 
 		static OP_Node *create( OP_Network *net, const char *name, OP_Operator *op );
 		static OP_TemplatePair *buildParameters();
@@ -69,14 +71,27 @@ class ROP_SceneCacheWriter : public ROP_Node
 		virtual ROP_RENDER_CODE renderFrame( fpreal time, UT_Interrupt *boss );
 		virtual ROP_RENDER_CODE endRender();
 
+		virtual bool updateParmsFlags();
+		
 		/// Called recursively to traverse the IECoreHoudini::HoudiniScene, starting with the Root Object,
 		/// and write the hierarchy to the output file.
 		virtual ROP_RENDER_CODE doWrite( const IECore::SceneInterface *liveScene, IECore::SceneInterface *outScene, double time );
 
 	private :
 
+		bool linked( const std::string &file ) const;
+		
+		enum Mode
+		{
+			NaturalLink = 0,
+			ForcedLink,
+			NaturalExpand,
+			ForcedExpand
+		};
+		
 		IECore::ConstSceneInterfacePtr m_liveScene;
 		IECore::SceneInterfacePtr m_outScene;
+		UT_StringMMPattern *m_forceFilter;
 
 };
 

include/IECoreHoudini/SceneCacheNode.h

@@ -108,7 +108,7 @@ class SceneCacheNode : public BaseType
 
 		/// Access point to the actual SceneCache. All users should only access the cache
 		/// using this method, in order to avoid re-opening existing files.
-		IECore::ConstSceneInterfacePtr scene();
+		IECore::ConstSceneInterfacePtr scene() const;
 
 	protected :
 

src/IECoreHoudini/HoudiniScene.cpp

@@ -90,6 +90,11 @@ HoudiniScene::~HoudiniScene()
 {
 }
 
+const OP_Node *HoudiniScene::node() const
+{
+	return retrieveNode( false, NullIfMissing );
+}
+
 std::string HoudiniScene::fileName() const
 {
 	throw Exception( "HoudiniScene does not support fileName()." );

src/IECoreHoudini/ROP_SceneCacheWriter.cpp

@@ -36,11 +36,14 @@
 
 #include "GEO/GEO_AttributeHandle.h"
 #include "GU/GU_Detail.h"
-#include "OBJ/OBJ_Node.h" 
+#include "OBJ/OBJ_Node.h"
+#include "OP/OP_Bundle.h"
 #include "OP/OP_Director.h" 
 #include "PRM/PRM_Include.h"
+#include "PRM/PRM_Parm.h"
 #include "PRM/PRM_SpareData.h"
 #include "ROP/ROP_Error.h"
+#include "UT/UT_StringMMPattern.h"
 
 #include "IECore/LinkedScene.h"
 
@@ -54,12 +57,13 @@ using namespace IECoreHoudini;
 const char *ROP_SceneCacheWriter::typeName = "ieSceneCacheWriter";
 
 ROP_SceneCacheWriter::ROP_SceneCacheWriter( OP_Network *net, const char *name, OP_Operator *op )
-	: ROP_Node( net, name, op ), m_liveScene( 0 ), m_outScene( 0 )
+	: ROP_Node( net, name, op ), m_liveScene( 0 ), m_outScene( 0 ), m_forceFilter( 0 )
 {
 }
 
 ROP_SceneCacheWriter::~ROP_SceneCacheWriter()
 {
+	delete m_forceFilter;
 }
 
 OP_Node *ROP_SceneCacheWriter::create( OP_Network *net, const char *name, OP_Operator *op )
@@ -69,16 +73,18 @@ OP_Node *ROP_SceneCacheWriter::create( OP_Network *net, const char *name, OP_Ope
 
 PRM_Name ROP_SceneCacheWriter::pFile( "file", "File" );
 PRM_Name ROP_SceneCacheWriter::pRootObject( "rootObject", "Root Object" );
+PRM_Name ROP_SceneCacheWriter::pForceObjects( "forceObjects", "Force Objects" );
 
 PRM_Default ROP_SceneCacheWriter::fileDefault( 0, "$HIP/output.scc" );
 PRM_Default ROP_SceneCacheWriter::rootObjectDefault( 0, "/obj" );
+PRM_SpareData ROP_SceneCacheWriter::forceObjectsSpareData;
 
 OP_TemplatePair *ROP_SceneCacheWriter::buildParameters()
 {
 	static PRM_Template *thisTemplate = 0;
 	if ( !thisTemplate )
 	{
-		thisTemplate = new PRM_Template[3];
+		thisTemplate = new PRM_Template[4];
 
 		thisTemplate[0] = PRM_Template(
 			PRM_FILE, 1, &pFile, &fileDefault, 0, 0, 0, 0, 0,
@@ -89,6 +95,15 @@ OP_TemplatePair *ROP_SceneCacheWriter::buildParameters()
 			PRM_STRING, PRM_TYPE_DYNAMIC_PATH, 1, &pRootObject, &rootObjectDefault, 0, 0, 0,
 			&PRM_SpareData::objPath, 0, "The node to use as the root of the SceneCache"
 		);
+		
+		forceObjectsSpareData.copyFrom( PRM_SpareData::objPath );
+		forceObjectsSpareData.setOpRelative( "/obj" );
+		
+		thisTemplate[2] = PRM_Template(
+			PRM_STRING, PRM_TYPE_DYNAMIC_PATH_LIST, 1, &pForceObjects, 0, 0, 0, 0,
+			&forceObjectsSpareData, 0, "Optional list of nodes to force as expanded objects. "
+			"If this list is used, then links will be stored for any node not listed."
+		);
 	}
 
 	static OP_TemplatePair *templatePair = 0;
@@ -116,7 +131,7 @@ int ROP_SceneCacheWriter::startRender( int nframes, fpreal s, fpreal e )
 		m_liveScene = new IECoreHoudini::HoudiniScene( nodePath, emptyPath, emptyPath );
 
 		// wrapping with a LinkedScene to ensure full expansion when writing the non-linked file
-		if ( boost::filesystem::path( file ).extension().string() != ".lscc" )
+		if ( !linked( file ) )
 		{
 			m_liveScene = new LinkedScene( m_liveScene );
 		}
@@ -137,6 +152,39 @@ int ROP_SceneCacheWriter::startRender( int nframes, fpreal s, fpreal e )
 		return false;
 	}
 
+	UT_String forceObjects;
+	evalString( forceObjects, pForceObjects.getToken(), 0, 0 );
+	
+	m_forceFilter =  0;
+	if ( linked( file ) && !forceObjects.equal( "" ) )
+	{
+		// get the list of nodes matching the filter
+		const PRM_SpareData *data = getParm( pForceObjects.getToken() ).getSparePtr();
+		OBJ_Node *baseNode = OPgetDirector()->findNode( data->getOpRelative() )->castToOBJNode();
+		OP_Bundle *bundle = getParmBundle( pForceObjects.getToken(), 0, forceObjects, baseNode, data->getOpFilter() );
+		
+		// add all of the parent nodes
+		UT_PtrArray<OP_Node *> nodes;
+		bundle->getMembers( nodes );
+		size_t numNodes = nodes.entries();
+		for ( size_t i = 0; i < numNodes; ++i )
+		{
+			OP_Node *current = nodes[i]->getParent();
+			while ( current )
+			{
+				bundle->addOp( current );
+				current = current->getParent();
+			}
+		}
+		
+		// build a matchable filter from all these nodes
+		UT_WorkBuffer buffer;
+		bundle->buildString( buffer );
+		buffer.copyIntoString( forceObjects );
+		m_forceFilter = new UT_StringMMPattern();
+		m_forceFilter->compile( forceObjects );
+	}
+	
 	return true;
 }
 
@@ -193,20 +241,47 @@ ROP_RENDER_CODE ROP_SceneCacheWriter::doWrite( const SceneInterface *liveScene,
 		outScene->writeTransform( liveScene->readTransform( time ), time );
 	}
 
-	bool link = false;
+	Mode mode = NaturalExpand;
+	const HoudiniScene *hScene = IECore::runTimeCast<const HoudiniScene>( liveScene );
+	if ( hScene && m_forceFilter )
+	{
+		UT_String nodePath;
+		hScene->node()->getFullPath( nodePath );
+		mode = ( nodePath.multiMatch( *m_forceFilter ) ) ? ForcedExpand : ForcedLink;
+	}
+	
 	SceneInterface::NameList attrs;
 	liveScene->attributeNames( attrs );
 	for ( SceneInterface::NameList::iterator it = attrs.begin(); it != attrs.end(); ++it )
 	{
-		outScene->writeAttribute( *it, liveScene->readAttribute( *it, time ), time );
 		if ( *it == LinkedScene::linkAttribute )
 		{
-			link = true;
+			if ( mode == ForcedExpand )
+			{
+				continue;
+			}
+			
+			mode = NaturalLink;
+		}
+		
+		outScene->writeAttribute( *it, liveScene->readAttribute( *it, time ), time );
+	}
+	
+	if ( mode == ForcedLink )
+	{
+		const SceneCacheNode<OP_Node> *sceneNode = static_cast< const SceneCacheNode<OP_Node>* >( hScene->node() );
+		if ( sceneNode )
+		{
+			ConstSceneInterfacePtr scene = sceneNode->scene();
+			if ( scene )
+			{
+				IECore::runTimeCast<LinkedScene>( outScene )->writeLink( scene );
+				return ROP_CONTINUE_RENDER;
+			}
 		}
 	}
 
-	// If this is a link, we exit now, since all other write calls will throw exceptions
-	if ( link )
+	if ( mode == NaturalLink )
 	{
 		return ROP_CONTINUE_RENDER;
 	}
@@ -243,3 +318,17 @@ ROP_RENDER_CODE ROP_SceneCacheWriter::doWrite( const SceneInterface *liveScene,
 
 	return ROP_CONTINUE_RENDER;
 }
+
+bool ROP_SceneCacheWriter::updateParmsFlags()
+{
+	UT_String value;
+	evalString( value, pFile.getToken(), 0, 0 );
+	std::string file = value.toStdString();
+	enableParm( pForceObjects.getToken(), linked( file ) );
+	return true;
+}
+
+bool ROP_SceneCacheWriter::linked( const std::string &file ) const
+{
+	return ( boost::filesystem::path( file ).extension().string() == ".lscc" );
+}

src/IECoreHoudini/SceneCacheNode.cpp

@@ -365,8 +365,13 @@ void SceneCacheNode<BaseType>::createMenu( PRM_Name *menu, const std::vector<std
 }
 
 template<typename BaseType>
-ConstSceneInterfacePtr SceneCacheNode<BaseType>::scene()
+ConstSceneInterfacePtr SceneCacheNode<BaseType>::scene() const
 {
+	if ( !this->hasParm( pFile.getToken() ) || !this->hasParm( pRoot.getToken() ) )
+	{
+		return 0;
+	}
+	
 	try
 	{
 		return this->scene( getFile(), getPath() );

test/IECoreHoudini/SceneCacheTest.py

@@ -1353,7 +1353,7 @@ def compareScene( self, a, b, time = 0, bakedObjects = [], parentTransform = Non
 				IECore.TransformOp()( input=ma, copyInput=False, matrix=IECore.M44dData( parentTransform ) )
 			self.assertEqual( ma, mb )
 
-		self.assertEqual( a.childNames(), b.childNames() )
+		self.assertEqual( sorted( a.childNames() ), sorted( b.childNames() ) )
 		for child in a.childNames() :
 			self.compareScene( a.child( child ), b.child( child ), time = time, bakedObjects = bakedObjects, parentTransform = parentTransform )
 
@@ -1582,6 +1582,93 @@ def testRopLinked( self ) :
 		xform.parm( "expand" ).pressButton()
 		self.assertEqual( xform.parm( "root" ).menuItems(), ( "/", "/1", "/1/2" ) )
 
+	def testRopForceObjects( self ) :
+		
+		s = self.writeSCC()
+		d = s.child( "1" ).createChild( "4" )
+		e = d.createChild( "5" )
+		box = IECore.MeshPrimitive.createBox(IECore.Box3f(IECore.V3f(0),IECore.V3f(1)))
+		d.writeObject( box, 0 )
+		e.writeObject( box, 0 )
+		
+		del s, d, e
+		
+		def testLinks( bakedObjects = None ) :
+			
+			if os.path.exists( TestSceneCache.__testLinkedOutFile ) :
+				os.remove( TestSceneCache.__testLinkedOutFile )
+			
+			rop.parm( "execute" ).pressButton()
+			self.assertEqual( rop.errors(), "" )
+			self.assertTrue( os.path.exists( TestSceneCache.__testLinkedOutFile ) )
+			linked = IECore.LinkedScene( TestSceneCache.__testLinkedOutFile, IECore.IndexedIO.OpenMode.Read )
+			if bakedObjects :
+				live = IECoreHoudini.HoudiniScene( xform.path(), rootPath = [ xform.name() ] )
+				self.compareScene( linked, live, bakedObjects = bakedObjects )
+			else :
+				orig = IECore.SceneCache( TestSceneCache.__testFile, IECore.IndexedIO.OpenMode.Read )
+				self.compareScene( orig, linked )
+			
+			# make sure the links are where we expect
+			unlinked = IECore.SceneCache( TestSceneCache.__testLinkedOutFile, IECore.IndexedIO.OpenMode.Read )
+			a = unlinked.child( "1" )
+			self.assertFalse( a.hasAttribute( IECore.LinkedScene.linkAttribute ) )
+			self.assertFalse( a.hasAttribute( IECore.LinkedScene.fileNameLinkAttribute ) )
+			self.assertFalse( a.hasAttribute( IECore.LinkedScene.rootLinkAttribute ) )
+			self.assertFalse( a.hasAttribute( IECore.LinkedScene.timeLinkAttribute ) )
+			b = a.child( "2" )
+			self.assertEqual( b.childNames(), [] )
+			self.assertFalse( b.hasAttribute( IECore.LinkedScene.linkAttribute ) )
+			self.assertTrue( b.hasAttribute( IECore.LinkedScene.fileNameLinkAttribute ) )
+			self.assertTrue( b.hasAttribute( IECore.LinkedScene.rootLinkAttribute ) )
+			self.assertFalse( b.hasAttribute( IECore.LinkedScene.timeLinkAttribute ) )
+			self.assertEqual( b.readAttribute( IECore.LinkedScene.fileNameLinkAttribute, 0 ), IECore.StringData( TestSceneCache.__testFile ) )
+			self.assertEqual( b.readAttribute( IECore.LinkedScene.rootLinkAttribute, 0 ), IECore.InternedStringVectorData( [ "1", "2" ] ) )
+			d = a.child( "4" )
+			self.assertFalse( d.hasAttribute( IECore.LinkedScene.linkAttribute ) )
+			self.assertFalse( d.hasAttribute( IECore.LinkedScene.fileNameLinkAttribute ) )
+			self.assertFalse( d.hasAttribute( IECore.LinkedScene.rootLinkAttribute ) )
+			self.assertFalse( d.hasAttribute( IECore.LinkedScene.timeLinkAttribute ) )
+		
+		# force b and below as links even though they are expanded
+		xform = self.xform()
+		xform.parm( "expand" ).pressButton()
+		rop = self.rop( xform )
+		rop.parm( "file" ).set( TestSceneCache.__testLinkedOutFile )
+		rop.parm( "forceObjects" ).set( "*4*" )
+		testLinks()
+		
+		# make sure parents expand if their child is forced
+		rop.parm( "forceObjects" ).set( "*5*" )
+		testLinks()
+		
+		# make sure normal geo gets expanded regardless
+		geo = xform.createNode( "geo", "real" )
+		geo.createNode( "box" )
+		testLinks( bakedObjects = [ "real" ] )
+		unlinked = IECore.SceneCache( TestSceneCache.__testLinkedOutFile, IECore.IndexedIO.OpenMode.Read )
+		real = unlinked.child( "real" )
+		self.assertFalse( real.hasAttribute( IECore.LinkedScene.linkAttribute ) )
+		self.assertFalse( real.hasAttribute( IECore.LinkedScene.fileNameLinkAttribute ) )
+		self.assertFalse( real.hasAttribute( IECore.LinkedScene.rootLinkAttribute ) )
+		self.assertFalse( real.hasAttribute( IECore.LinkedScene.timeLinkAttribute ) )
+		self.assertTrue( real.hasObject() )
+		geo.destroy()
+		
+		# make sure natural links (unexpanded branches) still work
+		hou.node( xform.path() + "/1/2" ).parm( "collapse" ).pressButton()
+		testLinks()
+		
+		# make sure normal SceneCaches aren't broken by forceObjects
+		rop.parm( "file" ).set( TestSceneCache.__testOutFile )
+		self.assertFalse( os.path.exists( TestSceneCache.__testOutFile ) )
+		rop.parm( "execute" ).pressButton()
+		self.assertEqual( rop.errors(), "" )
+		self.assertTrue( os.path.exists( TestSceneCache.__testOutFile ) )
+		orig = IECore.SceneCache( TestSceneCache.__testFile, IECore.IndexedIO.OpenMode.Read )
+		result = IECore.SceneCache( TestSceneCache.__testOutFile, IECore.IndexedIO.OpenMode.Read )
+		self.compareScene( orig, result )
+	
 	def testRopErrors( self ) :
 
 		xform = self.xform()