def testGLPoints( self ) :
fragmentSource = """
void main()
{
gl_FragColor = vec4( 1, 1, 1, 1 );
}
"""
r = IECoreGL.Renderer()
r.setOption( "gl:mode", IECore.StringData( "immediate" ) )
r.setOption( "gl:searchPath:shaderInclude", IECore.StringData( "./glsl" ) )
r.camera( "main", {
"projection" : IECore.StringData( "orthographic" ),
"projection:fov" : IECore.FloatData( 20 ),
"resolution" : IECore.V2iData( IECore.V2i( 256 ) ),
"clippingPlanes" : IECore.V2fData( IECore.V2f( 1, 1000 ) ),
"screenWindow" : IECore.Box2fData( IECore.Box2f( IECore.V2f( -3 ), IECore.V2f( 3 ) ) )
}
)
r.display( self.outputFileName, "tif", "rgba", {} )
with IECore.WorldBlock( r ) :
r.concatTransform( IECore.M44f.createTranslated( IECore.V3f( 0, 0, -6 ) ) )
r.shader( "surface", "white", { "gl:fragmentSource" : IECore.StringData( fragmentSource ) } )
with IECore.AttributeBlock( r ) :
r.setAttribute( "gl:pointsPrimitive:glPointWidth", IECore.FloatData( 20 ) )
r.points( 1, {
"P" : IECore.PrimitiveVariable( IECore.PrimitiveVariable.Interpolation.Vertex, IECore.V3fVectorData( [ IECore.V3f( 0 ) ] ) ),
"type" : IECore.PrimitiveVariable( IECore.PrimitiveVariable.Interpolation.Uniform, IECore.StringData( "gl:point" ) )
}
)
with IECore.AttributeBlock( r ) :
r.setAttribute( "gl:pointsPrimitive:glPointWidth", IECore.FloatData( 10 ) )
r.points( 1, {
"P" : IECore.PrimitiveVariable( IECore.PrimitiveVariable.Interpolation.Vertex, IECore.V3fVectorData( [ IECore.V3f( 1, 0, 0 ) ] ) ),
"type" : IECore.PrimitiveVariable( IECore.PrimitiveVariable.Interpolation.Uniform, IECore.StringData( "gl:point" ) )
}
)
expectedImage = IECore.Reader.create( os.path.dirname( __file__ ) + "/expectedOutput/glPoints.tif" ).read()
actualImage = IECore.Reader.create( self.outputFileName ).read()
self.assertEqual( IECore.ImageDiffOp()( imageA = expectedImage, imageB = actualImage, maxError = 0.05 ).value, False )
def testCoshadersStack( self ) :
self.assertEqual( os.system( "shaderdl -o test/IECoreRI/shaders/sxCoshaderTest.sdl test/IECoreRI/shaders/sxCoshaderTest.sl" ), 0 )
self.assertEqual( os.system( "shaderdl -o test/IECoreRI/shaders/sxCoshaderTestMain.sdl test/IECoreRI/shaders/sxCoshaderTestMain.sl" ), 0 )
r = IECoreRI.SXRenderer()
b = IECore.Box2i( IECore.V2i( 0 ), IECore.V2i( 100 ) )
points = self.__rectanglePoints( b )
with IECore.WorldBlock( r ) :
r.shader( "shader", "test/IECoreRI/shaders/sxCoshaderTest", { "shaderColor" : IECore.Color3f( 1, 0, 0 ), "__handle" : "cs1" } )
r.shader( "shader", "test/IECoreRI/shaders/sxCoshaderTest", { "sColor" : IECore.Color3f( 0, 1, 0 ), "__handle" : "cs2" } )
r.shader( "shader", "test/IECoreRI/shaders/sxCoshaderTest", { "tColor" : IECore.Color3f( 0, 0, 1 ), "__handle" : "cs3" } )
with IECore.AttributeBlock( r ) :
# these guys should be popped and therefore not affect the result
r.shader( "shader", "test/IECoreRI/shaders/sxCoshaderTest", { "shaderColor" : IECore.Color3f( 1, 1, 1 ), "__handle" : "cs1" } )
r.shader( "shader", "test/IECoreRI/shaders/sxCoshaderTest", { "sColor" : IECore.Color3f( 1, 1, 0 ), "__handle" : "cs2" } )
r.shader( "shader", "test/IECoreRI/shaders/sxCoshaderTest", { "tColor" : IECore.Color3f( 0.5, 0, 0.25 ), "__handle" : "cs3" } )
r.shader( "surface", "test/IECoreRI/shaders/sxCoshaderTestMain", { "coshaders" : IECore.StringVectorData( [ "cs1", "cs2", "cs3" ] ) } )
s = r.shade( points )
self.assertEqual( s["Ci"], IECore.ObjectReader( "test/IECoreRI/data/sxOutput/coshaders.cob" ).read() )
def testNestedGroupsWithAttributes(self):
r = IECore.CapturingRenderer()
with IECore.WorldBlock(r):
r.setAttribute("user:something", IECore.IntData(10))
with IECore.AttributeBlock(r):
r.setAttribute("user:something", IECore.IntData(20))
r.sphere(1, -1, 1, 360, {})
w = r.world()
self.assertEqual(w.getTransform(), None)
self.assertEqual(len(w.state()), 1)
self.assertEqual(w.state()[0].attributes["user:something"],
IECore.IntData(10))
c = w.children()
self.assertEqual(len(c), 1)
self.failUnless(isinstance(c[0], IECore.Group))
self.assertEqual(c[0].getTransform(), None)
self.assertEqual(len(c[0].state()), 1)
self.assertEqual(c[0].state()[0].attributes["user:something"],
IECore.IntData(20))
c = c[0].children()
self.assertEqual(len(c), 1)
self.failUnless(isinstance(c[0], IECore.SpherePrimitive))
def testGetAttribute(self):
r = IECore.CapturingRenderer()
with IECore.WorldBlock(r):
self.assertEqual(r.getAttribute("iDontExist"), None)
r.setAttribute("user:something", IECore.IntData(1))
self.assertEqual(r.getAttribute("user:something"),
IECore.IntData(1))
with IECore.AttributeBlock(r):
self.assertEqual(r.getAttribute("user:something"),
IECore.IntData(1))
r.setAttribute("user:something", IECore.IntData(2))
self.assertEqual(r.getAttribute("user:something"),
IECore.IntData(2))
r.setAttribute("user:somethingElse", IECore.IntData(20))
self.assertEqual(r.getAttribute("user:somethingElse"),
IECore.IntData(20))
self.assertEqual(r.getAttribute("user:something"),
IECore.IntData(1))
self.assertEqual(r.getAttribute("user:somethingElse"), None)
def render( self, renderer ) : with IECore.AttributeBlock( renderer ) : renderer.setAttribute( "name", self.__alembicInput.fullName() ) transform = self.__alembicInput.transformAtTime( self.__time ) if transform is not None : transform = IECore.M44f( transform[0,0], transform[0,1], transform[0,2], transform[0,3], transform[1,0], transform[1,1], transform[1,2], transform[1,3], transform[2,0], transform[2,1], transform[2,2], transform[2,3], transform[3,0], transform[3,1], transform[3,2], transform[3,3] ) renderer.concatTransform( transform ) primitive = self.__alembicInput.objectAtTime( self.__time, IECore.Primitive.staticTypeId() ) if primitive is not None : primitive.render( renderer ) for childIndex in range( 0, self.__alembicInput.numChildren() ) : child = self.__alembicInput.child( childIndex ) childProcedural = _ChildProcedural( child, self.__time ) if child.hasStoredBound() : renderer.procedural( childProcedural ) else : childProcedural.render( renderer )
def testLightsStack(self):
self.assertEqual(
os.system(
"shaderdl -Irsl -o test/IECoreRI/shaders/sxLightTest.sdl test/IECoreRI/shaders/sxLightTest.sl"
), 0)
self.assertEqual(
os.system(
"shaderdl -Irsl -o test/IECoreRI/shaders/sxIlluminanceTest.sdl test/IECoreRI/shaders/sxIlluminanceTest.sl"
), 0)
r = IECoreRI.SXRenderer()
with IECore.WorldBlock(r):
r.shader("surface", "test/IECoreRI/shaders/sxIlluminanceTest", {})
r.light("test/IECoreRI/shaders/sxLightTest", "light0", {})
with IECore.AttributeBlock(r):
# this guy should be popped and therefore not affect the result
r.light("test/IECoreRI/shaders/sxLightTest", "light1", {})
b = IECore.Box2i(IECore.V2i(0), IECore.V2i(20, 10))
points = self.__rectanglePoints(b)
s = r.shade(points, IECore.V2i(21, 11))
for i in range(0, len(points["P"])):
c = s["Ci"][i]
self.assertEqual(points["P"][i], IECore.V3f(c[0], c[1], c[2]))
def doRender(s, renderer, args):
try:
if s.__level == 0:
with IECore.AttributeBlock(renderer):
renderer.setAttribute("user:myTestAttribute",
IECore.IntData(11))
# rendering a child procedural
SimpleProcedural(1).render(renderer)
self.assertEqual(
renderer.getAttribute("user:myTestAttribute"),
IECore.IntData(11))
# rendering child procedural from inside a Group
g = IECore.Group()
g.addChild(SimpleProcedural(2))
g.render(renderer)
elif s.__level == 1:
self.assertEqual(
renderer.getAttribute("user:myTestAttribute"),
IECore.IntData(11))
elif s.__level == 2:
self.assertEqual(
renderer.getAttribute("user:myTestAttribute"),
IECore.IntData(11))
except Exception, e:
errors.append(IECore.exceptionInfo()[1])
def emit( offset ) : with IECore.AttributeBlock( renderer ) : renderer.concatTransform( IECore.M44f.createTranslated( offset ) ) renderer.concatTransform( IECore.M44f.createScaled( IECore.V3f( 0.5 ) ) ) renderer.procedural( CapturingRendererTest.SnowflakeProcedural( self.__maxLevel, self.__level + 1 ) )
def testEditShader( self ) :
# start an editable render with one light colour
r = IECoreRI.Renderer( "" )
r.setOption( "editable", True )
r.display( "test", "ie", "rgba",
{
"driverType" : IECore.StringData( "ImageDisplayDriver" ),
"handle" : IECore.StringData( "myLovelySphere" ),
"quantize" : IECore.FloatVectorData( [ 0, 0, 0, 0 ] ),
}
)
with IECore.WorldBlock( r ) :
r.light( "pointlight", "myLovelyLight", {} )
with IECore.AttributeBlock( r ) :
r.setAttribute( "name", "/sphere" )
r.concatTransform( IECore.M44f.createTranslated( IECore.V3f( 0, 0, -5 ) ) )
r.shader( "surface", "matte", { "Kd" : 1 } )
r.sphere( 1, -1, 1, 360, {} )
# give it a bit of time to finish
time.sleep( 1 )
# record the colour produced by the first render
i = IECore.ImageDisplayDriver.storedImage( "myLovelySphere" )
e = IECore.ImagePrimitiveEvaluator( i )
er = e.createResult()
e.pointAtUV( IECore.V2f( 0.5 ), er )
initialColor = IECore.Color3f( er.floatPrimVar( i["R"] ), er.floatPrimVar( i["G"] ), er.floatPrimVar( i["B"] ) )
# make an edit to the shader and wait for it to take hold
with IECore.EditBlock( r, "attribute", { "scopename" : "/sphere" } ) :
r.shader( "surface", "matte", { "Kd" : 0.5 } )
time.sleep( 1 )
# check the ratio of the two colours is as expected.
i = IECore.ImageDisplayDriver.storedImage( "myLovelySphere" )
e = IECore.ImagePrimitiveEvaluator( i )
er = e.createResult()
e.pointAtUV( IECore.V2f( 0.5 ), er )
newColor = IECore.Color3f( er.floatPrimVar( i["R"] ), er.floatPrimVar( i["G"] ), er.floatPrimVar( i["B"] ) )
self.assertEqual( newColor / initialColor, IECore.Color3f( .5 ) )
def render( self, renderer ) : if self.__level < self.__maxLevel : with IECore.AttributeBlock( renderer ) : renderer.procedural( CapturingRendererTest.GetOptionProcedural( self.__maxLevel, self.__level + 1 ) ) if renderer.getOption( "iDontExist" ) != None : CapturingRendererTest.GetOptionProcedural.failure = True if renderer.getOption( "user:ten" ) != IECore.IntData( 10 ) : CapturingRendererTest.GetOptionProcedural.failure = True
def testStack(self):
self.assertEqual(
os.system(
"shaderdl -o test/IECoreRI/shaders/sxStackTest.sdl test/IECoreRI/shaders/sxStackTest.sl"
), 0)
r = IECoreRI.SXRenderer()
b = IECore.Box2i(IECore.V2i(0), IECore.V2i(100))
points = self.__rectanglePoints(b)
self.assertEqual(r.getAttribute("color"),
IECore.Color3fData(IECore.Color3f(1)))
self.assertEqual(r.getAttribute("opacity"),
IECore.Color3fData(IECore.Color3f(1)))
with IECore.WorldBlock(r):
r.setAttribute("color", IECore.Color3f(1, 0, 0))
self.assertEqual(r.getAttribute("color"),
IECore.Color3fData(IECore.Color3f(1, 0, 0)))
r.shader("surface", "test/IECoreRI/shaders/sxStackTest.sdl",
{"blue": 1.0})
with IECore.AttributeBlock(r):
r.setAttribute("color", IECore.Color3f(0, 1, 0))
self.assertEqual(r.getAttribute("color"),
IECore.Color3fData(IECore.Color3f(0, 1, 0)))
r.shader("surface", "test/IECoreRI/shaders/sxStackTest.sdl",
{"blue": 0.5})
s = r.shade(points)
for c in s["Ci"]:
self.assertEqual(c, IECore.Color3f(0, 0, 0.5))
self.assertEqual(r.getAttribute("color"),
IECore.Color3fData(IECore.Color3f(1, 0, 0)))
s = r.shade(points)
for c in s["Ci"]:
self.assertEqual(c, IECore.Color3f(0, 0, 1))
self.assertEqual(r.getAttribute("color"),
IECore.Color3fData(IECore.Color3f(1)))
self.assertEqual(r.getAttribute("opacity"),
IECore.Color3fData(IECore.Color3f(1)))
def emit( offset, childname, recurse ) :
with IECore.AttributeBlock( renderer ) :
renderer.concatTransform( IECore.M44f.createTranslated( offset ) )
renderer.concatTransform( IECore.M44f.createScaled( IECore.V3f( 0.5 ) ) )
newName = self.__name + "/" + childname
if not recurse:
newName = newName + "_leaf"
renderer.setAttribute( "name", newName )
if recurse:
renderer.procedural( CapturingRendererTest.NamedSnowflakeProcedural( self.__maxLevel, self.__level + 1, newName ) )
else:
renderer.sphere( 1, -1, 1, 360, {} )
def testUserAttributes( self ) : r = IECoreArnold.Renderer() r.setAttribute( "user:a", IECore.IntData( 10 ) ) self.assertEqual( r.getAttribute( "user:a" ), IECore.IntData( 10 ) ) with IECore.WorldBlock( r ) : self.assertEqual( r.getAttribute( "user:a" ), IECore.IntData( 10 ) ) r.setAttribute( "user:a", IECore.IntData( 20 ) ) self.assertEqual( r.getAttribute( "user:a" ), IECore.IntData( 20 ) ) with IECore.AttributeBlock( r ) : r.setAttribute( "user:a", IECore.IntData( 30 ) ) self.assertEqual( r.getAttribute( "user:a" ), IECore.IntData( 30 ) ) self.assertEqual( r.getAttribute( "user:a" ), IECore.IntData( 20 ) )
def render(self, renderer):
with IECore.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 testNestedGroups(self):
r = IECore.CapturingRenderer()
with IECore.WorldBlock(r):
with IECore.AttributeBlock(r):
r.sphere(1, -1, 1, 360, {})
w = r.world()
self.assertEqual(len(w.state()), 0)
self.assertEqual(w.getTransform(), None)
c = w.children()
self.assertEqual(len(c), 1)
self.failUnless(isinstance(c[0], IECore.Group))
self.assertEqual(c[0].getTransform(), None)
self.assertEqual(len(c[0].state()), 0)
c = c[0].children()
self.assertEqual(len(c), 1)
self.failUnless(isinstance(c[0], IECore.SpherePrimitive))
def doRender(self, renderer, args):
with IECore.AttributeBlock(renderer):
g = IECore.Group()
g.addState(
IECore.AttributeState(
{"name": IECore.StringData("mySphere")}))
g.setTransform(
IECore.MatrixTransform(
IECore.M44f.createTranslated(args["translate"].value)))
innerGroup = IECore.Group()
innerGroup.setTransform(
IECore.MatrixTransform(
IECore.M44f.createTranslated(
args["extraTranslate"].value)))
innerGroup.addChild(
IECore.SpherePrimitive(args["radius"].value, -1, 1, 360))
g.addChild(innerGroup)
g.render(renderer)
def render(self, renderer):
with IECore.AttributeBlock(renderer):
self.__shader.render(renderer)
renderer.procedural(self.__child)
def runPointAtVTest( self, curvesPrimitive, expectedPositions=None, expectedLengths=None, visualTest=False, printPoints=False ) :
e = IECore.CurvesPrimitiveEvaluator( curvesPrimitive )
r = e.createResult()
p = IECore.V3fVectorData()
for ci in range( 0, curvesPrimitive.variableSize( IECore.PrimitiveVariable.Interpolation.Uniform ) ) :
numSamples = 50
for i in range( 0, numSamples ) :
s = e.pointAtV( ci, float( i ) / float( numSamples - 1 ), r )
self.failUnless( s )
p.append( r.point() )
if expectedPositions :
self.assertEqual( len( p ), len( expectedPositions ) )
for i in range( 0, len( p ) ) :
self.failUnless( p[i].equalWithAbsError( expectedPositions[i], 0.00001 ) )
if expectedLengths :
self.assertEqual( curvesPrimitive.numCurves(), len( expectedLengths ) )
linearNonPeriodic = ( curvesPrimitive.basis() == IECore.CubicBasisf.linear() ) and not curvesPrimitive.periodic()
for i in range( 0, curvesPrimitive.numCurves() ) :
if linearNonPeriodic :
self.assertEqual( e.curveLength( i ), expectedLengths[i] )
else :
self.assertAlmostEqual( e.curveLength( i ), expectedLengths[i], 5 )
if printPoints :
print repr( p ).replace( "),", "),\n" )
if visualTest :
import IECoreGL
IECoreGL.init( False )
r = IECoreGL.Renderer()
r.setOption( "gl:mode", IECore.StringData( "deferred" ) )
pointsPrimitive = IECore.PointsPrimitive( p )
pointsPrimitive["constantwidth"] = IECore.PrimitiveVariable( IECore.PrimitiveVariable.Interpolation.Constant, IECore.FloatData( 0.1 ) )
with IECore.WorldBlock( r ) :
w = IECoreGL.SceneViewer( "scene", r.scene() )
with IECore.AttributeBlock( r ) :
r.shader( "surface", "red", { "gl:fragmentSource" : IECore.StringData( "void main() { gl_FragColor = vec4( 1, 0, 0, 1 ); }" ) } )
r.setAttribute( "gl:curvesPrimitive:useGLLines", IECore.BoolData( True ) )
curvesPrimitive.render( r )
with IECore.AttributeBlock( r ) :
r.shader( "surface", "blue", { "gl:fragmentSource" : IECore.StringData( "void main() { gl_FragColor = vec4( 0, 0, 1, 1 ); }" ) } )
pointsPrimitive.render( r )
w.start()
def doRender( self, renderer, args ) :
rad = args["radius"].value
theta = args["theta"].value
with IECore.AttributeBlock( renderer ):
renderer.sphere( rad, -1, 1, theta, {} )
def testRenderStop(self):
# Tests a bug where it was impossible to stop an ipr render involving a procedural.
# The bug happened because in ipr mode, 3delight was keeping hold of a "ProceduralData" structure
# containing the renderer's RendererImplementation and the procedural, until the IPR
# render was terminated with a call to RiEnd().
# Unfortunately, the only way of calling RiEnd() in IECoreRI is to delete the renderer
# by reducing its reference count to zero, thereby destroying its implementation. This
# was impossible to do because 3delight was keeping hold of a reference to it.
# We fixed this by removing the RendererImplementation from the ProceduralData structure and
# putting other data there instead...
# We're going to excercise this by launching an IPR render of a procedural, then making
# sure that deleting the renderer kills the procedural. This impliess that the renderer
# has been successfully killed, which has called RiEnd() and released the contents of
# the ProceduralData structure.
IECore.initThreads()
r = IECoreRI.Renderer("")
r.setOption("editable", True)
r.display(
"test", "ie", "rgba", {
"driverType": IECore.StringData("ImageDisplayDriver"),
"handle": IECore.StringData("myLovelySphere"),
"quantize": IECore.FloatVectorData([0, 0, 0, 0]),
})
class BlahProcedural(IECore.Renderer.Procedural):
def __init__(self):
IECore.Renderer.Procedural.__init__(self)
def bound(self):
return IECore.Box3f(IECore.V3f(-10), IECore.V3f(10))
def render(self, renderer):
renderer.sphere(1, -1, 1, 360, {})
def hash(self):
return IECore.MurmurHash()
with IECore.WorldBlock(r):
with IECore.AttributeBlock(r):
r.concatTransform(
IECore.M44f.createTranslated(IECore.V3f(0, 0, -5)))
p = BlahProcedural()
r.procedural(p)
# give it time to finish
time.sleep(1)
# now try and kill a bunch of stuff...
procref = weakref.ref(p)
del p
del r
while gc.collect():
pass
IECore.RefCounted.collectGarbage()
# and check we've actually killed it:
self.failUnless(procref() is None)
def testAttributesAndShaders(self):
r = IECore.CapturingRenderer()
with IECore.WorldBlock(r):
r.setAttribute("user:test", IECore.BoolData(True))
r.shader("asdf", "surface", {"sss": IECore.IntData(1)})
with IECore.AttributeBlock(r):
r.shader("asdf2", "surface", {"aaa": IECore.IntData(1)})
with IECore.AttributeBlock(r):
r.setAttribute("name", IECore.StringData("sphere1"))
r.setAttribute("yahyah", IECore.StringData("blahblah"))
r.shader("sphere1Shader", "surface",
{"aaa": IECore.IntData(1)})
r.sphere(1, -1, 1, 360, {})
r.setAttribute("name", IECore.StringData("sphere2"))
r.shader("sphere2Shader", "surface",
{"bbb": IECore.IntData(1)})
r.sphere(1, -1, 1, 360, {})
with IECore.AttributeBlock(r):
r.setAttribute("name", IECore.StringData("sphere1"))
r.setAttribute("yahyah", IECore.StringData("blahblah"))
r.shader("sphere1Shader", "surface",
{"aaa": IECore.IntData(1)})
r.sphere(1, -1, 1, 360, {})
expectedStructure = {
"attributes": {
"user:test": IECore.BoolData(True)
},
"shaders": [("asdf", "surface",
IECore.CompoundData({"sss": IECore.IntData(1)}))],
"children": [{
"attributes": {},
"shaders": [("asdf2", "surface",
IECore.CompoundData({"aaa": IECore.IntData(1)}))],
"children": [
{
"attributes": {},
"shaders": {},
"children": [
{
"attributes": {
'name': IECore.StringData("sphere1"),
'yahyah': IECore.StringData("blahblah")
},
"shaders": [("sphere1Shader", "surface",
IECore.CompoundData(
{"aaa": IECore.IntData(1)}))],
"children": ["SpherePrimitive"],
},
{
"attributes": {
'name': IECore.StringData("sphere2"),
'yahyah': IECore.StringData("blahblah")
},
"shaders": [("sphere1Shader", "surface",
IECore.CompoundData(
{"aaa": IECore.IntData(1)})),
("sphere2Shader", "surface",
IECore.CompoundData(
{"bbb": IECore.IntData(1)}))],
"children": ["SpherePrimitive"],
},
],
},
{
"attributes": {
'name': IECore.StringData("sphere1"),
'yahyah': IECore.StringData("blahblah")
},
"shaders":
[("sphere1Shader", "surface",
IECore.CompoundData({"aaa": IECore.IntData(1)}))],
"children": ["SpherePrimitive"],
},
]
}]
}
self.checkStructure(r.world(), expectedStructure)
def render(self, renderer):
with IECore.AttributeBlock(renderer):
renderer.setAttribute("name", self.__alembicInput.fullName())
transform = self.__alembicInput.transformAtTime(self.__time)
if transform is not None:
transform = IECore.M44f(transform[0, 0], transform[0, 1],
transform[0, 2], transform[0, 3],
transform[1, 0], transform[1, 1],
transform[1, 2], transform[1, 3],
transform[2, 0], transform[2, 1],
transform[2, 2], transform[2, 3],
transform[3, 0], transform[3, 1],
transform[3, 2], transform[3, 3])
renderer.concatTransform(transform)
# print self.__alembicInput.fullName(), dir(self.__alembicInput)
# if self.__alembicInput.objectAtTime( self.__time):
# try:
# print type(self.__alembicInput.objectAtTime( self.__time))
# print self.__alembicInput.objectAtTime( self.__time).keys()
# except: pass
primitive = self.__alembicInput.objectAtTime(
self.__time, IECore.Primitive.staticTypeId())
if self.__motionBlurV:
geoNext = self.__motionBlur(primitive)
primitive = geoNext
if primitive is not None:
with IECore.AttributeBlock(renderer):
if renderer.typeName() != "IECoreGL::Renderer":
# print self.__alembicInput.fullName()
renderer.setAttribute("name",
self.__alembicInput.fullName())
renderer.setAttribute(
"ri:identifier:name",
IECore.StringData(self.__alembicInput.fullName()))
if 'primaryVisibility' in primitive.keys():
traceset = 'reflection' if primitive[
'visibleInReflections'].data[0] else ''
traceset += 'refraction' if primitive[
'visibleInRefractions'].data[0] else ''
traceset += 'shadow' if primitive[
'receiveShadows'].data[0] else ''
renderer.setAttribute(
"ri:visibility:camera",
IECore.IntData(
primitive['primaryVisibility'].data[0]))
renderer.setAttribute(
"ri:visibility:indirect",
IECore.IntData(
primitive['visibleInReflections'].data[0]
or
primitive['visibleInRefractions'].data[0]))
renderer.setAttribute(
"ri:visibility:transmission",
IECore.IntData(
primitive['castsShadows'].data[0]))
renderer.setAttribute(
"ri:user:receivesShadows",
IECore.IntData(
primitive['receiveShadows'].data[0]))
renderer.setAttribute(
"ri:matte",
IECore.BoolData(primitive['holdOut'].data[0]))
renderer.setAttribute(
"ri:shade:transmissionhitmode",
IECore.StringData('shader'))
# renderer.setAttribute( "ri:sides", IECore.IntData( primitive['doubleSided'].data[0]+1 ) )
# renderer.setAttribute( "doubleSided", IECore.BoolData( primitive['doubleSided'].data[0] ) )
# renderer.setAttribute( "ri:reverseOrientation", IECore.BoolData( primitive['opposite'].data[0] ) )
# renderer.setAttribute( "reverseOrientation", IECore.BoolData( primitive['opposite'].data[0] ) )
if traceset.strip():
renderer.setAttribute(
"ri:grouping:membership",
IECore.StringData(traceset))
del primitive['primaryVisibility']
del primitive['visibleInReflections']
del primitive['visibleInRefractions']
del primitive['castsShadows']
del primitive['receiveShadows']
del primitive['doubleSided']
del primitive['motionBlur']
del primitive['opposite']
del primitive['smoothShading']
del primitive['holdOut']
if self.__args['subdiv'].value:
primitive.interpolation = "catmullClark"
if 'N' not in primitive.keys():
primitive = IECore.MeshNormalsOp()(input=primitive)
# MeshNormalsOp returns inverted normals for some reason.
for n in range(len(primitive['N'].data)):
primitive['N'].data[
n] = -primitive['N'].data[n]
primitive.render(renderer)
# else:
# primitive = self.__alembicInput.objectAtTime( self.__time, IECore.Primitive.staticTypeId() )
# print dir(primitive)
# print primitive.keys()
for childIndex in range(0, self.__alembicInput.numChildren()):
child = self.__alembicInput.child(childIndex)
childProcedural = _ChildProcedural(child, self.__time,
self.__args)
if child.hasStoredBound():
renderer.procedural(childProcedural)
else:
childProcedural.render(renderer)
