Merge pull request #1371 from ImageEngine/tmpMergeRB-10.4-main

RB-10.4

Author: ivanimanishi

Changes

@@ -38,9 +38,29 @@ Breaking Changes
 - Primitive : Changed `variableIndexedView()` return type from `boost::optional` to `std::optional`.
 - MeshAlgo `distributePoints()` : Bug fixes mean subtle changes to the resulting points.
 
-10.4.x.x (relative to 10.4.9.1)
+10.4.10.0 (relative to 10.4.9.1)
 ========
 
+Improvements
+------------
+
+- IECoreNuke::LiveScene :
+  - Adding caching to speed up querying Nuke's GeometryList for large hierarchy
+  - Support for `ParticleSprite`
+  - `setOp` method to avoid re creating `LiveScene` from scratch
+
+Fixes
+-----
+
+- IECoreMaya.SceneShape : Fixed reading of time samples for expanded link locations
+  - Traverse the time plug connections to check for a maya global time connection
+- CheckedGILRelease : Safe to call if thread doesn't hold the GIL
+- IECoreNuke::SceneCacheReader : release GIL during `_validate` to avoid crash with Caribou
+- IECoreNuke::LiveScene :
+  - Fix crash when there is not input `GeoOp`.
+  - Fix uninitialized bounds
+  - Fix bug with duplicated parents
+  - Fix bug when querying children combined between multiple parents
 
 10.4.9.1 (relative to 10.4.9.0)
 ========

config/ie/options

@@ -415,9 +415,6 @@ if targetApp=="rv" :
 # find doxygen
 DOXYGEN = os.path.join( "/software/apps/doxygen", os.environ["DOXYGEN_VERSION"], platform, "bin", "doxygen" )
 
-# we need this so IECoreImage tests use a standard color conversion config
-os.environ["OCIO"] = "/software/config/openColorIO/nuke-default/config.ocio"
-
 # import vars we need to get our doxygen and python wrappers working
 envVarsToImport = [
 	"PATH",

include/IECoreNuke/Convert.h

@@ -112,6 +112,9 @@ IECORENUKE_API Imath::V3f convert( const DD::Image::Vector4 &from );
 template<>
 IECORENUKE_API Imath::Color3f convert( const DD::Image::Vector4 &from );
 
+template<>
+IECORENUKE_API Imath::Color4f convert( const DD::Image::Vector4 &from );
+
 /// Discards from.w
 template<>
 IECORENUKE_API Imath::V3d convert( const DD::Image::Vector4 &from );

include/IECoreNuke/FromNukePointsConverter.h

@@ -56,7 +56,7 @@ class IECORENUKE_API FromNukePointsConverter : public FromNukeConverter
 
 		/// The caller is responsible for ensuring that geo is alive
 		/// for as long as the converter is.
-		FromNukePointsConverter( const DD::Image::GeoInfo *geo );
+		FromNukePointsConverter( const DD::Image::GeoInfo *geo, DD::Image::Op* op );
 		virtual ~FromNukePointsConverter();
 
 	protected :
@@ -66,6 +66,7 @@ class IECORENUKE_API FromNukePointsConverter : public FromNukeConverter
 	private :
 
 		const DD::Image::GeoInfo *m_geo;
+		DD::Image::Op* m_op;
 
 };
 

include/IECoreNuke/LiveScene.h

@@ -60,7 +60,7 @@ class IECORENUKE_API LiveScene : public IECoreScene::SceneInterface
 		IE_CORE_DECLARERUNTIMETYPEDEXTENSION( LiveScene, LiveSceneTypeId, IECoreScene::SceneInterface );
 
 		LiveScene();
-		LiveScene( DD::Image::GeoOp *op, const std::string rootPath="/" );
+		LiveScene( DD::Image::GeoOp *op, const IECoreScene::SceneInterface::Path& rootPath=IECoreScene::SceneInterface::rootPath );
 
 		~LiveScene() override;
 
@@ -111,18 +111,30 @@ class IECORENUKE_API LiveScene : public IECoreScene::SceneInterface
 		static double timeToFrame( const double& time );
 		static double frameToTime( const int& frame );
 
+		typedef std::map<double, DD::Image::GeometryList> FrameGeometryCache;
+		typedef std::map<DD::Image::Hash, FrameGeometryCache> OpGeometryCache;
+		typedef std::map<const LiveScene*, OpGeometryCache> LiveSceneGeometryCache;
+
+		void setOp( DD::Image::GeoOp* op );
+		const DD::Image::GeoOp *getOp() const;
+
 		private:
 
-		DD::Image::GeoOp *op() const;
-		DD::Image::GeometryList geometryList( const double* time=nullptr ) const;
+		DD::Image::GeometryList geometryList( const double& frame ) const;
+		DD::Image::GeometryList geometryList( DD::Image::Op* op, const double& frame ) const;
+		unsigned objectNum( const double* time=nullptr ) const;
+		DD::Image::GeoInfo* object( const unsigned& index, const double* time=nullptr ) const;
 
 		std::string geoInfoPath( const int& index ) const;
 
 		DD::Image::GeoOp *m_op;
-		std::string m_rootPath;
+		//std::string m_rootPath;
+		IECoreScene::SceneInterface::Path m_rootPath;
 		IECore::PathMatcher m_pathMatcher;
 		typedef std::map<unsigned, std::string> objectPathMap;
 		mutable objectPathMap m_objectPathMap;
+
+		void cacheGeometryList( const double& frame ) const;
 };
 
 IE_CORE_DECLAREPTR( LiveScene );

include/IECoreNuke/LiveSceneHolder.h

@@ -57,6 +57,7 @@ class IECORENUKE_API LiveSceneHolder : public DD::Image::GeoOp
 		virtual void knobs( DD::Image::Knob_Callback f );
 		virtual const char *Class() const;
 		virtual const char *node_help() const;
+		IECoreNuke::LiveScenePtr liveScene();
 
 	private :
 

include/IECorePython/CheckedGILRelease.h

@@ -0,0 +1,66 @@
+//////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (c) 2023, Image Engine Design Inc. All rights reserved.
+//
+//  Redistribution and use in source and binary forms, with or without
+//  modification, are permitted provided that the following conditions are
+//  met:
+//
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//
+//     * Redistributions in binary form must reproduce the above copyright
+//       notice, this list of conditions and the following disclaimer in the
+//       documentation and/or other materials provided with the distribution.
+//
+//     * Neither the name of Image Engine Design nor the names of any
+//       other contributors to this software may be used to endorse or
+//       promote products derived from this software without specific prior
+//       written permission.
+//
+//  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+//  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+//  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+//  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+//  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+//  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+//  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+//  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+//  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+//  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+//  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+//////////////////////////////////////////////////////////////////////////
+
+#ifndef IECOREPYTHON_CHECKEDGILRELEASE_H
+#define IECOREPYTHON_CHECKEDGILRELEASE_H
+
+#include "boost/python.hpp"
+
+#include "IECorePython/Export.h"
+
+namespace IECorePython
+{
+
+/// This class checks if we hold the GIL and if we do releases the GIL upon construction and reacquires it
+/// upon destruction, otherwise it's a no op. It should be used in bindings to C++ functions
+/// which may take a while to return - for instance heavy computations
+/// or IO.
+class IECOREPYTHON_API CheckedGILRelease : boost::noncopyable
+{
+
+	public :
+
+		CheckedGILRelease();
+		~CheckedGILRelease();
+
+	private :
+
+		bool m_gilThreadsInitialised;
+		PyThreadState *m_state;
+
+};
+
+} // namespace IECorePython
+
+#endif // IECOREPYTHON_CHECKEDGILRELEASE_H

src/IECoreMaya/SceneShape.cpp

@@ -45,11 +45,18 @@
 #include "maya/MFnDagNode.h"
 #include "maya/MTime.h"
 #include "maya/MEvaluationNode.h"
+#include "maya/MItDependencyGraph.h"
+
 
 using namespace IECore;
 using namespace IECoreScene;
 using namespace IECoreMaya;
 
+namespace
+{
+const MString g_mayaGlobalTimeNodeName( "time1" );
+}
+
 MTypeId SceneShape::id = SceneShapeId;
 MObject SceneShape::aSceneFilePlug;
 MObject SceneShape::aSceneRootPlug;
@@ -256,7 +263,7 @@ ConstObjectPtr SceneShape::readSceneShapeLink( const MDagPath &p )
 	SceneShape *sceneShape = findScene( p, true, &dagPath );
 	if ( !sceneShape )
 	{
-		throw Exception("readSceneShapeLink: Could not find SceneShape!");
+		throw Exception( "readSceneShapeLink: Could not find SceneShape!" );
 	}
 
 	const SceneInterface *scene = sceneShape->getSceneInterface().get();
@@ -270,26 +277,36 @@ ConstObjectPtr SceneShape::readSceneShapeLink( const MDagPath &p )
 	MPlug timePlug = fnChildDag.findPlug( aTime, false, &st );
 	if( !st )
 	{
-		throw Exception( "Could not find 'time' plug in SceneShape!");
+		throw Exception( "Could not find 'time' plug in SceneShape!" );
 	}
 
-	// if time plug is connected to maya global time, then we assume there's no time remapping between the Maya scene and the loaded scene.
-	MPlugArray array;
-	timePlug.connectedTo( array, true, false, &st );
-	if( !st )
+	MItDependencyGraph it = MItDependencyGraph( timePlug, MFn::kInvalid, MItDependencyGraph::kUpstream, MItDependencyGraph::kDepthFirst, MItDependencyGraph::kPlugLevel );
+	for ( ; !it.isDone() ; it.next() )
 	{
-		throw Exception( "Could not find 'time' plug connections in SceneShape!");
-	}
+		MPlug currPlug = it.thisPlug( &st );
+		CHECK_MSTATUS(st);
+		MFnDependencyNode nodeFn( currPlug.node(), &st );
+		CHECK_MSTATUS(st);
 
-	for ( unsigned int i = 0; i < array.length(); i++ )
-	{
-		if ( array[i].name() == "time1.outTime" )
+		if ( nodeFn.name() == g_mayaGlobalTimeNodeName )
 		{
-			/// connected to time, so no time remapping between maya scene and loaded scene.
+			/// The plug is connected to maya global time, so no time remapping is happening
 			return LinkedScene::linkAttributeData( scene );
 		}
+
+		unsigned int nodeId = nodeFn.typeId().id();
+		bool isSceneShape = nodeId == SceneShapeId || nodeId == SceneShapeProxyId;
+		if ( !isSceneShape )
+		{
+			/// The time plug is not connected to global maya time or a scene shape (expanded hierarchy),
+			/// so we assume some kind of time manipulation (a maya add node to offset the value or similiar)
+			MTime time;
+			timePlug.getValue( time );
+			return LinkedScene::linkAttributeData( scene, time.as( MTime::kSeconds ) );
+		}
 	}
-	/// couldn't find connection to maya time, so this node is mapping the time some other way.
+
+	/// The time plug doesn't have any connection at all (time hold)
 	MTime time;
 	timePlug.getValue( time );
 	return LinkedScene::linkAttributeData( scene, time.as( MTime::kSeconds ) );

src/IECoreNuke/Convert.cpp

@@ -121,6 +121,12 @@ Imath::Color3f convert( const DD::Image::Vector4 &from )
 	return Imath::Color3f( from.x, from.y, from.z );
 }
 
+template<>
+Imath::Color4f convert( const DD::Image::Vector4 &from )
+{
+	return Imath::Color4f( from.x, from.y, from.z, from.w );
+}
+
 template<>
 Imath::M44f convert( const DD::Image::Matrix4 &from )
 {

src/IECoreNuke/FromNukeCameraConverter.cpp

@@ -90,7 +90,7 @@ IECore::ObjectPtr FromNukeCameraConverter::doConversion( IECore::ConstCompoundOb
 	// TODO - I haven't tested any of this - I'm not sure how to use it, because it doesn't appear to
 	// be used anywhere.  Why does it even exist?
 	V2f screenWindowScale = IECore::convert<Imath::V2f>( m_camera->win_scale() );
-	V2f screenWindowTranslate = IECore::convert<Imath::V2f>( m_camera->win_scale() );
+	V2f screenWindowTranslate = IECore::convert<Imath::V2f>( m_camera->win_translate() );
 	result->setAperture( V2f( m_camera->film_width(), m_camera->film_height() ) * screenWindowScale );
 	result->setApertureOffset( screenWindowTranslate );