Merge branch 'RB-10.4' into main

Author: johnhaddon

.github/workflows/main.yml

@@ -78,7 +78,7 @@ jobs:
             os: windows-2019
             buildType: RELWITHDEBINFO
             options: .github/workflows/main/options.windows
-            dependenciesURL: https://github.com/hypothetical-inc/gafferDependencies/releases/download/6.2.0/gafferDependencies-6.2.0-Python3-windows.zip
+            dependenciesURL: https://github.com/hypothetical-inc/gafferDependencies/releases/download/6.2.1/gafferDependencies-6.2.1-Python3-windows.zip
             tests: testCore testCorePython testScene testImage testAlembic testUSD testVDB
             publish: false
 

Changes

@@ -1,3 +1,19 @@
+10.4.4.0 (relative to 10.4.3.1)
+========
+
+Improvements
+------------
+
+- USD :
+  - Added loading of `float4` USD shader parameters as `Color4` parameters.
+  - Added support for Arnold-USD's convention for representing connections to individual indices of an array.
+
+Build
+-----
+
+- Added compatibility with USD 23.02.
+- Updated Windows dependencies to 6.2.1.
+
 10.4.3.1 (relative to 10.4.3.0)
 ========
 

SConstruct

@@ -56,8 +56,8 @@ SConsignFile()
 
 ieCoreMilestoneVersion = 10 # for announcing major milestones - may contain all of the below
 ieCoreMajorVersion = 4 # backwards-incompatible changes
-ieCoreMinorVersion = 3 # new backwards-compatible features
-ieCorePatchVersion = 1 # bug fixes
+ieCoreMinorVersion = 4 # new backwards-compatible features
+ieCorePatchVersion = 0 # bug fixes
 ieCoreVersionSuffix = "" # used for alpha/beta releases. Example: "a1", "b2", etc.
 
 ###########################################################################################

contrib/IECoreUSD/src/IECoreUSD/DataAlgo.cpp

@@ -215,6 +215,8 @@ static const std::map<pxr::TfType, IECore::DataPtr (*)( const pxr::VtValue &, Ge
 	{ TfType::Find<VtArray<GfVec2f>>(), &dataFromArray<GfVec2f> },
 	{ TfType::Find<GfVec3f>(), &dataFromValue<GfVec3f> },
 	{ TfType::Find<VtArray<GfVec3f>>(), &dataFromArray<GfVec3f> },
+	{ TfType::Find<GfVec4f>(), &dataFromValue<GfVec4f> },
+	{ TfType::Find<VtArray<GfVec4f>>(), &dataFromArray<GfVec4f> },
 	{ TfType::Find<GfVec2d>(), &dataFromValue<GfVec2d> },
 	{ TfType::Find<VtArray<GfVec2d>>(), &dataFromArray<GfVec2d> },
 	{ TfType::Find<GfVec3d>(), &dataFromValue<GfVec3d> },

contrib/IECoreUSD/src/IECoreUSD/ShaderAlgo.cpp

@@ -49,6 +49,8 @@
 #include "boost/algorithm/string/replace.hpp"
 #include "boost/pointer_cast.hpp"
 
+#include <regex>
+
 #if PXR_VERSION < 2102
 #define IsContainer IsNodeGraph
 #endif
@@ -98,6 +100,25 @@ void readAdditionalLightParameters( const pxr::UsdPrim &prim, IECore::CompoundDa
 #endif
 }
 
+const std::regex g_arrayIndexFromUSDRegex( ":i([0-9]+)$" );
+const std::string g_arrayIndexFromUSDFormat( "[$1]" );
+IECore::InternedString fromUSDParameterName( const pxr::TfToken &usdName )
+{
+	// USD doesn't support connections to array indices. So Arnold-USD emulates
+	// them using its own `parameter:i<N>`syntax - see https://github.com/Autodesk/arnold-usd/pull/381.
+	// We convert these to the regular `parameter[N]` syntax during loading.
+	return std::regex_replace( usdName.GetString(), g_arrayIndexFromUSDRegex, g_arrayIndexFromUSDFormat );
+}
+
+const std::regex g_arrayIndexFromCortexRegex( "\\[([0-9]+)\\]$" );
+const std::string g_arrayIndexFromCortexFormat( ":i$1" );
+pxr::TfToken toUSDParameterName( IECore::InternedString cortexName )
+{
+	return pxr::TfToken(
+		std::regex_replace( cortexName.string(), g_arrayIndexFromCortexRegex, g_arrayIndexFromCortexFormat )
+	);
+}
+
 IECoreScene::ShaderNetwork::Parameter readShaderNetworkWalk( const pxr::SdfPath &anchorPath, const pxr::UsdShadeOutput &output, IECoreScene::ShaderNetwork &shaderNetwork );
 
 IECore::InternedString readShaderNetworkWalk( const pxr::SdfPath &anchorPath, const pxr::UsdShadeConnectableAPI &usdShader, IECoreScene::ShaderNetwork &shaderNetwork )
@@ -146,7 +167,7 @@ IECore::InternedString readShaderNetworkWalk( const pxr::SdfPath &anchorPath, co
 					anchorPath, usdSource.GetOutput( usdSourceName ), shaderNetwork
 				);
 				connections.push_back( {
-					sourceHandle, { handle, IECore::InternedString( i.GetBaseName().GetString() ) }
+					sourceHandle, { handle, fromUSDParameterName( i.GetBaseName() ) }
 				} );
 			}
 			else
@@ -160,7 +181,7 @@ IECore::InternedString readShaderNetworkWalk( const pxr::SdfPath &anchorPath, co
 
 		if( IECore::DataPtr d = IECoreUSD::DataAlgo::fromUSD( pxr::UsdAttribute( valueAttribute ) ) )
 		{
-			parameters[ i.GetBaseName().GetString() ] = d;
+			parameters[fromUSDParameterName( i.GetBaseName() )] = d;
 		}
 	}
 
@@ -244,7 +265,7 @@ pxr::UsdShadeOutput IECoreUSD::ShaderAlgo::writeShaderNetwork( const IECoreScene
 		for( const auto &p : expandedParameters->readable() )
 		{
 			pxr::UsdShadeInput input = usdShader.CreateInput(
-				pxr::TfToken( p.first.string() ),
+				toUSDParameterName( p.first ),
 				DataAlgo::valueTypeName( p.second.get() )
 			);
 			input.Set( DataAlgo::toUSD( p.second.get() ) );
@@ -278,7 +299,7 @@ pxr::UsdShadeOutput IECoreUSD::ShaderAlgo::writeShaderNetwork( const IECoreScene
 			pxr::UsdShadeInput dest = usdShader.GetInput( pxr::TfToken( c.destination.name.string() ) );
 			if( ! dest.GetPrim().IsValid() )
 			{
-				dest = usdShader.CreateInput( pxr::TfToken( c.destination.name.string() ), pxr::SdfValueTypeNames->Token );
+				dest = usdShader.CreateInput( toUSDParameterName( c.destination.name ), pxr::SdfValueTypeNames->Token );
 			}
 
 			pxr::UsdShadeShader sourceUsdShader = pxr::UsdShadeShader::Get( shaderContainer.GetStage(), shaderContainer.GetPath().AppendChild( pxr::TfToken( pxr::TfMakeValidIdentifier( c.source.shader.string() ) ) ) );

contrib/IECoreUSD/src/IECoreUSD/USDScene.cpp

@@ -82,6 +82,7 @@ IECORE_POP_DEFAULT_VISIBILITY
 #include "tbb/concurrent_hash_map.h"
 
 #include <iostream>
+#include <mutex>
 
 using namespace IECore;
 using namespace IECoreScene;

contrib/IECoreUSD/test/IECoreUSD/USDSceneTest.py

@@ -283,6 +283,8 @@ def testPrimVarTypes ( self ) :
 			'test_Float2_Scalar_constant' : IECore.V2fData( imath.V2f( 0.1, 0.2 ) ),
 			'test_Float3_Array_constant' : IECore.V3fVectorData( [imath.V3f( 1.1, 1.2, 1.3 ), imath.V3f( 2.1, 2.2, 2.3 ), imath.V3f( 3.1, 3.2, 3.3 )] ),
 			'test_Float3_Scalar_constant' : IECore.V3fData( imath.V3f( 0.1, 0.2, 0.3 ) ),
+			'test_Float4_Array_constant' : IECore.Color4fVectorData( [imath.Color4f( 1.1, 1.2, 1.3, 1.4 ), imath.Color4f( 2.1, 2.2, 2.3, 2.4 ), imath.Color4f( 3.1, 3.2, 3.3, 3.4 )] ),
+			'test_Float4_Scalar_constant' : IECore.Color4fData( imath.Color4f( 0.1, 0.2, 0.3, 0.4 ) ),
 			'test_Float_Array_constant' : IECore.FloatVectorData( [0.7, 0.8, 0.9] ),
 			'test_Float_Scalar_constant' : IECore.FloatData( 0.6 ),
 			'test_Half_Array_constant' : IECore.HalfVectorData( [0.0999756, 0.199951, 0.300049] ),
@@ -2482,7 +2484,7 @@ def assertAttributesValues( sphere ):
 
 		# Check that the USD file written looks as expected
 		stage = pxr.Usd.Stage.Open( fileName )
-		sphereUsd = pxr.UsdGeom.Imageable( stage.GetPrimAtPath( "/sphere" ) )
+		sphereUsd = pxr.UsdGeom.PrimvarsAPI( stage.GetPrimAtPath( "/sphere" ) )
 		self.assertEqual( sphereUsd.GetPrim().GetAttribute( "customNamespaced:testAnimated" ).Get( 0 ), 0 )
 		self.assertEqual( sphereUsd.GetPrimvar( "test" ).Get( 0 ), "cyan" )
 		self.assertEqual( sphereUsd.GetPrimvar( "user:bongo" ).Get( 0 ), "cyan" )
@@ -2491,7 +2493,7 @@ def assertAttributesValues( sphere ):
 		self.assertEqual( sphereUsd.GetPrim().GetAttribute( "radius" ).Get( 0 ), 10 )
 		self.assertEqual( sphereUsd.GetPrim().GetAttribute( "studio:foo" ).Get( 0 ), "brown" )
 
-		abUsd = pxr.UsdGeom.Imageable( stage.GetPrimAtPath( "/ab" ) )
+		abUsd = pxr.UsdGeom.PrimvarsAPI( stage.GetPrimAtPath( "/ab" ) )
 		self.assertEqual( abUsd.GetPrimvar( "bar" ).Get( 0 ), "black" )
 		self.assertEqual( abUsd.GetPrimvar( "bar" ).GetAttr().GetMetadata( "cortex_isConstantPrimitiveVariable" ), True )
 		self.assertEqual( abUsd.GetPrimvar( "notUserPrefixAttribute" ).Get( 0 ), "orange" )
@@ -3271,5 +3273,34 @@ def testPointInstancerPrimvars( self ) :
 		self.assertEqual( points["myColor"].interpolation, IECoreScene.PrimitiveVariable.Interpolation.Vertex )
 		self.assertEqual( points["myColor"].indices, None )
 
+	def testArnoldArrayInputs( self ) :
+
+		def assertExpectedArrayInputs( network ) :
+
+			inputs = network.inputConnections( "rampRGB" )
+			self.assertEqual( len( inputs ), 2 )
+			self.assertEqual( inputs[0], ( ( "noise", "out" ), ( "rampRGB", "color[0]" ) ) )
+			self.assertEqual( inputs[1], ( ( "flat", "out" ), ( "rampRGB", "color[1]" ) ) )
+
+		# Load original USD out of USD-Arnold.
+
+		scene = IECoreScene.SceneInterface.create(
+			os.path.join( os.path.dirname( __file__ ), "data", "arnoldArrayInputs.usda" ),
+			IECore.IndexedIO.OpenMode.Read
+		)
+		network = scene.child( "sphere" ).readAttribute( "ai:surface", 0 )
+
+		assertExpectedArrayInputs( network )
+
+		# Write our own USD from that data, to check we can round-trip it.
+
+		fileName = os.path.join( self.temporaryDirectory(), "arnoldArrayInputsRewritten.usda" )
+		scene = IECoreScene.SceneInterface.create( fileName, IECore.IndexedIO.OpenMode.Write )
+		scene.createChild( "sphere" ).writeAttribute( "ai:surface", network, 0 )
+
+		del scene
+		scene = IECoreScene.SceneInterface.create( fileName, IECore.IndexedIO.OpenMode.Read )
+		assertExpectedArrayInputs( scene.child( "sphere" ).readAttribute( "ai:surface", 0 ) )
+
 if __name__ == "__main__":
 	unittest.main()

contrib/IECoreUSD/test/IECoreUSD/data/arnoldArrayInputs.usda

@@ -0,0 +1,47 @@
+#usda 1.0
+
+def Sphere "sphere"
+{
+    rel material:binding = </rampSurface>
+}
+
+def Material "rampSurface"
+{
+    token outputs:arnold:surface.connect = </rampSurface/standardSurface.outputs:surface>
+
+    def Shader "standardSurface"
+    {
+        uniform token info:id = "arnold:standard_surface"
+        color3f inputs:base_color = (0.8, 0.8, 0.8)
+        prepend color3f inputs:base_color.connect = </rampSurface/rampRGB.outputs:out>
+        float inputs:indirect_specular = 0
+        token outputs:surface
+    }
+
+    def Shader "rampRGB"
+    {
+        uniform token info:id = "arnold:ramp_rgb"
+        color3f[] inputs:color = [(0, 0, 0), (0.5, 0.5, 0.5)]
+        prepend color3f inputs:color:i0.connect = </rampSurface/noise.outputs:out>
+        prepend color3f inputs:color:i1.connect = </rampSurface/flat.outputs:out>
+        int[] inputs:interpolation = [1, 1]
+        float[] inputs:position = [0, 1]
+        token inputs:type = "v"
+        color3f outputs:out
+    }
+
+    def Shader "noise"
+    {
+        uniform token info:id = "arnold:noise"
+        color3f inputs:color1 = (1, 0, 0)
+        color3f inputs:color2 = (0, 1, 0)
+        color3f outputs:out
+    }
+
+    def Shader "flat"
+    {
+        uniform token info:id = "arnold:flat"
+        color3f inputs:color = (0, 0, 1)
+        color3f outputs:out
+    }
+}