ShaderNetworkAlgo : Remove functions deprecated in 10.4.7.0

Author: danieldresser-ie

Changes

@@ -1,7 +1,10 @@
 10.x.x.x (relative to 10.6.x.x)
 ========
 
+Breaking Changes
+----------------
 
+- IECoreScene::ShaderNetworkAlgo : Removed deprecated functions componentConnectionAdapterLabel, convertOSLComponentConnections, collapseSplineParameters, expandSplineParameters.
 
 10.6.x.x (relative to 10.6.1.0)
 ========

contrib/IECoreUSD/src/IECoreUSD/ShaderAlgo.cpp

@@ -65,7 +65,12 @@ namespace
 {
 
 const pxr::TfToken g_blindDataToken( "cortex:blindData" );
-pxr::TfToken g_legacyAdapterLabelToken( IECoreScene::ShaderNetworkAlgo::componentConnectionAdapterLabel().string() );
+
+// Hardcoded to match an old name used by Cortex when writing USD with OSL version earlier than 1.10 (
+// ie. a pre-2021 version of gafferDependencies ). We no longer expose this in the API, but I'm not sure
+// if we're ready to drop support for loading these old files.
+IECore::InternedString g_legacyAdapterLabelString( "cortex_autoAdapter" );
+pxr::TfToken g_legacyAdapterLabelToken( g_legacyAdapterLabelString.string() );
 
 std::pair<pxr::TfToken, std::string> shaderIdAndType( const pxr::UsdShadeConnectableAPI &connectable )
 {
@@ -267,7 +272,7 @@ IECore::InternedString readShaderNetworkWalk( const pxr::SdfPath &anchorPath, co
 	pxr::VtValue metadataValue;
 	if( usdShader.GetPrim().GetMetadata( g_legacyAdapterLabelToken, &metadataValue ) && metadataValue.Get<bool>() )
 	{
-		newShader->blindData()->writable()[ IECoreScene::ShaderNetworkAlgo::componentConnectionAdapterLabel() ] = new IECore::BoolData( true );
+		newShader->blindData()->writable()[ g_legacyAdapterLabelString ] = new IECore::BoolData( true );
 	}
 
 	shaderNetwork.addShader( handle, std::move( newShader ) );

include/IECoreScene/ShaderNetworkAlgo.h

@@ -95,9 +95,6 @@ IECORESCENE_API void registerJoinAdapter( const std::string &destinationShaderTy
 /// Removes an adapter registration.
 IECORESCENE_API void deregisterJoinAdapter( const std::string &destinationShaderType, IECore::TypeId destinationParameterType );
 
-/// \deprecated
-IECORESCENE_API const IECore::InternedString &componentConnectionAdapterLabel();
-
 /// Converts various aspects of how shaders are stored to be ready to pass directly to OSL.
 /// The `oslVersion` argument is used to determine how conversion is performed, and should be passed a
 /// value of `OSL_VERSION`. Conversions include:
@@ -113,15 +110,6 @@ IECORESCENE_API const IECore::InternedString &componentConnectionAdapterLabel();
 ///     using an adapter shader.
 IECORESCENE_API void convertToOSLConventions( ShaderNetwork *network, int oslVersion );
 
-/// Finds connections involving the individual components of point/color parameters, and converts them
-/// for use with OSL. The `oslVersion` argument is used to determine how conversion is performed,
-/// and should be passed a value of `OSL_VERSION`. For OSL prior to 1.10, intermediate shaders are
-/// inserted to emulate connections between components. For later versions, no new shaders are inserted, but
-/// components are renamed from our `.x, .y, .z` suffixes to OSL's `[0], [1], [2]` suffixes.
-/// \deprecated: Use convertToOSLConventions instead
-IECORESCENE_API void convertOSLComponentConnections( ShaderNetwork *network );
-IECORESCENE_API void convertOSLComponentConnections( ShaderNetwork *network, int oslVersion );
-
 /// Converts from the legacy ObjectVector format previously used to represent shader networks.
 IECORESCENE_API ShaderNetworkPtr convertObjectVector( const IECore::ObjectVector *network );
 
@@ -147,16 +135,6 @@ IECORESCENE_API void collapseSplines( ShaderNetwork *network, std::string target
 /// If `targetPrefix` is given, only translates connections to shaders with a type starting with this string
 IECORESCENE_API void expandSplines( ShaderNetwork *network, std::string targetPrefix = "" );
 
-
-/// \deprecated: Use collapseSplines on the whole network, which can handle input connections, and supports
-/// different spline conventions for different renderers' shader libraries
-IECORESCENE_API IECore::ConstCompoundDataPtr collapseSplineParameters( const IECore::ConstCompoundDataPtr& parametersData );
-
-/// \deprecated: Use expandSplines on the whole network, which can handle input connections, and supports
-/// different spline conventions for different renderers' shader libraries
-IECORESCENE_API IECore::ConstCompoundDataPtr expandSplineParameters( const IECore::ConstCompoundDataPtr& parametersData );
-
-
 } // namespace ShaderNetworkAlgo
 
 } // namespace IECoreScene

src/IECoreScene/ShaderNetworkAlgo.cpp

@@ -269,6 +269,12 @@ const bool g_defaultAdapterRegistrations = [] () {
 	return true;
 } ();
 
+const InternedString &componentConnectionAdapterLabel()
+{
+	static InternedString ret( "cortex_autoAdapter" );
+	return ret;
+}
+
 bool isSplitAdapter( const Shader *shader, InternedString &component, InternedString &inParameter, InternedString &outParameter )
 {
 	if( auto *d = shader->blindData()->member<InternedStringData>( g_splitAdapterComponent ) )
@@ -283,7 +289,7 @@ bool isSplitAdapter( const Shader *shader, InternedString &component, InternedSt
 		}
 		return true;
 	}
-	else if( auto *b = shader->blindData()->member<BoolData>( ShaderNetworkAlgo::componentConnectionAdapterLabel() ) )
+	else if( auto *b = shader->blindData()->member<BoolData>( componentConnectionAdapterLabel() ) )
 	{
 		// Legacy format.
 		if( b->readable() && shader->getName() == "MaterialX/mx_swizzle_color_float" )
@@ -313,7 +319,7 @@ bool isJoinAdapter( const Shader *shader, std::array<InternedString, 4> &inParam
 			return true;
 		}
 	}
-	else if( auto *b = shader->blindData()->member<BoolData>( ShaderNetworkAlgo::componentConnectionAdapterLabel() ) )
+	else if( auto *b = shader->blindData()->member<BoolData>( componentConnectionAdapterLabel() ) )
 	{
 		// Legacy format.
 		if( b->readable() && shader->getName() == "MaterialX/mx_pack_color" )
@@ -590,12 +596,6 @@ void ShaderNetworkAlgo::deregisterJoinAdapter( const std::string &destinationSha
 	joinAdapters()[destinationShaderType].erase( destinationParameterType );
 }
 
-const InternedString &ShaderNetworkAlgo::componentConnectionAdapterLabel()
-{
-	static InternedString ret( "cortex_autoAdapter" );
-	return ret;
-}
-
 //////////////////////////////////////////////////////////////////////////
 // OSL Utilities
 //////////////////////////////////////////////////////////////////////////
@@ -624,20 +624,13 @@ ShaderNetwork::Parameter convertComponentSuffix( const ShaderNetwork::Parameter
 	);
 }
 
-} // namespace
-
-void ShaderNetworkAlgo::convertOSLComponentConnections( ShaderNetwork *network )
-{
-	convertOSLComponentConnections( network, 10900 /* OSL 1.9 */ );
-}
-
-void ShaderNetworkAlgo::convertOSLComponentConnections( ShaderNetwork *network, int oslVersion )
+void convertOSLComponentConnections( ShaderNetwork *network, int oslVersion )
 {
 	if( oslVersion < 11000 )
 	{
 		// OSL doesn't support component-level connections,
 		// so we emulate them by inserting conversion shaders for OSL nodes.
-		addComponentConnectionAdapters( network, "osl:" );
+		ShaderNetworkAlgo::addComponentConnectionAdapters( network, "osl:" );
 		return;
 	}
 
@@ -681,6 +674,9 @@ void ShaderNetworkAlgo::convertOSLComponentConnections( ShaderNetwork *network,
 	}
 }
 
+} // namespace
+
+
 void ShaderNetworkAlgo::convertToOSLConventions( ShaderNetwork *network, int oslVersion )
 {
 	expandSplines( network, "osl:" );
@@ -1434,41 +1430,3 @@ void ShaderNetworkAlgo::expandSplines( ShaderNetwork *network, std::string targe
 
 	}
 }
-
-IECore::ConstCompoundDataPtr ShaderNetworkAlgo::collapseSplineParameters( const IECore::ConstCompoundDataPtr &parametersData )
-{
-	return collapseSplineParametersInternal( parametersData, "" );
-}
-
-IECore::ConstCompoundDataPtr ShaderNetworkAlgo::expandSplineParameters( const IECore::ConstCompoundDataPtr &parametersData )
-{
-	const CompoundDataMap &parameters( parametersData->readable() );
-
-	CompoundDataPtr newParametersData;
-	CompoundDataMap *newParameters = nullptr;
-
-	for( const auto &i : parameters )
-	{
-		if( const SplinefColor3fData *colorSpline = runTimeCast<const SplinefColor3fData>( i.second.get() ) )
-		{
-			ensureParametersCopy( parameters, newParametersData, newParameters );
-			newParameters->erase( i.first );
-			expandSpline( i.first, colorSpline->readable(), *newParameters, "" );
-		}
-		else if( const SplineffData *floatSpline = runTimeCast<const SplineffData>( i.second.get() ) )
-		{
-			ensureParametersCopy( parameters, newParametersData, newParameters );
-			newParameters->erase( i.first );
-			expandSpline( i.first, floatSpline->readable(), *newParameters, "" );
-		}
-	}
-
-	if( newParametersData )
-	{
-		return newParametersData;
-	}
-	else
-	{
-		return parametersData;
-	}
-}

src/IECoreScene/bindings/ShaderNetworkAlgoBinding.cpp

@@ -65,26 +65,6 @@ void registerJoinAdapterWrapper( const std::string &destinationShaderType, IECor
 	ShaderNetworkAlgo::registerJoinAdapter( destinationShaderType, destinationParameterType, adapter, inParameters, outParameter );
 }
 
-void convertOSLComponentConnectionsWrapper( ShaderNetwork *network, int oslVersion )
-{
-	ShaderNetworkAlgo::convertOSLComponentConnections( network, oslVersion );
-}
-
-CompoundDataPtr collapseSplineParametersWrapper( CompoundDataPtr parameters )
-{
-	return boost::const_pointer_cast< CompoundData >( ShaderNetworkAlgo::collapseSplineParameters( parameters ) );
-}
-
-CompoundDataPtr expandSplineParametersWrapper( CompoundDataPtr parameters )
-{
-	return boost::const_pointer_cast< CompoundData >( ShaderNetworkAlgo::expandSplineParameters( parameters ) );
-}
-
-std::string componentConnectionAdapterLabelWrapper()
-{
-	return ShaderNetworkAlgo::componentConnectionAdapterLabel().string();
-}
-
 } // namespace
 
 void IECoreSceneModule::bindShaderNetworkAlgo()
@@ -101,13 +81,9 @@ void IECoreSceneModule::bindShaderNetworkAlgo()
 	def( "deregisterSplitAdapter", &ShaderNetworkAlgo::deregisterSplitAdapter, ( arg( "destinationShaderType" ), arg( "component" ) ) );
 	def( "registerJoinAdapter", &registerJoinAdapterWrapper, ( arg( "destinationShaderType" ), arg( "destinationParameterType" ), arg( "adapter" ), arg( "inParameters" ), arg( "outParameter" ) ) );
 	def( "deregisterJoinAdapter", &ShaderNetworkAlgo::deregisterJoinAdapter, ( arg( "destinationShaderType" ), arg( "destinationParameterType" ) ) );
-	def( "componentConnectionAdapterLabel", &componentConnectionAdapterLabelWrapper );
 	def( "convertToOSLConventions", &ShaderNetworkAlgo::convertToOSLConventions );
-	def( "convertOSLComponentConnections", &convertOSLComponentConnectionsWrapper, ( arg( "network" ), arg( "oslVersion" ) = 10900 ) );
 	def( "convertObjectVector", &ShaderNetworkAlgo::convertObjectVector );
 	def( "collapseSplines", &ShaderNetworkAlgo::collapseSplines, ( arg( "network" ), arg( "targetPrefix" ) = "" ) );
 	def( "expandSplines", &ShaderNetworkAlgo::expandSplines, ( arg( "network" ), arg( "targetPrefix" ) = "" ) );
-	def( "collapseSplineParameters", &collapseSplineParametersWrapper );
-	def( "expandSplineParameters", &expandSplineParametersWrapper );
 
 }

test/IECoreScene/ShaderNetworkAlgoTest.py

@@ -116,45 +116,6 @@ def testRemoveUnusedShaders( self ) :
 
 	def testConvertColorComponentOutputConnection( self ) :
 
-		# OSL < 1.10
-
-		n = IECoreScene.ShaderNetwork(
-			shaders = {
-				"texture" : IECoreScene.Shader( "noise", "osl:shader" ),
-				"surface" : IECoreScene.Shader( "plastic", "osl:surface" ),
-			},
-			connections = [
-				( ( "texture", "out.r" ), ( "surface", "Kd" ) ),
-				( ( "texture", "out.g" ), ( "surface", "Ks" ) ),
-				( ( "texture", "out.g" ), ( "surface", "Kt" ) ),
-			],
-			output = "surface"
-		)
-
-		self.assertEqual( len( n ), 2 )
-
-		IECoreScene.ShaderNetworkAlgo.convertOSLComponentConnections( n )
-		self.assertEqual( len( n ), 4 )
-
-		self.assertEqual( len( n.inputConnections( "surface" ) ), 3 )
-		self.assertEqual( len( n.inputConnections( "texture" ) ), 0 )
-
-		kdInput = n.input( ( "surface", "Kd" ) )
-		self.assertEqual( kdInput.name, "out" )
-		self.assertEqual( n.getShader( kdInput.shader ).type, "osl:shader" )
-		self.assertEqual( n.getShader( kdInput.shader ).name, "MaterialX/mx_swizzle_color_float" )
-		self.assertEqual( n.getShader( kdInput.shader ).parameters["channels"].value, "r" )
-
-		ksInput = n.input( ( "surface", "Ks" ) )
-		self.assertEqual( ksInput.name, "out" )
-		self.assertEqual( n.getShader( ksInput.shader ).type, "osl:shader" )
-		self.assertEqual( n.getShader( ksInput.shader ).name, "MaterialX/mx_swizzle_color_float" )
-		self.assertEqual( n.getShader( ksInput.shader ).parameters["channels"].value, "g" )
-
-		self.assertEqual( n.input( ( "surface", "Kt" ) ), ksInput )
-
-		# OSL > 1.10
-
 		n = IECoreScene.ShaderNetwork(
 			shaders = {
 				"texture" : IECoreScene.Shader( "noise", "osl:shader" ),
@@ -170,7 +131,7 @@ def testConvertColorComponentOutputConnection( self ) :
 
 		self.assertEqual( len( n ), 2 )
 
-		IECoreScene.ShaderNetworkAlgo.convertOSLComponentConnections( n, 11000 )
+		IECoreScene.ShaderNetworkAlgo.convertToOSLConventions( n, 11000 )
 		self.assertEqual( len( n ), 2 )
 
 		self.assertEqual( len( n.inputConnections( "surface" ) ), 3 )
@@ -182,8 +143,6 @@ def testConvertColorComponentOutputConnection( self ) :
 
 	def testConvertColorComponentInputConnection( self ) :
 
-		# OSL < 1.10
-
 		n = IECoreScene.ShaderNetwork(
 			shaders = {
 				"texture1" : IECoreScene.Shader( "floatNoise", "osl:shader" ),
@@ -202,49 +161,7 @@ def testConvertColorComponentInputConnection( self ) :
 
 		self.assertEqual( len( n ), 3 )
 
-		IECoreScene.ShaderNetworkAlgo.convertOSLComponentConnections( n )
-		self.assertEqual( len( n ), 4 )
-
-		self.assertFalse( n.input( ( "surface", "Cs.r" ) ) )
-		self.assertFalse( n.input( ( "surface", "Cs.g" ) ) )
-		self.assertFalse( n.input( ( "surface", "Cs.b" ) ) )
-
-		csInput = n.input( ( "surface", "Cs" ) )
-		self.assertEqual( csInput.name, "out" )
-
-		packShader = n.getShader( csInput.shader )
-		self.assertEqual( packShader.name, "MaterialX/mx_pack_color" )
-		self.assertEqual( packShader.type, "osl:shader" )
-
-		self.assertEqual( packShader.parameters["in1"], IECore.FloatData( 0.2 ) )
-		self.assertEqual( packShader.parameters["in2"], IECore.FloatData( 0.3 ) )
-		self.assertEqual( packShader.parameters["in3"], IECore.FloatData( 0.4 ) )
-
-		self.assertEqual( n.input( ( csInput.shader, "in1" ) ), ( "texture1", "out" ) )
-		self.assertEqual( n.input( ( csInput.shader, "in2" ) ), ( "", "" ) )
-		self.assertEqual( n.input( ( csInput.shader, "in3" ) ), ( "texture2", "out" ) )
-
-		# OSL > 1.10
-
-		n = IECoreScene.ShaderNetwork(
-			shaders = {
-				"texture1" : IECoreScene.Shader( "floatNoise", "osl:shader" ),
-				"texture2" : IECoreScene.Shader( "floatNoise", "osl:shader" ),
-				"surface" : IECoreScene.Shader(
-					"plastic", "osl:surface",
-					parameters = { "Cs" : imath.Color3f( 0.2, 0.3, 0.4 ) }
-				)
-			},
-			connections = [
-				( ( "texture1", "out" ), ( "surface", "Cs.r" ) ),
-				( ( "texture2", "out" ), ( "surface", "Cs.b" ) ),
-			],
-			output = "surface"
-		)
-
-		self.assertEqual( len( n ), 3 )
-
-		IECoreScene.ShaderNetworkAlgo.convertOSLComponentConnections( n, 11000 )
+		IECoreScene.ShaderNetworkAlgo.convertToOSLConventions( n, 11000 )
 		self.assertEqual( len( n ), 3 )
 
 		self.assertEqual( n.input( ( "surface", "Cs[0]" ) ), ( "texture1", "out" ) )
@@ -268,7 +185,7 @@ def testArnoldComponentConnectionsNotConverted( self ) :
 		)
 
 		n2 = n.copy()
-		IECoreScene.ShaderNetworkAlgo.convertOSLComponentConnections( n2 )
+		IECoreScene.ShaderNetworkAlgo.convertToOSLConventions( n2, 11000 )
 		self.assertEqual( n, n2 )
 
 	def testAddRemoveComponentConnectionAdapters( self ) :