def testCacheFile(f):
sc = IECoreScene.SceneCache(f, IECore.IndexedIO.OpenMode.Read)
a = sc.child("a")
self.failUnless(a.hasObject())
self.failUnless(
isinstance(a.readObject(0), IECoreScene.MeshPrimitive))
self.failUnless(
a.readTransformAsMatrix(0).equalWithAbsError(matrix, 1e-6))
b = a.child("b")
self.failUnless(b.hasObject())
self.failUnless(
isinstance(b.readObject(0), IECoreScene.MeshPrimitive))
self.failUnless(
b.readTransformAsMatrix(0).equalWithAbsError(matrix, 1e-6))
c = b.child("c")
self.failUnless(c.hasObject())
self.failUnless(
isinstance(c.readObject(0), IECoreScene.MeshPrimitive))
self.failUnless(
c.readTransformAsMatrix(0).equalWithAbsError(matrix, 1e-6))
def testUVProvidedAsV2f( self ) :
shader = self.compileShader( os.path.dirname( __file__ ) + "/shaders/globals.osl" )
rp = self.rectanglePoints()
rp["uv"] = IECore.V2fVectorData(
[ IECore.V2f( u, v ) for u, v in zip( rp["u"], rp["v"] ) ]
)
del rp["u"]
del rp["v"]
for uvIndex, uvName in enumerate( [ "u", "v" ] ) :
e = GafferOSL.ShadingEngine( IECore.ObjectVector( [
IECoreScene.Shader( shader, "osl:surface", { "global" : uvName } ),
] ) )
p = e.shade( rp )
for i, c in enumerate( p["Ci"] ) :
self.assertEqual( c, IECore.Color3f( rp["uv"][i][uvIndex] ) )
def matrixShader(self):
s = IECoreScene.Shader("test", "gl:surface")
s.parameters["gl:fragmentSource"] = """
uniform mat3 m3;
uniform mat3 m3v[8];
uniform mat4 m4;
uniform mat4 m4v[8];
void main()
{
vec3 accum = vec3( 0 );
for( int i = 0; i < 8; i += 1 ) accum += m3v[i] * vec3( 0, 1, 0 ) + (m4v[i] * vec4( 0, 1, 0, 0 )).xyz;
gl_FragColor = vec4( m3 * vec3( 0, 0, 1) + (m4 * vec4( 0, 0, 1, 1 )).xyz + accum, 1.0);
}
"""
return s
def assertAssignment(expected, envVar):
env = os.environ.copy()
if envVar is not None:
env["GAFFERSCENE_SHADERASSIGNMENT_OSL_PREFIX"] = envVar
o = subprocess.check_output([
"gaffer", "execute", script["fileName"].getValue(), "-nodes",
"writer"
],
env=env)
scene = IECoreScene.SceneCache(
script["writer"]["fileName"].getValue(),
IECore.IndexedIO.OpenMode.Read)
sphere = scene.child("sphere")
self.assertEqual(
[i for i in sphere.attributeNames() if ":surface" in i],
[expected])
def testInitialisationOfVectorData( self ) : # This exercises a bug whereby the resampling methods that use averaging # were not initialising the results to zero before accumulating. m = IECoreScene.MeshPrimitive.createPlane( imath.Box2f( imath.V2f( -1 ), imath.V2f( 1 ) ), imath.V2i( 100 ) ) for i in range( 0, 10 ) : for interpolation in ( IECoreScene.PrimitiveVariable.Interpolation.Uniform, IECoreScene.PrimitiveVariable.Interpolation.FaceVarying ) : pv = IECoreScene.PrimitiveVariable( interpolation, IECore.V2fVectorData( [ imath.V2f( 0 ) ] * m.variableSize( interpolation ) ) ) IECoreScene.MeshAlgo.resamplePrimitiveVariable( m, pv, IECoreScene.PrimitiveVariable.Interpolation.Vertex ) self.assertEqual( len( pv.data ), m.variableSize( IECoreScene.PrimitiveVariable.Interpolation.Vertex ) ) for v in pv.data : self.assertEqual( v, imath.V2f( 0 ) )
def testHash(self):
d = IECoreScene.Display()
h = d.hash()
d.setName("somethingElse")
self.assertNotEqual(h, d.hash())
h = d.hash()
d.setType("tif")
self.assertNotEqual(h, d.hash())
h = d.hash()
d.setData("a")
self.assertNotEqual(h, d.hash())
h = d.hash()
d.parameters()["something"] = IECore.StringData("a")
self.assertNotEqual(h, d.hash())
h = d.hash()
def testCurveLengthAccuracy(self):
pts = IECore.V3fVectorData()
pts.append(imath.V3f(0, 0, 0))
pts.append(imath.V3f(0, 0, 0))
pts.append(imath.V3f(0, 0, 0))
pts.append(imath.V3f(1000, 0, 0))
pts.append(imath.V3f(1000, 0, 0))
pts.append(imath.V3f(1000, 0, 0))
c = IECoreScene.CurvesPrimitive(IECore.IntVectorData([len(pts)]),
IECore.CubicBasisf.bSpline(), False,
pts)
e = IECoreScene.CurvesPrimitiveEvaluator(c)
self.assertAlmostEqual(e.curveLength(0), 1000.0, 3)
# measure the length of a semicircle:
pts = IECore.V3fVectorData()
pts.append(imath.V3f(1, 0, 0))
pts.append(imath.V3f(1, 0, 0))
for i in range(0, 201):
angle = math.pi * float(i) / 200
pts.append(imath.V3f(math.cos(angle), math.sin(angle), 0))
pts.append(imath.V3f(-1, 0, 0))
pts.append(imath.V3f(-1, 0, 0))
c = IECoreScene.CurvesPrimitive(IECore.IntVectorData([len(pts)]),
IECore.CubicBasisf.bSpline(), False,
pts)
e = IECoreScene.CurvesPrimitiveEvaluator(c)
self.assertAlmostEqual(e.curveLength(0), 3.1415926, 3)
# measure the perimeter of a circle:
pts = IECore.V3fVectorData()
for i in range(0, 401):
angle = 2 * math.pi * float(i) / 400
pts.append(imath.V3f(math.cos(angle), math.sin(angle), 0))
c = IECoreScene.CurvesPrimitive(IECore.IntVectorData([len(pts)]),
IECore.CubicBasisf.bSpline(), True,
pts)
e = IECoreScene.CurvesPrimitiveEvaluator(c)
self.assertAlmostEqual(e.curveLength(0), 2 * 3.1415926, 3)
def testDirtyPropagation(self):
outputs = GafferScene.Outputs()
cs = GafferTest.CapturingSlot(outputs.plugDirtiedSignal())
p = outputs.addOutput(
"test",
IECoreScene.Output("name", "type", "data", {
"paramA": 1,
"paramB": 2
}))
self.assertTrue(outputs["out"]["globals"] in [c[0] for c in cs])
del cs[:]
p["name"].setValue("newName")
self.assertTrue(outputs["out"]["globals"] in [c[0] for c in cs])
del cs[:]
outputs["outputs"].removeChild(p)
self.assertTrue(outputs["out"]["globals"] in [c[0] for c in cs])
def floatArrayShader(self):
s = IECoreScene.Shader("test", "gl:surface")
s.parameters["gl:fragmentSource"] = """
uniform float f[8];
uniform vec2 f2[8];
uniform vec3 f3[8];
uniform vec4 f4[8];
void main()
{
vec3 accum = vec3( 0 );
for( int i = 0; i < 8; i += 1 ) accum += 0.01 * ( vec3(f[i], 0, 0) + vec3(f2[i], 0) + f3[i] + f4[i].xyz );
gl_FragColor = vec4( accum, 1.0);
}
"""
return s
def testOpenLinear( self ) : # open, cubic curve: i = IECore.IntVectorData( [ 4 ] ) p = IECore.V3fVectorData( [ imath.V3f( 0 ), imath.V3f( 1 ), imath.V3f( 2 ), imath.V3f( 3 ) ] ) coreCurves = IECoreScene.CurvesPrimitive( i, IECore.CubicBasisf.linear(), False, p ) converter = IECoreMaya.ToMayaObjectConverter.create( coreCurves ) transform = maya.cmds.createNode( "transform" ) self.assert_( converter.convert( transform ) ) mayaCurve = maya.cmds.listRelatives( transform, shapes=True )[0] self.assertEqual( maya.cmds.getAttr( mayaCurve + ".boundingBoxMin" ), [( 0, 0, 0 )] ) self.assertEqual( maya.cmds.getAttr( mayaCurve + ".boundingBoxMax" ), [( 3, 3, 3 )] ) self.assertEqual( maya.cmds.getAttr( mayaCurve + ".degree" ), 1 ) self.assertEqual( maya.cmds.getAttr( mayaCurve + ".cv[*]" ), [(0,0,0),(1,1,1),(2,2,2),(3,3,3)] )
def testRaisesExceptionIfSamePrimvarHasDifferentInterpolation( self ) : pointsA = IECoreScene.PointsPrimitive( IECore.V3fVectorData( [imath.V3f( x ) for x in range( 2 )] ) ) pointsB = IECoreScene.PointsPrimitive( IECore.V3fVectorData( [imath.V3f( x ) for x in range( 2 )] ) ) # constant then vertex) pointsA["foo"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.Constant, IECore.FloatData( 0.5 ) ) pointsB["foo"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.Vertex, IECore.IntVectorData( [1, 2] ) ) self.assertRaises( RuntimeError, lambda : IECoreScene.PointsAlgo.mergePoints( [pointsA, pointsB] ) ) # swap the order (vertex then constant) pointsA["foo"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.Vertex, IECore.IntVectorData( [1, 2] ) ) pointsB["foo"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.Constant, IECore.FloatData( 0.5 ) ) self.assertRaises( RuntimeError, lambda : IECoreScene.PointsAlgo.mergePoints( [pointsA, pointsB] ) )
def testShaderNetworkRender(self):
f = GafferArnold.ArnoldShader()
f.loadShader("flat")
f["parameters"]["color"].setValue(imath.Color3f(1, 1, 0))
s = GafferArnold.ArnoldShader()
s.loadShader("utility")
s["parameters"]["color"].setInput(f["parameters"]["color"])
r = GafferScene.Private.IECoreScenePreview.Renderer.create(
"Arnold",
GafferScene.Private.IECoreScenePreview.Renderer.RenderType.Batch)
r.output(
"test",
IECoreScene.Output("test", "ieDisplay", "rgba", {
"driverType": "ImageDisplayDriver",
"handle": "test"
}))
mesh = r.object(
"mesh",
IECoreScene.MeshPrimitive.createPlane(
imath.Box2f(imath.V2f(-1), imath.V2f(1))),
r.attributes(s.attributes()))
mesh.transform(imath.M44f().translate(imath.V3f(0, 0, -5)))
r.render()
image = GafferImage.ObjectToImage()
image["object"].setValue(
IECoreImage.ImageDisplayDriver.removeStoredImage("test"))
sampler = GafferImage.ImageSampler()
sampler["image"].setInput(image["out"])
sampler["pixel"].setValue(imath.V2f(320, 240))
self.assertAlmostEqual(sampler["color"]["r"].getValue(), 1, 5)
self.assertAlmostEqual(sampler["color"]["g"].getValue(), 1, 5)
self.assertEqual(sampler["color"]["b"].getValue(), 0)
def testIDSelect(self):
r = IECoreGL.Renderer()
r.setOption("gl:mode", IECore.StringData("deferred"))
with IECoreScene.WorldBlock(r):
r.concatTransform(imath.M44f().translate(imath.V3f(0, 0, -5)))
r.concatTransform(imath.M44f().translate(imath.V3f(-1, 0, 0)))
r.setAttribute("name", IECore.StringData("frontLeft"))
r.sphere(1, -1, 1, 360, {})
r.concatTransform(imath.M44f().translate(imath.V3f(0, 0, -1)))
r.setAttribute("name", IECore.StringData("backLeft"))
r.sphere(1, -1, 1, 360, {})
r.concatTransform(imath.M44f().translate(imath.V3f(2, 0, 1)))
r.setAttribute("name", IECore.StringData("frontRight"))
r.sphere(1, -1, 1, 360, {})
r.concatTransform(imath.M44f().translate(imath.V3f(0, 0, -1)))
r.setAttribute("name", IECore.StringData("backRight"))
r.sphere(1, -1, 1, 360, {})
s = r.scene()
s.setCamera(IECoreGL.Camera())
ss = s.select(IECoreGL.Selector.Mode.IDRender,
imath.Box2f(imath.V2f(0.25, 0.5), imath.V2f(0.26, 0.51)))
self.assertEqual(len(ss), 1)
self.assertEqual(
IECoreGL.NameStateComponent.nameFromGLName(ss[0].name),
"frontLeft")
ss = s.select(IECoreGL.Selector.Mode.IDRender,
imath.Box2f(imath.V2f(0.75, 0.5), imath.V2f(0.76, 0.51)))
self.assertEqual(len(ss), 1)
self.assertEqual(
IECoreGL.NameStateComponent.nameFromGLName(ss[0].name),
"frontRight")
def testTimeSetting(self):
fileName = "{}/testUSDTimeSettings.scc".format(
self.temporaryDirectory())
for sampleType in ("transform", "attribute", "object"):
m = IECoreScene.SceneCache(fileName,
IECore.IndexedIO.OpenMode.Write)
t = m.createChild("t")
if sampleType == "transform":
t.writeTransform(
IECore.M44dData(imath.M44d().translate(imath.V3d(1, 0,
0))), 1.0)
t.writeTransform(
IECore.M44dData(imath.M44d().translate(imath.V3d(2, 0,
0))), 2.0)
elif sampleType == "attribute":
t.writeAttribute(IECoreScene.SceneInterface.visibilityName,
IECore.BoolData(True), 1.0)
t.writeAttribute(IECoreScene.SceneInterface.visibilityName,
IECore.BoolData(False), 2.0)
else:
boxA = IECoreScene.MeshPrimitive.createBox(
imath.Box3f(imath.V3f(0), imath.V3f(1)))
t.writeObject(boxA, 1.0)
boxB = IECoreScene.MeshPrimitive.createBox(
imath.Box3f(imath.V3f(1), imath.V3f(2)))
t.writeObject(boxB, 2.0)
del m, t
# root
stage = pxr.Usd.Stage.Open(fileName)
root = stage.GetPseudoRoot()
metadata = root.GetAllMetadata()
self.assertEqual(metadata["startTimeCode"], 24.0)
self.assertEqual(metadata["endTimeCode"], 48.0)
self.assertEqual(metadata["timeCodesPerSecond"], 24.0)
def testPrimitiveVariablesCorrectlyFilteredIfDeleteInverterd(self):
points = self.points()
points["delete"] = IECoreScene.PrimitiveVariable(
IECoreScene.PrimitiveVariable.Interpolation.Vertex,
IECore.FloatVectorData([0.0, 1.0] * 5))
self.assertTrue(points.arePrimitiveVariablesValid())
points = IECoreScene.PointsAlgo.deletePoints(points,
points["delete"],
invert=True)
self.assertTrue(points.arePrimitiveVariablesValid())
self.assertEqual(points.numPoints, 5)
self.assertEqual(points["delete"].data,
IECore.FloatVectorData([1.0] * 5))
self.assertEqual(points["delete"].interpolation,
IECoreScene.PrimitiveVariable.Interpolation.Vertex)
self.assertEqual(points["a"].data, IECore.FloatData(0.5))
self.assertEqual(points["a"].interpolation,
IECoreScene.PrimitiveVariable.Interpolation.Constant)
self.assertEqual(points["b"].data,
IECore.FloatVectorData(range(1, 11, 2)))
self.assertEqual(points["b"].interpolation,
IECoreScene.PrimitiveVariable.Interpolation.Vertex)
self.assertEqual(points["c"].data, IECore.FloatVectorData([0]))
self.assertEqual(points["c"].interpolation,
IECoreScene.PrimitiveVariable.Interpolation.Uniform)
self.assertEqual(points["d"].data,
IECore.FloatVectorData(range(1, 11, 2)))
self.assertEqual(points["d"].interpolation,
IECoreScene.PrimitiveVariable.Interpolation.Varying)
self.assertEqual(points["e"].data,
IECore.FloatVectorData(range(1, 11, 2)))
self.assertEqual(
points["e"].interpolation,
IECoreScene.PrimitiveVariable.Interpolation.FaceVarying)
def test( self ) :
r = IECoreGL.Renderer()
r.setOption( "gl:mode", IECore.StringData( "immediate" ) )
r.setOption( "gl:searchPath:shader", IECore.StringData( os.path.dirname( __file__ ) + "/shaders" ) )
r.camera( "main", {
"projection" : IECore.StringData( "orthographic" ),
"resolution" : IECore.V2iData( imath.V2i( 256 ) ),
"clippingPlanes" : IECore.V2fData( imath.V2f( 1, 1000 ) ),
"screenWindow" : IECore.Box2fData( imath.Box2f( imath.V2f( -1 ), imath.V2f( 1 ) ) )
}
)
r.display( self.outputFileName, "tif", "rgba", {} )
with IECoreScene.WorldBlock( r ) :
r.concatTransform( imath.M44f().translate( imath.V3f( 0, 0, -5 ) ) )
r.shader( "surface", "color", { "colorValue" : IECore.Color3fData( imath.Color3f( 0, 0, 1 ) ) } )
r.disk( 1, 0, 360, {} )
i = IECore.Reader.create( self.outputFileName ).read()
reader = IECore.Reader.create( os.path.dirname( __file__ ) + "/images/disk.tif" )
reader["rawChannels"].setTypedValue( True )
i2 = reader.read()
# blue where there must be an object
# red where we don't mind
# black where there must be nothing
a = i["A"]
r2 = i2["R"]
b2 = i2["B"]
for i in range( r2.size() ) :
if b2[i] > 0.5 :
self.assertEqual( a[i], 1 )
elif r2[i] < 0.5 :
self.assertEqual( a[i], 0 )
def testCompressionParameter(self):
""" Test LimitSmoothSkinningInfluencesOp in indexed mode with compression on"""
ssd = self.original()
compressedAfterIndexed = self.compressedAfterIndexed()
op = IECoreScene.LimitSmoothSkinningInfluencesOp()
op.parameters()['input'].setValue(ssd)
op.parameters()['mode'].setValue(
IECoreScene.LimitSmoothSkinningInfluencesOp.Mode.Indexed)
op.parameters()['influenceIndices'].setFrameListValue(
IECore.FrameList.parse("1"))
op.parameters()['compressResult'].setTypedValue(True)
op.parameters()['applyLocks'].setValue(False)
result = op.operate()
self.assertEqual(result.influenceNames(), ssd.influenceNames())
self.assertEqual(result.influencePose(), ssd.influencePose())
self.assertNotEqual(result.pointInfluenceIndices(),
ssd.pointInfluenceIndices())
self.assertNotEqual(result.pointIndexOffsets(),
ssd.pointIndexOffsets())
self.assertNotEqual(result.pointInfluenceCounts(),
ssd.pointInfluenceCounts())
self.assertNotEqual(result.pointInfluenceWeights(),
ssd.pointInfluenceWeights())
self.assertNotEqual(result, ssd)
self.assertEqual(result.influenceNames(),
compressedAfterIndexed.influenceNames())
self.assertEqual(result.influencePose(),
compressedAfterIndexed.influencePose())
self.assertEqual(result.pointIndexOffsets(),
compressedAfterIndexed.pointIndexOffsets())
self.assertEqual(result.pointInfluenceCounts(),
compressedAfterIndexed.pointInfluenceCounts())
self.assertEqual(result.pointInfluenceIndices(),
compressedAfterIndexed.pointInfluenceIndices())
self.assertEqual(result.pointInfluenceWeights(),
compressedAfterIndexed.pointInfluenceWeights())
self.assertEqual(result, compressedAfterIndexed)
def testContextManager(self):
r = IECoreGL.Renderer()
r.setOption("gl:mode", IECore.StringData("deferred"))
r.setOption("gl:searchPath:shader",
IECore.StringData(os.path.dirname(__file__) + "/shaders"))
with IECoreScene.WorldBlock(r):
r.concatTransform(imath.M44f().translate(imath.V3f(0, 0, -5)))
r.setAttribute("name", IECore.StringData("one"))
r.shader(
"surface", "color",
{"colorValue": IECore.Color3fData(imath.Color3f(1, 0, 0))})
r.sphere(1, -1, 1, 360, {})
r.concatTransform(imath.M44f().translate(imath.V3f(-1, 0, 0)))
r.setAttribute("name", IECore.StringData("two"))
r.sphere(1, -1, 1, 360, {})
scene = r.scene()
scene.setCamera(None)
IECoreGL.Camera(imath.M44f(),
False).render(IECoreGL.State.defaultState())
hits = []
with IECoreGL.Selector(imath.Box2f(imath.V2f(0), imath.V2f(1)),
IECoreGL.Selector.Mode.IDRender,
hits) as selector:
IECoreGL.State.bindBaseState()
selector.baseState().bind()
scene.root().render(selector.baseState())
names = [
IECoreGL.NameStateComponent.nameFromGLName(x.name) for x in hits
]
self.assertEqual(len(names), 2)
self.assert_("one" in names)
self.assert_("two" in names)
def testPointsWithoutWidth( self ) : r = GafferScene.Private.IECoreScenePreview.Renderer.create( "3Delight", GafferScene.Private.IECoreScenePreview.Renderer.RenderType.SceneDescription, self.temporaryDirectory() + "/test.nsi", ) points = IECoreScene.PointsPrimitive( IECore.V3fVectorData( [ imath.V3f( x ) for x in range( 0, 4 ) ] ) ) r.object( "testPoints", points, r.attributes( IECore.CompoundObject() ), ) r.render() del r nsi = self.__parse( self.temporaryDirectory() + "/test.nsi" ) self.__assertInNSI( '"width" "float" 1 1', nsi )
def testUnrepresentable( self ) : testCamera = maya.cmds.camera()[0] cortexCamera = IECoreScene.Camera() cortexCamera.setProjection( "orthographic" ) cortexCamera.setAperture( imath.V2f( 1, 2 ) ) cortexCamera.setClippingPlanes( imath.V2f( 1, 100 ) ) self.assertTrue( IECoreMaya.ToMayaCameraConverter( cortexCamera ).convert( testCamera ) ) self.assertIECoreCamAndMayaCamEqual( cortexCamera, testCamera ) roundTrip = IECoreMaya.FromMayaCameraConverter( testCamera ).convert() self.assertIECoreCamsAlmostEqual( cortexCamera, roundTrip ) cortexCamera.setApertureOffset( imath.V2f( 3, 4 ) ) self.assertTrue( IECoreMaya.ToMayaCameraConverter( cortexCamera ).convert( testCamera ) ) self.assertIECoreCamAndMayaCamEqual( cortexCamera, testCamera ) roundTrip = IECoreMaya.FromMayaCameraConverter( testCamera ).convert() self.assertIECoreCamsAlmostEqual( cortexCamera, roundTrip ) maya.cmds.delete( testCamera )
def test2Curve3SegmentPeriodicLinear(self):
v = imath.V3f
c = IECoreScene.CurvesPrimitive(
IECore.IntVectorData([6, 6]), IECore.CubicBasisf.linear(), True,
IECore.V3fVectorData([
v(0, 1, 0),
v(0, 0, 0),
v(1, 0, 0),
v(1, 1, 0),
v(2, 1, 0),
v(2, 0, 0),
v(0, 2, 0),
v(0, 1, 0),
v(1, 1, 0),
v(1, 2, 0),
v(2, 2, 0),
v(2, 1, 0)
]))
self.runTest(c)
def test2Curve3SegmentBSpline(self):
v = imath.V3f
c = IECoreScene.CurvesPrimitive(
IECore.IntVectorData([6, 6]), IECore.CubicBasisf.bSpline(), False,
IECore.V3fVectorData([
v(0, 1, 0),
v(0, 0, 0),
v(1, 0, 0),
v(1, 1, 0),
v(2, 1, 0),
v(2, 0, 0),
v(0, 2, 0),
v(0, 1, 0),
v(1, 1, 0),
v(1, 2, 0),
v(2, 2, 0),
v(2, 1, 0)
]))
self.runTest(c)
def test( self ) : f = IECoreScene.Font( "test/IECore/data/fonts/Vera.ttf" ) g = f.meshGroup( "hello world" ) m = f.mesh( "hello world" ) self.assertTrue( g.isInstanceOf( IECoreScene.Group.staticTypeId() ) ) self.assertTrue( m.isInstanceOf( IECoreScene.MeshPrimitive.staticTypeId() ) ) v = 0 for c in g.children() : self.assertTrue( c.isInstanceOf( IECoreScene.Group.staticTypeId() ) ) self.assertEqual( len( c.children() ), 1 ) self.assertTrue( c.children()[0].isInstanceOf( IECoreScene.MeshPrimitive.staticTypeId() ) ) self.assertEqual( c.children()[0]["P"].data.getInterpretation(), IECore.GeometricData.Interpretation.Point ) v += c.children()[0]["P"].data.size() self.assertEqual( v, m["P"].data.size() )
def testSpline( self ) :
shader = self.compileShader( os.path.dirname( __file__ ) + "/shaders/splineParameters.osl" )
spline = IECore.SplinefColor3f(
IECore.CubicBasisf.bSpline(),
[
( 0, IECore.Color3f( 1 ) ),
( 0, IECore.Color3f( 1 ) ),
( 1, IECore.Color3f( 0 ) ),
( 1, IECore.Color3f( 0 ) ),
]
)
e = GafferOSL.ShadingEngine( IECore.ObjectVector( [
IECoreScene.Shader( shader, "osl:surface", { "colorSpline" : spline } )
] ) )
rp = self.rectanglePoints()
p = e.shade( rp )
for i in range( 0, len( p["Ci"] ) ) :
self.assertTrue( p["Ci"][i].equalWithAbsError( spline( rp["v"][i] ), 0.001 ) )
def testParameters( self ) :
shader = self.compileShader( os.path.dirname( __file__ ) + "/shaders/parameterTypes.osl" )
e = GafferOSL.ShadingEngine( IECore.ObjectVector( [
IECoreScene.Shader( shader, "osl:surface", {
"f" : 1.0,
"i" : 2,
"s" : "three",
"c" : IECore.Color3f( 4, 5, 6 ),
"vec" : IECore.V3fData( IECore.V3f( 7, 8, 9 ), IECore.GeometricData.Interpretation.Vector ),
"p" : IECore.V3fData( IECore.V3f( 10, 11, 12 ), IECore.GeometricData.Interpretation.Point ),
"n" : IECore.V3fData( IECore.V3f( 13, 14, 15 ), IECore.GeometricData.Interpretation.Normal ),
"noInterp" : IECore.V3f( 16, 17, 18 ),
} )
] ) )
rp = self.rectanglePoints()
p = e.shade( rp )
for i in range( 0, len( p["Ci"] ) ) :
self.assertEqual( p["Ci"][i], IECore.Color3f( 0, 1, 0 ) )
def testPrimvarCopy(self):
p1 = self._buildPoints(1.0)
p2 = self._buildPoints(2.0)
points = IECore.ObjectVector()
points.append(p1)
points.append(p2)
op = IECoreScene.PointsMotionOp()
result = op(snapshotTimes=IECore.FloatVectorData([1, 2]),
pointsPrimitives=points)
# proves that the output correspond exactly to the input
self.assertEqual(len(result), 2)
self.assertEqual(result[1], p1)
self.assertEqual(result[2], p2)
self.assertNotEqual(result[1], p2)
p1["P"].data[3] = imath.V3f(1, 2, 3)
self.assertEqual(p1["P"].data[3], imath.V3f(1, 2, 3))
# proves that destroying the original input value, keeps the output untouched.
self.assertEqual(result[1]["P"].data[3], imath.V3f(4))
def render(self, renderer):
with IECoreScene.AttributeBlock(renderer):
renderer.setAttribute("name", IECore.StringData(self.__name))
if self.__depth < self.__maxDepth:
for n in ("1", "2"):
renderer.procedural(
InstancingTest.RandomMeshProcedural(
self.__meshes,
self.__name + "/" + n,
self.__depth + 1,
self.__maxDepth,
))
else:
mesh = self.__meshes[int(self.__name.split("/")[-1]) - 1]
mesh.render(renderer)
def testVertAttribsCantBeConverted(self):
points = self.points()
points["floatVert"] = IECoreScene.PrimitiveVariable(
IECoreScene.PrimitiveVariable.Interpolation.FaceVarying,
IECore.FloatVectorData(1))
sop = self.emptySop()
self.assertNotEqual(
IECoreHoudini.FromHoudiniPointsConverter(sop).convert(), points)
self.assertTrue(
IECoreHoudini.ToHoudiniPointsConverter(points).convert(sop))
allAttribs = [x.name() for x in sop.geometry().globalAttribs()]
allAttribs.extend([x.name() for x in sop.geometry().pointAttribs()])
allAttribs.extend([x.name() for x in sop.geometry().primAttribs()])
allAttribs.extend([x.name() for x in sop.geometry().vertexAttribs()])
self.assertTrue("floatVert" not in allAttribs)
del points["floatVert"]
self.comparePrimAndSop(points, sop)
def testGlobalAsNeededAttribute(self):
s = self.compileShader(os.path.dirname(__file__) + "/shaders/red.osl")
e = GafferOSL.ShadingEngine(
IECoreScene.ShaderNetwork(
shaders={
"output": IECoreScene.Shader(s, "osl:surface", {}),
},
output="output",
))
self.assertTrue(e.needsAttribute("P"))
self.assertFalse(e.needsAttribute("N"))
self.assertFalse(e.needsAttribute("u"))
self.assertFalse(e.needsAttribute("v"))
self.assertFalse(e.needsAttribute("time"))
s = self.compileShader(
os.path.dirname(__file__) + "/shaders/globals.osl")
e = GafferOSL.ShadingEngine(
IECoreScene.ShaderNetwork(shaders={
"output":
IECoreScene.Shader(s, "osl:surface", {"global": "P"}),
},
output="output"))
self.assertTrue(e.needsAttribute("P"))
self.assertFalse(e.needsAttribute("N"))
self.assertFalse(e.needsAttribute("uv"))
self.assertFalse(e.needsAttribute("u"))
self.assertFalse(e.needsAttribute("v"))
self.assertFalse(e.needsAttribute("time"))
e = GafferOSL.ShadingEngine(
IECoreScene.ShaderNetwork(shaders={
"output":
IECoreScene.Shader(s, "osl:surface", {"global": "u"}),
},
output="output"))
self.assertTrue(e.needsAttribute("P"))
self.assertFalse(e.needsAttribute("N"))
self.assertTrue(e.needsAttribute("uv"))
self.assertTrue(e.needsAttribute("u"))
self.assertFalse(e.needsAttribute("v"))
self.assertFalse(e.needsAttribute("time"))
def testSceneTranslationOnly(self):
plane = GafferScene.Plane()
outputs = GafferScene.Outputs()
outputs.addOutput(
"beauty",
IECoreScene.Output(self.temporaryDirectory() + "/test.exr", "exr",
"rgba", {}))
render = GafferDelight.DelightRender()
render["in"].setInput(outputs["out"])
render["mode"].setValue(render.Mode.RenderMode)
with Gaffer.Context() as context:
context["scene:render:sceneTranslationOnly"] = IECore.BoolData(
True)
render["task"].execute()
self.assertFalse(
os.path.exists(self.temporaryDirectory() + "/test.exr"))
def testBoolIndexedView( self ) : IECoreScene.testPrimitiveVariableBoolIndexedView()
def testParallelClosestPoint( self ) : IECoreScene.testCurvesPrimitiveEvaluatorParallelClosestPoint()
def testParallelFakeAttributeRead( self ) : IECoreScene.testSceneCacheParallelFakeAttributeRead()
def testParallelResultCreation( self ) : IECoreScene.testCurvesPrimitiveEvaluatorParallelResultCreation()
def testVariableIndexedView( self ) : IECoreScene.testVariableIndexedView()
