def testIndexedUVs(self):
m = IECore.MeshPrimitive.createPlane(
IECore.Box2f(IECore.V2f(-1), IECore.V2f(1)))
m["uv"] = IECore.PrimitiveVariable(
IECore.PrimitiveVariable.Interpolation.FaceVarying, m["uv"].data,
IECore.IntVectorData([0, 3, 1, 2]))
uvData = m["uv"].data
uvIds = m["uv"].indices
with IECoreArnold.UniverseBlock(writable=True):
n = IECoreArnold.NodeAlgo.convert(m, "testMesh")
uvs = arnold.AiNodeGetArray(n, "uvlist")
self.assertEqual(arnold.AiArrayGetNumElements(uvs.contents), 4)
uvIndices = arnold.AiNodeGetArray(n, "uvidxs")
self.assertEqual(arnold.AiArrayGetNumElements(uvIndices.contents),
4)
for i in range(0, 4):
aiUv = arnold.AiArrayGetVec2(uvs, i)
aiUVId = arnold.AiArrayGetInt(uvIndices, i)
aiIndexedUV = arnold.AiArrayGetVec2(uvs, aiUVId)
self.assertEqual(aiUVId, uvIds[i])
self.assertEqual(aiUv,
arnold.AtVector2(uvData[i][0], uvData[i][1]))
self.assertEqual(
aiIndexedUV,
arnold.AtVector2(uvData[uvIds[i]][0], uvData[uvIds[i]][1]))
def testIndexedFaceVaryingPrimitiveVariables(self):
m = IECoreScene.MeshPrimitive.createPlane(
imath.Box2f(imath.V2f(-1), imath.V2f(1)),
imath.V2i(2, 1),
)
self.assertEqual(
m.variableSize(
IECoreScene.PrimitiveVariable.Interpolation.FaceVarying), 8)
m["myPrimVar"] = IECoreScene.PrimitiveVariable(
IECoreScene.PrimitiveVariable.Interpolation.FaceVarying,
IECore.FloatVectorData([5, 10]),
IECore.IntVectorData([0, 0, 0, 0, 1, 1, 1, 1]))
with IECoreArnold.UniverseBlock(writable=True) as universe:
n = IECoreArnold.NodeAlgo.convert(m, universe, "testMesh")
a = arnold.AiNodeGetArray(n, "myPrimVar")
ia = arnold.AiNodeGetArray(n, "myPrimVaridxs")
self.assertEqual(arnold.AiArrayGetNumElements(a.contents), 2)
self.assertEqual(arnold.AiArrayGetNumElements(ia.contents), 8)
for i in range(0, len(m["myPrimVar"].data)):
self.assertEqual(arnold.AiArrayGetFlt(a, i),
m["myPrimVar"].data[i])
for i in range(0, len(m["myPrimVar"].indices)):
self.assertEqual(arnold.AiArrayGetUInt(ia, i),
m["myPrimVar"].indices[i])
def testUVs(self):
m = IECoreScene.MeshPrimitive.createPlane(
imath.Box2f(imath.V2f(-1), imath.V2f(1)))
m["uv"] = IECoreScene.PrimitiveVariable(
IECoreScene.PrimitiveVariable.Interpolation.FaceVarying,
m["uv"].expandedData())
uvData = m["uv"].data
with IECoreArnold.UniverseBlock(writable=True) as universe:
n = IECoreArnold.NodeAlgo.convert(m, universe, "testMesh")
uvs = arnold.AiNodeGetArray(n, "uvlist")
self.assertEqual(arnold.AiArrayGetNumElements(uvs.contents), 4)
uvIndices = arnold.AiNodeGetArray(n, "uvidxs")
self.assertEqual(arnold.AiArrayGetNumElements(uvIndices.contents),
4)
for i in range(0, 4):
p = arnold.AiArrayGetVec2(uvs, i)
self.assertEqual(arnold.AiArrayGetVec2(uvs, i),
arnold.AtVector2(uvData[i][0], uvData[i][1]))
self.assertEqual(arnold.AiArrayGetInt(uvIndices, i), i)
def testIndexedUVs(self):
m = IECoreScene.MeshPrimitive.createPlane(
imath.Box2f(imath.V2f(-1), imath.V2f(1)))
uvData = m["uv"].data
uvIds = m["uv"].indices
with IECoreArnold.UniverseBlock(writable=True) as universe:
n = IECoreArnold.NodeAlgo.convert(m, universe, "testMesh")
uvs = arnold.AiNodeGetArray(n, "uvlist")
self.assertEqual(arnold.AiArrayGetNumElements(uvs.contents), 4)
uvIndices = arnold.AiNodeGetArray(n, "uvidxs")
self.assertEqual(arnold.AiArrayGetNumElements(uvIndices.contents),
4)
for i in range(0, 4):
aiUv = arnold.AiArrayGetVec2(uvs, i)
aiUVId = arnold.AiArrayGetInt(uvIndices, i)
aiIndexedUV = arnold.AiArrayGetVec2(uvs, aiUVId)
self.assertEqual(aiUVId, uvIds[i])
self.assertEqual(aiUv,
arnold.AtVector2(uvData[i][0], uvData[i][1]))
self.assertEqual(
aiIndexedUV,
arnold.AtVector2(uvData[uvIds[i]][0], uvData[uvIds[i]][1]))
def testIntData(self):
with IECoreArnold.UniverseBlock(writable=True):
n = arnold.AiNode("standard_surface")
IECoreArnold.ParameterAlgo.setParameter(n, "customInt",
IECore.IntData(42))
IECoreArnold.ParameterAlgo.setParameter(n, "customUInt",
IECore.UIntData(43))
IECoreArnold.ParameterAlgo.setParameter(
n, "customIntVectorData", IECore.IntVectorData([5, 6, 7]))
IECoreArnold.ParameterAlgo.setParameter(
n, "customUIntVectorData",
IECore.UIntVectorData([12, 2147483649]))
self.assertEqual(arnold.AiNodeGetInt(n, "customInt"), 42)
self.assertEqual(arnold.AiNodeGetUInt(n, "customUInt"), 43)
a = arnold.AiNodeGetArray(n, "customIntVectorData")
self.assertEqual(arnold.AiArrayGetNumElements(a.contents), 3)
self.assertEqual(arnold.AiArrayGetInt(a, 0), 5)
self.assertEqual(arnold.AiArrayGetInt(a, 1), 6)
self.assertEqual(arnold.AiArrayGetInt(a, 2), 7)
a = arnold.AiNodeGetArray(n, "customUIntVectorData")
self.assertEqual(arnold.AiArrayGetNumElements(a.contents), 2)
self.assertEqual(arnold.AiArrayGetUInt(a, 0), 12)
self.assertEqual(arnold.AiArrayGetUInt(a, 1), 2147483649)
def testMotion( self ) : p1 = IECoreScene.PointsPrimitive( IECore.V3fVectorData( [ imath.V3f( 10 ) ] * 10 ) ) p1["width"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.Vertex, IECore.FloatVectorData( [ 1 ] * 10 ), ) p2 = IECoreScene.PointsPrimitive( IECore.V3fVectorData( [ imath.V3f( 20 ) ] * 10 ) ) p2["width"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.Vertex, IECore.FloatVectorData( [ 2 ] * 10 ), ) with IECoreArnold.UniverseBlock( writable = True ) : n = IECoreArnold.NodeAlgo.convert( [ p1, p2 ], -0.25, 0.25, "testPoints" ) a = arnold.AiNodeGetArray( n, "points" ) self.assertEqual( arnold.AiArrayGetNumElements( a.contents ), 10 ) self.assertEqual( arnold.AiArrayGetNumKeys( a.contents ), 2 ) r = arnold.AiNodeGetArray( n, "radius" ) self.assertEqual( arnold.AiArrayGetNumElements( r.contents ), 10 ) self.assertEqual( arnold.AiArrayGetNumKeys( r.contents ), 2 ) for i in range( 0, 10 ) : self.assertEqual( arnold.AiArrayGetVec( a, i ), arnold.AtVector( 10 ) ) self.assertEqual( arnold.AiArrayGetFlt( r, i ), 0.5 ) for i in range( 11, 20 ) : self.assertEqual( arnold.AiArrayGetVec( a, i ), arnold.AtVector( 20 ) ) self.assertEqual( arnold.AiArrayGetFlt( r, i ), 1 ) self.assertEqual( arnold.AiNodeGetFlt( n, "motion_start" ), -0.25 ) self.assertEqual( arnold.AiNodeGetFlt( n, "motion_end" ), 0.25 )
def testAdditionalUVs(self):
m = IECoreScene.MeshPrimitive.createPlane(
imath.Box2f(imath.V2f(-1), imath.V2f(1)))
m["myMap"] = m["uv"]
uvData = m["myMap"].data
indicesData = m["myMap"].indices
with IECoreArnold.UniverseBlock(writable=True) as universe:
n = IECoreArnold.NodeAlgo.convert(m, universe, "testMesh")
uvs = arnold.AiNodeGetArray(n, "myMap")
self.assertEqual(arnold.AiArrayGetNumElements(uvs.contents), 4)
uvIndices = arnold.AiNodeGetArray(n, "myMapidxs")
self.assertEqual(arnold.AiArrayGetNumElements(uvIndices.contents),
4)
for i in range(0, 4):
p = arnold.AiArrayGetVec2(uvs, i)
self.assertEqual(arnold.AiArrayGetVec2(uvs, i),
arnold.AtVector2(uvData[i][0], uvData[i][1]))
self.assertEqual(arnold.AiArrayGetInt(uvIndices, i),
indicesData[i])
def testExpandVertexIndexedUVs(self):
vertsPerFace = IECore.IntVectorData([4, 4])
vertexIds = IECore.IntVectorData([0, 1, 4, 3, 1, 2, 5, 4])
positions = IECore.V3fVectorData([
imath.V3f(0, 0, 0),
imath.V3f(1, 0, 0),
imath.V3f(2, 0, 0),
imath.V3f(0, 1, 0),
imath.V3f(1, 1, 0),
imath.V3f(2, 1, 0)
])
m = IECoreScene.MeshPrimitive(vertsPerFace, vertexIds, "linear",
positions)
m["uv"] = IECoreScene.PrimitiveVariable(
IECoreScene.PrimitiveVariable.Interpolation.Vertex,
IECore.V2fVectorData([
imath.V2f(0, 0),
imath.V2f(1, 0),
imath.V2f(0, 1),
imath.V2f(1, 1)
], IECore.GeometricData.Interpretation.UV),
IECore.IntVectorData([0, 1, 1, 2, 3, 3]))
self.assertTrue(m.arePrimitiveVariablesValid())
with IECoreArnold.UniverseBlock(writable=True) as universe:
n = IECoreArnold.NodeAlgo.convert(m, universe, "testMesh")
uvArray = arnold.AiNodeGetArray(n, "uvlist")
self.assertEqual(arnold.AiArrayGetNumElements(uvArray.contents), 4)
self.assertEqual(arnold.AiArrayGetVec2(uvArray, 0),
arnold.AtVector2(0, 0))
self.assertEqual(arnold.AiArrayGetVec2(uvArray, 1),
arnold.AtVector2(1, 0))
self.assertEqual(arnold.AiArrayGetVec2(uvArray, 2),
arnold.AtVector2(0, 1))
self.assertEqual(arnold.AiArrayGetVec2(uvArray, 3),
arnold.AtVector2(1, 1))
uvIndicesArray = arnold.AiNodeGetArray(n, "uvidxs")
self.assertEqual(
arnold.AiArrayGetNumElements(uvIndicesArray.contents), 8)
self.assertEqual(arnold.AiArrayGetInt(uvIndicesArray, 0), 0)
self.assertEqual(arnold.AiArrayGetInt(uvIndicesArray, 1), 1)
self.assertEqual(arnold.AiArrayGetInt(uvIndicesArray, 2), 3)
self.assertEqual(arnold.AiArrayGetInt(uvIndicesArray, 3), 2)
self.assertEqual(arnold.AiArrayGetInt(uvIndicesArray, 4), 1)
self.assertEqual(arnold.AiArrayGetInt(uvIndicesArray, 5), 1)
self.assertEqual(arnold.AiArrayGetInt(uvIndicesArray, 6), 3)
self.assertEqual(arnold.AiArrayGetInt(uvIndicesArray, 7), 3)
def testConvertShutterCurve(self):
with IECoreArnold.UniverseBlock(writable=True):
camera = IECoreScene.Camera()
camera.setProjection("perspective")
camera.parameters()["shutter_curve"] = IECore.Splineff(
IECore.CubicBasisf.linear(),
[
(0, -0.1),
(0.25, 1),
(0.75, 1.1),
(1.1, 0),
],
)
node = IECoreArnold.NodeAlgo.convert(camera, "camera")
curve = arnold.AiNodeGetArray(node, "shutter_curve")
self.assertEqual(arnold.AiArrayGetNumElements(curve), 4)
self.assertEqual(arnold.AiArrayGetVec2(curve, 0),
arnold.AtVector2(0, 0))
self.assertEqual(arnold.AiArrayGetVec2(curve, 1),
arnold.AtVector2(0.25, 1))
self.assertEqual(arnold.AiArrayGetVec2(curve, 2),
arnold.AtVector2(0.75, 1))
self.assertEqual(arnold.AiArrayGetVec2(curve, 3),
arnold.AtVector2(1, 0))
camera.parameters()["shutter_curve"] = IECore.Splineff(
IECore.CubicBasisf.catmullRom(),
[
(0, 0),
(0, 0),
(0.25, 1),
(0.75, 1),
(1, 0),
(1, 0),
],
)
node = IECoreArnold.NodeAlgo.convert(camera, "camera")
curve = arnold.AiNodeGetArray(node, "shutter_curve")
self.assertEqual(arnold.AiArrayGetNumElements(curve), 25)
for i in range(0, 25):
point = arnold.AiArrayGetVec2(curve, i)
self.assertAlmostEqual(min(
camera.parameters()["shutter_curve"].value(point.x), 1),
point.y,
delta=0.0001)
def testNPrimitiveVariable( self ) : c = IECore.CurvesPrimitive( IECore.IntVectorData( [ 4 ] ), IECore.CubicBasisf.catmullRom() ) c["P"] = IECore.PrimitiveVariable( IECore.PrimitiveVariable.Interpolation.Vertex, IECore.V3fVectorData( [ IECore.V3f( x, 0, 0 ) for x in range( 0, 4 ) ] ) ) with IECoreArnold.UniverseBlock( writable = True ) : # No N - should be a ribbon n = IECoreArnold.NodeAlgo.convert( c, "testCurve" ) self.assertEqual( arnold.AiNodeGetStr( n, "mode" ), "ribbon" ) self.assertEqual( arnold.AiArrayGetNumElements( arnold.AiNodeGetArray( n, "orientations" ).contents ), 0 ) # N - should be oriented c["N"] = IECore.PrimitiveVariable( IECore.PrimitiveVariable.Interpolation.Vertex, IECore.V3fVectorData( [ IECore.V3f( 0, math.sin( x ), math.cos( x ) ) for x in range( 0, 4 ) ] ) ) n = IECoreArnold.NodeAlgo.convert( c, "testCurve" ) self.assertEqual( arnold.AiNodeGetStr( n, "mode" ), "oriented" ) orientations = arnold.AiNodeGetArray( n, "orientations" ) self.assertEqual( arnold.AiArrayGetNumElements( orientations.contents ), 4 ) for i in range( 0, 4 ) : self.assertEqual( arnold.AiArrayGetVec( orientations, i ), arnold.AtVector( 0, math.sin( i ), math.cos( i ) ) ) # Motion blurred N - should be oriented and deforming c2 = c.copy() c2["N"] = IECore.PrimitiveVariable( IECore.PrimitiveVariable.Interpolation.Vertex, IECore.V3fVectorData( [ IECore.V3f( 0, math.sin( x + 0.2 ), math.cos( x + 0.2 ) ) for x in range( 0, 4 ) ] ) ) n = IECoreArnold.NodeAlgo.convert( [ c, c2 ], 0.0, 1.0, "testCurve" ) self.assertEqual( arnold.AiNodeGetStr( n, "mode" ), "oriented" ) orientations = arnold.AiNodeGetArray( n, "orientations" ) self.assertEqual( arnold.AiArrayGetNumElements( orientations.contents ), 4 ) self.assertEqual( arnold.AiArrayGetNumKeys( orientations.contents ), 2 ) for i in range( 0, 4 ) : self.assertEqual( arnold.AiArrayGetVec( orientations, i ), arnold.AtVector( 0, math.sin( i ), math.cos( i ) ) ) self.assertEqual( arnold.AiArrayGetVec( orientations, i + 4 ), arnold.AtVector( 0, math.sin( i + 0.2 ), math.cos( i + 0.2 ) ) )
def testLightFilters(self):
s = Gaffer.ScriptNode()
s["lightFilter"] = GafferArnold.ArnoldLightFilter()
s["lightFilter"].loadShader("light_blocker")
s["attributes"] = GafferScene.StandardAttributes()
s["attributes"]["in"].setInput(s["lightFilter"]["out"])
s["attributes"]["attributes"]["filteredLights"]["enabled"].setValue(
True)
s["attributes"]["attributes"]["filteredLights"]["value"].setValue(
"defaultLights")
s["light"] = GafferArnold.ArnoldLight()
s["light"].loadShader("point_light")
s["gobo"] = GafferArnold.ArnoldShader()
s["gobo"].loadShader("gobo")
s["assignment"] = GafferScene.ShaderAssignment()
s["assignment"]["in"].setInput(s["light"]["out"])
s["assignment"]["shader"].setInput(s["gobo"]["out"])
s["group"] = GafferScene.Group()
s["group"]["in"][0].setInput(s["attributes"]["out"])
s["group"]["in"][1].setInput(s["assignment"]["out"])
s["render"] = GafferArnold.ArnoldRender()
s["render"]["in"].setInput(s["group"]["out"])
s["render"]["mode"].setValue(s["render"].Mode.SceneDescriptionMode)
s["render"]["fileName"].setValue(self.temporaryDirectory() +
"/test.ass")
s["render"]["task"].execute()
with IECoreArnold.UniverseBlock(writable=True):
arnold.AiASSLoad(self.temporaryDirectory() + "/test.ass")
light = arnold.AiNodeLookUpByName("light:/group/light")
linkedFilters = arnold.AiNodeGetArray(light, "filters")
numFilters = arnold.AiArrayGetNumElements(linkedFilters.contents)
self.assertEqual(numFilters, 2)
linkedFilter = arnold.cast(arnold.AiArrayGetPtr(linkedFilters, 0),
arnold.POINTER(arnold.AtNode))
linkedGobo = arnold.cast(arnold.AiArrayGetPtr(linkedFilters, 1),
arnold.POINTER(arnold.AtNode))
self.assertEqual(arnold.AiNodeGetName(linkedFilter),
"lightFilter:/group/lightFilter")
self.assertEqual(
arnold.AiNodeEntryGetName(
arnold.AiNodeGetNodeEntry(linkedFilter)), "light_blocker")
self.assertEqual(
arnold.AiNodeEntryGetName(
arnold.AiNodeGetNodeEntry(linkedGobo)), "gobo")
def testVertexUVs(self):
c = IECoreScene.CurvesPrimitive(IECore.IntVectorData([2, 2]),
IECore.CubicBasisf.linear())
c["P"] = IECoreScene.PrimitiveVariable(
IECoreScene.PrimitiveVariable.Interpolation.Vertex,
IECore.V3fVectorData([imath.V3f(x, 0, 0) for x in range(0, 4)]))
c["uv"] = IECoreScene.PrimitiveVariable(
IECoreScene.PrimitiveVariable.Interpolation.Vertex,
IECore.V2fVectorData([
imath.V2f(1, 2),
imath.V2f(3, 4),
imath.V2f(5, 6),
imath.V2f(7, 8),
], IECore.GeometricData.Interpretation.UV))
with IECoreArnold.UniverseBlock(writable=True) as universe:
n = IECoreArnold.NodeAlgo.convert(c, universe, "testCurve")
uvs = arnold.AiNodeGetArray(n, "uvs").contents
self.assertEqual(arnold.AiArrayGetNumElements(uvs), 4)
self.assertEqual(arnold.AiArrayGetVec2(uvs, 0),
arnold.AtVector2(1, 2))
self.assertEqual(arnold.AiArrayGetVec2(uvs, 1),
arnold.AtVector2(3, 4))
self.assertEqual(arnold.AiArrayGetVec2(uvs, 2),
arnold.AtVector2(5, 6))
self.assertEqual(arnold.AiArrayGetVec2(uvs, 3),
arnold.AtVector2(7, 8))
def testMotion(self):
c1 = IECoreScene.CurvesPrimitive(IECore.IntVectorData([4]))
c2 = IECoreScene.CurvesPrimitive(IECore.IntVectorData([4]))
c1["P"] = IECoreScene.PrimitiveVariable(
IECoreScene.PrimitiveVariable.Interpolation.Vertex,
IECore.V3fVectorData([imath.V3f(1)] * 4),
)
c2["P"] = IECoreScene.PrimitiveVariable(
IECoreScene.PrimitiveVariable.Interpolation.Vertex,
IECore.V3fVectorData([imath.V3f(2)] * 4),
)
with IECoreArnold.UniverseBlock(writable=True) as universe:
n = IECoreArnold.NodeAlgo.convert([c1, c2], -0.25, 0.25, universe,
"testCurve")
a = arnold.AiNodeGetArray(n, "points")
self.assertEqual(arnold.AiArrayGetNumElements(a.contents), 4)
self.assertEqual(arnold.AiArrayGetNumKeys(a.contents), 2)
for i in range(0, 4):
self.assertEqual(arnold.AiArrayGetVec(a, i),
arnold.AtVector(1))
for i in range(4, 8):
self.assertEqual(arnold.AiArrayGetVec(a, i),
arnold.AtVector(2))
self.assertEqual(arnold.AiNodeGetFlt(n, "motion_start"), -0.25)
self.assertEqual(arnold.AiNodeGetFlt(n, "motion_end"), 0.25)
def testColor4fVectorDataPrimimitiveVariable(self):
m = IECoreScene.MeshPrimitive.createPlane(
imath.Box2f(imath.V2f(-1), imath.V2f(1)))
m["myColor"] = IECoreScene.PrimitiveVariable(
IECoreScene.PrimitiveVariable.Interpolation.Vertex,
IECore.Color4fVectorData([
imath.Color4f(1, 0, 0, 1),
imath.Color4f(0, 2, 0, 0),
imath.Color4f(0, 0, 3, 0.25),
imath.Color4f(4, 0, 0, 1),
]))
with IECoreArnold.UniverseBlock(writable=True) as universe:
n = IECoreArnold.NodeAlgo.convert(m, universe, "testMesh")
a = arnold.AiNodeGetArray(n, "myColor")
self.assertEqual(arnold.AiArrayGetType(a.contents),
arnold.AI_TYPE_RGBA)
self.assertEqual(arnold.AiArrayGetNumElements(a.contents), 4)
self.assertEqual(arnold.AiArrayGetRGBA(a, 0),
arnold.AtRGBA(1, 0, 0, 1))
self.assertEqual(arnold.AiArrayGetRGBA(a, 1),
arnold.AtRGBA(0, 2, 0, 0))
self.assertEqual(arnold.AiArrayGetRGBA(a, 2),
arnold.AtRGBA(0, 0, 3, 0.25))
self.assertEqual(arnold.AiArrayGetRGBA(a, 3),
arnold.AtRGBA(4, 0, 0, 1))
def testSampleDeduplication(self):
camera = IECoreScene.Camera()
camera.setProjection("perspective")
with IECoreArnold.UniverseBlock(writable=True):
animatedNode = IECoreArnold.NodeAlgo.convert([camera, camera], 1.0,
2.0, "samples")
node = IECoreArnold.NodeAlgo.convert(camera, "sample")
for parameter in [
"screen_window_min",
"screen_window_max",
"fov",
"aperture_size",
"focus_distance",
]:
if parameter.startswith("screen_"):
self.assertEqual(
arnold.AiNodeGetVec2(animatedNode, parameter).x,
arnold.AiNodeGetVec2(node, parameter).x)
self.assertEqual(
arnold.AiNodeGetVec2(animatedNode, parameter).y,
arnold.AiNodeGetVec2(node, parameter).y)
else:
self.assertEqual(
arnold.AiNodeGetFlt(animatedNode, parameter),
arnold.AiNodeGetFlt(node, parameter))
array = arnold.AiNodeGetArray(animatedNode, parameter)
self.assertEqual(arnold.AiArrayGetNumElements(array), 1)
self.assertEqual(arnold.AiArrayGetNumKeys(array), 1)
def testIndexedUniformPrimitiveVariables(self):
# We expect uniform indexed variables to be expanded out fully
# when converting to Arnold, because Arnold only supports indexing
# for FaceVarying variables.
m = IECoreScene.MeshPrimitive.createPlane(
imath.Box2f(imath.V2f(-1), imath.V2f(1)),
imath.V2i(4, 1),
)
self.assertEqual(
m.variableSize(
IECoreScene.PrimitiveVariable.Interpolation.Uniform), 4)
m["myPrimVar"] = IECoreScene.PrimitiveVariable(
IECoreScene.PrimitiveVariable.Interpolation.Uniform,
IECore.FloatVectorData([5, 10]), IECore.IntVectorData([0, 1, 0,
1]))
with IECoreArnold.UniverseBlock(writable=True) as universe:
n = IECoreArnold.NodeAlgo.convert(m, universe, "testMesh")
self.assertEqual(
arnold.AiNodeLookUpUserParameter(n, "myPrimVaridxs"), None)
a = arnold.AiNodeGetArray(n, "myPrimVar")
self.assertEqual(arnold.AiArrayGetNumElements(a.contents), 4)
for i in range(0, 4):
self.assertEqual(
arnold.AiArrayGetFlt(a, i),
m["myPrimVar"].data[m["myPrimVar"].indices[i]])
def testNormals(self):
m = IECoreScene.MeshPrimitive.createPlane(
imath.Box2f(imath.V2f(-0.9), imath.V2f(0.9)))
m["N"] = IECoreScene.PrimitiveVariable(
IECoreScene.PrimitiveVariable.Interpolation.Vertex,
IECore.V3fVectorData([
imath.V3f(1, 0, 0),
imath.V3f(1, 0, 0),
imath.V3f(1, 0, 0),
imath.V3f(1, 0, 0)
]))
mFaceVaryingIndexed = IECoreScene.MeshPrimitive.createBox(
imath.Box3f(imath.V3f(-0.9), imath.V3f(0.9)))
mVertexIndexed = IECoreScene.MeshPrimitive.createPlane(
imath.Box2f(imath.V2f(-0.9), imath.V2f(0.9)), imath.V2i(3))
mVertexIndexed["N"] = IECoreScene.PrimitiveVariable(
IECoreScene.PrimitiveVariable.Interpolation.Vertex,
IECore.V3fVectorData([imath.V3f(1, 0, 0),
imath.V3f(-1, 0, 0)]),
IECore.IntVectorData([0] * 8 + [1] * 8))
with IECoreArnold.UniverseBlock(writable=True) as universe:
n = IECoreArnold.NodeAlgo.convert(m, universe, "testMesh")
normals = arnold.AiNodeGetArray(n, "nlist")
self.assertEqual(arnold.AiArrayGetNumElements(normals.contents), 4)
for i in range(0, 4):
self.assertEqual(arnold.AiArrayGetVec(normals, i),
arnold.AtVector(1, 0, 0))
n = IECoreArnold.NodeAlgo.convert(mFaceVaryingIndexed, universe,
"testMesh2")
normals = arnold.AiNodeGetArray(n, "nlist")
normalIndices = arnold.AiNodeGetArray(n, "nidxs")
refNormals = [(0, 0, -1), (1, 0, 0), (0, 0, 1), (-1, 0, 0),
(0, 1, 0), (0, -1, 0)]
for i in range(0, 24):
self.assertEqual(
arnold.AiArrayGetVec(
normals, arnold.AiArrayGetInt(normalIndices, i)),
arnold.AtVector(*refNormals[i // 4]))
n = IECoreArnold.NodeAlgo.convert(mVertexIndexed, universe,
"testMesh3")
normals = arnold.AiNodeGetArray(n, "nlist")
normalIndices = arnold.AiNodeGetArray(n, "nidxs")
for i in range(0, 36):
s = [0, (i // 2) % 2, 1][i // 12]
self.assertEqual(
arnold.AiArrayGetVec(
normals, arnold.AiArrayGetInt(normalIndices, i)),
arnold.AtVector(-1 if s else 1, 0, 0))
def __arrayToSet( self, a ) : result = set() for i in range( 0, arnold.AiArrayGetNumElements( a.contents ) ) : if arnold.AiArrayGetType( a.contents ) == arnold.AI_TYPE_STRING : result.add( arnold.AiArrayGetStr( a, i ) ) else : raise TypeError return result
def testLightFiltersMany(self):
# \todo: this can easily be turned into a performance test
s = Gaffer.ScriptNode()
s["lightFilter"] = GafferArnold.ArnoldLightFilter()
s["lightFilter"].loadShader("light_blocker")
s["lightFilter"]["filteredLights"].setValue("defaultLights")
s["planeFilters"] = GafferScene.Plane("Plane")
s["planeFilters"]["divisions"].setValue(imath.V2i(9))
s["instancerFilters"] = GafferScene.Instancer("Instancer")
s["instancerFilters"]["in"].setInput(s["planeFilters"]["out"])
s["instancerFilters"]["instances"].setInput(s["lightFilter"]["out"])
s["instancerFilters"]["parent"].setValue("/plane")
s["light"] = GafferArnold.ArnoldLight()
s["light"].loadShader("point_light")
s["planeLights"] = GafferScene.Plane("Plane")
s["planeLights"]["divisions"].setValue(imath.V2i(9))
s["instancerLights"] = GafferScene.Instancer("Instancer")
s["instancerLights"]["in"].setInput(s["planeLights"]["out"])
s["instancerLights"]["instances"].setInput(s["light"]["out"])
s["instancerLights"]["parent"].setValue("/plane")
s["group"] = GafferScene.Group("Group")
s["group"]["in"][0].setInput(s["instancerFilters"]["out"])
s["group"]["in"][1].setInput(s["instancerLights"]["out"])
s["render"] = GafferArnold.ArnoldRender()
s["render"]["in"].setInput(s["group"]["out"])
s["render"]["mode"].setValue(s["render"].Mode.SceneDescriptionMode)
s["render"]["fileName"].setValue(self.temporaryDirectory() +
"/testMany.ass")
s["render"]["task"].execute()
with IECoreArnold.UniverseBlock(writable=True):
foo = self.temporaryDirectory() + "/testMany.ass"
print foo
arnold.AiASSLoad(foo)
for i in range(100):
light = arnold.AiNodeLookUpByName(
"light:/group/plane1/instances/light/%s" % i)
linkedFilters = arnold.AiNodeGetArray(light, "filters")
numFilters = arnold.AiArrayGetNumElements(
linkedFilters.contents)
self.assertEqual(numFilters, 100)
def testStringArray( self ) : with IECoreArnold.UniverseBlock( writable = True ) : n = arnold.AiNode( "polymesh" ) IECoreArnold.ParameterAlgo.setParameter( n, "trace_sets", IECore.StringVectorData( [ "a", "b" ] ) ) a = arnold.AiNodeGetArray( n, "trace_sets" ) self.assertEqual( arnold.AiArrayGetNumElements( a.contents ), 2 ) self.assertEqual( arnold.AiArrayGetStr( a, 0 ), "a" ) self.assertEqual( arnold.AiArrayGetStr( a, 1 ), "b" )
def testConstantArrayPrimitiveVariable( self ) : p = IECoreScene.PointsPrimitive( IECore.V3fVectorData( 10 ) ) p["myPrimVar"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.Constant, IECore.IntVectorData( range( 0, 10 ) ) ) with IECoreArnold.UniverseBlock( writable = True ) : n = IECoreArnold.NodeAlgo.convert( p, "testPoints" ) a = arnold.AiNodeGetArray( n, "myPrimVar" ) self.assertEqual( arnold.AiArrayGetNumElements( a.contents ), 10 ) for i in range( 0, 10 ) : self.assertEqual( arnold.AiArrayGetInt( a, i ), i )
def testMotion(self):
m1 = IECore.MeshPrimitive.createPlane(
IECore.Box2f(IECore.V2f(-1), IECore.V2f(1)))
IECore.MeshNormalsOp()(input=m1, copyInput=False)
m2 = m1.copy()
m2["P"].data[0] -= IECore.V3f(0, 0, 1)
m2["P"].data[1] -= IECore.V3f(0, 0, 1)
IECore.MeshNormalsOp()(input=m2, copyInput=False)
with IECoreArnold.UniverseBlock(writable=True):
node = IECoreArnold.NodeAlgo.convert([m1, m2], -0.25, 0.25,
"testMesh")
vList = arnold.AiNodeGetArray(node, "vlist")
self.assertEqual(arnold.AiArrayGetNumElements(vList.contents), 4)
self.assertEqual(arnold.AiArrayGetNumKeys(vList.contents), 2)
nList = arnold.AiNodeGetArray(node, "nlist")
self.assertEqual(arnold.AiArrayGetNumElements(nList.contents), 4)
self.assertEqual(arnold.AiArrayGetNumKeys(nList.contents), 2)
for i in range(0, 4):
p = arnold.AiArrayGetVec(vList, i)
self.assertEqual(IECore.V3f(p.x, p.y, p.z), m1["P"].data[i])
n = arnold.AiArrayGetVec(nList, i)
self.assertEqual(IECore.V3f(n.x, n.y, n.z), m1["N"].data[i])
for i in range(4, 8):
p = arnold.AiArrayGetVec(vList, i)
self.assertEqual(IECore.V3f(p.x, p.y, p.z),
m2["P"].data[i - 4])
n = arnold.AiArrayGetVec(nList, i)
self.assertEqual(IECore.V3f(n.x, n.y, n.z),
m2["N"].data[i - 4])
self.assertEqual(arnold.AiNodeGetFlt(node, "motion_start"), -0.25)
self.assertEqual(arnold.AiNodeGetFlt(node, "motion_end"), 0.25)
def testUVs(self):
m = IECore.MeshPrimitive.createPlane(
IECore.Box2f(IECore.V2f(-1), IECore.V2f(1)))
uvData = m["uv"].data
with IECoreArnold.UniverseBlock(writable=True):
n = IECoreArnold.NodeAlgo.convert(m, "testMesh")
uvs = arnold.AiNodeGetArray(n, "uvlist")
self.assertEqual(arnold.AiArrayGetNumElements(uvs.contents), 4)
uvIndices = arnold.AiNodeGetArray(n, "uvidxs")
self.assertEqual(arnold.AiArrayGetNumElements(uvIndices.contents),
4)
for i in range(0, 4):
p = arnold.AiArrayGetVec2(uvs, i)
self.assertEqual(arnold.AiArrayGetVec2(uvs, i),
arnold.AtVector2(uvData[i][0], uvData[i][1]))
self.assertEqual(arnold.AiArrayGetInt(uvIndices, i), i)
def testFaceVaryingPrimitiveVariables(self):
m = IECoreScene.MeshPrimitive.createPlane(
imath.Box2f(imath.V2f(-1), imath.V2f(1)),
imath.V2i(2),
)
self.assertEqual(
m.variableSize(
IECoreScene.PrimitiveVariable.Interpolation.FaceVarying), 16)
m["myPrimVar"] = IECoreScene.PrimitiveVariable(
IECoreScene.PrimitiveVariable.Interpolation.FaceVarying,
IECore.FloatVectorData(range(0, 16)))
with IECoreArnold.UniverseBlock(writable=True):
n = IECoreArnold.NodeAlgo.convert(m, "testMesh")
a = arnold.AiNodeGetArray(n, "myPrimVar")
ia = arnold.AiNodeGetArray(n, "myPrimVaridxs")
self.assertEqual(arnold.AiArrayGetNumElements(a.contents), 16)
self.assertEqual(arnold.AiArrayGetNumElements(ia.contents), 16)
for i in range(0, 16):
self.assertEqual(arnold.AiArrayGetFlt(a, i), i)
self.assertEqual(arnold.AiArrayGetUInt(ia, i), i)
def testNoLinkedLightsOnLights(self):
sphere = GafferScene.Sphere()
meshLightShader = GafferArnold.ArnoldShader()
meshLightShader.loadShader("flat")
meshLightFilter = GafferScene.PathFilter()
meshLightFilter["paths"].setValue(IECore.StringVectorData(["/sphere"]))
meshLight = GafferArnold.ArnoldMeshLight()
meshLight["in"].setInput(sphere["out"])
meshLight["filter"].setInput(meshLightFilter["out"])
meshLight["parameters"]["color"].setInput(meshLightShader["out"])
light1 = GafferArnold.ArnoldLight()
light1.loadShader("point_light")
light2 = GafferArnold.ArnoldLight()
light2.loadShader("point_light")
# Trigger light linking by unlinking a light
light2["defaultLight"].setValue(False)
group = GafferScene.Group()
group["in"][0].setInput(meshLight["out"])
group["in"][1].setInput(light1["out"])
group["in"][2].setInput(light2["out"])
render = GafferArnold.ArnoldRender()
render["in"].setInput(group["out"])
render["mode"].setValue(render.Mode.SceneDescriptionMode)
render["fileName"].setValue(self.temporaryDirectory() + "/test.ass")
render["task"].execute()
with IECoreArnold.UniverseBlock(writable=True):
arnold.AiASSLoad(self.temporaryDirectory() + "/test.ass")
sphere = arnold.AiNodeLookUpByName("/group/sphere")
self.assertIsNotNone(sphere)
self.assertEqual(
arnold.AiArrayGetNumElements(
arnold.AiNodeGetArray(sphere, "light_group")), 0)
self.assertFalse(arnold.AiNodeGetBool(sphere, "use_light_group"))
def testVertexPrimitiveVariable( self ) : for interpolation in ( "Vertex", "Varying", "FaceVarying" ) : p = IECoreScene.PointsPrimitive( IECore.V3fVectorData( 10 ) ) p["myPrimVar"] = IECoreScene.PrimitiveVariable( getattr( IECoreScene.PrimitiveVariable.Interpolation, interpolation ), IECore.IntVectorData( range( 0, 10 ) ) ) self.assertTrue( p.arePrimitiveVariablesValid() ) with IECoreArnold.UniverseBlock( writable = True ) : n = IECoreArnold.NodeAlgo.convert( p, "testPoints" ) a = arnold.AiNodeGetArray( n, "myPrimVar" ) self.assertEqual( arnold.AiArrayGetNumElements( a.contents ), 10 ) for i in range( 0, 10 ) : self.assertEqual( arnold.AiArrayGetInt( a, i ), i )
def testBoolVectorPrimitiveVariables(self):
m = IECoreScene.MeshPrimitive.createPlane(
imath.Box2f(imath.V2f(-1), imath.V2f(1)))
m["myBoolPrimVar"] = IECoreScene.PrimitiveVariable(
IECoreScene.PrimitiveVariable.Interpolation.Vertex,
IECore.BoolVectorData([True, False, True, False]))
with IECoreArnold.UniverseBlock(writable=True) as universe:
n = IECoreArnold.NodeAlgo.convert(m, universe, "testMesh")
a = arnold.AiNodeGetArray(n, "myBoolPrimVar")
self.assertEqual(arnold.AiArrayGetNumElements(a.contents), 4)
self.assertEqual(arnold.AiArrayGetBool(a, 0), True)
self.assertEqual(arnold.AiArrayGetBool(a, 1), False)
self.assertEqual(arnold.AiArrayGetBool(a, 2), True)
self.assertEqual(arnold.AiArrayGetBool(a, 3), False)
def testVertexPrimitiveVariables(self):
m = IECoreScene.MeshPrimitive.createPlane(
imath.Box2f(imath.V2f(-1), imath.V2f(1)))
m["myPrimVar"] = IECoreScene.PrimitiveVariable(
IECoreScene.PrimitiveVariable.Interpolation.Vertex,
IECore.FloatVectorData([0, 1, 2, 3]))
m["myV3fPrimVar"] = IECoreScene.PrimitiveVariable(
IECoreScene.PrimitiveVariable.Interpolation.Vertex,
IECore.V3fVectorData([imath.V3f(v) for v in range(0, 4)]))
with IECoreArnold.UniverseBlock(writable=True) as universe:
n = IECoreArnold.NodeAlgo.convert(m, universe, "testMesh")
a = arnold.AiNodeGetArray(n, "myPrimVar")
v = arnold.AiNodeGetArray(n, "myV3fPrimVar")
self.assertEqual(arnold.AiArrayGetNumElements(a.contents), 4)
for i in range(0, 4):
self.assertEqual(arnold.AiArrayGetFlt(a, i), i)
self.assertEqual(arnold.AiArrayGetVec(v, i), i)
def testDefaultLightsMistakesDontForceLinking(self):
light = GafferArnold.ArnoldLight()
light.loadShader("point_light")
sphere = GafferScene.Sphere()
# It doesn't make sense to add a non-light to the "defaultLights"
# set like this, but in the event of user error, we don't want to
# emit light links unnecessarily.
sphereSet = GafferScene.Set()
sphereSet["in"].setInput(sphere["out"])
sphereSet["name"].setValue("defaultLights")
sphereSet["paths"].setValue(IECore.StringVectorData(["/sphere"]))
group = GafferScene.Group()
group["in"][0].setInput(light["out"])
group["in"][1].setInput(sphereSet["out"])
render = GafferArnold.ArnoldRender()
render["in"].setInput(group["out"])
render["mode"].setValue(render.Mode.SceneDescriptionMode)
render["fileName"].setValue(self.temporaryDirectory() + "/test.ass")
render["task"].execute()
with IECoreArnold.UniverseBlock(writable=True):
arnold.AiASSLoad(self.temporaryDirectory() + "/test.ass")
sphere = arnold.AiNodeLookUpByName("/group/sphere")
self.assertIsNotNone(sphere)
self.assertEqual(
arnold.AiArrayGetNumElements(
arnold.AiNodeGetArray(sphere, "light_group")), 0)
self.assertFalse(arnold.AiNodeGetBool(sphere, "use_light_group"))
def testNormals(self):
m = IECoreScene.MeshPrimitive.createPlane(
imath.Box2f(imath.V2f(-0.9), imath.V2f(0.9)))
m["N"] = IECoreScene.PrimitiveVariable(
IECoreScene.PrimitiveVariable.Interpolation.Vertex,
IECore.V3fVectorData([
imath.V3f(1, 0, 0),
imath.V3f(1, 0, 0),
imath.V3f(1, 0, 0),
imath.V3f(1, 0, 0)
]))
with IECoreArnold.UniverseBlock(writable=True):
n = IECoreArnold.NodeAlgo.convert(m, "testMesh")
normals = arnold.AiNodeGetArray(n, "nlist")
self.assertEqual(arnold.AiArrayGetNumElements(normals.contents), 4)
for i in range(0, 4):
self.assertEqual(arnold.AiArrayGetVec(normals, i),
arnold.AtVector(1, 0, 0))