def reloadProcedural():
n = hou.node(".")
type = n.evalParm("__opType")
ver = n.evalParm("__opVersion")
if type=="" or ver=="":
return
ver = int(ver)
fn = IECoreHoudini.FnProceduralHolder(n)
IECore.ClassLoader.defaultProceduralLoader().refresh()
cl = IECoreHoudini.proc( type, ver )
# cache our existing parameters
parms = fn.getParameterised().parameters().values()
saved_parms = {}
for p in parms:
saved_parms[p.name] = p.getValue().value
# reload parameter interface
fn.setParameterised(cl)
# restore parameter values
for p in saved_parms.keys():
hparm = n.parm("parm_%s" % p)
if hparm:
hparm.set( saved_parms[p] )
def testProceduralHolder(self):
obj = hou.node("/obj")
geo = obj.createNode("geo", run_init_scripts=False)
proc = geo.createNode("ieProceduralHolder")
self.assert_(proc)
fn = IECoreHoudini.FnProceduralHolder(proc)
self.assert_(fn)
return fn
def createProcedural(self, path="primitiveParameters/multiple", version=1):
obj = hou.node("/obj")
geo = obj.createNode("geo", run_init_scripts=False)
proc = geo.createNode("ieProceduralHolder")
fn = IECoreHoudini.FnProceduralHolder(proc)
fn.setProcedural(path, version)
return (proc, fn)
def testObjectWasDeleted(self):
obj = hou.node("/obj")
geo = obj.createNode("geo", run_init_scripts=False)
proc = geo.createNode( "ieProceduralHolder" )
fn = IECoreHoudini.FnProceduralHolder( proc )
cl = IECore.ClassLoader.defaultProceduralLoader().load( "sphereProcedural", 1 )()
proc.destroy()
self.assertEqual( fn.hasParameterised(), False )
fn.setParameterised(cl)
def testAnimatedValues( self ) : sphere = IECoreHoudini.FnProceduralHolder.create( "test", "sphereProcedural", 1 ) fn = IECoreHoudini.FnProceduralHolder( sphere ) sphere.parm( "parm_radius" ).setExpression( "$FF" ) hou.setFrame( 1 ) self.assertEqual( sphere.evalParm( "parm_radius" ), 1 ) self.assertEqual( fn.getProcedural().parameters()["radius"].getTypedValue(), 1 ) hou.setFrame( 12.25 ) self.assertEqual( sphere.evalParm( "parm_radius" ), 12.25 ) # values haven't been flushed yet self.assertAlmostEqual( fn.getProcedural().parameters()["radius"].getTypedValue(), 1 ) # so we flush them fn.setParameterisedValues() self.assertAlmostEqual( fn.getProcedural().parameters()["radius"].getTypedValue(), 12.25 )
def testProceduralParameters(self):
obj = hou.node("/obj")
geo = obj.createNode("geo", run_init_scripts=False)
proc = geo.createNode( "ieProceduralHolder" )
fn = IECoreHoudini.FnProceduralHolder( proc )
fn.setProcedural( "parameterTypes", 1 )
# set a lot of parameters via houdini
proc.parmTuple("parm_a").set( [123] )
proc.parmTuple("parm_d").set( ["hello"] )
proc.parmTuple("parm_g").set( (2,4) )
proc.parmTuple("parm_h").set( (1,4,8) )
proc.parmTuple("parm_i").set( (2,4) )
proc.parmTuple("parm_i_3").set( (1, 2, 3, 4,
5, 6, 7, 8,
9, 10, 11, 12,
13, 14, 15, 16 ) )
proc.parmTuple("parm_i_4").set( (1, 2, 3, 4,
5, 6, 7, 8,
9, 10, 11, 12,
13, 14, 15, 16 ) )
proc.parmTuple("parm_compound_j").set( (1,4,8) )
proc.parmTuple("parm_compound_k").set( (1, 2, 3, 4,
5, 6, 7, 8,
9, 10, 11, 12,
13, 14, 15, 16 ) )
proc.parmTuple("parm_l").set( (1,0,0) )
proc.parmTuple("parm_m").set( (1,1,0,1) )
proc.parmTuple("parm_o").set( ["myFile.tif"] )
proc.parmTuple("parm_p").set( [os.getcwd()] )
proc.parmTuple("parm_q").set( [True] )
proc.parmTuple("parm_r").set( ["mySequence.####.tif"] )
proc.parmTuple("parm_s").set( [-1, -2, 10, 20] )
proc.parmTuple("parm_s_1").set( [-1, -2, 10, 20] )
proc.parmTuple("parm_s_2").set( [-1, -2, -3, 10, 20, 30] )
proc.parmTuple("parm_t").set( [-1, -2, -3, 10, 20, 30] )
proc.parmTuple("parm_u").set( (64, 128) )
proc.parmTuple("parm_v").set( (25,26,27) )
# flush our parameters through to our parameterised procedural
proc.cook(force=True)
# generate our bounds
parameterised = fn.getParameterised()
self.failUnless( parameterised.isInstanceOf( IECore.TypeId.RunTimeTyped ) )
box = parameterised.bound()
self.assertEqual( box, IECore.Box3f( IECore.V3f(0,0,0), IECore.V3f(1,1,1) ) )
return ( proc, parameterised )
def testMatchString(self): (op,fn)=self.testProceduralParameters() fn = IECoreHoudini.FnProceduralHolder(op) self.assertEqual( op.parm( "__classMatchString" ).eval(), "*" ) op.parm( "__className" ).set( "sphereProcedural" ) op.parm( "__className" ).pressButton() cl = fn.getParameterised() self.assertEqual( cl.typeName(), "sphereProcedural" ) op.parm( "__classMatchString" ).set( "nestedChild" ) results = fn.classNames() self.assertEqual( len(fn.classNames()), 1 ) op.parm( "__className" ).set( "sphereProcedural" ) # this still works, should it be invalid? op.parm( "__className" ).pressButton() cl = fn.getParameterised() self.assertEqual( cl.typeName(), "sphereProcedural" ) op.parm( "__classMatchString" ).set( "*" ) self.assert_( len(fn.classNames()) > 1 )
def testCortexInputs(self):
(proc, fn) = self.createProcedural()
torus = proc.parent().createNode("torus")
torus.parm("rows").set(10)
torus.parm("cols").set(10)
op = torus.createOutputNode("ieOpHolder")
IECoreHoudini.FnOpHolder(op).setOp("objectDebug", 1)
op.parm("parm_quiet").set(True)
proc.setInput(0, op)
box = proc.createInputNode(2, "box")
proc2 = proc.createInputNode(3, "ieProceduralHolder")
fn2 = IECoreHoudini.FnProceduralHolder(proc2)
fn2.setProcedural("primitiveParameters/meshRender", 1)
torus2 = proc2.createInputNode(0, "torus")
torus2.parm("rows").set(10)
torus2.parm("cols").set(10)
proc.cook()
self.assertEqual(len(proc.errors()), 0)
self.assertEqual(len(proc2.errors()), 0)
self.assertEqual(len(op.errors()), 0)
self.assertEqual(len(proc.geometry().points()), 1)
self.assertEqual(len(proc2.geometry().points()), 1)
self.assertEqual(len(op.geometry().points()), 1)
converterSop = op.createOutputNode("ieCortexConverter")
self.assertEqual(len(converterSop.geometry().points()), 100)
result = IECoreHoudini.FromHoudiniGeometryConverter.create(
converterSop).convert()
self.assertEqual(result.typeId(), IECore.TypeId.MeshPrimitive)
self.assertEqual(result.numFaces(), 100)
converterSop = proc2.createOutputNode("ieCortexConverter")
self.assertEqual(len(converterSop.geometry().points()), 100)
result = IECoreHoudini.FromHoudiniGeometryConverter.create(
converterSop).convert()
self.assertEqual(result.typeId(), IECore.TypeId.MeshPrimitive)
self.assertEqual(result.numFaces(), 100)
converterSop = proc.createOutputNode("ieCortexConverter")
self.assertEqual(len(converterSop.geometry().points()), 208)
result = IECoreHoudini.FromHoudiniGeometryConverter.create(
converterSop).convert()
self.assertEqual(result.typeId(), IECore.TypeId.Group)
self.assertEqual(result.children()[0].typeId(),
IECore.TypeId.MeshPrimitive)
self.assertEqual(result.children()[0].numFaces(), 206)
self.assertEqual(result.children()[1].typeId(),
IECore.TypeId.PointsPrimitive)
self.assertEqual(result.children()[1].numPoints, 0)
def testProceduralConversion( self ) : obj = hou.node( "/obj" ) geo = obj.createNode( "geo", run_init_scripts=False ) holder = geo.createNode( "ieProceduralHolder" ) fn = IECoreHoudini.FnProceduralHolder( holder ) fn.setProcedural( "pointRender", 1 ) holder.parm( "parm_npoints" ).set( 123 ) converter = holder.createOutputNode( "ieCortexConverter" ) geo = converter.geometry() self.assertEqual( len(geo.points()), 123 ) self.assertEqual( len(geo.prims()), 1 ) fn.setProcedural( "meshRender", 1 ) holder.parm( "parm_path" ).set( "test/IECoreHoudini/data/torus_with_normals.cob" ) geo = converter.geometry() self.assertEqual( len(geo.points()), 100 ) self.assertEqual( len(geo.prims()), 100 ) self.assertEqual( sorted([ x.name() for x in geo.pointAttribs() ]), [ "N", "P", "Pw" ] ) self.assertTrue( geo.findPointAttrib( "N" ).isTransformedAsNormal() )
def syncSopParametersWithProcedural(n):
fn = IECoreHoudini.FnProceduralHolder( n )
parms = fn.getParameterised().parameters().values()
for p in parms:
if n.parm("parm_%s"%p.name):
setHoudiniParm( n, p )
