Merge branch 'RB-10.6'

Author: murraystevenson

Changes

@@ -1,7 +1,18 @@
 10.7.x.x (relative to 10.7.0.0a2)
 ========
 
+Improvements
+------------
+
+- ShaderNetworkAlgo : Added render adaptor API, allowing just-in-time modifications to
+  ShaderNetworks during translation for rendering [^1].
+
+Fixes
+-----
+
+- CoordinateSystem : Added backwards compatibility for legacy transform [^1].
 
+[^1]: To be omitted from the notes for the final 10.7.0.0 release.
 
 10.7.0.0a2 (relative to 10.7.0.0a1)
 ==========
@@ -31,11 +42,28 @@ Breaking Changes
   - Removed deprecated functions componentConnectionAdapterLabel, convertOSLComponentConnections, collapseSplineParameters, expandSplineParameters.
   - Switch support for Spline parameters to support for Ramp parameters.
 
-10.6.x.x (relative to 10.6.2.1)
+10.6.x.x (relative to 10.6.3.0)
 ========
 
 
 
+10.6.3.0 (relative to 10.6.2.2)
+========
+
+Improvements
+------------
+
+- ShaderNetworkAlgo : Added render adaptor API, allowing just-in-time modifications to
+  ShaderNetworks during translation for rendering.
+
+10.6.2.2
+========
+
+Fixes
+-----
+
+- CoordinateSystem : Added backwards compatibility for legacy transform.
+
 10.6.2.1 (relative to 10.6.2.0)
 ========
 

SConstruct

@@ -41,15 +41,12 @@
 #
 ##########################################################################
 
-import SCons
-import shutil
 import glob
 import sys
 import os
 import re
 import subprocess
 import platform
-import distutils
 
 EnsureSConsVersion( 3, 0, 2 )  # Substfile is a default builder as of 3.0.2
 SConsignFile()

include/IECoreScene/ShaderNetworkAlgo.h

@@ -137,6 +137,39 @@ IECORESCENE_API void expandRamps( ShaderNetwork *network, std::string targetPref
 /// 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 );
 
+/// Render Adaptors
+/// ===============
+///
+/// Render adaptors are functions called to make "just in time" modifications to
+/// shader networks prior to rendering. They have access to a fully resolved
+/// attribute state, which can be used to drive the modifications. There is currently
+/// a single built-in adaptor, which uses `ShaderNetworkAlgo::applySubstitutions()`
+/// to allow strings such as texture paths to be substituted in from attributes that
+/// define them.
+///
+/// Adaptors are performance critical, so are deliberately not available via
+/// the Python API. They must be implemented in C++ only.
+
+/// A function that adapts the shader network for rendering, given the full
+/// inherited `attributes` for an object. Must be threadsafe.
+using RenderAdaptorFunction = void (*)( ShaderNetwork *shaderNetwork, IECore::InternedString attributeName, const IECore::CompoundObject *attributes );
+/// A function that appends to `hash` to uniquely identify the work that will be
+/// performed by an AdaptorFunction. Particular attention must be paid to
+/// the performance of any such function, as it will be called frequently. If an
+/// adaptor will be a no-op, then nothing should be appended to the hash.
+/// Must be threadsafe.
+using RenderAdaptorHashFunction = void (*)( const ShaderNetwork *shaderNetwork, IECore::InternedString attributeName, const IECore::CompoundObject *attributes, IECore::MurmurHash &hash );
+
+/// Registers an adaptor.
+IECORESCENE_API void registerRenderAdaptor( const std::string &name, RenderAdaptorHashFunction hashFunction, RenderAdaptorFunction adaptorFunction );
+/// Removes a previously registered adaptor with the specified name.
+IECORESCENE_API void deregisterRenderAdaptor( const std::string &name );
+
+/// Hashes all the currently registered adaptors for `shaderNetwork`.
+IECORESCENE_API void hashRenderAdaptors( const ShaderNetwork *shaderNetwork, IECore::InternedString attributeName, const IECore::CompoundObject *attributes, IECore::MurmurHash &hash );
+/// Applies all the currently registered adaptors to `shaderNetwork`.
+IECORESCENE_API void applyRenderAdaptors( ShaderNetwork *shaderNetwork, IECore::InternedString attributeName, const IECore::CompoundObject *attributes );
+
 } // namespace ShaderNetworkAlgo
 
 } // namespace IECoreScene

src/IECoreScene/CoordinateSystem.cpp

@@ -34,8 +34,12 @@
 
 #include "IECoreScene/CoordinateSystem.h"
 
+#include "IECore/SimpleTypedData.h"
 #include "IECore/MurmurHash.h"
 
+#include "Imath/ImathMatrix.h"
+#include "Imath/ImathMatrixAlgo.h"
+
 using namespace IECore;
 using namespace IECoreScene;
 using namespace boost;
@@ -104,6 +108,30 @@ void CoordinateSystem::load( LoadContextPtr context )
 	unsigned int v = m_ioVersion;
 	ConstIndexedIOPtr container = context->container( staticTypeName(), v );
 	container->read( g_nameEntry, m_name );
+
+	// CoordinateSystem used to have a transform property, but that has
+	// been removed in favour of transforms being accessed independently
+	// of objects in SceneInterface (and Gaffer). If a legacy transform
+	// exists, load it and stash it as blind data for use by legacy tools.
+
+	ConstIndexedIOPtr matrixTransformContainer = container;
+	for( auto name : { "transform", "data", "MatrixTransform", "data" } )
+	{
+		matrixTransformContainer = matrixTransformContainer->subdirectory( name, IndexedIO::MissingBehaviour::NullIfMissing );
+		if( !matrixTransformContainer )
+		{
+			break;
+		}
+	}
+
+	const IndexedIO::EntryID matrixEntry( "matrix" );
+	if( matrixTransformContainer && matrixTransformContainer->hasEntry( matrixEntry ) )
+	{
+		M44fDataPtr matrix = new M44fData;
+		float *f = matrix->writable().getValue();
+		matrixTransformContainer->read( matrixEntry, f, 16 );
+		blindData()->writable()["LegacyTransform"] = matrix;
+	}
 }
 
 void CoordinateSystem::hash( MurmurHash &h ) const

src/IECoreScene/ShaderNetworkAlgo.cpp

@@ -1423,3 +1423,92 @@ void ShaderNetworkAlgo::convertDeprecatedSplines( ShaderNetwork *network )
 
 	}
 }
+
+
+//////////////////////////////////////////////////////////////////////////
+// Render Adaptors
+//////////////////////////////////////////////////////////////////////////
+
+namespace
+{
+
+struct RenderAdaptor
+{
+	std::string name;
+	IECoreScene::ShaderNetworkAlgo::RenderAdaptorHashFunction hash;
+	IECoreScene::ShaderNetworkAlgo::RenderAdaptorFunction apply;
+};
+
+using RenderAdaptors = std::vector<RenderAdaptor>;
+RenderAdaptors &renderAdaptors()
+{
+	static RenderAdaptors g_renderAdaptors;
+	return g_renderAdaptors;
+}
+
+bool g_stringSubstitutionsRegistration = [] () {
+
+	IECoreScene::ShaderNetworkAlgo::registerRenderAdaptor(
+		"stringSubstitution",
+		// Hash
+		[] ( const IECoreScene::ShaderNetwork *shaderNetwork, InternedString attributeName, const IECore::CompoundObject *attributes, IECore::MurmurHash &hash ) {
+			shaderNetwork->hashSubstitutions( attributes, hash );
+		},
+		// Apply
+		[] ( IECoreScene::ShaderNetwork *shaderNetwork, InternedString attributeName, const IECore::CompoundObject *attributes ) {
+			shaderNetwork->applySubstitutions( attributes );
+		}
+	);
+
+	return true;
+} ();
+
+} // namespace
+
+void ShaderNetworkAlgo::registerRenderAdaptor( const std::string &name, RenderAdaptorHashFunction hashFunction, RenderAdaptorFunction adaptorFunction )
+{
+	// Replace existing adaptor if it exists.
+	RenderAdaptors &a = renderAdaptors();
+	for( auto &x : a )
+	{
+		if( x.name == name )
+		{
+			x.hash = hashFunction;
+			x.apply = adaptorFunction;
+			return;
+		}
+	}
+	// Otherwise add new adaptor.
+	a.push_back( { name, hashFunction, adaptorFunction } );
+}
+
+void ShaderNetworkAlgo::deregisterRenderAdaptor( const std::string &name )
+{
+	RenderAdaptors &a = renderAdaptors();
+	a.erase(
+		std::remove_if(
+			a.begin(),
+			a.end(),
+			[&] ( const RenderAdaptor &x ) {
+				return x.name == name;
+			}
+		),
+		a.end()
+	);
+}
+
+void ShaderNetworkAlgo::hashRenderAdaptors( const IECoreScene::ShaderNetwork *shaderNetwork, InternedString attributeName, const IECore::CompoundObject *attributes, IECore::MurmurHash &hash )
+{
+	for( const auto &x : renderAdaptors() )
+	{
+		x.hash( shaderNetwork, attributeName, attributes, hash );
+	}
+}
+
+void ShaderNetworkAlgo::applyRenderAdaptors( IECoreScene::ShaderNetwork *shaderNetwork, InternedString attributeName, const IECore::CompoundObject *attributes )
+{
+	for( const auto &x : renderAdaptors() )
+	{
+		x.apply( shaderNetwork, attributeName, attributes );
+	}
+}

test/IECoreScene/CoordinateSystemTest.py

@@ -87,6 +87,14 @@ def testEquality( self ) :
 		self.assertNotEqual( c2, c1 )
 		c1.setName( "test" )
 
+	def testLegacyTransform( self ) :
+
+		c = IECore.ObjectReader( os.path.join( "test", "IECoreScene", "data", "coordinateSystemLegacyTransform.cob" ) ).read()
+		self.assertTrue( c.blindData().has_key( "LegacyTransform" ) )
+
+		expected = imath.M44f().translate( imath.V3f( 0, 2, 0 ) )
+		self.assertEqual( c.blindData()["LegacyTransform"].value, expected )
+
 	def tearDown( self ) :
 
 		if os.path.exists( os.path.join( "test", "IECore", "data", "coordSys.cob" ) ) :