LiveScene: Support for ParticleSprite as PointsPrimitive.

Author: lucienfostier

src/IECoreNuke/LiveScene.cpp

@@ -36,9 +36,11 @@
 
 #include "DDImage/Scene.h"
 #include "DDImage/Execute.h"
+#include "DDImage/ParticleOp.h"
 
 #include "IECoreNuke/Convert.h"
 #include "IECoreNuke/MeshFromNuke.h"
+#include "IECoreNuke/FromNukePointsConverter.h"
 
 #include "IECore/Exception.h"
 #include "IECore/NullObject.h"
@@ -204,7 +206,6 @@ unsigned LiveScene::objects( const double* time) const
 	{
 		frame = m_op->outputContext().frame();
 	}
-	
 	cacheGeometryList( frame );
 
 	DD::Image::Hash h;
@@ -246,7 +247,6 @@ DD::Image::GeoInfo* LiveScene::object( const unsigned& index, const double* time
 	{
 		frame = m_op->outputContext().frame();
 	}
-	
 	cacheGeometryList( frame );
 
 	DD::Image::Hash h;
@@ -305,13 +305,18 @@ DD::Image::GeometryList LiveScene::geometryList( const double& frame ) const
 {
 	// Nuke Geometry API is not thread safe so we need to use a mutex here to avoid crashes.
 	tbb::recursive_mutex::scoped_lock l( g_mutex );
-	auto result = geometryList( m_op, frame );
+	DD::Image::GeometryList result;
 
-	if ( !result.objects() && m_op->input( 0 ) )
+	if( m_op->input0() && m_op->input0()->particleOp() )
 	{
 		auto particleToGeo = Op::create( "ParticleToGeo", m_op );
+		particleToGeo->set_input( 0, m_op->input0() );
 		result = geometryList( particleToGeo, frame );
 	}
+	else
+	{
+		result = geometryList( m_op, frame );
+	}
 
 	return result;
 }
@@ -388,7 +393,6 @@ void LiveScene::writeBound( const Imath::Box3d &bound, double time )
 
 ConstDataPtr LiveScene::readTransform( double time ) const
 {
-	
 	for( unsigned i=0; i < objects( &time ); ++i )
 	{
 		auto nameValue = geoInfoPath( i );
@@ -487,15 +491,27 @@ bool LiveScene::hasObject() const
 
 ConstObjectPtr LiveScene::readObject( double time, const IECore::Canceller *canceller) const
 {
-	for( unsigned i=0; i < geometryList().objects(); ++i )
+	for( unsigned i=0; i < objects(); ++i )
 	{
 		auto nameValue = geoInfoPath( i );
 		auto result = m_pathMatcher.match( nameValue );
 		if ( result == IECore::PathMatcher::ExactMatch )
 		{
-			auto geoInfo = geometryList( &time ).object( i );
-			MeshFromNukePtr converter = new IECoreNuke::MeshFromNuke( &geoInfo );
-			return converter->convert();
+			auto geoInfo = object( i, &time );
+			if ( !geoInfo )
+			{
+				return IECore::NullObject::defaultNullObject();
+			}
+			if ( geoInfo->primitives() == 1 && ( geoInfo->primitive( 0 )->getPrimitiveType() == DD::Image::PrimitiveType::eParticlesSprite ) )
+			{
+				auto converter = new IECoreNuke::FromNukePointsConverter( geoInfo, m_op->input0() );
+				return converter->convert();
+			}
+			else
+			{
+				MeshFromNukePtr converter = new IECoreNuke::MeshFromNuke( geoInfo );
+				return converter->convert();
+			}
 		}
 	}
 
@@ -514,7 +530,6 @@ void LiveScene::writeObject( const Object *object, double time )
 
 void LiveScene::childNames( NameList &childNames ) const
 {
-
 	childNames.clear();
 	std::vector<std::string> allPaths;
 

test/IECoreNuke/SceneCacheWriterTest.py

@@ -61,6 +61,20 @@ def temporaryDirectory( self ) :
 
 		return self.__temporaryDirectory
 
+	def testWriteEmptyScene( self ):
+
+		outputFile = os.path.join( self.temporaryDirectory(), "empty.scc" )
+
+		writer = nuke.createNode( "WriteGeo" )
+		writer["file"].fromScript( outputFile )
+
+		nuke.execute( writer, 1001, 1001 )
+
+		self.assertTrue( os.path.exists( outputFile ) )
+
+		scene = IECoreScene.SharedSceneInterfaces.get( outputFile )
+		self.assertEqual( scene.childNames(), [] )
+
 	def testWriteSimpleSphere( self ):
 
 		outputFile = os.path.join( self.temporaryDirectory(), "sphere.scc" )
@@ -88,7 +102,6 @@ def testWriteSimpleSphere( self ):
 
 		self.assertEqual( mesh.topologyHash(), liveSceneMesh.topologyHash() )
 
-
 	def testWriteSceneCacheReader( self ):
 		import random
 		import IECoreScene
@@ -121,6 +134,49 @@ def testWriteSceneCacheReader( self ):
 				pointIndex = random.choice( range( len( mesh["P"].data ) ) )
 				self.assertAlmostEqual( mesh["P"].data[pointIndex], expectedMesh["P"].data[pointIndex], 4 )
 
+	def testWriteParticle( self ):
+
+		outputFile = os.path.join( self.temporaryDirectory(), "particle.scc" )
+
+		noise = nuke.createNode( "Noise")
+		card = nuke.createNode( "Card2" )
+		card.setInput( 0, noise )
+		particle = nuke.createNode( "ParticleEmitter" )
+		particle.setInput( 1, card )
+		particle["size_variation"].setValue( 2 )
+		particle["color_from_texture"].setValue( True )
+		particle["spread"].setValue( .3 )
+		writer = nuke.createNode( "WriteGeo" )
+		writer["file"].fromScript( outputFile )
+
+		nuke.execute( writer, 0, 24 )
+
+		self.assertTrue( os.path.exists( outputFile ) )
+
+		scene = IECoreScene.SharedSceneInterfaces.get( outputFile )
+
+		self.assertEqual( scene.childNames(), ["object0"] )
+
+		pointsPrim = scene.scene( ["object0",] ).readObject( 1 )
+		self.assertEqual( set( pointsPrim.keys() ), set( ["Cs", "P", "pid", "width", "velocity", "alpha"] ) )
+
+		self.assertEqual( pointsPrim.numPoints, 100 )
+		self.assertEqual( scene.scene( ["object0",] ).readObject( 0.04 ).numPoints, 10 )
+		self.assertEqual( scene.scene( ["object0",] ).readObject( 0.5 ).numPoints, 100 )
+
+		self.assertAlmostEqual( pointsPrim["P"].data[12], imath.V3f(-0.559, 1.797, 1.677), delta=.015 )
+		self.assertAlmostEqual( pointsPrim["Cs"].data[21], imath.Color4f(0.241325, 0.241325, 0.241325, 1), delta=.015 )
+		self.assertAlmostEqual( pointsPrim["alpha"].data[72], 1.0, delta=.015 )
+		self.assertAlmostEqual( pointsPrim["width"].data[99], .105, delta=.015 )
+		self.assertAlmostEqual( pointsPrim["pid"].data[92], 197, delta=.015 )
+		self.assertAlmostEqual( pointsPrim["velocity"].data[72], imath.V3f(-18.424, 4.602, 14.675), delta=.015 )
+
+	def assertAlmostEqual( self, left, right, delta=None ):
+		if isinstance( left, ( imath.V3f, imath.Color3f, imath.Color4f ) ):
+			for index, _ in enumerate( left ):
+				super( SceneCacheWriterTest, self ).assertAlmostEqual( left[index], right[index], delta=delta )
+		else:
+			super( SceneCacheWriterTest, self ).assertAlmostEqual( left, right, delta=delta )
 
 if __name__ == "__main__":
 	unittest.main()