Merge pull request #6806 from GafferHQ/renderManProgress

RenderMan : Add progress reporting option

Author: johnhaddon

Changes.md

@@ -6,6 +6,7 @@ Improvements
 
 - Crop : Added `Auto` mode for `areaSource`, automatically cropping to show only non-empty pixels.
 - GraphEditor : Improved responsiveness of select-drag, by deferring NodeEditor update until the drag ends.
+- RenderManOptions : Added `ri:progress` option to control logging of render progress.
 
 API
 ---

python/IECoreRenderManTest/RendererTest.py

@@ -167,6 +167,31 @@ def testObject( self ) :
 		image = IECoreImage.ImageDisplayDriver.storedImage( "myLovelySphere" )
 		self.assertEqual( max( image["A"] ), 1 )
 
+	def testProgress( self ) :
+
+		messageHandler = IECore.CapturingMessageHandler()
+		renderer = GafferScene.Private.IECoreScenePreview.Renderer.create(
+			self.renderer,
+			GafferScene.Private.IECoreScenePreview.Renderer.RenderType.Batch,
+			messageHandler = messageHandler
+		)
+
+		renderer.output(
+			"beauty",
+			IECoreScene.Output(
+				( self.temporaryDirectory() / "beauty.exr" ).as_posix(),
+				"exr",
+				"rgba",
+				{
+				}
+			)
+		)
+
+		renderer.option( "ri:progressMode", IECore.IntData( 2 ) )
+		renderer.render()
+
+		self.assertRegex( "".join( [ m.message for m in messageHandler.messages ] ), "R90000.*%" )
+
 	def testMissingLightShader( self ) :
 
 		messageHandler = IECore.CapturingMessageHandler()

src/IECoreRenderMan/Globals.cpp

@@ -69,9 +69,11 @@ const IECore::InternedString g_sampleFilterOption( "ri:samplefilter" );
 const IECore::InternedString g_pixelFilterNameOption( "ri:Ri:PixelFilterName" );
 const IECore::InternedString g_pixelFilterWidthOption( "ri:Ri:PixelFilterWidth" );
 const IECore::InternedString g_pixelVarianceOption( "ri:Ri:PixelVariance" );
+const IECore::InternedString g_progressModeOption( "ri:progressMode" );
 const IECore::InternedString g_xpuCPUConfigOption( "ri:xpuCpuConfig" );
 const IECore::InternedString g_xpuGPUConfigOption( "ri:xpuGpuConfig" );
 
+const RtUString g_progressModeParameter( "progressMode" );
 const RtUString g_xpuCPUConfigParameter( "xpu:cpuconfig" );
 ConstDataPtr g_xpuCPUConfigDefault = new IntData( 1 );
 // We default GPUs to off, on the assumption that most rendering will still occur
@@ -194,6 +196,11 @@ Globals::Globals( RtUString rileyVariant, IECoreScenePreview::Renderer::RenderTy
 		m_options.SetString( Loader::strings().k_bucket_order, RtUString( "circle" ) );
 	}
 
+	m_renderParameters.SetString(
+		RtUString( "renderMode" ),
+		renderType == IECoreScenePreview::Renderer::RenderType::Interactive ? RtUString( "interactive" ) : RtUString( "batch" )
+	);
+
 	for( const auto &[name, value] : g_lpeLobeDefaults )
 	{
 		// Set up default lobe definitions.
@@ -337,6 +344,25 @@ void Globals::option( const IECore::InternedString &name, const IECore::Object *
 		auto data = optionCast<const Data>( value, name );
 		ParamListAlgo::convertParameter( g_xpuGPUConfigParameter, data ? data : g_xpuGPUConfigDefault.get(), m_rileyParameters );
 	}
+	else if( name == g_progressModeOption )
+	{
+		if( auto *d = optionCast<const IntData>( value, name ) )
+		{
+			// This is the XPU way of requesting progress reporting - an undocumented
+			// parameter passed to the `Riley::Render()` call.
+			m_renderParameters.SetInteger( RtUString( "progressMode" ), d->readable() );
+			// But RIS wants progress specified as a "command line argument" to
+			// `PRManRenderBegin()` instead, so we smuggle the value into `Session.cpp`
+			// via `m_options` as well.
+			/// \todo Remove when RIS is no longer.
+			m_options.SetInteger( RtUString( "progressMode" ), d->readable() );
+		}
+		else
+		{
+			m_renderParameters.Remove( RtUString( "progressMode" ) );
+			m_options.Remove( RtUString( "progressMode" ) );
+		}
+	}
 	else if( boost::starts_with( name.c_str(), "ri:lpe:" ) )
 	{
 		const RtUString renderManName( name.c_str() + g_renderManPrefix.size() );
@@ -532,18 +558,14 @@ void Globals::render()
 	switch( m_session->renderType )
 	{
 		case IECoreScenePreview::Renderer::Batch : {
-			RtParamList renderOptions;
-			renderOptions.SetString( RtUString( "renderMode" ), RtUString( "batch" ) );
-			m_session->riley->Render( { 1, &m_renderView }, renderOptions );
+			m_session->riley->Render( { 1, &m_renderView }, m_renderParameters );
 			break;
 		}
 		case IECoreScenePreview::Renderer::Interactive :
 			/// \todo Would it reduce latency if we reused the same thread?
 			m_interactiveRenderThread = std::thread(
 				[this] {
-					RtParamList renderOptions;
-					renderOptions.SetString( RtUString( "renderMode" ), RtUString( "interactive" ) );
-					m_session->riley->Render( { 1, &m_renderView }, renderOptions );
+					m_session->riley->Render( { 1, &m_renderView }, m_renderParameters );
 				}
 			);
 			break;

src/IECoreRenderMan/Globals.h

@@ -98,6 +98,7 @@ class Globals : public boost::noncopyable
 
 		RtParamList m_rileyParameters;
 		RtParamList m_options;
+		RtParamList m_renderParameters;
 		std::string m_cameraOption;
 		IECoreScene::ConstShaderPtr m_integratorToConvert;
 		IECoreScene::ConstShaderNetworkPtr m_displayFilterToConvert;

src/IECoreRenderMan/Session.cpp

@@ -59,6 +59,7 @@ const RtUString g_lightColorUStr( "lightColor" );
 const RtUString g_lightColorMapUStr( "lightColorMap" );
 const RtUString g_portalNameUStr( "portalName" );
 const RtUString g_portalToDomeUStr( "portalToDome" );
+const RtUString g_progressModeUStr( "progressMode" );
 const RtUString g_pxrDomeLightUStr( "PxrDomeLight" );
 const RtUString g_pxrPortalLightUStr( "PxrPortalLight" );
 const RtUString g_tintUStr( "tint" );
@@ -167,7 +168,14 @@ Session::Session( RtUString rileyVariant, const RtParamList &rileyParameters, IE
 		args.push_back( "-recover" );
 		args.push_back( "1" );
 	}
-
+	int32_t progressMode = 0;
+	if( options.GetInteger( g_progressModeUStr, progressMode ) && progressMode )
+	{
+		// This is needed for RIS, but doesn't do anything for XPU. For XPU
+		// we have to pass `progressMode` to the `Riley::Render()` call - see
+		// `Globals.cpp`.
+		args.push_back( progressMode == 1 ? "-Progress" : "-progress" );
+	}
 	m_riCtl->PRManRenderBegin( args.size(), args.data() );
 
 	if( messageHandler )

startup/GafferScene/renderManOptions.py

@@ -259,8 +259,9 @@
 
 		},
 
-		# Add an option to allow checkpoint recovery - this is handled by `IECoreRenderMan::Session::Session()`
-		# since it is not an official RenderMan option.
+		# Add options to allow checkpoint recovery and progress logging - these
+		# are not official RenderMan options so have special handling in
+		# IECoreRenderMan.
 
 		"option:ri:checkpoint:recover" : {
 
@@ -272,6 +273,23 @@
 
 		},
 
+		"option:ri:progressMode" : {
+
+			"defaultValue" : 0,
+			"description" : "Reports render progress percentage.",
+			"label" : "Report Progress",
+			# The statistics section isn't ideal for this, but of the available
+			# sections it's the one that makes most sense. It seems daft to make
+			# a new section for this one thing.
+			"layout:section" : Gaffer.Metadata.value( "option:ri:statistics:jsonFilename", "layout:section" ),
+			# In theory RenderMan accepts values of 0, 1 and 2, but the
+			# distinction (whether or not a linefeed is used) is lost by the
+			# time it is passed through our MessageHandlers. So just present as
+			# a simple boolean option.
+			"plugValueWidget:type" : "GafferUI.BoolPlugValueWidget",
+
+		},
+
 		# Add options to specify which devices XPU should use. Since there don't
 		# seem to be any names for this specified in the USD schemas shipping
 		# with RenderMan, we're using the names from HdPrmanLoaderTokens in the