Updated to Cortex 9.0.0-a6.

cortex-9.0.0-a3/Changes → cortex-9.0.0-a6/Changes

@@ -1,3 +1,48 @@
+# 9.0.0-a6
+
+#### IECore
+
+- Multithreaded PointSmoothSkinningOp
+- Added ExternalProcedural object type
+- Added HasBaseType type trait
+- Added boost::hash compatibility for MurmurHash
+
+#### IECoreRI
+
+- Added support for DynamicLoad and DelayedReadArchive procedurals
+
+#### IECoreArnold
+
+- Added support for delayed load DSO and .ass procedurals
+
+# 9.0.0-a5
+
+#### IECore
+
+- LinkedScene::hash now takes extra children at links into account
+
+#### IECoreRI
+
+- Added support for RiFrame blocks in IECoreRI::Renderer.
+
+#### IECoreMaya
+
+- Renamed IECoreMaya::MayaScene to IECoreMaya::LiveScene
+
+#### IECoreHoudini
+
+- Renamed IECoreHoudini::HoudiniScene to IECoreHoudini::LiveScene
+
+# 9.0.0-a4
+
+#### IECore
+
+- Bug fix in StreamIndexedIO that was causing sporadic crashes when loading SceneCaches during procedural expansion.
+- Fixed some minor bounding box bugs in IECore.SceneCache
+- Child bounds can now dilate bounds explicitly specified using IECore.SceneCache.writeBound()
+- IECore.LinkedScene now supports extra children at link locations
+- Fixed TransformOp double transform bug
+
 # 9.0.0-a3
 
 #### IECore

cortex-9.0.0-a3/SConstruct → cortex-9.0.0-a6/SConstruct

@@ -53,7 +53,7 @@ SConsignFile()
 ieCoreMajorVersion=9
 ieCoreMinorVersion=0
 ieCorePatchVersion=0
-ieCoreVersionSuffix="a3"	# used for alpha/beta releases. Example: "a1", "b2", etc.
+ieCoreVersionSuffix="a6"	# used for alpha/beta releases. Example: "a1", "b2", etc.
 
 ###########################################################################################
 # Command line options

cortex-9.0.0-a3/config/ie/buildAll → cortex-9.0.0-a6/config/ie/buildAll

@@ -66,10 +66,12 @@ if IEEnv.platform() == "cent6.x86_64" :
 		build( [ "APP=maya", "APP_VERSION="+mayaVersion, "DL_VERSION=10.0.142", "ARNOLD_VERSION=4.0.9.1" ] )
 
 	for nukeVersion in IEEnv.activeAppVersions( "nuke" ) :
-		build( [ "APP=nuke", "APP_VERSION="+nukeVersion ] )
+		if nukeVersion.startswith( "8" ) :
+			build( [ "APP=nuke", "APP_VERSION="+nukeVersion ] )
 
 	for houdiniVersion in IEEnv.activeAppVersions( "houdini" ) :
-		build( [ "APP=houdini", "APP_VERSION="+houdiniVersion ] )
+		if houdiniVersion.endswith( "-python2.7" ) :
+			build( [ "APP=houdini", "APP_VERSION="+houdiniVersion ] )
 
 	installDocs()
 

cortex-9.0.0-a3/config/ie/options → cortex-9.0.0-a6/config/ie/options

@@ -402,7 +402,7 @@ else :
 	# We use basePrefix for IECoreRI, but dlPrefix for the renderman procedurals. See the note in
 	# the dlReg section for an explanation.
 	INSTALL_RMANLIB_NAME = os.path.join( basePrefix, "lib", compiler, compilerVersion, "$IECORE_NAME-$IECORE_MAJOR_VERSION" )
-	INSTALL_RMANPROCEDURAL_NAME = os.path.join( dlPrefix, "3delight", dlVersion, "procedurals", "$IECORE_NAME" )
+	INSTALL_RMANPROCEDURAL_NAME = os.path.join( dlPrefix, "3delight", dlVersion, "procedurals", "python", "$PYTHON_VERSION", "$IECORE_NAME" )
 	INSTALL_RMANDISPLAY_NAME = os.path.join( dlPrefix, "3delight", dlVersion, "displayDrivers", "$IECORE_NAME" )
 	INSTALL_ARNOLDLIB_NAME = os.path.join( basePrefix, "lib", compiler, compilerVersion, "$IECORE_NAME-$IECORE_MAJOR_VERSION" )
 	INSTALL_ARNOLDPROCEDURAL_NAME = os.path.join( basePrefix, "arnold", arnoldVersion, "plugins", "$IECORE_NAME" )

cortex-9.0.0-a3/config/ie/postCoreHoudiniInstall → cortex-9.0.0-a6/config/ie/postCoreHoudiniInstall

@@ -42,7 +42,7 @@
 import sys
 
 import VersionControl 
-VersionControl.setVersion('IEBuild', '6.6.1') 
+VersionControl.setVersion('IEBuild', '6.15.0') 
 import IEBuild  
 
 cortexMajorVersion=ARGUMENTS['MAJOR']

cortex-9.0.0-a3/contrib/IECoreArnold/src/IECoreArnold/RendererImplementation.cpp → cortex-9.0.0-a6/contrib/IECoreArnold/src/IECoreArnold/RendererImplementation.cpp

@@ -638,22 +638,33 @@ void IECoreArnold::RendererImplementation::procedural( IECore::Renderer::Procedu
 		return;
 	}
 
-	// we have to transform the bound, as we're not applying the current transform to the
-	// procedural node, but instead applying absolute transforms to the shapes the procedural
-	// generates.
-	bound = transform( bound, m_transformStack.top() );
-
 	AtNode *procedural = AiNode( "procedural" );
-	AiNodeSetPnt( procedural, "min", bound.min.x, bound.min.y, bound.min.z );
-	AiNodeSetPnt( procedural, "max", bound.max.x, bound.max.y, bound.max.z );
+
+	if( ExternalProcedural *externalProc = dynamic_cast<ExternalProcedural *>( proc.get() ) )
+	{
+		AiNodeSetStr( procedural, "dso", externalProc->fileName().c_str() );
+		ToArnoldConverter::setParameters( procedural, externalProc->parameters() );
+		applyTransformToNode( procedural );
+	}
+	else
+	{
+
+		// we have to transform the bound, as we're not applying the current transform to the
+		// procedural node, but instead applying absolute transforms to the shapes the procedural
+		// generates.
+		bound = transform( bound, m_transformStack.top() );
 
-	AiNodeSetPtr( procedural, "funcptr", (void *)procLoader );
+		AiNodeSetPtr( procedural, "funcptr", (void *)procLoader );
 
-	ProceduralData *data = new ProceduralData;
-	data->procedural = proc;
-	data->renderer = new IECoreArnold::Renderer( new RendererImplementation( *this ) );
+		ProceduralData *data = new ProceduralData;
+		data->procedural = proc;
+		data->renderer = new IECoreArnold::Renderer( new RendererImplementation( *this ) );
 
-	AiNodeSetPtr( procedural, "userptr", data );
+		AiNodeSetPtr( procedural, "userptr", data );
+	}
+
+	AiNodeSetPnt( procedural, "min", bound.min.x, bound.min.y, bound.min.z );
+	AiNodeSetPnt( procedural, "max", bound.max.x, bound.max.y, bound.max.z );
 
 	// we call addNode() rather than addShape() as we don't want to apply transforms and
 	// shaders and attributes to procedurals. if we do, they override the things we set

cortex-9.0.0-a3/contrib/IECoreArnold/test/IECoreArnold/RendererTest.py → cortex-9.0.0-a6/contrib/IECoreArnold/test/IECoreArnold/RendererTest.py

@@ -682,7 +682,46 @@ def testLight( self ) :
 		self.assertTrue( result.floatPrimVar( e.R() ) > 0.2 )
 		self.assertAlmostEqual( result.floatPrimVar( e.R() ) * 0.5, result.floatPrimVar( e.G() ) )
 		self.assertAlmostEqual( result.floatPrimVar( e.R() ) * 0.25, result.floatPrimVar( e.B() ) )
+
+	def testExternalProcedural( self ) :
+
+		r = IECoreArnold.Renderer( self.__assFileName )
+
+		with IECore.WorldBlock( r ) :
 
+			r.procedural(
+				r.ExternalProcedural(
+					"test.so",
+					IECore.Box3f(
+						IECore.V3f( 1, 2, 3 ),
+						IECore.V3f( 4, 5, 6 )
+					),
+					{
+						"colorParm" : IECore.Color3f( 1, 2, 3 ),
+						"stringParm" : "test",
+						"floatParm" : 1.5,
+						"intParm" : 2,
+					}
+				)
+			)
+
+
+		ass = "".join( file( self.__assFileName ).readlines() )
+		print ass
+
+		self.assertTrue( "procedural" in ass )
+		self.assertTrue( "min 1 2 3" in ass )
+		self.assertTrue( "max 4 5 6" in ass )
+		self.assertTrue( "dso \"test.so\"" in ass )
+		self.assertTrue( "declare stringParm constant STRING" in ass )
+		self.assertTrue( "declare floatParm constant FLOAT" in ass )
+		self.assertTrue( "declare intParm constant INT" in ass )
+		self.assertTrue( "declare colorParm constant RGB" in ass )
+		self.assertTrue( "stringParm \"test\"" in ass )
+		self.assertTrue( "floatParm 1.5" in ass )
+		self.assertTrue( "intParm 2" in ass )
+		self.assertTrue( "colorParm 1 2 3" in ass )
+
 	def tearDown( self ) :
 
 		for f in [