USDScene : Fix loading of asset paths containing <UDIM> tokens

Author: johnhaddon

contrib/IECoreUSD/src/IECoreUSD/DataAlgo.cpp

@@ -38,12 +38,13 @@
 #include "IECore/MessageHandler.h"
 
 IECORE_PUSH_DEFAULT_VISIBILITY
-#include "pxr/usd/sdf/schema.h"
-
 #include "pxr/base/gf/matrix3f.h"
 #include "pxr/base/gf/matrix3d.h"
 #include "pxr/base/gf/matrix4f.h"
 #include "pxr/base/gf/matrix4d.h"
+
+#include "pxr/usd/sdf/layerUtils.h"
+#include "pxr/usd/sdf/schema.h"
 IECORE_POP_DEFAULT_VISIBILITY
 
 #include "boost/unordered_map.hpp"
@@ -139,9 +140,46 @@ IECore::DataPtr dataFromArray( const pxr::VtValue &value, GeometricData::Interpr
 	return d;
 }
 
+IECore::DataPtr dataFromSdfAssetPath( const SdfAssetPath &assetPath, const pxr::UsdAttribute *attribute = nullptr )
+{
+	if( assetPath.GetResolvedPath().size() || !assetPath.GetAssetPath().size() || !attribute )
+	{
+		return new StringData( assetPath.GetResolvedPath() );
+	}
+
+	// Path resolution failed, for a couple of possible reasons :
+	//
+	// - The asset may not exist. In this case we still want to load the source
+	//   asset path so that users can debug the problem.
+	// - The source path may have contained a `<UDIM>` token, which is not
+	//   understood by ArResolvers. USD defers all UDIM handling to UsdImaging,
+	//   which is of no use to us. We still want to load the source path
+	//   because the `<UDIM>` token will be resolved by the Cortex Renderer.
+	//
+	// In both cases, the source path may be relative to the layer in which
+	// it was authored, which may be buried deep in a complex composition, so
+	// we need to find that layer and make the path absolute.
+
+	SdfLayerHandle layer;
+	for( const auto &spec : attribute->GetPropertyStack() )
+	{
+		if(
+			spec->HasDefaultValue() ||
+			spec->GetLayer()->GetNumTimeSamplesForPath( spec->GetPath() )
+		)
+		{
+			return new StringData(
+				SdfComputeAssetPathRelativeToLayer( spec->GetLayer(), assetPath.GetAssetPath() )
+			);
+		}
+	}
+
+	return new StringData();
+}
+
 IECore::DataPtr dataFromSdfAssetPath( const pxr::VtValue &value, GeometricData::Interpretation interpretation, bool arrayAccepted )
 {
-	return new StringData( value.Get<SdfAssetPath>().GetResolvedPath() );
+	return dataFromSdfAssetPath( value.UncheckedGet<SdfAssetPath>() );
 }
 
 static const std::map<pxr::TfType, IECore::DataPtr (*)( const pxr::VtValue &, GeometricData::Interpretation, bool )> g_fromVtValueConverters = {
@@ -281,7 +319,15 @@ IECore::DataPtr IECoreUSD::DataAlgo::fromUSD( const pxr::UsdAttribute &attribute
 		return nullptr;
 	}
 
-	return DataAlgo::fromUSD( value, attribute.GetTypeName(), arrayAccepted );
+	if( value.IsHolding<SdfAssetPath>() )
+	{
+		// Special case to deal with resolution of UDIM textures.
+		return dataFromSdfAssetPath( value.UncheckedGet<SdfAssetPath>(), &attribute );
+	}
+	else
+	{
+		return DataAlgo::fromUSD( value, attribute.GetTypeName(), arrayAccepted );
+	}
 }
 
 //////////////////////////////////////////////////////////////////////////

contrib/IECoreUSD/test/IECoreUSD/USDSceneTest.py

@@ -2955,6 +2955,31 @@ def testAssetAttributes( self ) :
 			os.path.normcase( os.path.join( os.path.dirname( __file__ ), "data", "cube.usda" ) )
 		)
 
+	def testTextureParameters( self ) :
+
+		root = IECoreScene.SceneInterface.create(
+			os.path.join( os.path.dirname( __file__ ), "data", "textureParameters.usda" ),
+			IECore.IndexedIO.OpenMode.Read
+		)
+		sphere = root.child( "model" ).child( "sphere" )
+
+		self.assertEqual( sphere.attributeNames(), [ "surface" ] )
+		network = sphere.readAttribute( "surface", 0 )
+
+		self.assertEqual( network.size(), 4 )
+		self.assertEqual(
+			os.path.normpath( network.getShader( "relativeTexture" ).parameters["file"].value ),
+			os.path.join( os.path.dirname( __file__ ), "myTexture.tx" ),
+		)
+		self.assertEqual(
+			os.path.normpath( network.getShader( "relativeUDIMTexture" ).parameters["file"].value ),
+			os.path.join( os.path.dirname( __file__ ), "myTexture.<UDIM>.tx" ),
+		)
+		self.assertEqual(
+			os.path.normpath( network.getShader( "udimTexture" ).parameters["file"].value ),
+			os.path.normpath( "/full/path/to/myTexture.<UDIM>.tx" )
+		)
+
 	def testExposedShaderInput( self ) :
 
 		root = IECoreScene.SceneInterface.create(

contrib/IECoreUSD/test/IECoreUSD/data/textureParameters.usda

@@ -0,0 +1,52 @@
+#usda 1.0
+
+def "model"
+{
+
+	def Sphere "sphere"
+	{
+		rel material:binding = </model/materials/textureParameterTest>
+	}
+
+	def Scope "materials"
+	{
+
+		def Material "textureParameterTest"
+		{
+			token outputs:surface.connect = </model/materials/textureParameterTest/previewSurface.outputs:surface>
+
+			def Shader "previewSurface"
+			{
+				uniform token info:id = "UsdPreviewSurface"
+				color3f inputs:diffuseColor.connect = </model/materials/textureParameterTest/relativeTexture.outputs:rgb>
+				normal3f inputs:normal.connect = </model/materials/textureParameterTest/relativeUDIMTexture.outputs:rgb>
+				float inputs:roughness.connect = </model/materials/textureParameterTest/udimTexture.outputs:r>
+				token outputs:surface
+			}
+
+			def Shader "relativeTexture"
+			{
+				uniform token info:id = "UsdUVTexture"
+				asset inputs:file = @../myTexture.tx@
+				vector3f outputs:rgb
+			}
+
+			def Shader "relativeUDIMTexture"
+			{
+				uniform token info:id = "UsdUVTexture"
+				asset inputs:file = @../myTexture.<UDIM>.tx@
+				vector3f outputs:rgb
+
+			}
+
+			def Shader "udimTexture"
+			{
+				uniform token info:id = "UsdUVTexture"
+				asset inputs:file = @/full/path/to/myTexture.<UDIM>.tx@
+				float outputs:r
+			}
+		}
+	}
+}
+
+