Switch to using RampData for shader parameters instead of SplineData

Author: danieldresser-ie

contrib/IECoreUSD/src/IECoreUSD/ShaderAlgo.cpp

@@ -302,7 +302,7 @@ IECoreScene::ShaderNetwork::Parameter readShaderNetworkWalk( const pxr::SdfPath
 IECoreScene::ConstShaderNetworkPtr adaptShaderNetworkForWriting( const IECoreScene::ShaderNetwork *shaderNetwork )
 {
 	IECoreScene::ShaderNetworkPtr result = shaderNetwork->copy();
-	IECoreScene::ShaderNetworkAlgo::expandSplines( result.get() );
+	IECoreScene::ShaderNetworkAlgo::expandRamps( result.get() );
 	IECoreScene::ShaderNetworkAlgo::addComponentConnectionAdapters( result.get() );
 	return result;
 }
@@ -529,7 +529,7 @@ IECoreScene::ShaderNetworkPtr IECoreUSD::ShaderAlgo::readShaderNetwork( const px
 	result->setOutput( outputHandle );
 
 	IECoreScene::ShaderNetworkAlgo::removeComponentConnectionAdapters( result.get() );
-	IECoreScene::ShaderNetworkAlgo::collapseSplines( result.get() );
+	IECoreScene::ShaderNetworkAlgo::collapseRamps( result.get() );
 
 	return result;
 }

contrib/IECoreUSD/test/IECoreUSD/USDSceneTest.py

@@ -2917,12 +2917,13 @@ def testShaders( self ) :
 		surface.parameters["c"] = IECore.StringData( "42" )
 		surface.parameters["d"] = IECore.Color3fData( imath.Color3f( 3 ) )
 		surface.parameters["e"] = IECore.V3fVectorData( [ imath.V3f( 7 ) ] )
-		surface.parameters["f"] = IECore.SplineffData( IECore.Splineff( IECore.CubicBasisf.bSpline(),
-			( ( 0, 1 ), ( 10, 2 ), ( 20, 0 ), ( 21, 2 ) ) )
-		)
-		surface.parameters["g"] = IECore.SplinefColor3fData( IECore.SplinefColor3f( IECore.CubicBasisf.linear(),
-			( ( 0, imath.Color3f(1) ), ( 10, imath.Color3f(2) ), ( 20, imath.Color3f(0) ) ) )
-		)
+		surface.parameters["f"] = IECore.RampffData( IECore.Rampff(
+			( ( 0, 1 ), ( 10, 2 ), ( 20, 0 ), ( 21, 2 ) ), IECore.RampInterpolation.BSpline
+		) )
+		surface.parameters["g"] = IECore.RampfColor3fData( IECore.RampfColor3f(
+			( ( 0, imath.Color3f(1) ), ( 10, imath.Color3f(2) ), ( 20, imath.Color3f(0) ) ),
+			IECore.RampInterpolation.Linear
+		) )
 
 		add1 = IECoreScene.Shader( "add", "ai:shader" )
 		add1.parameters["b"] = IECore.FloatData( 3.0 )
@@ -2978,11 +2979,13 @@ def testShaders( self ) :
 		dest.parameters["a"] = IECore.Color3fData( imath.Color3f( 0.0 ) )
 		dest.parameters["b"] = IECore.Color3fData( imath.Color3f( 0.0 ) )
 		dest.parameters["c"] = IECore.FloatData( 0.0 )
-		dest.parameters["sf"] = IECore.SplineffData( IECore.Splineff( IECore.CubicBasisf.catmullRom(),
-			( ( 0, 1 ), ( 10, 2 ), ( 20, 0 ), ( 30, 1 ) )
+		dest.parameters["sf"] = IECore.RampffData( IECore.Rampff(
+			( ( 0, 1 ), ( 10, 2 ), ( 20, 0 ), ( 30, 1 ) ),
+			IECore.RampInterpolation.CatmullRom
 		) )
-		dest.parameters["sc"] = IECore.SplinefColor3fData( IECore.SplinefColor3f( IECore.CubicBasisf.linear(),
-			( ( 0, imath.Color3f(1) ), ( 10, imath.Color3f(2) ), ( 20, imath.Color3f(0) ) )
+		dest.parameters["sc"] = IECore.RampfColor3fData( IECore.RampfColor3f(
+			( ( 0, imath.Color3f(1) ), ( 10, imath.Color3f(2) ), ( 20, imath.Color3f(0) ) ),
+			IECore.RampInterpolation.Linear
 		) )
 
 		componentConnectionNetwork = IECoreScene.ShaderNetwork()
@@ -3016,19 +3019,19 @@ def testShaders( self ) :
 		) )
 		componentConnectionNetwork.setOutput( IECoreScene.ShaderNetwork.Parameter( "dest", "" ) )
 
-		# Float to spline element connection
+		# Float to ramp element connection
 		componentConnectionNetwork.addConnection( IECoreScene.ShaderNetwork.Connection(
 			IECoreScene.ShaderNetwork.Parameter( "source1", "out" ),
 			IECoreScene.ShaderNetwork.Parameter( "dest", "sf[3].y" )
 		) )
 
-		# Color to spline element connection
+		# Color to ramp element connection
 		componentConnectionNetwork.addConnection( IECoreScene.ShaderNetwork.Connection(
 			IECoreScene.ShaderNetwork.Parameter( "source3", "out" ),
 			IECoreScene.ShaderNetwork.Parameter( "dest", "sc[2].y" )
 		) )
 
-		# Float to spline element component connection
+		# Float to ramp element component connection
 		componentConnectionNetwork.addConnection( IECoreScene.ShaderNetwork.Connection(
 			IECoreScene.ShaderNetwork.Parameter( "source1", "out" ),
 			IECoreScene.ShaderNetwork.Parameter( "dest", "sc[0].y.g" )

include/IECore/SplineParameter.h

@@ -41,6 +41,12 @@
 namespace IECore
 {
 
+// \todo : Using Spline*Data has basically been deprecated in favour of Ramp*Data.
+// Setting up data this way will no longer work with renderer backends. In theory,
+// the right thing to do might be to replace this with RampParameter ... but on
+// the other hand, Parameter itself probably should be deprecated ( these days,
+// anyone using Cortex to build UIs is probably using Gaffer ).
+
 typedef TypedParameter<Splineff> SplineffParameter;
 typedef TypedParameter<Splinedd> SplineddParameter;
 typedef TypedParameter<SplinefColor3f> SplinefColor3fParameter;

include/IECoreImage/SplineToImage.h

@@ -54,6 +54,8 @@ namespace IECoreImage
 
 /// This Op creates ImagePrimitives from SplineData.
 /// \todo Different projections would be nice.
+/// \todo If we wanted to keep this up to date, it should probably take RampData instead
+/// of SplineData, but ImagePrimitive is on the path to deprecation anyway.
 /// \ingroup imageProcessingGroup
 class IECOREIMAGE_API SplineToImage : public IECore::Op
 {

include/IECoreScene/ShaderNetworkAlgo.h

@@ -103,37 +103,39 @@ IECORESCENE_API void deregisterJoinAdapter( const std::string &destinationShader
 ///     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.
-/// - Splines
-///     We support SplineData as a parameter type. For OSL, these must be converted to 3 parameters named
-///     `<splineName>Positions`, `<splineName>Values` and `<splineName>Basis`. We also support input
-///     connections to spline Y values, specified as `<splineName>[N].y`, which currently must be implemented
+/// - Ramps
+///     We support RampData as a parameter type. For OSL, these must be converted to 3 parameters named
+///     `<rampName>Positions`, `<rampName>Values` and `<rampName>Basis`. We also support input
+///     connections to ramp Y values, specified as `<rampName>[N].y`, which currently must be implemented
 ///     using an adapter shader.
 IECORESCENE_API void convertToOSLConventions( ShaderNetwork *network, int oslVersion );
 
 /// Converts from the legacy ObjectVector format previously used to represent shader networks.
 IECORESCENE_API ShaderNetworkPtr convertObjectVector( const IECore::ObjectVector *network );
 
-/// We use a convention where ramps are represented by a single SplineData in Cortex, but must be expanded
+/// We use a convention where ramps are represented by a single RampData in Cortex, but must be expanded
 /// out into basic types when being passed to a renderer. We need two functions to convert back and forth.
 
-
-/// Look throughout the network for parameters matching our spline convention, for any possible <prefix> :
+/// Look throughout the network for parameters matching our ramp convention, for any possible <prefix> :
 /// <prefix>Positions, a float vector parameter
 /// <prefix>Values, a vector of a value type, such as float or color
 /// <prefix>Basis, a string parameter
 /// For each set of parameters found matching this convention, the 3 parameters will be replaced with one
-/// spline parameter named <prefix>. If input connections are represented using an adapter shader, they
-/// will be converted to direct connections to the spline using our support for spline element
+/// ramp parameter named <prefix>. If input connections are represented using an adapter shader, they
+/// will be converted to direct connections to the ramp using our support for ramp element
 /// connections.
 /// If `targetPrefix` is given, only translates connections to shaders with a type starting with this string
-IECORESCENE_API void collapseSplines( ShaderNetwork *network, std::string targetPrefix = "" );
+IECORESCENE_API void collapseRamps( ShaderNetwork *network, std::string targetPrefix = "" );
 
-/// Look throughout the network for spline parameters. If any are found, they will be expanded out into
+/// Look throughout the network for ramp parameters. If any are found, they will be expanded out into
 /// 3 parameters named <name>Positions, <name>Values and <name>Basis.
-/// We also support input connections to spline Y values, specified as `<splineName>[N].y`, which currently
+/// We also support input connections to ramp Y values, specified as `<rampName>[N].y`, which currently
 /// must be implemented by inserting an adapter shader.
 /// 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 = "" );
+IECORESCENE_API void expandRamps( ShaderNetwork *network, std::string targetPrefix = "" );
+
+/// Used when dealing with SCC files written before Cortex 10.7, which used Spline*Data instead of Ramp*Data
+IECORESCENE_API void convertDeprecatedSplines( ShaderNetwork *network );
 
 } // namespace ShaderNetworkAlgo
 

src/IECoreGL/ShaderStateComponent.cpp

@@ -132,6 +132,8 @@ class ShaderStateComponent::Implementation : public IECore::RefCounted
 				if( p->type == GL_SAMPLER_2D )
 				{
 					ConstTexturePtr texture = nullptr;
+					// TODO - this probably should actually be updated to take Ramp, but in order to test
+					// that, I need to figure out where this is used.
 					if(
 						it->second->typeId() == (IECore::TypeId)IECoreImage::ImagePrimitiveTypeId ||
 						it->second->typeId() == IECore::CompoundDataTypeId ||

src/IECoreScene/SceneCache.cpp

@@ -47,6 +47,7 @@
 #include "IECore/MessageHandler.h"
 #include "IECore/ObjectInterpolator.h"
 #include "IECore/SimpleTypedData.h"
+#include "IECore/SplineData.h"
 #include "IECore/TransformationMatrixData.h"
 #include "IECore/PathMatcherData.h"
 
@@ -1156,6 +1157,31 @@ class SceneCache::ReaderImplementation : public SceneCache::Implementation
 				}
 			}
 
+			if( const ShaderNetwork *shaderNetwork = runTimeCast<const ShaderNetwork>( result.get() ) )
+			{
+				bool needsDeprecatedSplineConversion = false;
+				for( const auto &s : shaderNetwork->shaders() )
+				{
+					for( const auto &p : s.second->parameters() )
+					{
+						IECore::TypeId typeId = p.second->typeId();
+						if(
+							typeId == SplineffData::staticTypeId() ||
+							typeId == SplinefColor3fData::staticTypeId()
+						)
+						needsDeprecatedSplineConversion = true;
+					}
+				}
+
+				if( needsDeprecatedSplineConversion )
+				{
+					ShaderNetworkPtr resultNetwork = shaderNetwork->copy();
+
+					ShaderNetworkAlgo::convertDeprecatedSplines( resultNetwork.get() );
+					result = resultNetwork;
+				}
+			}
+
 			return result;
 		}