Merge pull request #155 from andrewkaufman/customAttributes

ldmoser · ldmoser · commit f334a2f20075 · 2013-10-22T17:26:20.000-07:00
Custom Attributes in Houdini
diff --git a/include/IECoreHoudini/HoudiniScene.h b/include/IECoreHoudini/HoudiniScene.h
@@ -117,13 +117,15 @@ class HoudiniScene : public IECore::SceneInterface
 		
 		typedef boost::function<bool (const OP_Node *)> HasFn;
 		typedef boost::function<IECore::ConstObjectPtr (const OP_Node *, double &)> ReadFn;
+		typedef boost::function<IECore::ConstObjectPtr (const OP_Node *, const Name &, double &)> ReadAttrFn;
 		typedef boost::function<bool (const OP_Node *, const Name &)> HasTagFn;
 		typedef boost::function<void (const OP_Node *, NameList &, bool)> ReadTagsFn;
+		typedef boost::function<void (const OP_Node *, NameList &)> ReadNamesFn;
 		
 		// Register callbacks for custom named attributes.
-		// The has function will be called during hasAttribute and it stops in the first one that returns true.
-		// The read method is called if the has method returns true, so it should return a valid Object pointer or raise an Exception.
-		static void registerCustomAttribute( const Name &attrName, HasFn hasFn, ReadFn readFn );
+		// The names function will be called during attributeNames and hasAttribute.
+		// The read method is called if the names method returns the expected attribute, so it should return a valid Object pointer or raise an Exception.
+		static void registerCustomAttributes( ReadNamesFn namesFn, ReadAttrFn readFn );
 		
 		// Register callbacks for nodes to define custom tags
 		// The functions will be called during hasTag and readTags.
@@ -152,10 +154,10 @@ class HoudiniScene : public IECore::SceneInterface
 		const char *contentPathValue() const;
 		
 		/// Struct for registering readers for custom Attributes.
-		struct CustomReader
+		struct CustomAttributeReader
 		{
-			HasFn m_has;
-			ReadFn m_read;
+			ReadNamesFn m_names;
+			ReadAttrFn m_read;
 		};
 		
 		/// Struct for registering readers for custom Tags.
@@ -165,7 +167,7 @@ class HoudiniScene : public IECore::SceneInterface
 			ReadTagsFn m_read;
 		};
 		
-		static std::map<Name, CustomReader> &customAttributeReaders();
+		static std::vector<CustomAttributeReader> &customAttributeReaders();
 		static std::vector<CustomTagReader> &customTagReaders();
 		
 		UT_String m_nodePath;
diff --git a/include/IECoreHoudini/OBJ_SceneCacheTransform.h b/include/IECoreHoudini/OBJ_SceneCacheTransform.h
@@ -132,8 +132,8 @@ class OBJ_SceneCacheTransform : public OBJ_SceneCacheNode<OBJ_SubNet>
 		};
 		static HoudiniSceneAddOn g_houdiniSceneAddOn;
 		
-		static bool hasLink( const OP_Node *node );
-		static IECore::ConstObjectPtr readLink( const OP_Node *node, double time );
+		static void attributeNames( const OP_Node *node, IECore::SceneInterface::NameList &attrs );
+		static IECore::ConstObjectPtr readAttribute( const OP_Node *node, const IECore::SceneInterface::Name &name, double time );
 		static bool hasTag( const OP_Node *node, const IECore::SceneInterface::Name &tag );
 		static void readTags( const OP_Node *node, IECore::SceneInterface::NameList &tags, bool includeChildren );
 		
diff --git a/src/IECoreHoudini/HoudiniScene.cpp b/src/IECoreHoudini/HoudiniScene.cpp
@@ -306,10 +306,17 @@ void HoudiniScene::writeTransform( const Data *transform, double time )
 
 bool HoudiniScene::hasAttribute( const Name &name ) const
 {
-	std::map<Name, CustomReader>::const_iterator it = customAttributeReaders().find( name );
-	if ( it != customAttributeReaders().end() )
+	OP_Node *node = retrieveNode();
+	
+	const std::vector<CustomAttributeReader> &attributeReaders = customAttributeReaders();
+	for ( std::vector<CustomAttributeReader>::const_iterator it = attributeReaders.begin(); it != attributeReaders.end(); ++it )
 	{
-		return it->second.m_has( retrieveNode() );
+		NameList names;
+		it->m_names( node, names );
+		if ( std::find( names.begin(), names.end(), name ) != names.end() )
+		{
+			return true;
+		}
 	}
 	
 	return false;
@@ -318,21 +325,29 @@ bool HoudiniScene::hasAttribute( const Name &name ) const
 void HoudiniScene::attributeNames( NameList &attrs ) const
 {
 	attrs.clear();
-	for ( std::map<Name, CustomReader>::const_iterator it = customAttributeReaders().begin(); it != customAttributeReaders().end(); ++it )
+	
+	OP_Node *node = retrieveNode();
+	
+	const std::vector<CustomAttributeReader> &attributeReaders = customAttributeReaders();
+	for ( std::vector<CustomAttributeReader>::const_iterator it = attributeReaders.begin(); it != attributeReaders.end(); ++it )
 	{
-		if ( it->second.m_has( retrieveNode() ) )
-		{
-			attrs.push_back( it->first );
-		}
+		NameList names;
+		it->m_names( node, names );
+		attrs.insert( attrs.end(), names.begin(), names.end() );
 	}
 }
 
 ConstObjectPtr HoudiniScene::readAttribute( const Name &name, double time ) const
 {
-	std::map<Name, CustomReader>::const_iterator it = customAttributeReaders().find( name );
-	if ( it != customAttributeReaders().end() )
+	OP_Node *node = retrieveNode();
+	
+	const std::vector<CustomAttributeReader> &attributeReaders = customAttributeReaders();
+	for ( std::vector<CustomAttributeReader>::const_iterator it = attributeReaders.begin(); it != attributeReaders.end(); ++it )
 	{
-		return it->second.m_read( retrieveNode(), time );
+		if ( IECore::ConstObjectPtr object = it->m_read( node, name, time ) )
+		{
+			return object;
+		}
 	}
 	
 	return 0;
@@ -999,17 +1014,17 @@ const char *HoudiniScene::contentPathValue() const
 	return name.c_str();
 }
 
-void HoudiniScene::registerCustomAttribute( const Name &attrName, HasFn hasFn, ReadFn readFn )
+void HoudiniScene::registerCustomAttributes( ReadNamesFn namesFn, ReadAttrFn readFn )
 {
-	CustomReader r;
-	r.m_has = hasFn;
+	CustomAttributeReader r;
+	r.m_names = namesFn;
 	r.m_read = readFn;
-	customAttributeReaders()[attrName] = r;
+	customAttributeReaders().push_back( r );
 }
 
-std::map<SceneInterface::Name, HoudiniScene::CustomReader> &HoudiniScene::customAttributeReaders()
+std::vector<HoudiniScene::CustomAttributeReader> &HoudiniScene::customAttributeReaders()
 {
-	static std::map<SceneInterface::Name, HoudiniScene::CustomReader> readers;
+	static std::vector<HoudiniScene::CustomAttributeReader> readers;
 	return readers;
 }
 
diff --git a/src/IECoreHoudini/OBJ_SceneCacheTransform.cpp b/src/IECoreHoudini/OBJ_SceneCacheTransform.cpp
@@ -422,28 +422,36 @@ OBJ_SceneCacheTransform::HoudiniSceneAddOn OBJ_SceneCacheTransform::g_houdiniSce
 
 OBJ_SceneCacheTransform::HoudiniSceneAddOn::HoudiniSceneAddOn()
 {
-	HoudiniScene::registerCustomAttribute( LinkedScene::linkAttribute, OBJ_SceneCacheTransform::hasLink, OBJ_SceneCacheTransform::readLink );
+	HoudiniScene::registerCustomAttributes( OBJ_SceneCacheTransform::attributeNames, OBJ_SceneCacheTransform::readAttribute );
 	HoudiniScene::registerCustomTags( OBJ_SceneCacheTransform::hasTag, OBJ_SceneCacheTransform::readTags );
 }
 
-bool OBJ_SceneCacheTransform::hasLink( const OP_Node *node )
+void OBJ_SceneCacheTransform::attributeNames( const OP_Node *node, SceneInterface::NameList &attrs )
 {
 	// make sure its a SceneCacheNode
 	if ( !node->hasParm( pFile.getToken() ) || !node->hasParm( pRoot.getToken() ) )
 	{
-		return false;
+		return;
+	}
+	
+	const SceneCacheNode<OP_Node> *sceneNode = reinterpret_cast< const SceneCacheNode<OP_Node>* >( node );
+	/// \todo: do we need to ensure the file exists first?
+	ConstSceneInterfacePtr scene = OBJ_SceneCacheTransform::scene( sceneNode->getFile(), sceneNode->getPath() );
+	if ( !scene )
+	{
+		return;
 	}
 	
+	scene->attributeNames( attrs );
+	
 	const char *expanded = pExpanded.getToken();
 	if ( node->hasParm( expanded ) && !node->evalInt( expanded, 0, 0 ) )
 	{
-		return true;
+		attrs.push_back( LinkedScene::linkAttribute );
 	}
-	
-	return false;
 }
 
-IECore::ConstObjectPtr OBJ_SceneCacheTransform::readLink( const OP_Node *node, double time )
+IECore::ConstObjectPtr OBJ_SceneCacheTransform::readAttribute( const OP_Node *node, const SceneInterface::Name &name, double time )
 {
 	// make sure its a SceneCacheNode
 	if ( !node->hasParm( pFile.getToken() ) || !node->hasParm( pRoot.getToken() ) )
@@ -459,7 +467,18 @@ IECore::ConstObjectPtr OBJ_SceneCacheTransform::readLink( const OP_Node *node, d
 		return 0;
 	}
 	
-	return LinkedScene::linkAttributeData( scene, time );
+	if ( name == LinkedScene::linkAttribute )
+	{
+		const char *expanded = pExpanded.getToken();
+		if ( node->hasParm( expanded ) && !node->evalInt( expanded, 0, 0 ) )
+		{
+			return LinkedScene::linkAttributeData( scene, time );
+		}
+		
+		return 0;
+	}
+	
+	return scene->readAttribute( name, time );
 }
 
 bool OBJ_SceneCacheTransform::hasTag( const OP_Node *node, const SceneInterface::Name &tag )
diff --git a/test/IECoreHoudini/SceneCacheTest.py b/test/IECoreHoudini/SceneCacheTest.py
@@ -1225,6 +1225,78 @@ def testLiveTags( self ) :
 			self.assertTrue( scene.hasTag( tag ) )
 		self.assertFalse( scene.hasTag( "notATag" ) )
 	
+	def writeAttributeSCC( self ) :
+		
+		scene = self.writeSCC()
+		sc1 = scene.child( str( 1 ) )
+		sc2 = sc1.child( str( 2 ) )
+		sc3 = sc2.child( str( 3 ) )
+		sc1.writeAttribute( "label", IECore.StringData( "a" ), 0 )
+		sc1.writeAttribute( "color", IECore.Color3dData( IECore.Color3d( 0.5 ) ), 0 )
+		sc2.writeAttribute( "label", IECore.StringData( "b" ), 0 )
+		sc2.writeAttribute( "material", IECore.StringData( "rubber" ), 0 )
+		sc3.writeAttribute( "label", IECore.StringData( "c" ), 0 )
+		sc3.writeAttribute( "animColor", IECore.Color3dData( IECore.Color3d( 0 ) ), 0 )
+		sc3.writeAttribute( "animColor", IECore.Color3dData( IECore.Color3d( 0.5 ) ), 0.5 )
+		sc3.writeAttribute( "animColor", IECore.Color3dData( IECore.Color3d( 1 ) ), 1 )
+		
+		return scene
+	
+	def testLiveAttributes( self ) :
+		
+		self.writeAttributeSCC()
+		
+		xform = self.xform()
+		xform.parm( "hierarchy" ).set( IECoreHoudini.SceneCacheNode.Hierarchy.SubNetworks )
+		xform.parm( "depth" ).set( IECoreHoudini.SceneCacheNode.Depth.AllDescendants )
+		
+		# its a link before it is expanded
+		scene = IECoreHoudini.HoudiniScene( xform.path() )
+		self.assertEqual( scene.attributeNames(), [ IECore.LinkedScene.linkAttribute ] )
+		self.assertTrue( scene.hasAttribute( IECore.LinkedScene.linkAttribute ) )
+		self.assertEqual(
+			scene.readAttribute( IECore.LinkedScene.linkAttribute, 0 ),
+			IECore.CompoundData( {
+				"time" : IECore.DoubleData( 0 ),
+				"fileName" : IECore.StringData( "test/test.scc" ),
+				"root" : IECore.InternedStringVectorData( [] )
+			} )
+		)
+		
+		# the link disapears once expanded
+		xform.parm( "expand" ).pressButton()
+		self.assertEqual( scene.attributeNames(), [] )
+		self.assertFalse( scene.hasAttribute( IECore.LinkedScene.linkAttribute ) )
+		self.assertEqual( scene.readAttribute( IECore.LinkedScene.linkAttribute, 0 ), None )
+		
+		# nodes expose their attributes
+		a = scene.child( "1" )
+		self.assertEqual( sorted(a.attributeNames()), [ "color", "label", "sceneInterface:animatedObjectPrimVars" ] )
+		for attr in a.attributeNames() :
+			self.assertTrue( a.hasAttribute( attr ) )
+		self.assertFalse( a.hasAttribute( "material" ) )
+		self.assertEqual( a.readAttribute( "label", 0 ), IECore.StringData( "a" ) )
+		self.assertEqual( a.readAttribute( "color", 0 ), IECore.Color3dData( IECore.Color3d( 0.5 ) ) )
+		
+		b = a.child( "2" )
+		self.assertEqual( sorted(b.attributeNames()), [ "label", "material", "sceneInterface:animatedObjectPrimVars" ] )
+		for attr in b.attributeNames() :
+			self.assertTrue( b.hasAttribute( attr ) )
+		self.assertFalse( b.hasAttribute( "color" ) )
+		self.assertEqual( b.readAttribute( "label", 0 ), IECore.StringData( "b" ) )
+		self.assertEqual( b.readAttribute( "material", 0 ), IECore.StringData( "rubber" ) )
+		
+		c = b.child( "3" )
+		self.assertEqual( sorted(c.attributeNames()), [ "animColor", "label", "sceneInterface:animatedObjectPrimVars" ] )
+		for attr in c.attributeNames() :
+			self.assertTrue( c.hasAttribute( attr ) )
+		self.assertFalse( c.hasAttribute( "color" ) )
+		self.assertFalse( c.hasAttribute( "material" ) )
+		self.assertEqual( c.readAttribute( "label", 0 ), IECore.StringData( "c" ) )
+		self.assertEqual( c.readAttribute( "animColor", 0 ), IECore.Color3dData( IECore.Color3d( 0 ) ) )
+		self.assertEqual( c.readAttribute( "animColor", 0.5 ), IECore.Color3dData( IECore.Color3d( 0.5 ) ) )
+		self.assertEqual( c.readAttribute( "animColor", 1 ), IECore.Color3dData( IECore.Color3d( 1 ) ) )
+	
 	def testReloadButton( self ) :
 		
 		def testNode( node ) :
@@ -1410,6 +1482,19 @@ def compareScene( self, a, b, time = 0, bakedObjects = [], parentTransform = Non
 			self.assertTrue( ab.min.equalWithAbsError( bb.min, 1e-6 ) )
 			self.assertTrue( ab.max.equalWithAbsError( bb.max, 1e-6 ) )
 		
+		aAttrs = a.attributeNames()
+		bAttrs = b.attributeNames()
+		# need to remove the animatedObjectPrimVars attribute since it doesn't exist in some circumstances
+		if "sceneInterface:animatedObjectPrimVars" in aAttrs :
+			aAttrs.remove( "sceneInterface:animatedObjectPrimVars" )
+		if "sceneInterface:animatedObjectPrimVars" in bAttrs :
+			bAttrs.remove( "sceneInterface:animatedObjectPrimVars" )
+		self.assertEqual( aAttrs, bAttrs )
+		for attr in aAttrs :
+			self.assertTrue( a.hasAttribute( attr ) )
+			self.assertTrue( b.hasAttribute( attr ) )
+			self.assertEqual( a.readAttribute( attr, time ), b.readAttribute( attr, time ) )
+		
 		self.assertEqual( a.hasObject(), b.hasObject() )
 		if a.hasObject() :
 			ma = a.readObject( time )
@@ -1654,7 +1739,7 @@ def testRopLinked( self ) :
 	
 	def testRopForceObjects( self ) :
 		
-		s = self.writeSCC()
+		s = self.writeAttributeSCC()
 		d = s.child( "1" ).createChild( "4" )
 		e = d.createChild( "5" )
 		box = IECore.MeshPrimitive.createBox(IECore.Box3f(IECore.V3f(0),IECore.V3f(1)))
@@ -1693,14 +1778,15 @@ def testLinks( bakedObjects = None ) :
 			self.assertTrue( b.hasAttribute( IECore.LinkedScene.rootLinkAttribute ) )
 			self.assertEqual( b.readAttribute( IECore.LinkedScene.fileNameLinkAttribute, 0 ), IECore.StringData( TestSceneCache.__testFile ) )
 			self.assertEqual( b.readAttribute( IECore.LinkedScene.rootLinkAttribute, 0 ), IECore.InternedStringVectorData( [ "1", "2" ] ) )
-			self.assertEqual( b.readAttribute( IECore.LinkedScene.timeLinkAttribute, 0 ), IECore.DoubleData( 1.0 / hou.fps() ) )
+			self.assertEqual( b.readAttribute( IECore.LinkedScene.timeLinkAttribute, 0 ), IECore.DoubleData( 0 ) )
 			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
+		hou.setTime( -1.0 / hou.fps() )
 		xform = self.xform()
 		xform.parm( "expand" ).pressButton()
 		rop = self.rop( xform )

Original file line number	Diff line number	Diff line change
`@@ -306,10 +306,17 @@ void HoudiniScene::writeTransform( const Data *transform, double time )`
`306`	`306`
`307`	`307`	`bool HoudiniScene::hasAttribute( const Name &name ) const`
`308`	`308`	`{`
`309`		`- std::map<Name, CustomReader>::const_iterator it = customAttributeReaders().find( name );`
`310`		`- if ( it != customAttributeReaders().end() )`
	`309`	`+ OP_Node *node = retrieveNode();`
	`310`	`+`
	`311`	`+ const std::vector<CustomAttributeReader> &attributeReaders = customAttributeReaders();`
	`312`	`+ for ( std::vector<CustomAttributeReader>::const_iterator it = attributeReaders.begin(); it != attributeReaders.end(); ++it )`
`311`	`313`	`{`
`312`		`- return it->second.m_has( retrieveNode() );`
	`314`	`+ NameList names;`
	`315`	`+ it->m_names( node, names );`
	`316`	`+ if ( std::find( names.begin(), names.end(), name ) != names.end() )`
	`317`	`+ {`
	`318`	`+ return true;`
	`319`	`+ }`
`313`	`320`	`}`
`314`	`321`
`315`	`322`	`return false;`
`@@ -318,21 +325,29 @@ bool HoudiniScene::hasAttribute( const Name &name ) const`
`318`	`325`	`void HoudiniScene::attributeNames( NameList &attrs ) const`
`319`	`326`	`{`
`320`	`327`	`attrs.clear();`
`321`		`- for ( std::map<Name, CustomReader>::const_iterator it = customAttributeReaders().begin(); it != customAttributeReaders().end(); ++it )`
	`328`	`+`
	`329`	`+ OP_Node *node = retrieveNode();`
	`330`	`+`
	`331`	`+ const std::vector<CustomAttributeReader> &attributeReaders = customAttributeReaders();`
	`332`	`+ for ( std::vector<CustomAttributeReader>::const_iterator it = attributeReaders.begin(); it != attributeReaders.end(); ++it )`
`322`	`333`	`{`
`323`		`- if ( it->second.m_has( retrieveNode() ) )`
`324`		`- {`
`325`		`- attrs.push_back( it->first );`
`326`		`- }`
	`334`	`+ NameList names;`
	`335`	`+ it->m_names( node, names );`
	`336`	`+ attrs.insert( attrs.end(), names.begin(), names.end() );`
`327`	`337`	`}`
`328`	`338`	`}`
`329`	`339`
`330`	`340`	`ConstObjectPtr HoudiniScene::readAttribute( const Name &name, double time ) const`
`331`	`341`	`{`
`332`		`- std::map<Name, CustomReader>::const_iterator it = customAttributeReaders().find( name );`
`333`		`- if ( it != customAttributeReaders().end() )`
	`342`	`+ OP_Node *node = retrieveNode();`
	`343`	`+`
	`344`	`+ const std::vector<CustomAttributeReader> &attributeReaders = customAttributeReaders();`
	`345`	`+ for ( std::vector<CustomAttributeReader>::const_iterator it = attributeReaders.begin(); it != attributeReaders.end(); ++it )`
`334`	`346`	`{`
`335`		`- return it->second.m_read( retrieveNode(), time );`
	`347`	`+ if ( IECore::ConstObjectPtr object = it->m_read( node, name, time ) )`
	`348`	`+ {`
	`349`	`+ return object;`
	`350`	`+ }`
`336`	`351`	`}`
`337`	`352`
`338`	`353`	`return 0;`
`@@ -999,17 +1014,17 @@ const char *HoudiniScene::contentPathValue() const`
`999`	`1014`	`return name.c_str();`
`1000`	`1015`	`}`
`1001`	`1016`
`1002`		`-void HoudiniScene::registerCustomAttribute( const Name &attrName, HasFn hasFn, ReadFn readFn )`
	`1017`	`+void HoudiniScene::registerCustomAttributes( ReadNamesFn namesFn, ReadAttrFn readFn )`
`1003`	`1018`	`{`
`1004`		`- CustomReader r;`
`1005`		`- r.m_has = hasFn;`
	`1019`	`+ CustomAttributeReader r;`
	`1020`	`+ r.m_names = namesFn;`
`1006`	`1021`	`r.m_read = readFn;`
`1007`		`- customAttributeReaders()[attrName] = r;`
	`1022`	`+ customAttributeReaders().push_back( r );`
`1008`	`1023`	`}`
`1009`	`1024`
`1010`		`-std::map<SceneInterface::Name, HoudiniScene::CustomReader> &HoudiniScene::customAttributeReaders()`
	`1025`	`+std::vector<HoudiniScene::CustomAttributeReader> &HoudiniScene::customAttributeReaders()`
`1011`	`1026`	`{`
`1012`		`- static std::map<SceneInterface::Name, HoudiniScene::CustomReader> readers;`
	`1027`	`+ static std::vector<HoudiniScene::CustomAttributeReader> readers;`
`1013`	`1028`	`return readers;`
`1014`	`1029`	`}`
`1015`	`1030`
Original file line number	Diff line number	Diff line change
`@@ -422,28 +422,36 @@ OBJ_SceneCacheTransform::HoudiniSceneAddOn OBJ_SceneCacheTransform::g_houdiniSce`
`422`	`422`
`423`	`423`	`OBJ_SceneCacheTransform::HoudiniSceneAddOn::HoudiniSceneAddOn()`
`424`	`424`	`{`
`425`		`- HoudiniScene::registerCustomAttribute( LinkedScene::linkAttribute, OBJ_SceneCacheTransform::hasLink, OBJ_SceneCacheTransform::readLink );`
	`425`	`+ HoudiniScene::registerCustomAttributes( OBJ_SceneCacheTransform::attributeNames, OBJ_SceneCacheTransform::readAttribute );`
`426`	`426`	`HoudiniScene::registerCustomTags( OBJ_SceneCacheTransform::hasTag, OBJ_SceneCacheTransform::readTags );`
`427`	`427`	`}`
`428`	`428`
`429`		`-bool OBJ_SceneCacheTransform::hasLink( const OP_Node *node )`
	`429`	`+void OBJ_SceneCacheTransform::attributeNames( const OP_Node *node, SceneInterface::NameList &attrs )`
`430`	`430`	`{`
`431`	`431`	`// make sure its a SceneCacheNode`
`432`	`432`	`if ( !node->hasParm( pFile.getToken() ) \|\| !node->hasParm( pRoot.getToken() ) )`
`433`	`433`	`{`
`434`		`- return false;`
	`434`	`+ return;`
	`435`	`+ }`
	`436`	`+`
	`437`	`+ const SceneCacheNode<OP_Node> sceneNode = reinterpret_cast< const SceneCacheNode<OP_Node> >( node );`
	`438`	`+ /// \todo: do we need to ensure the file exists first?`
	`439`	`+ ConstSceneInterfacePtr scene = OBJ_SceneCacheTransform::scene( sceneNode->getFile(), sceneNode->getPath() );`
	`440`	`+ if ( !scene )`
	`441`	`+ {`
	`442`	`+ return;`
`435`	`443`	`}`
`436`	`444`
	`445`	`+ scene->attributeNames( attrs );`
	`446`	`+`
`437`	`447`	`const char *expanded = pExpanded.getToken();`
`438`	`448`	`if ( node->hasParm( expanded ) && !node->evalInt( expanded, 0, 0 ) )`
`439`	`449`	`{`
`440`		`- return true;`
	`450`	`+ attrs.push_back( LinkedScene::linkAttribute );`
`441`	`451`	`}`
`442`		`-`
`443`		`- return false;`
`444`	`452`	`}`
`445`	`453`
`446`		`-IECore::ConstObjectPtr OBJ_SceneCacheTransform::readLink( const OP_Node *node, double time )`
	`454`	`+IECore::ConstObjectPtr OBJ_SceneCacheTransform::readAttribute( const OP_Node *node, const SceneInterface::Name &name, double time )`
`447`	`455`	`{`
`448`	`456`	`// make sure its a SceneCacheNode`
`449`	`457`	`if ( !node->hasParm( pFile.getToken() ) \|\| !node->hasParm( pRoot.getToken() ) )`
`@@ -459,7 +467,18 @@ IECore::ConstObjectPtr OBJ_SceneCacheTransform::readLink( const OP_Node *node, d`
`459`	`467`	`return 0;`
`460`	`468`	`}`
`461`	`469`
`462`		`- return LinkedScene::linkAttributeData( scene, time );`
	`470`	`+ if ( name == LinkedScene::linkAttribute )`
	`471`	`+ {`
	`472`	`+ const char *expanded = pExpanded.getToken();`
	`473`	`+ if ( node->hasParm( expanded ) && !node->evalInt( expanded, 0, 0 ) )`
	`474`	`+ {`
	`475`	`+ return LinkedScene::linkAttributeData( scene, time );`
	`476`	`+ }`
	`477`	`+`
	`478`	`+ return 0;`
	`479`	`+ }`
	`480`	`+`
	`481`	`+ return scene->readAttribute( name, time );`
`463`	`482`	`}`
`464`	`483`
`465`	`484`	`bool OBJ_SceneCacheTransform::hasTag( const OP_Node *node, const SceneInterface::Name &tag )`