Merge branch 'RB-10.4' into main

Author: johnhaddon

Changes

@@ -1,3 +1,16 @@
+10.4.1.1 (relative to 10.4.1.0)
+========
+
+Fixes
+-----
+
+- AlembicScene : Fixed hash for animated visibility attribute (#1295).
+- Font : Fixed crashes caused by negative `char` values (#1291).
+- IECoreMaya : Fixed erroneous display of hidden locations in VP2 (#1290).
+- IECoreMaya : Updated SceneShape drawing to respect ancestral visibility overrides (#1290).
+- IECoreMaya : Fixed SceneShape isolate selection in maya (#1290).
+- USDScene : Fixed loading of primitive variables from UsdGeomPointInstancers (#1292).
+
 10.4.1.0 (relative to 10.4.0.0)
 ========
 
@@ -60,6 +73,17 @@ Build
 
 - Updated IE options file to support Nuke 13.x custom dependencies (#1263).
 
+10.3.7.2 (relative to 10.3.7.1)
+========
+
+Fixes
+-----
+
+- IECoreMaya : Fixed erroneous display of hidden locations in VP2 (#1290).
+- IECoreMaya : Updated SceneShape drawing to respect ancestral visibility overrides (#1290).
+- IECoreMaya : Fixed SceneShape isolate selection in maya (#1290).
+- USDScene : Fixed loading of primitive variables from UsdGeomPointInstancers (#1292).
+
 10.3.7.1 (relative to 10.3.7.0)
 ========
 

SConstruct

@@ -57,7 +57,7 @@ SConsignFile()
 ieCoreMilestoneVersion = 10 # for announcing major milestones - may contain all of the below
 ieCoreMajorVersion = 4 # backwards-incompatible changes
 ieCoreMinorVersion = 1 # new backwards-compatible features
-ieCorePatchVersion = 0 # bug fixes
+ieCorePatchVersion = 1 # bug fixes
 ieCoreVersionSuffix = "" # used for alpha/beta releases. Example: "a1", "b2", etc.
 
 ###########################################################################################

contrib/IECoreAlembic/src/IECoreAlembic/AlembicScene.cpp

@@ -850,12 +850,26 @@ class AlembicScene::AlembicReader : public AlembicIO
 			const IXformSchema &schema = m_xform.getSchema();
 			ICompoundProperty compoundProperty = schema.getUserProperties();
 
+			bool haveAttributes = false;
+			bool haveAnimation = false;
+
 			if( compoundProperty.valid() )
+			{
+				haveAttributes = true;
+				haveAnimation = haveAnimation || isAnimated( compoundProperty );
+			}
+
+			if( auto visibilityReader = scalarPropertyReader( visibilityName ) )
+			{
+				haveAttributes = true;
+				haveAnimation = haveAnimation || !visibilityReader->isConstant();
+			}
+
+			if( haveAttributes )
 			{
 				h.append( fileName() );
 				h.append( m_xform ? m_xform.getFullName() : "/" );
-
-				if( isAnimated( compoundProperty ) )
+				if( haveAnimation )
 				{
 					h.append( time );
 				}

contrib/IECoreAlembic/test/IECoreAlembic/AlembicSceneTest.py

@@ -1964,24 +1964,46 @@ def testVisibilityAttribute( self ) :
 
 		fileName = os.path.join( self.temporaryDirectory(), "visibilityAttribute.abc" )
 		root = IECoreScene.SceneInterface.create( fileName, IECore.IndexedIO.OpenMode.Write )
+
 		root.createChild( "withoutAttribute" )
-		child = root.createChild( "withAttribute" )
+
+		child = root.createChild( "withAnimatedAttribute" )
 		child.writeAttribute( "scene:visible", IECore.BoolData( True ), 0 )
 		child.writeAttribute( "scene:visible", IECore.BoolData( False ), 1 )
 
+		child = root.createChild( "withStaticAttribute" )
+		child.writeAttribute( "scene:visible", IECore.BoolData( True ), 0 )
+
 		del child, root
 
 		root = IECoreScene.SceneInterface.create( fileName, IECore.IndexedIO.OpenMode.Read )
 
-		child = root.child( "withAttribute" )
+		child = root.child( "withoutAttribute" )
+		self.assertNotIn( "scene:visible", child.attributeNames() )
+		self.assertFalse( child.hasAttribute( "scene:visible" ) )
+		withoutHash = child.hash( IECoreScene.SceneInterface.HashType.AttributesHash, 0 )
+
+		child = root.child( "withAnimatedAttribute" )
 		self.assertIn( "scene:visible", child.attributeNames() )
 		self.assertTrue( child.hasAttribute( "scene:visible" ) )
 		self.assertEqual( child.readAttribute( "scene:visible", 0 ), IECore.BoolData( True ) )
 		self.assertEqual( child.readAttribute( "scene:visible", 1 ), IECore.BoolData( False ) )
+		animatedFrame1Hash = child.hash( IECoreScene.SceneInterface.HashType.AttributesHash, 1 )
+		self.assertNotEqual( child.hash( IECoreScene.SceneInterface.HashType.AttributesHash, 0 ), animatedFrame1Hash )
+		self.assertNotEqual( child.hash( IECoreScene.SceneInterface.HashType.AttributesHash, 0 ), withoutHash )
+		self.assertNotEqual( animatedFrame1Hash, withoutHash )
 
-		child = root.child( "withoutAttribute" )
-		self.assertNotIn( "scene:visible", child.attributeNames() )
-		self.assertFalse( child.hasAttribute( "scene:visible" ) )
+		child = root.child( "withStaticAttribute" )
+		self.assertIn( "scene:visible", child.attributeNames() )
+		self.assertTrue( child.hasAttribute( "scene:visible" ) )
+		self.assertEqual( child.readAttribute( "scene:visible", 0 ), IECore.BoolData( True ) )
+		self.assertEqual( child.readAttribute( "scene:visible", 1 ), IECore.BoolData( True ) )
+		self.assertEqual(
+			child.hash( IECoreScene.SceneInterface.HashType.AttributesHash, 0 ),
+			child.hash( IECoreScene.SceneInterface.HashType.AttributesHash, 1 ),
+		)
+		self.assertNotEqual( child.hash( IECoreScene.SceneInterface.HashType.AttributesHash, 1 ), animatedFrame1Hash )
+		self.assertNotEqual( child.hash( IECoreScene.SceneInterface.HashType.AttributesHash, 1 ), withoutHash )
 
 if __name__ == "__main__":
     unittest.main()

contrib/IECoreUSD/src/IECoreUSD/PointInstancerAlgo.cpp

@@ -123,6 +123,10 @@ IECore::ObjectPtr readPointInstancer( pxr::UsdGeomPointInstancer &pointInstancer
 
 	newPoints->variables["prototypeRoots"] = IECoreScene::PrimitiveVariable( IECoreScene::PrimitiveVariable::Constant, prototypeRootsData );
 
+	// Primitive variables
+
+	PrimitiveAlgo::readPrimitiveVariables( pxr::UsdGeomPrimvarsAPI( pointInstancer ), time, newPoints.get(), canceller );
+
 	return newPoints;
 }
 
@@ -136,7 +140,10 @@ bool pointInstancerMightBeTimeVarying( pxr::UsdGeomPointInstancer &instancer )
 		instancer.GetScalesAttr().ValueMightBeTimeVarying() ||
 		instancer.GetVelocitiesAttr().ValueMightBeTimeVarying() ||
 		instancer.GetAccelerationsAttr().ValueMightBeTimeVarying() ||
-		instancer.GetAngularVelocitiesAttr().ValueMightBeTimeVarying()
+		instancer.GetAngularVelocitiesAttr().ValueMightBeTimeVarying() ||
+		PrimitiveAlgo::primitiveVariablesMightBeTimeVarying(
+			pxr::UsdGeomPrimvarsAPI( instancer )
+		)
 	;
 }
 

contrib/IECoreUSD/test/IECoreUSD/USDSceneTest.py

@@ -3240,5 +3240,36 @@ def testMultipleLights( self ) :
 			self.assertIsInstance( attribute, IECoreScene.ShaderNetwork )
 			self.assertEqual( attribute.outputShader().parameters["exposure"], IECore.FloatData( exposure ) )
 
+	def testPointInstancerPrimvars( self ) :
+
+		# Use the USD API to author a point instancer with primvars on it.
+
+		fileName = os.path.join( self.temporaryDirectory(), "pointInstancePrimvars.usda" )
+		stage = pxr.Usd.Stage.CreateNew( fileName )
+		points = pxr.UsdGeom.PointInstancer.Define( stage, "/points" )
+		points.CreatePositionsAttr( [ ( v, v, v ) for v in range( 0, 5 ) ] )
+
+		primvars = pxr.UsdGeom.PrimvarsAPI( points )
+		primvar = primvars.CreatePrimvar( "myColor", pxr.Sdf.ValueTypeNames.Color3fArray, "vertex" )
+		primvar.Set(
+			[ ( c, c, c ) for c in range( 1, 6 ) ]
+		)
+
+		stage.GetRootLayer().Save()
+
+		# Check we can load the primvar via a SceneInterface.
+
+		root = IECoreScene.SceneInterface.create( fileName, IECore.IndexedIO.OpenMode.Read )
+		points = root.child( "points" ).readObject( 0 )
+
+		self.assertIsInstance( points, IECoreScene.PointsPrimitive )
+		self.assertIn( "myColor", points )
+		self.assertEqual(
+			points["myColor"].data,
+			IECore.Color3fVectorData( [ imath.Color3f( c ) for c in range( 1, 6 ) ] )
+		)
+		self.assertEqual( points["myColor"].interpolation, IECoreScene.PrimitiveVariable.Interpolation.Vertex )
+		self.assertEqual( points["myColor"].indices, None )
+
 if __name__ == "__main__":
 	unittest.main()

include/IECoreMaya/LiveScene.h

@@ -78,9 +78,6 @@ class IECOREMAYA_API LiveScene : public IECoreScene::SceneInterface
 		/// Name of maya attribute overriding `IECoreScene::SceneInterface::visibilityName`
 		static IECoreScene::SceneInterface::Name visibilityOverrideName;
 
-		/// Returns the MDagPath object to the scene node
-		MDagPath dagPath() const;
-
 		/*
 		 * Bounding box
 		 */
@@ -188,6 +185,19 @@ class IECOREMAYA_API LiveScene : public IECoreScene::SceneInterface
 		/// Currently raises an exception
 		void hash( HashType hashType, double time, IECore::MurmurHash &h ) const override;
 
+		/*
+		* Utility functions
+		*/
+
+		/// Returns the MDagPath object to the scene node
+		MDagPath dagPath() const;
+
+		/// Returns the scene path corresponding to the maya dag path
+		static void dagPathToPath( MDagPath dagPath, IECoreScene::SceneInterface::Path &path );
+
+		/// Returns the maya dag path corresponding to the scene path
+		static void pathToDagPath( const IECoreScene::SceneInterface::Path &path, MDagPath &dagPath );
+
 		/// Translates cortex attribute name to maya attribute name
 		/// Returns an empty string if there are no valid mappings
 		static Name toMayaAttributeName( const Name &name );

include/IECoreMaya/SceneShapeInterface.h

@@ -138,6 +138,8 @@ class IECOREMAYA_API SceneShapeInterface: public MPxComponentShape
 		const std::vector< IECore::InternedString > & componentNames() const;
 		/// Return the value of the time plug for the SceneShape.
 		double time() const;
+		/// Determines scene visibility while accounting for ancestral visibility overrides
+		static bool isVisible( const MDagPath &dagPath );
 
 	protected :
 

src/IECoreMaya/LiveScene.cpp

@@ -206,20 +206,7 @@ void LiveScene::path( Path &p ) const
 		throw Exception( "IECoreMaya::LiveScene::path: Dag path no longer exists!" );
 	}
 
-	std::string pathStr( m_dagPath.fullPathName().asChar() );
-	boost::tokenizer<boost::char_separator<char> > t( pathStr, boost::char_separator<char>( "|" ) );
-
-	p.clear();
-
-	for (
-		boost::tokenizer<boost::char_separator<char> >::iterator it = t.begin();
-		it != t.end();
-		++it
-	)
-	{
-		p.push_back( Name( *it ) );
-	}
-
+	dagPathToPath( m_dagPath, p );
 }
 
 Imath::Box3d LiveScene::readBound( double time ) const
@@ -1122,6 +1109,66 @@ void LiveScene::hash( HashType hashType, double time, MurmurHash &h ) const
 	throw Exception( "Hashes currently not supported in IECoreMaya::LiveScene objects." );
 }
 
+void LiveScene::dagPathToPath( MDagPath dagPath, IECoreScene::SceneInterface::Path &path )
+{
+	tbb::recursive_mutex::scoped_lock l( g_mutex );
+	path.clear();
+
+	if( dagPath.isValid() )
+	{
+		// Only transforms can be part of the path
+		if( !dagPath.hasFn( MFn::kTransform ) )
+		{
+			dagPath.pop();
+		}
+
+		const std::string pathStr( dagPath.fullPathName().asChar() );
+		const boost::tokenizer< boost::char_separator<char> > tokens( pathStr, boost::char_separator<char>( "|" ) );
+		for ( const auto &token : tokens )
+		{
+			path.push_back( token );
+		}
+
+		return;
+	}
+
+	throw Exception( "IECoreMaya::LiveScene::dagPathToPath invalid dag path." );
+}
+
+void LiveScene::pathToDagPath( const IECoreScene::SceneInterface::Path &path, MDagPath &dagPath )
+{
+	tbb::recursive_mutex::scoped_lock l( g_mutex );
+
+	if( path.empty() )
+	{
+		MItDag itDag;
+		itDag.getPath( dagPath );
+		return;
+	}
+
+	std::string dagPathStr;
+	for( const auto &name : path )
+	{
+		dagPathStr += "|";
+		dagPathStr += name;
+	}
+
+	MSelectionList sel;
+	if( sel.add( dagPathStr.c_str() ) && sel.getDagPath( 0, dagPath ) )
+	{
+		return;
+	}
+
+	// Invalid dag path
+	std::string pathStr;
+	IECoreScene::SceneInterface::pathToString( path, pathStr );
+	throw Exception(
+		boost::str(
+			boost::format( "IECoreMaya::LiveScene::pathToDagPath invalid conversion to dag path from \"%1%\"." ) % pathStr
+		)
+	);
+}
+
 void LiveScene::registerCustomObject( HasFn hasFn, ReadFn readFn )
 {
 	CustomReader r;

src/IECoreMaya/SceneShapeInterface.cpp

@@ -57,6 +57,7 @@
 #include "IECoreMaya/ToMayaCurveConverter.h"
 #include "IECoreMaya/MayaTypeIds.h"
 #include "IECoreMaya/PostLoadCallback.h"
+#include "IECoreMaya/LiveScene.h"
 
 #include "IECorePython/ScopedGILLock.h"
 #include "IECorePython/ScopedGILRelease.h"
@@ -97,6 +98,7 @@
 #include "maya/MFnGeometryData.h"
 #include "maya/MPlugArray.h"
 #include "maya/MFileIO.h"
+#include "maya/MAnimControl.h"
 
 #if MAYA_API_VERSION >= 201600
 
@@ -539,6 +541,38 @@ double SceneShapeInterface::time() const
 	return time.as( MTime::kSeconds );
 }
 
+bool SceneShapeInterface::isVisible( const MDagPath &dagPath )
+{
+	// Let maya check for basic dag visibility
+	// Maya handles hidden shapes, display layers, render layers, and intermediate objects
+	if( !dagPath.isVisible() )
+	{
+		return false;
+	}
+
+	// Check for ancestral visibility via LiveScene which accounts for visibility overrides which are not exposed to maya
+	IECoreMaya::ConstLiveScenePtr liveScene = new IECoreMaya::LiveScene();
+	const double currentTime = MAnimControl::currentTime().as( MTime::kSeconds );
+
+	SceneInterface::Path scenePath;
+	IECoreMaya::LiveScene::dagPathToPath( dagPath, scenePath );
+	const size_t pathLength = scenePath.size();
+	for( size_t i = 0; i < pathLength; ++i )
+	{
+		ConstSceneInterfacePtr scene = liveScene->scene( scenePath );
+		ConstBoolDataPtr liveSceneVisibility = runTimeCast<const BoolData>( scene->readAttribute( SceneInterface::visibilityName, currentTime ) );
+		if( liveSceneVisibility && !liveSceneVisibility->readable() )
+		{
+			// Not visible due to a visibility override
+			return false;
+		}
+
+		scenePath.pop_back();
+	}
+
+	return true;
+}
+
 MBoundingBox SceneShapeInterface::boundingBox() const
 {
 	MBoundingBox bound( MPoint( -1, -1, -1 ), MPoint( 1, 1, 1 ) );