Beispiel #1
0
    def test(self):

        light = GafferSceneTest.TestLight()
        camera = GafferScene.Camera()
        procedural = GafferScene.ExternalProcedural()
        group = GafferScene.Group()

        group["in"][0].setInput(light["out"])
        group["in"][1].setInput(camera["out"])
        group["in"][2].setInput(procedural["out"])

        parameters = GafferScene.Parameters()
        parameters["in"].setInput(group["out"])

        self.assertSceneValid(parameters["out"])
        self.assertScenesEqual(parameters["out"], group["out"])
        self.assertSceneHashesEqual(parameters["out"], group["out"])

        parameters["parameters"].addMember("test", 10)

        filter = GafferScene.PathFilter()
        filter["paths"].setValue(IECore.StringVectorData(["/group/*"]))
        parameters["filter"].setInput(filter["out"])

        self.assertSceneValid(parameters["out"])
        self.assertScenesEqual(parameters["out"],
                               group["out"],
                               childPlugNamesToIgnore=("object", ))
        self.assertSceneHashesEqual(parameters["out"],
                                    group["out"],
                                    childPlugNamesToIgnore=("object", ))

        lightIn = group["out"].object("/group/light")
        lightOut = parameters["out"].object("/group/light")
        self.assertNotEqual(lightIn, lightOut)
        self.assertEqual(lightOut.parameters["test"], IECore.IntData(10))
        del lightOut.parameters["test"]
        self.assertEqual(lightIn, lightOut)
        self.assertTrue(isinstance(lightOut, IECore.Light))

        cameraIn = group["out"].object("/group/camera")
        cameraOut = parameters["out"].object("/group/camera")
        self.assertNotEqual(cameraIn, cameraOut)
        self.assertEqual(cameraOut.parameters()["test"], IECore.IntData(10))
        del cameraOut.parameters()["test"]
        self.assertEqual(cameraIn, cameraOut)
        self.assertTrue(isinstance(cameraOut, IECore.Camera))

        proceduralIn = group["out"].object("/group/procedural")
        proceduralOut = parameters["out"].object("/group/procedural")
        self.assertNotEqual(proceduralIn, proceduralOut)
        self.assertEqual(proceduralOut.parameters()["test"],
                         IECore.IntData(10))
        del proceduralOut.parameters()["test"]
        self.assertEqual(proceduralIn, proceduralOut)
        self.assertTrue(isinstance(proceduralOut, IECore.ExternalProcedural))
    def testNonInterpolableObjectSamples(self):

        frame = GafferTest.FrameNode()

        procedural = GafferScene.ExternalProcedural()
        procedural["parameters"]["frame"] = Gaffer.NameValuePlug("frame", 0.0)
        procedural["parameters"]["frame"]["value"].setInput(frame["output"])

        with Gaffer.Context() as c:
            c["scene:path"] = IECore.InternedStringVectorData(["procedural"])
            samples = GafferScene.Private.RendererAlgo.objectSamples(
                procedural["out"]["object"], [0.75, 1.25])

        self.assertEqual(len(samples), 1)
        self.assertEqual(samples[0].parameters()["frame"].value, 1.0)
    def test(self):

        camera = GafferScene.Camera()
        procedural = GafferScene.ExternalProcedural()
        group = GafferScene.Group()

        group["in"][0].setInput(camera["out"])
        group["in"][1].setInput(procedural["out"])

        parameters = GafferScene.Parameters()
        parameters["in"].setInput(group["out"])

        self.assertSceneValid(parameters["out"])
        self.assertScenesEqual(parameters["out"], group["out"])
        self.assertSceneHashesEqual(parameters["out"], group["out"])

        parameters["parameters"].addChild(Gaffer.NameValuePlug("test", 10))

        filter = GafferScene.PathFilter()
        filter["paths"].setValue(IECore.StringVectorData(["/group/*"]))
        parameters["filter"].setInput(filter["out"])

        self.assertSceneValid(parameters["out"])
        self.assertScenesEqual(parameters["out"],
                               group["out"],
                               checks=self.allSceneChecks - {"object"})
        self.assertSceneHashesEqual(parameters["out"],
                                    group["out"],
                                    checks=self.allSceneChecks - {"object"})

        cameraIn = group["out"].object("/group/camera")
        cameraOut = parameters["out"].object("/group/camera")
        self.assertNotEqual(cameraIn, cameraOut)
        self.assertEqual(cameraOut.parameters()["test"], IECore.IntData(10))
        del cameraOut.parameters()["test"]
        self.assertEqual(cameraIn, cameraOut)
        self.assertTrue(isinstance(cameraOut, IECoreScene.Camera))

        proceduralIn = group["out"].object("/group/procedural")
        proceduralOut = parameters["out"].object("/group/procedural")
        self.assertNotEqual(proceduralIn, proceduralOut)
        self.assertEqual(proceduralOut.parameters()["test"],
                         IECore.IntData(10))
        del proceduralOut.parameters()["test"]
        self.assertEqual(proceduralIn, proceduralOut)
        self.assertTrue(
            isinstance(proceduralOut, IECoreScene.ExternalProcedural))
    def test(self):

        n = GafferScene.ExternalProcedural()
        self.assertTrue(n["name"].getValue(), "procedural")

        self.assertSceneValid(n["out"])

        n["bound"].setValue(imath.Box3f(imath.V3f(1, 2, 3), imath.V3f(4, 5,
                                                                      6)))
        n["fileName"].setValue("test.so")
        n["parameters"].addChild(Gaffer.NameValuePlug("testFloat", 1.0))

        p = n["out"].object("/procedural")

        self.assertTrue(isinstance(p, IECoreScene.ExternalProcedural))
        self.assertEqual(p.getFileName(), "test.so")
        self.assertEqual(p.getBound(),
                         imath.Box3f(imath.V3f(1, 2, 3), imath.V3f(4, 5, 6)))
        self.assertEqual(p.parameters().keys(), ["testFloat"])
        self.assertEqual(p.parameters()["testFloat"], IECore.FloatData(1.0))