Cortex 9, Arnold 5, exploratory PR

SConstruct

@@ -3101,7 +3101,7 @@ if doConfigure :
 		arnoldTestEnv["ENV"]["ARNOLD_PLUGIN_PATH"] = "contrib/IECoreArnold/test/IECoreArnold/plugins"
 		arnoldTest = arnoldTestEnv.Command( "contrib/IECoreArnold/test/IECoreArnold/results.txt", arnoldPythonModule, pythonExecutable + " $TEST_ARNOLD_SCRIPT" )
 		NoCache( arnoldTest )
-		arnoldTestEnv.Depends( arnoldTest, [ arnoldPythonModule + arnoldProceduralForTest + arnoldDriverForTest ] )
+		arnoldTestEnv.Depends( arnoldTest, [ arnoldPythonModule + arnoldProceduralForTest + arnoldDriverForTest + arnoldLibrary ] )
 		arnoldTestEnv.Depends( arnoldTest, glob.glob( "contrib/IECoreArnold/test/IECoreArnold/*.py" ) )
 		arnoldTestEnv.Alias( "testArnold", arnoldTest )
 

config/ie/options

@@ -387,7 +387,7 @@ HDF5_LIB_PATH = os.path.join( "/software/apps/hdf5", hdf5Version, platform, comp
 DOXYGEN = os.path.join( "/software/apps/doxygen", os.environ["DOXYGEN_VERSION"], platform, "bin", "doxygen" )
 
 # import vars we need to get our doxygen and python wrappers working
-ENV_VARS_TO_IMPORT="PATH COMPILER COMPILER_VERSION PYTHONPATH IEENV_ROOT IEENV_WORKING_PATH IEENV_LIBRARY_PREFIX_PATH DOXYGEN_VERSION IEENV_DEBUG IEENV_DEBUG_PYTHON IEENV_DEBUGGER IEENV_DEBUGGER_ARGS DELIGHT_CONF SCONS_VERSION DL_VERSION DL_SHADERS_PATH DL_DISPLAYS_PATH"
+ENV_VARS_TO_IMPORT="PATH COMPILER COMPILER_VERSION PYTHONPATH IEENV_ROOT IEENV_WORKING_PATH IEENV_LIBRARY_PREFIX_PATH DOXYGEN_VERSION IEENV_DEBUG IEENV_DEBUG_PYTHON IEENV_DEBUGGER IEENV_DEBUGGER_ARGS DELIGHT_CONF SCONS_VERSION DL_VERSION DL_SHADERS_PATH DL_DISPLAYS_PATH solidangle_LICENSE"
 
 # make sure the tests can run
 testLibs = [ pythonReg["location"] + "/" + compiler + "/" + compilerVersion + "/lib", compilerReg["location"] + "/lib" ]

contrib/IECoreArnold/include/IECoreArnold/CurvesAlgo.h

@@ -46,7 +46,7 @@ namespace CurvesAlgo
 {
 
 AtNode *convert( const IECore::CurvesPrimitive *curves );
-AtNode *convert( const std::vector<const IECore::CurvesPrimitive *> &samples, const std::vector<float> &sampleTimes );
+AtNode *convert( const std::vector<const IECore::CurvesPrimitive *> &samples, float motionStart, float motionEnd );
 
 } // namespace CurvesAlgo
 

contrib/IECoreArnold/include/IECoreArnold/InstancingConverter.h

@@ -72,8 +72,8 @@ class IECOREARNOLD_API InstancingConverter : public IECore::RefCounted
 		AtNode *convert( const IECore::Primitive *primitive, const IECore::MurmurHash &additionalHash );
 
 		/// Motion blurred versions of the above conversion functions.
-		AtNode *convert( const std::vector<const IECore::Primitive *> &samples, const std::vector<float> &sampleTimes );
-		AtNode *convert( const std::vector<const IECore::Primitive *> &samples, const std::vector<float> &sampleTimes, const IECore::MurmurHash &additionalHash );
+		AtNode *convert( const std::vector<const IECore::Primitive *> &samples, float motionStart, float motionEnd );
+		AtNode *convert( const std::vector<const IECore::Primitive *> &samples, float motionStart, float motionEnd, const IECore::MurmurHash &additionalHash );
 
 	private :
 

contrib/IECoreArnold/include/IECoreArnold/MeshAlgo.h

@@ -46,7 +46,7 @@ namespace MeshAlgo
 {
 
 AtNode *convert( const IECore::MeshPrimitive *mesh );
-AtNode *convert( const std::vector<const IECore::MeshPrimitive *> &samples, const std::vector<float> &sampleTimes );
+AtNode *convert( const std::vector<const IECore::MeshPrimitive *> &samples, float motionStart, float motionEnd );
 
 } // namespace MeshAlgo
 

contrib/IECoreArnold/include/IECoreArnold/NodeAlgo.h

@@ -53,14 +53,14 @@ AtNode *convert( const IECore::Object *object );
 /// equivalent moving Arnold object. If no motion converter
 /// is available, then returns a standard conversion of the
 /// first sample.
-AtNode *convert( const std::vector<const IECore::Object *> &samples, const std::vector<float> &sampleTimes );
+AtNode *convert( const std::vector<const IECore::Object *> &samples, float motionStart, float motionEnd );
 
 /// Signature of a function which can convert an IECore::Object
 /// into an Arnold object.
 typedef AtNode * (*Converter)( const IECore::Object * );
 /// Signature of a function which can convert a series of IECore::Object
 /// samples into a moving Arnold object.
-typedef AtNode * (*MotionConverter)( const std::vector<const IECore::Object *> &samples, const std::vector<float> &sampleTimes );
+typedef AtNode * (*MotionConverter)( const std::vector<const IECore::Object *> &samples, float motionStart, float motionEnd );
 
 /// Registers a converter for a specific type.
 /// Use the ConverterDescription utility class in preference to
@@ -77,7 +77,7 @@ class ConverterDescription
 
 		/// Type-specific conversion functions.
 		typedef AtNode *(*Converter)( const T * );
-		typedef AtNode *(*MotionConverter)( const std::vector<const T *> &, const std::vector<float> & );
+		typedef AtNode *(*MotionConverter)( const std::vector<const T *> &, float, float );
 
 		ConverterDescription( Converter converter, MotionConverter motionConverter = NULL )
 		{
@@ -90,6 +90,11 @@ class ConverterDescription
 
 };
 
+/// Arnold does not support non-uniform sampling.  It just takes a start and end time, and assume
+/// the samples are distributed evenly between them.  We need to throw an exception if given data
+/// we can't render.
+void ensureUniformTimeSamples( const std::vector<float> &times );
+
 } // namespace NodeAlgo
 
 } // namespace IECoreArnold

contrib/IECoreArnold/include/IECoreArnold/ParameterAlgo.h

@@ -49,11 +49,13 @@ namespace ParameterAlgo
 {
 
 IECOREARNOLD_API void setParameter( AtNode *node, const AtParamEntry *parameter, const IECore::Data *value );
+IECOREARNOLD_API void setParameter( AtNode *node, AtString name, const IECore::Data *value );
 IECOREARNOLD_API void setParameter( AtNode *node, const char *name, const IECore::Data *value );
 IECOREARNOLD_API void setParameters( AtNode *node, const IECore::CompoundDataMap &values );
 
 IECOREARNOLD_API IECore::DataPtr getParameter( AtNode *node, const AtParamEntry *parameter );
 IECOREARNOLD_API IECore::DataPtr getParameter( AtNode *node, const AtUserParamEntry *parameter );
+IECOREARNOLD_API IECore::DataPtr getParameter( AtNode *node, AtString name );
 IECOREARNOLD_API IECore::DataPtr getParameter( AtNode *node, const char *name );
 IECOREARNOLD_API void getParameters( AtNode *node, IECore::CompoundDataMap &values );
 

contrib/IECoreArnold/include/IECoreArnold/PointsAlgo.h

@@ -46,7 +46,7 @@ namespace PointsAlgo
 {
 
 AtNode *convert( const IECore::PointsPrimitive *points );
-AtNode *convert( const std::vector<const IECore::PointsPrimitive *> &samples, const std::vector<float> &sampleTimes );
+AtNode *convert( const std::vector<const IECore::PointsPrimitive *> &samples, float motionStart, float motionEnd );
 
 } // namespace PointsAlgo
 

contrib/IECoreArnold/include/IECoreArnold/Renderer.h

@@ -95,10 +95,12 @@ class IECOREARNOLD_API Renderer : public IECore::Renderer
 		///
 		/// \li <b>"ai:visibility:camera" BoolData( true )</b>
 		/// \li <b>"ai:visibility:shadow" BoolData( true )</b>
-		/// \li <b>"ai:visibility:reflected" BoolData( true )</b>
-		/// \li <b>"ai:visibility:refracted" BoolData( true )</b>
-		/// \li <b>"ai:visibility:diffuse" BoolData( true )</b>
-		/// \li <b>"ai:visibility:glossy" BoolData( true )</b>
+		/// \li <b>"ai:visibility:diffuseReflect" BoolData( true )</b>
+		/// \li <b>"ai:visibility:specularReflect" BoolData( true )</b>
+		/// \li <b>"ai:visibility:diffuseTransmit" BoolData( true )</b>
+		/// \li <b>"ai:visibility:specularTransmit" BoolData( true )</b>
+		/// \li <b>"ai:visibility:volume" BoolData( true )</b>
+		/// \li <b>"ai:visibility:subsurface" BoolData( true )</b>
 		///
 		/// \li <b>"ai:*:*" Data</b><br>
 		/// Mapped to shape node parameters, such that "ai:nodeType:parameterName"

contrib/IECoreArnold/include/IECoreArnold/SphereAlgo.h

@@ -46,7 +46,7 @@ namespace SphereAlgo
 {
 
 AtNode *convert( const IECore::SpherePrimitive *sphere );
-AtNode *convert( const std::vector<const IECore::SpherePrimitive *> &samples, const std::vector<float> &sampleTimes );
+AtNode *convert( const std::vector<const IECore::SpherePrimitive *> &samples, float motionStart, float motionEnd );
 
 } // namespace SphereAlgo
 

contrib/IECoreArnold/include/IECoreArnold/private/RendererImplementation.h

@@ -149,11 +149,11 @@ class RendererImplementation : public IECore::Renderer
 			RendererPtr renderer;
 		};
 
-		static int procLoader( AtProcVtable *vTable );
+		static int procFunc( AtProceduralNodeMethods *methods );
 		static int procInit( AtNode *node, void **userPtr );
-		static int procCleanup( void *userPtr );
-		static int procNumNodes( void *userPtr );
-		static AtNode *procGetNode( void *userPtr, int i );
+		static int procCleanup( const AtNode *node, void *userPtr );
+		static int procNumNodes( const AtNode *node, void *userPtr );
+		static AtNode *procGetNode( const AtNode *node, void *userPtr, int i );
 
 		boost::shared_ptr<UniverseBlock> m_universe;
 		InstancingConverterPtr m_instancingConverter;
@@ -195,7 +195,9 @@ class RendererImplementation : public IECore::Renderer
 		AttributeStack m_attributeStack;
 
 		// motion blur stuff
-		std::vector<float> m_motionTimes;
+		unsigned int m_motionBlockSize;
+		float m_motionStart;
+		float m_motionEnd;
 		std::vector<IECore::ConstPrimitivePtr> m_motionPrimitives;
 
 		// list of nodes that have been output so far. we have

contrib/IECoreArnold/src/IECoreArnold/CameraAlgo.cpp

@@ -89,8 +89,8 @@ AtNode *CameraAlgo::convert( const IECore::Camera *camera )
 	const Imath::V2i &resolution = cameraCopy->parametersData()->member<V2iData>( "resolution", true )->readable();
 	const float pixelAspectRatio = cameraCopy->parametersData()->member<FloatData>( "pixelAspectRatio", true )->readable();
 	float aspect = pixelAspectRatio * (float)resolution.x / (float)resolution.y;
-	AiNodeSetPnt2( result, "screen_window_min", screenWindow.min.x, screenWindow.min.y * aspect );
-	AiNodeSetPnt2( result, "screen_window_max", screenWindow.max.x, screenWindow.max.y * aspect );
+	AiNodeSetVec2( result, "screen_window_min", screenWindow.min.x, screenWindow.min.y * aspect );
+	AiNodeSetVec2( result, "screen_window_max", screenWindow.max.x, screenWindow.max.y * aspect );
 
 	// Set any Arnold-specific parameters
 

contrib/IECoreArnold/src/IECoreArnold/CurvesAlgo.cpp

@@ -124,7 +124,7 @@ AtNode *CurvesAlgo::convert( const IECore::CurvesPrimitive *curves )
 	return result;
 }
 
-AtNode *CurvesAlgo::convert( const std::vector<const IECore::CurvesPrimitive *> &samples, const std::vector<float> &sampleTimes )
+AtNode *CurvesAlgo::convert( const std::vector<const IECore::CurvesPrimitive *> &samples, float motionStart, float motionEnd )
 {
 	AtNode *result = convertCommon( samples.front() );
 
@@ -155,7 +155,8 @@ AtNode *CurvesAlgo::convert( const std::vector<const IECore::CurvesPrimitive *>
 		IECore::msg( IECore::Msg::Warning, "CurvesAlgo::convert", "Missing sample for primitive variable \"N\" - not setting orientations." );
 	}
 
-	AiNodeSetArray( result, "deform_time_samples", AiArrayConvert( sampleTimes.size(), 1, AI_TYPE_FLOAT, &sampleTimes.front() ) );
+	AiNodeSetFlt( result, "motion_start", motionStart );
+	AiNodeSetFlt( result, "motion_end", motionEnd );
 
 	return result;
 }

contrib/IECoreArnold/src/IECoreArnold/InstancingConverter.cpp

@@ -88,12 +88,12 @@ AtNode *InstancingConverter::convert( const IECore::Primitive *primitive, const
 	return NULL;
 }
 
-AtNode *InstancingConverter::convert( const std::vector<const IECore::Primitive *> &samples, const std::vector<float> &sampleTimes )
+AtNode *InstancingConverter::convert( const std::vector<const IECore::Primitive *> &samples, float motionStart, float motionEnd )
 {
-	return convert( samples, sampleTimes, IECore::MurmurHash() );
+	return convert( samples, motionStart, motionEnd, IECore::MurmurHash() );
 }
 
-AtNode *InstancingConverter::convert( const std::vector<const IECore::Primitive *> &samples, const std::vector<float> &sampleTimes, const IECore::MurmurHash &additionalHash )
+AtNode *InstancingConverter::convert( const std::vector<const IECore::Primitive *> &samples, float motionStart, float motionEnd, const IECore::MurmurHash &additionalHash )
 {
 	IECore::MurmurHash h;
 	for( std::vector<const IECore::Primitive *>::const_iterator it = samples.begin(), eIt = samples.end(); it != eIt; ++it )
@@ -106,7 +106,7 @@ AtNode *InstancingConverter::convert( const std::vector<const IECore::Primitive
 	if( m_data->cache.insert( a, h ) )
 	{
 		std::vector<const IECore::Object *> objectSamples( samples.begin(), samples.end() );
-		a->second = NodeAlgo::convert( objectSamples, sampleTimes );
+		a->second = NodeAlgo::convert( objectSamples, motionStart, motionEnd );
 		return a->second;
 	}
 	else

contrib/IECoreArnold/src/IECoreArnold/MeshAlgo.cpp

@@ -126,13 +126,13 @@ void convertIndexedUVSet( const std::string &setName, PrimitiveVariableMap &vari
 	const vector<int> &indices = indicesData->readable();
 
 	int numUVs = 1 + *max_element( indices.begin(), indices.end() );
-	AtArray *uvsArray = AiArrayAllocate( numUVs, 1, AI_TYPE_POINT2 );
+	AtArray *uvsArray = AiArrayAllocate( numUVs, 1, AI_TYPE_VECTOR2 );
 	AtArray *indicesArray = AiArrayAllocate( indices.size(), 1, AI_TYPE_UINT );
 
 	for( size_t i = 0, e = indices.size(); i < e; ++i )
 	{
-		AtPoint2 uv = { s[i], 1.0f - t[i] };
-		AiArraySetPnt2( uvsArray, indices[i], uv );
+		AtVector2 uv( s[i], 1.0f - t[i] );
+		AiArraySetVec2( uvsArray, indices[i], uv );
 		AiArraySetUInt( indicesArray, i, indices[i] );
 	}
 
@@ -190,11 +190,11 @@ void convertUVSet( const std::string &setName, PrimitiveVariableMap &variables,
 	const vector<float> &s = sData->readable();
 	const vector<float> &t = tData->readable();
 
-	AtArray *uvsArray = AiArrayAllocate( s.size(), 1, AI_TYPE_POINT2 );
+	AtArray *uvsArray = AiArrayAllocate( s.size(), 1, AI_TYPE_VECTOR2 );
 	for( size_t i = 0, e = s.size(); i < e; ++i )
 	{
-		AtPoint2 uv = { s[i], 1.0f - t[i] };
-		AiArraySetPnt2( uvsArray, i, uv );
+		AtVector2 uv( s[i], 1.0f - t[i] );
+		AiArraySetVec2( uvsArray, i, uv );
 	}
 
 	AtArray *indicesArray = NULL;
@@ -391,7 +391,7 @@ AtNode *MeshAlgo::convert( const IECore::MeshPrimitive *mesh )
 	return result;
 }
 
-AtNode *MeshAlgo::convert( const std::vector<const IECore::MeshPrimitive *> &samples, const std::vector<float> &sampleTimes )
+AtNode *MeshAlgo::convert( const std::vector<const IECore::MeshPrimitive *> &samples, float motionStart, float motionEnd )
 {
 	AtNode *result = convertCommon( samples.front() );
 
@@ -428,7 +428,8 @@ AtNode *MeshAlgo::convert( const std::vector<const IECore::MeshPrimitive *> &sam
 
 	// add time sampling
 
-	AiNodeSetArray( result, "deform_time_samples", AiArrayConvert( sampleTimes.size(), 1, AI_TYPE_FLOAT, &sampleTimes.front() ) );
+	AiNodeSetFlt( result, "motion_start", motionStart );
+	AiNodeSetFlt( result, "motion_end", motionEnd );
 
 	return result;
 }

contrib/IECoreArnold/src/IECoreArnold/NodeAlgo.cpp

@@ -89,7 +89,7 @@ AtNode *convert( const IECore::Object *object )
 	return it->second.converter( object );
 }
 
-AtNode *convert( const std::vector<const IECore::Object *> &samples, const std::vector<float> &sampleTimes )
+AtNode *convert( const std::vector<const IECore::Object *> &samples, float motionStart, float motionEnd )
 {
 	if( samples.empty() )
 	{
@@ -115,7 +115,7 @@ AtNode *convert( const std::vector<const IECore::Object *> &samples, const std::
 
 	if( it->second.motionConverter )
 	{
-		return it->second.motionConverter( samples, sampleTimes );
+		return it->second.motionConverter( samples, motionStart, motionEnd );
 	}
 	else
 	{
@@ -128,6 +128,42 @@ void registerConverter( IECore::TypeId fromType, Converter converter, MotionConv
 	registry().insert( Registry::value_type( fromType, Converters( converter, motionConverter ) ) );
 }
 
+void ensureUniformTimeSamples( const std::vector<float> &times )
+{
+	if( times.size() == 0 )
+	{
+		throw IECore::Exception( "Motion block times must not be empty" );
+	}
+
+	float motionStart = times[0];
+	float motionEnd = times[ times.size() - 1 ];
+
+	for( unsigned int i = 0; i < times.size(); i++ )
+	{
+		// Use a really coarse epsilon to check if the values are uniform - if someone is sloppy with
+		// floating point precision when computing their sample times, we don't want to stop them from rendering.
+		// But we should warn someone if they are actually trying to use a feature Arnold doesn't support.
+		const float uniformity_epsilon = 0.01;
+		float expectedTime = motionStart + ( motionEnd - motionStart ) / ( times.size() - 1 ) * i;
+		if( times[i] < expectedTime - uniformity_epsilon || times[i] > expectedTime + uniformity_epsilon )
+		{
+			std::stringstream text;
+			text << "Arnold does not support non-uniform motion blocks.\n";
+			text << "Invalid motion block: [ " << times[0];
+			for( unsigned int j = 1; j < times.size(); j++ )
+			{
+				text << ", " << times[j];
+			}
+			text << " ]\n";
+			text << "( sample " << i << ", with value " << times[i] << " does not match " << expectedTime << ")\n";
+			throw IECore::Exception( text.str() );
+
+
+		}
+	}
+
+}
+
 } // namespace NodeAlgo
 
 } // namespace IECoreArnold