Merge pull request #466 from johnhaddon/proceduralBounds

Procedurals without bounds

Author: davidsminor

contrib/IECoreArnold/src/IECoreArnold/RendererImplementation.cpp

@@ -671,8 +671,11 @@ void IECoreArnold::RendererImplementation::procedural( IECore::Renderer::Procedu
 		// we have to transform the bound, as we're not applying the current transform to the
 		// procedural node, but instead applying absolute transforms to the shapes the procedural
 		// generates.
-		bound = transform( bound, m_transformStack.top() );
-	
+		if( bound != Procedural::noBound )
+		{
+			bound = transform( bound, m_transformStack.top() );
+		}
+
 		AiNodeSetPtr( procedural, "funcptr", (void *)procLoader );
 
 		ProceduralData *data = new ProceduralData;
@@ -682,9 +685,17 @@ void IECoreArnold::RendererImplementation::procedural( IECore::Renderer::Procedu
 		AiNodeSetPtr( procedural, "userptr", data );
 	}
 
-	AiNodeSetPnt( procedural, "min", bound.min.x, bound.min.y, bound.min.z );
-	AiNodeSetPnt( procedural, "max", bound.max.x, bound.max.y, bound.max.z );
-	
+	if( bound != Procedural::noBound )
+	{
+		AiNodeSetPnt( procedural, "min", bound.min.x, bound.min.y, bound.min.z );
+		AiNodeSetPnt( procedural, "max", bound.max.x, bound.max.y, bound.max.z );
+	}
+	else
+	{
+		// No bound available - expand procedural immediately.
+		AiNodeSetBool( procedural, "load_at_init", true );
+	}
+
 	// we call addNode() rather than addShape() as we don't want to apply transforms and
 	// shaders and attributes to procedurals. if we do, they override the things we set
 	// on the nodes generated by the procedurals, which is frankly useless.

contrib/IECoreArnold/test/IECoreArnold/ProceduralTest.py

@@ -34,6 +34,7 @@
 
 from __future__ import with_statement
 
+import re
 import arnold
 import unittest
 
@@ -222,6 +223,28 @@ def hash( self ):
 			r.procedural( EmptyProcedural() )
 
 		self.failIf( "ignoring parameter max" in self.__arnoldMessages )
-		
+
+	def testNoBound( self ) :
+
+		r = IECoreArnold.Renderer( "/tmp/test.ass" )
+
+		with IECore.WorldBlock( r ) :
+
+			r.procedural(
+				r.ExternalProcedural(
+					"test.so",
+					r.Procedural.noBound,
+					{}
+				)
+			)
+
+		l = "".join( open( "/tmp/test.ass" ).readlines() )
+
+		self.assertTrue( "procedural" in l )
+		self.assertFalse( "inf" in l )
+		self.assertFalse( re.search( r"\bmin\b", l ) )
+		self.assertFalse( re.search( r"\bmax\b", l ) )
+		self.assertTrue( "load_at_init" in l )
+
 if __name__ == "__main__":
     unittest.main()

include/IECore/Renderer.h

@@ -357,6 +357,13 @@ class IECORE_API Renderer : public RunTimeTyped
 				/// and this feature will be disabled.
 				virtual MurmurHash hash() const = 0;
 
+				/// Sentinel value which may be returned by bound()
+				/// implementations if a bound is not available, or
+				/// computing one would be prohibitively expensive.
+				/// Renderers should expand such procedurals
+				/// unconditionally.
+				static const Imath::Box3f noBound;
+
 		};
 		IE_CORE_DECLAREPTR( Procedural );
 
@@ -428,7 +435,7 @@ class IECORE_API Renderer : public RunTimeTyped
 		/// Ends the current scene edit.
 		virtual void editEnd() = 0;
 		//@}
-		
+
 };
 
 }

src/IECore/Renderer.cpp

@@ -36,8 +36,11 @@
 #include "IECore/CompoundObject.h"
 #include "IECore/CompoundParameter.h"
 
+using namespace Imath;
 using namespace IECore;
 
+const Box3f Renderer::Procedural::noBound( V3f( -std::numeric_limits<float>::infinity() ), V3f( std::numeric_limits<float>::infinity() ) );
+
 IE_CORE_DEFINERUNTIMETYPED( Renderer );
 
 Renderer::Renderer()

src/IECoreGL/Renderer.cpp

@@ -229,6 +229,11 @@ struct IECoreGL::Renderer::MemberData
 		}
 
 		Imath::Box3f b = p->bound();
+		if( b == Procedural::noBound )
+		{
+			return true;
+		}
+
 		switch( implementation->getState<CullingSpaceStateComponent>()->value() )
 		{
 			case ObjectSpace :

src/IECorePython/RendererBinding.cpp

@@ -87,7 +87,7 @@ class ProceduralWrap : public Renderer::Procedural, public Wrapper<Renderer::Pro
 			}
 			return Imath::Box3f(); // empty
 		}
-		
+
 		virtual void render( Renderer *r ) const
 		{
 			ScopedGILLock gilLock;
@@ -118,7 +118,7 @@ class ProceduralWrap : public Renderer::Procedural, public Wrapper<Renderer::Pro
 				msg( Msg::Error, "ProceduralWrap::render", "Caught unknown exception" );
 			}
 		}
-		
+
 		virtual MurmurHash hash() const
 		{
 			ScopedGILLock gilLock;
@@ -394,7 +394,7 @@ void bindRenderer()
 		.def("instance", &Renderer::instance)
 
 		.def("command", &command)
-		
+
 		.def("editBegin", &editBegin)
 		.def("editEnd", &Renderer::editEnd)
 	;
@@ -404,6 +404,7 @@ void bindRenderer()
 		.def( "bound", &Renderer::Procedural::bound )
 		.def( "render", &Renderer::Procedural::render )
 		.def( "hash", &Renderer::Procedural::hash )
+		.def_readonly( "noBound", &Renderer::Procedural::noBound )
 	;
 
 	RefCountedClass<Renderer::ExternalProcedural, Renderer::Procedural>( "ExternalProcedural" )

src/IECoreRI/RendererImplementation.cpp

@@ -1940,19 +1940,13 @@ void IECoreRI::RendererImplementation::emitPatchMeshPrimitive( const IECore::Pat
 		pv.n(), pv.tokens(), pv.values()
 	);
 }
-	
+
 /////////////////////////////////////////////////////////////////////////////////////////
 // procedurals
 /////////////////////////////////////////////////////////////////////////////////////////
 
 void IECoreRI::RendererImplementation::procedural( IECore::Renderer::ProceduralPtr proc )
 {
-	Imath::Box3f bound = proc->bound();
-	if( bound.isEmpty() )
-	{
-		return;
-	}
-
 	ScopedContext scopedContext( m_context );
 
 	if( ExternalProcedural *externalProc = dynamic_cast<ExternalProcedural *>( proc.get() ) )
@@ -1967,9 +1961,14 @@ void IECoreRI::RendererImplementation::procedural( IECore::Renderer::ProceduralP
 
 void IECoreRI::RendererImplementation::standardProcedural( Procedural *proc )
 {
+	const Imath::Box3f bound = proc->bound();
+	if( bound.isEmpty() )
+	{
+		return;
+	}
 
 	RtBound riBound;
-	convert( proc->bound(), riBound );
+	convert( bound, riBound );
 
 	ProceduralData *data = new ProceduralData;
 	data->procedural = proc;
@@ -2050,8 +2049,14 @@ void dynamicLoadFree( void *voidData )
 
 void IECoreRI::RendererImplementation::externalProcedural( ExternalProcedural *proc )
 {
+	const Imath::Box3f bound = proc->bound();
+	if( bound.isEmpty() )
+	{
+		return;
+	}
+
 	RtBound riBound;
-	convert( proc->bound(), riBound );
+	convert( bound, riBound );
 
 	if( boost::algorithm::ends_with( proc->fileName(), ".rib" ) )
 	{

test/IECoreRI/Renderer.py

@@ -39,37 +39,51 @@
 import os
 
 from IECore import *
+import IECore
 import IECoreRI
 
 class SimpleProcedural( Renderer.Procedural ) :
 
-	def __init__( self, scale ) :
+	def __init__( self, scale, computeBound = True ) :
 
 		Renderer.Procedural.__init__( self )
 		self.__scale = scale
+		self.__computeBound = computeBound
 		self.__t = StringData( "hello" )
 		self.__c = CompoundData()
 		self.__c["a"] = IntData( 4 )
 
+		self.numBoundCalls = 0
+		self.numRenderCalls = 0
+
 	def bound( self ) :
 
-		return Box3f( V3f( -self.__scale ), V3f( self.__scale ) )
+		self.numBoundCalls += 1
+
+		if self.__computeBound :
+			return Box3f( V3f( -self.__scale ), V3f( self.__scale ) )
+		else :
+			return self.noBound
 
 	def render( self, renderer ) :
 
+		self.numRenderCalls += 1
 		self.rendererTypeName = renderer.typeName()
 		self.rendererTypeId = renderer.typeId()
 
-		renderer.transformBegin()
+		with IECore.TransformBlock( renderer ) :
 
-		m = M44f()
-		m.scale( V3f( self.__scale ) )
-		renderer.concatTransform( m )
+			m = M44f()
+			m.scale( V3f( self.__scale ) )
+			renderer.concatTransform( m )
+
+			if self.__computeBound :
+				renderer.procedural( SimpleProcedural( 1, False ) )
+			else :
+				renderer.sphere( 1, -1, 1, 360, {} )
 
-		renderer.transformEnd()
-	
 	def hash( self ):
-	
+
 		h = MurmurHash()
 		return h
 
@@ -215,13 +229,13 @@ def testCompoundDataAttributes( self ) :
 	def testProcedural( self ) :
 
 		r = IECoreRI.Renderer( "test/IECoreRI/output/testProcedural.rib" )
-		r.worldBegin()
-
-		p = SimpleProcedural( 10.5 )
-		r.procedural( p )
+		with WorldBlock( r ) :
 
-		r.worldEnd()
+			p = SimpleProcedural( 10.5 )
+			r.procedural( p )
 
+		self.assertEqual( p.numBoundCalls, 1 )
+		self.assertEqual( p.numRenderCalls, 1 )
 		self.assertEqual( p.rendererTypeId, IECoreRI.Renderer.staticTypeId() )
 		self.assertEqual( p.rendererTypeName, "IECoreRI::Renderer" )
 		self.assertEqual( p.rendererTypeName, IECoreRI.Renderer.staticTypeName() )
@@ -713,10 +727,53 @@ def testLightPrefixes( self ) :
 		self.assertTrue( 'LightSource "renderManLight"' in rib )
 		self.assertFalse( "arnold" in rib )
 
+	def testProceduralWithoutBounds( self ) :
+
+		r = IECoreRI.Renderer( "" )
+
+		r.camera(
+			"main",
+			{
+				"projection" : IECore.StringData( "orthographic" ),
+				"resolution" : IECore.V2iData( IECore.V2i( 256 ) ),
+				"clippingPlanes" : IECore.V2fData( IECore.V2f( 0.1, 1000 ) ),
+				"screenWindow" : IECore.Box2fData( IECore.Box2f( IECore.V2f( -1 ), IECore.V2f( 1 ) ) ),
+			}
+		)
+		r.display(
+			"test", "ieDisplay", "rgba",
+			{
+				"driverType" : "ImageDisplayDriver",
+				"handle" : "test",
+				"quantize" : FloatVectorData( [ 0, 0, 0, 0 ] ),
+			}
+		)
+
+		# Must use the raytrace hider in order to use unspecified
+		# procedural bounds in 3delight - it is not supported in
+		# REYES mode.
+		r.setOption( "ri:hider", "raytrace" )
+
+		with IECore.WorldBlock( r ) :
+
+			r.concatTransform( IECore.M44f.createTranslated( IECore.V3f( 0, 0, -10 ) ) )
+
+			procedural = SimpleProcedural( 1, computeBound = False )
+			r.procedural( procedural )
+
+		self.assertEqual( procedural.numRenderCalls, 1 )
+
+		image = IECore.ImageDisplayDriver.removeStoredImage( "test" )
+
+		e = IECore.PrimitiveEvaluator.create( image )
+		result = e.createResult()
+		e.pointAtUV( IECore.V2f( 0.5, 0.5 ), result )
+		self.assertEqual( result.floatPrimVar( e.A() ), 1 )
+
 	def tearDown( self ) :
 
 		IECoreRI.TestCase.tearDown( self )
-		
+
 		files = [
 			"test/IECoreRI/shaders/types.sdl",
 		]