small SceneReader/writer updates, + a branch in SceneProcedural that renders VisibleRenderables

Changes

@@ -1,3 +1,5 @@
+* SceneProcedural now renders general VisibleRenderables too...
+
 * Added base classes Executable and Despatcher and two derived Node classes: ExecutableNode and ExecutableOpHolder.
 
 * Added an enabled/disabled plug to all SceneNodes. Nodes with no inputs output an empty scene when disabled, and SceneProcessors output the first input unchanged. The enabled/disabled state can be toggled using the node right click menu or the "d" hotkey in the Graph Editor.

include/GafferScene/SceneReader.h

@@ -51,6 +51,7 @@ class SceneReader : public FileSource
 		virtual ~SceneReader();
 
 		IE_CORE_DECLARERUNTIMETYPEDEXTENSION( SceneReader, SceneReaderTypeId, FileSource )
+
 
 	protected :
 
@@ -72,6 +73,7 @@ class SceneReader : public FileSource
 		class Cache;
 		static Cache &cache();
 
+		static const double g_frameRate;
 };
 
 } // namespace GafferScene

include/GafferScene/SceneWriter.h

@@ -70,7 +70,8 @@ class SceneWriter : public Gaffer::Node
 		void writeLocation( GafferScene::ScenePlug *scenePlug, const ScenePlug::ScenePath &scenePath, IECore::SceneInterface *output );
 
 		static size_t g_firstPlugIndex;
-
+
+		static const double g_frameRate;
 };
 
 } // namespace GafferScene

python/GafferSceneTest/SceneReadWriteTest.py

@@ -212,18 +212,18 @@ def writeAnimatedSCC( self ) :
 		sc3.writeObject( mesh, time )
 		sc3.writeTransform( IECore.M44dData(), time )
 
-		for time in [ 0.5, 1, 1.5, 2, 5, 10 ] :
+		for frame in [ 0.5, 1, 1.5, 2, 5, 10 ] :
 
-			matrix = IECore.M44d.createTranslated( IECore.V3d( 1, time, 0 ) )
-			sc1.writeTransform( IECore.M44dData( matrix ), time )
+			matrix = IECore.M44d.createTranslated( IECore.V3d( 1, frame, 0 ) )
+			sc1.writeTransform( IECore.M44dData( matrix ), float( frame ) / 24 )
 
-			mesh["Cd"] = IECore.PrimitiveVariable( IECore.PrimitiveVariable.Interpolation.Uniform, IECore.V3fVectorData( [ IECore.V3f( time, 1, 0 ) ] * 6 ) )
-			sc2.writeObject( mesh, time )
-			matrix = IECore.M44d.createTranslated( IECore.V3d( 2, time, 0 ) )
-			sc2.writeTransform( IECore.M44dData( matrix ), time )
+			mesh["Cd"] = IECore.PrimitiveVariable( IECore.PrimitiveVariable.Interpolation.Uniform, IECore.V3fVectorData( [ IECore.V3f( frame, 1, 0 ) ] * 6 ) )
+			sc2.writeObject( mesh, float( frame ) / 24 )
+			matrix = IECore.M44d.createTranslated( IECore.V3d( 2, frame, 0 ) )
+			sc2.writeTransform( IECore.M44dData( matrix ), float( frame ) / 24 )
 
-			matrix = IECore.M44d.createTranslated( IECore.V3d( 3, time, 0 ) )
-			sc3.writeTransform( IECore.M44dData( matrix ), time )
+			matrix = IECore.M44d.createTranslated( IECore.V3d( 3, frame, 0 ) )
+			sc3.writeTransform( IECore.M44dData( matrix ), float( frame ) / 24 )
 
 	def testAnimatedScene( self ) :
 

src/GafferScene/SceneProcedural.cpp

@@ -277,6 +277,11 @@ void SceneProcedural::render( RendererPtr renderer ) const
 					}
 					break; // no motion blur for these chappies.
 				}
+				else if( const VisibleRenderable* renderable = runTimeCast< const VisibleRenderable >( object.get() ) )
+				{
+					renderable->render( renderer );
+					break; // no motion blur for these chappies.
+				}
 
 			}
 		}

src/GafferScene/SceneReader.cpp

@@ -41,7 +41,9 @@
 #include "IECore/FileIndexedIO.h"
 #include "IECore/LRUCache.h"
 #include "IECore/SceneInterface.h"
+#include "IECore/SharedSceneInterfaces.h"
 #include "IECore/InternedString.h"
+#include "IECore/SceneCache.h"
 
 #include "Gaffer/Context.h"
 #include "GafferScene/SceneReader.h"
@@ -53,96 +55,13 @@ using namespace GafferScene;
 
 IE_CORE_DEFINERUNTIMETYPED( SceneReader );
 
-//////////////////////////////////////////////////////////////////////////
-// SceneReader::Cache Implementation
-//////////////////////////////////////////////////////////////////////////
-
-class SceneReader::Cache
-{
-
-	private :
-
-		IE_CORE_FORWARDDECLARE( FileAndMutex )
-
-	public :
-
-		Cache()
-			:	m_fileCache( fileCacheGetter, 200 )
-		{
-		};
-
-		/// This class provides access to a particular location within
-		/// the SceneInterface, and ensures that access is threadsafe by holding
-		/// a mutex on the file.
-		class Entry : public IECore::RefCounted
-		{
-
-			public :
-
-				SceneInterface *sceneInterface()
-				{
-					return m_entry;
-				}
-
-			private :
-
-				Entry( FileAndMutexPtr fileAndMutex )
-					:	m_fileAndMutex( fileAndMutex ), m_lock( m_fileAndMutex->mutex )
-				{
-				}
-
-				FileAndMutexPtr m_fileAndMutex;
-				tbb::mutex::scoped_lock m_lock;
-				SceneInterfacePtr m_entry;
-
-				friend class Cache;
-
-		};
-
-		IE_CORE_DECLAREPTR( Entry )
-
-		EntryPtr entry( const std::string &fileName, const ScenePath &scenePath )
-		{
-			FileAndMutexPtr f = m_fileCache.get( fileName );
-			EntryPtr result = new Entry( f ); // this locks the mutex for us
-			result->m_entry = result->m_fileAndMutex->file->scene( scenePath );
-			return result;
-		}
-
-		void clear()
-		{
-			m_fileCache.clear();
-		}
-
-	private :
-
-		class FileAndMutex : public IECore::RefCounted
-		{
-			public :
-
-				typedef tbb::mutex Mutex;
-				Mutex mutex;
-				SceneInterfacePtr file;
-
-		};
-
-		static FileAndMutexPtr fileCacheGetter( const std::string &fileName, size_t &cost )
-		{
-			FileAndMutexPtr result = new FileAndMutex;
-			result->file = SceneInterface::create( fileName, IndexedIO::Read );
-			cost = 1;
-			return result;
-		}
-
-		typedef LRUCache<std::string, FileAndMutexPtr> FileCache;
-		FileCache m_fileCache;
-
-};
-
 //////////////////////////////////////////////////////////////////////////
 // SceneReader implementation
 //////////////////////////////////////////////////////////////////////////
 
+/// \todo hard coded framerate should be replaced with a getTime() method on Gaffer::Context or something
+const double SceneReader::g_frameRate( 24 );
+
 SceneReader::SceneReader( const std::string &name )
 	:	FileSource( name )
 {
@@ -161,8 +80,10 @@ Imath::Box3f SceneReader::computeBound( const ScenePath &path, const Gaffer::Con
 		return Box3f();
 	}
 
-	Cache::EntryPtr entry = cache().entry( fileName, path );
-	Box3d b = entry->sceneInterface()->readBound( context->getFrame() );
+	ConstSceneInterfacePtr s = SharedSceneInterfaces::get( fileName );
+	s = s->scene( path );
+
+	Box3d b = s->readBound( context->getFrame() / g_frameRate );
 
 	if( b.isEmpty() )
 	{
@@ -180,8 +101,10 @@ Imath::M44f SceneReader::computeTransform( const ScenePath &path, const Gaffer::
 		return M44f();
 	}
 
-	Cache::EntryPtr entry = cache().entry( fileName, path );
-	M44d t = entry->sceneInterface()->readTransformAsMatrix( context->getFrame() );
+	ConstSceneInterfacePtr s = SharedSceneInterfaces::get( fileName );
+	s = s->scene( path );
+
+	M44d t = s->readTransformAsMatrix( context->getFrame() / g_frameRate );
 
 	return M44f(
 		t[0][0], t[0][1], t[0][2], t[0][3],
@@ -199,16 +122,28 @@ IECore::ConstCompoundObjectPtr SceneReader::computeAttributes( const ScenePath &
 		return parent->attributesPlug()->defaultValue();
 	}
 
-	Cache::EntryPtr entry = cache().entry( fileName, path );
+
+	ConstSceneInterfacePtr s = SharedSceneInterfaces::get( fileName );
+	s = s->scene( path );
 
 	SceneInterface::NameList nameList;
-	entry->sceneInterface()->readAttributeNames( nameList );
+	s->readAttributeNames( nameList );
 
 	CompoundObjectPtr result = new CompoundObject;
 
 	for( SceneInterface::NameList::iterator it = nameList.begin(); it != nameList.end(); ++it )
 	{
-		result->members()[ std::string( *it ) ] = entry->sceneInterface()->readAttribute( *it, context->getFrame() );
+		// these internal attributes should be ignored:
+		if( *it == SceneCache::animatedObjectTopologyAttribute )
+		{
+			continue;
+		}
+		if( *it == SceneCache::animatedObjectPrimVarsAttribute )
+		{
+			continue;
+		}
+
+		result->members()[ std::string( *it ) ] = s->readAttribute( *it, context->getFrame() / g_frameRate );
 	}
 
 	return result;
@@ -222,12 +157,14 @@ IECore::ConstObjectPtr SceneReader::computeObject( const ScenePath &path, const
 		return parent->objectPlug()->defaultValue();
 	}
 
-	Cache::EntryPtr entry = cache().entry( fileName, path );
+	ConstSceneInterfacePtr s = SharedSceneInterfaces::get( fileName );
+	s = s->scene( path );
+
 	ObjectPtr o;
 
-	if( entry->sceneInterface()->hasObject() )
+	if( s->hasObject() )
 	{
-		ObjectPtr o = entry->sceneInterface()->readObject( context->getFrame() );
+		ObjectPtr o = s->readObject( context->getFrame() / g_frameRate );
 
 		return o? o : parent->objectPlug()->defaultValue();
 	}
@@ -243,10 +180,11 @@ IECore::ConstInternedStringVectorDataPtr SceneReader::computeChildNames( const S
 		return parent->childNamesPlug()->defaultValue();
 	}
 
-	Cache::EntryPtr entry = cache().entry( fileName, path );
+	ConstSceneInterfacePtr s = SharedSceneInterfaces::get( fileName );
+	s = s->scene( path );
 
 	InternedStringVectorDataPtr result = new InternedStringVectorData;
-	entry->sceneInterface()->childNames( result->writable() );
+	s->childNames( result->writable() );
 
 	return result;
 }
@@ -256,12 +194,6 @@ IECore::ConstCompoundObjectPtr SceneReader::computeGlobals( const Gaffer::Contex
 	return parent->globalsPlug()->defaultValue();
 }
 
-SceneReader::Cache &SceneReader::cache()
-{
-	static Cache c;
-	return c;
-}
-
 void SceneReader::plugSet( Gaffer::Plug *plug )
 {
 	// this clears the cache every time the refresh count is updated, so you don't get entries
@@ -270,13 +202,13 @@ void SceneReader::plugSet( Gaffer::Plug *plug )
 	// way of doing this!
 	if( plug == refreshCountPlug() )
 	{
-		cache().clear();
+		SharedSceneInterfaces::clear();
 	}
 }
 
 /// \todo this hash needs to be smarter - it should detect if the scene cache is animated or not
 void SceneReader::hash( const Gaffer::ValuePlug *output, const Gaffer::Context *context, IECore::MurmurHash &h ) const
 {
 	FileSource::hash( output, context, h );
-	h.append( context->getFrame() );
+	h.append( context->getFrame() / g_frameRate );
 }

src/GafferScene/SceneWriter.cpp

@@ -35,6 +35,7 @@
 //////////////////////////////////////////////////////////////////////////
 
 #include "GafferScene/SceneWriter.h"
+#include "GafferScene/SceneReader.h"
 #include "Gaffer/Context.h"
 #include "Gaffer/ScriptNode.h"
 
@@ -48,6 +49,9 @@ using namespace GafferScene;
 
 IE_CORE_DEFINERUNTIMETYPED( SceneWriter );
 
+/// \todo hard coded framerate should be replaced with a getTime() method on Gaffer::Context or something
+const double SceneWriter::g_frameRate( 24 );
+
 size_t SceneWriter::g_firstPlugIndex = 0;
 
 SceneWriter::SceneWriter( const std::string &name )
@@ -101,25 +105,25 @@ void SceneWriter::writeLocation( GafferScene::ScenePlug *scenePlug, const SceneP
 	ConstCompoundObjectPtr attributes = scenePlug->attributesPlug()->getValue();
 	for( CompoundObject::ObjectMap::const_iterator it = attributes->members().begin(), eIt = attributes->members().end(); it != eIt; it++ )
 	{
-		output->writeAttribute( it->first, it->second.get(), script->context()->getFrame() );
+		output->writeAttribute( it->first, it->second.get(), script->context()->getFrame() / g_frameRate );
 	}
 
 	if( scenePath.empty() )
 	{
 		ConstCompoundObjectPtr globals = scenePlug->globalsPlug()->getValue();
-		output->writeAttribute( "gaffer:globals", globals, script->context()->getFrame() );
+		output->writeAttribute( "gaffer:globals", globals, script->context()->getFrame() / g_frameRate );
 	}
 
 	ConstObjectPtr object = scenePlug->objectPlug()->getValue();
 
 	if( object->typeId() != IECore::NullObjectTypeId && scenePath.size() > 0 )
 	{
-		output->writeObject( object, script->context()->getFrame() );
+		output->writeObject( object, script->context()->getFrame() / g_frameRate );
 	}
 
 	Imath::Box3f b = scenePlug->boundPlug()->getValue();
 
-	output->writeBound( Imath::Box3d( Imath::V3f( b.min ), Imath::V3f( b.max ) ), script->context()->getFrame() );
+	output->writeBound( Imath::Box3d( Imath::V3f( b.min ), Imath::V3f( b.max ) ), script->context()->getFrame() / g_frameRate );
 
 	if( scenePath.size() )
 	{
@@ -131,7 +135,7 @@ void SceneWriter::writeLocation( GafferScene::ScenePlug *scenePlug, const SceneP
 			t[3][0], t[3][1], t[3][2], t[3][3]
 		);
 
-		output->writeTransform( new IECore::M44dData( transform ), script->context()->getFrame() );
+		output->writeTransform( new IECore::M44dData( transform ), script->context()->getFrame() / g_frameRate );
 	}
 
 	ConstInternedStringVectorDataPtr childNames = scenePlug->childNamesPlug()->getValue();