USDScene : Handle USDGeomXformable's ResetXformStack

Because we don't have an equivalent in Cortex, we need to emulate this by applying the inverse of the parent matrix to the local matrix of the location where the stack reset is requested.

Author: johnhaddon

contrib/IECoreUSD/src/IECoreUSD/USDScene.cpp

@@ -438,6 +438,47 @@ class ShaderNetworkCache : public LRUCache<pxr::SdfPath, IECoreScene::ConstShade
 
 };
 
+Imath::M44d localTransform( const pxr::UsdPrim &prim, pxr::UsdTimeCode time )
+{
+	pxr::UsdGeomXformable transformable( prim );
+	if( !transformable )
+	{
+		return Imath::M44d();
+	}
+
+	pxr::GfMatrix4d transform;
+	bool reset = false;
+	transformable.GetLocalTransformation( &transform, &reset, time );
+	Imath::M44d result = DataAlgo::fromUSD( transform );
+
+	if( reset )
+	{
+		// Apply inverse of parent's world transform.
+		Imath::M44d parentWorldTransform;
+		pxr::UsdPrim parentPrim = prim.GetParent();
+		while( parentPrim )
+		{
+			parentWorldTransform = parentWorldTransform * localTransform( parentPrim, time );
+			parentPrim = parentPrim.GetParent();
+		}
+		result = result * parentWorldTransform.inverse();
+	}
+
+	if( ( prim.GetParent().IsPseudoRoot() || reset ) && pxr::UsdGeomGetStageUpAxis( prim.GetStage() ) == pxr::UsdGeomTokens->z )
+	{
+		// Apply Z-up to Y-up correction
+		static Imath::M44d b(
+			0, 0, 1, 0,
+			1, 0, 0, 0,
+			0, 1, 0, 0,
+			0, 0, 0, 1
+		);
+		result = result * b;
+	}
+
+	return result;
+}
+
 } // namespace
 
 class USDScene::Location : public RefCounted
@@ -720,33 +761,7 @@ ConstDataPtr USDScene::readTransform( double time ) const
 
 Imath::M44d USDScene::readTransformAsMatrix( double time ) const
 {
-	pxr::UsdGeomXformable transformable( m_location->prim );
-	if( !transformable )
-	{
-		return Imath::M44d();
-	}
-
-	bool zUp = m_location->prim.GetParent().IsPseudoRoot() && pxr::UsdGeomGetStageUpAxis( m_root->getStage() ) == pxr::UsdGeomTokens->z;
-
-	pxr::GfMatrix4d transform;
-	bool reset = false;
-
-	transformable.GetLocalTransformation( &transform, &reset, m_root->getTime( time ) );
-	Imath::M44d returnValue = DataAlgo::fromUSD( transform );
-
-	if ( zUp )
-	{
-		static Imath::M44d b
-			(
-				0, 0, 1, 0,
-				1, 0, 0, 0,
-				0, 1, 0, 0,
-				0, 0, 0, 1
-			);
-
-		returnValue = returnValue * b;
-	}
-	return returnValue;
+	return localTransform( m_location->prim, m_root->getTime( time ) );
 }
 
 ConstObjectPtr USDScene::readObject( double time, const Canceller *canceller ) const
@@ -1396,7 +1411,26 @@ void USDScene::transformHash( double time, IECore::MurmurHash &h ) const
 	{
 		h.append( m_root->fileName() );
 		appendPrimOrMasterPath( m_location->prim, h );
-		if( xformable.TransformMightBeTimeVarying() )
+
+		bool mightBeTimeVarying = xformable.TransformMightBeTimeVarying();
+		if( !mightBeTimeVarying && xformable.GetResetXformStack() )
+		{
+			// Because we have to apply the inverse of our parent's transform, if
+			// that is time varying then so are we.
+			pxr::UsdPrim parentPrim = m_location->prim.GetParent();
+			while( parentPrim )
+			{
+				pxr::UsdGeomXformable parentXFormable( parentPrim );
+				if( parentXFormable && parentXFormable.TransformMightBeTimeVarying() )
+				{
+					mightBeTimeVarying = true;
+					break;
+				}
+				parentPrim = parentPrim.GetParent();
+			}
+		}
+
+		if( mightBeTimeVarying )
 		{
 			h.append( time );
 		}

contrib/IECoreUSD/test/IECoreUSD/USDSceneTest.py

@@ -3406,5 +3406,77 @@ def testRoundTripIndexedNormals( self ) :
 		root = IECoreScene.SceneInterface.create( fileName, IECore.IndexedIO.OpenMode.Read )
 		self.assertEqual( root.child( "mesh").readObject( 0.0 ), mesh )
 
+	def testResetXFormStack( self ) :
+
+		fileName = os.path.join( self.temporaryDirectory(), "resetXFormStack.usda" )
+		stage = pxr.Usd.Stage.CreateNew( fileName )
+
+		g1 = pxr.UsdGeom.Xform.Define( stage, "/g1" )
+		g1.AddScaleOp().Set( pxr.Gf.Vec3f( 1, 2, 3 ) )
+
+		g2 = pxr.UsdGeom.Xform.Define( stage, "/g1/g2" )
+		g2.AddTranslateOp().Set( pxr.Gf.Vec3f( 4, 5, 6 ) )
+
+		g3 = pxr.UsdGeom.Xform.Define( stage, "/g1/g2/g3" )
+		g3.AddTranslateOp().Set( pxr.Gf.Vec3f( 1, 0, 1 ) )
+		g3.SetResetXformStack( True )
+
+		pxr.UsdGeom.Sphere.Define( stage, "/g1/g2/g3/s" )
+
+		stage.GetRootLayer().Save()
+		del stage
+
+		worldTransform = imath.M44d()
+		location = IECoreScene.SceneInterface.create( fileName, IECore.IndexedIO.OpenMode.Read )
+		for name in [ "g1", "g2", "g3", "s" ] :
+			location = location.child( name )
+			worldTransform = location.readTransformAsMatrix( 0 ) * worldTransform
+			self.assertEqual(
+				location.hash( location.HashType.TransformHash, 1 ), # There is no animation,
+				location.hash( location.HashType.TransformHash, 2 ), # so hashes should be identical
+			)
+
+		self.assertEqual( worldTransform, imath.M44d().translate( imath.V3f( 1, 0, 1 ) ) )
+
+	def testResetXFormStackHash( self ) :
+
+		fileName = os.path.join( self.temporaryDirectory(), "resetXFormStackHash.usda" )
+		stage = pxr.Usd.Stage.CreateNew( fileName )
+
+		# /g1 (animated transform)
+		#  /g2a (reset transform stack)
+		#  /g2b
+
+		g1 = pxr.UsdGeom.Xform.Define( stage, "/g1" )
+		scaleOp = g1.AddScaleOp()
+		scaleOp.Set( pxr.Gf.Vec3f( 2 ), 1 )
+		scaleOp.Set( pxr.Gf.Vec3f( 4 ), 2 )
+
+		g2a = pxr.UsdGeom.Xform.Define( stage, "/g1/g2a" )
+		g2a.SetResetXformStack( True )
+		pxr.UsdGeom.Xform.Define( stage, "/g1/g2b" )
+
+		stage.GetRootLayer().Save()
+		del stage
+
+		root = IECoreScene.SceneInterface.create( fileName, IECore.IndexedIO.OpenMode.Read )
+		g2a = root.scene( [ "g1", "g2a" ] )
+		g2b = root.scene( [ "g1", "g2b" ] )
+
+		# Hash should be animated because the reset needs to account
+		# for animation on parent.
+
+		self.assertNotEqual(
+			g2a.hash( g2a.HashType.TransformHash, 1 ),
+			g2a.hash( g2a.HashType.TransformHash, 2 ),
+		)
+
+		# Hash should be static, because there is no reset.
+
+		self.assertEqual(
+			g2b.hash( g2a.HashType.TransformHash, 1 ),
+			g2b.hash( g2a.HashType.TransformHash, 2 ),
+		)
+
 if __name__ == "__main__":
 	unittest.main()