IECoreMaya : Updated SceneShape drawing to respect ancestral visibilty.

There have been visibility discrepancies when a layout is collasped
or expanded. When collasped, the drawing code is able to read
visibility overrides and hide the appropriate sub-hierarchies.
However, when the same layout is expanded the visibility was tested
at each expanded location, and it failed to consider overrides
which occured further up in the hierarchy.

This commit solves this discrepancy by using LiveScene to determine
if the sceneShape is should actually be invisible due to an
override further up the hierarchy. SceneShape registers a custom
readAttribute function with LiveScene, so LiveScene is able to
correctly read the visibility overrides during its traversal.

In regards to performance, when a SceneShape is fully expanded, and
there is a deep hierarchy of visible transforms, this commit will
slightly impact the frame rate since LiveScene will be performing extra
work to ensure there are no visiblity overrides. Some of this overhead
may be reduced through the use of an extra visiblity tracking cache,
but there is also a price to pay for the extra message callbacks
necessary to keep the cache synchronized. On a fully visible robot with
~2870 locations, the frame rate dropped ~1.2 fps.

However, in practice at IE, this will not affect the performance of our
animation rigs since all SceneShapes will be expanded to maya geometry.
In this scenario, MDagPath::isVisible() will return False since
the SceneShape will be set to an intermediate object, and the LiveScene
code path will not be executed.

Author: bradleyhenke

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/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 ) );

src/IECoreMaya/SceneShapeSubSceneOverride.cpp

@@ -1923,16 +1923,15 @@ void SceneShapeSubSceneOverride::collectInstances( Instances &instances ) const
 	MDagPathArray dagPaths;
 	dagNode.getAllPaths(dagPaths);
 	size_t numInstances = dagPaths.length();
-
 	instances.reserve( numInstances );
+
 	for( size_t pathIndex = 0; pathIndex < numInstances; ++pathIndex )
 	{
 		MDagPath& path = dagPaths[pathIndex];
 		MMatrix matrix = path.inclusiveMatrix();
 		bool pathSelected = isPathSelected( selectionList, path );
 		bool componentMode = componentsSelectable( path );
-		MFnDagNode nodeFn( path );
-		bool visible = path.isVisible();
+		bool visible = IECoreMaya::SceneShapeInterface::isVisible( path );
 
 		instances.emplace_back( matrix, pathSelected, componentMode, path, visible );
 	}

src/IECoreMaya/SceneShapeUI.cpp

@@ -102,6 +102,13 @@ void SceneShapeUI::getDrawRequests( const MDrawInfo &info, bool objectAndActiveO
 	{
 		return;
 	}
+
+	// make sure we don't have an ancestral visibility override which makes us invisible
+	if( !SceneShapeInterface::isVisible( info.multiPath() ) )
+	{
+		return;
+	}
+
 	// the node we're meant to be drawing
 	SceneShape *sceneShape = (SceneShape *)surfaceShape();