Beispiel #1
0
    def testTargetMode(self):

        targetTranslate = imath.V3f(1, 2, 3)
        constrainedTranslate = imath.V3f(10, 11, 12)

        plane1 = GafferScene.Plane()
        plane1["transform"]["translate"].setValue(targetTranslate)
        plane1["name"].setValue("target")

        plane2 = GafferScene.Plane()
        plane2["transform"]["translate"].setValue(constrainedTranslate)
        plane2["name"].setValue("constrained")

        group = GafferScene.Group()
        group["in"][0].setInput(plane1["out"])
        group["in"][1].setInput(plane2["out"])

        self.assertSceneValid(group["out"])

        aim = GafferScene.AimConstraint()
        aim["target"].setValue("/group/target")
        aim["in"].setInput(group["out"])

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

        self.assertSceneValid(aim["out"])

        self.assertEqual(group["out"].fullTransform("/group/target"),
                         aim["out"].fullTransform("/group/target"))
        self.assertEqual(
            group["out"].fullTransform("/group/constrained").translation(),
            aim["out"].fullTransform("/group/constrained").translation())

        direction = aim["out"].fullTransform(
            "/group/constrained").multDirMatrix(aim["aim"].getValue())
        expectedDirection = targetTranslate - constrainedTranslate
        self.assertAlmostEqual(
            direction.normalized().dot(expectedDirection.normalized()), 1, 6)

        aim["targetMode"].setValue(aim.TargetMode.BoundMin)

        direction = aim["out"].fullTransform(
            "/group/constrained").multDirMatrix(aim["aim"].getValue())
        expectedDirection = plane1["out"].bound(
            "/plane").min() + targetTranslate - constrainedTranslate
        self.assertAlmostEqual(
            direction.normalized().dot(expectedDirection.normalized()), 1, 6)

        aim["targetMode"].setValue(aim.TargetMode.BoundMax)

        direction = aim["out"].fullTransform(
            "/group/constrained").multDirMatrix(aim["aim"].getValue())
        expectedDirection = plane1["out"].bound(
            "/plane").max() + targetTranslate - constrainedTranslate
        self.assertAlmostEqual(
            direction.normalized().dot(expectedDirection.normalized()), 1, 6)
Beispiel #2
0
    def testConstrainedWithExistingRotation(self):

        targetTranslate = imath.V3f(1, 2, 3)
        constrainedTranslate = imath.V3f(10, 11, 12)

        plane1 = GafferScene.Plane()
        plane1["transform"]["translate"].setValue(targetTranslate)
        plane1["name"].setValue("target")

        plane2 = GafferScene.Plane()
        plane2["transform"]["translate"].setValue(constrainedTranslate)
        plane2["transform"]["rotate"].setValue(imath.V3f(90, 0, 0))
        plane2["name"].setValue("constrained")

        group = GafferScene.Group()
        group["in"][0].setInput(plane1["out"])
        group["in"][1].setInput(plane2["out"])

        self.assertSceneValid(group["out"])

        aim = GafferScene.AimConstraint()
        aim["target"].setValue("/group/target")
        aim["in"].setInput(group["out"])

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

        self.assertSceneValid(aim["out"])

        self.assertEqual(group["out"].fullTransform("/group/target"),
                         aim["out"].fullTransform("/group/target"))
        self.assertEqual(
            group["out"].fullTransform("/group/constrained").translation(),
            aim["out"].fullTransform("/group/constrained").translation())

        direction = aim["out"].fullTransform(
            "/group/constrained").multDirMatrix(aim["aim"].getValue())
        self.assertAlmostEqual(
            (targetTranslate - constrainedTranslate).normalized().dot(
                direction.normalized()), 1, 6)
    def testInteractionWithAimConstraints(self):

        script = Gaffer.ScriptNode()

        # Cube at ( 0, 10, 0 ), aimed at a sphere at the origin.

        script["sphere"] = GafferScene.Sphere()

        script["cube"] = GafferScene.Cube()
        script["cube"]["transform"]["translate"]["y"].setValue(10)

        script["parent"] = GafferScene.Parent()
        script["parent"]["parent"].setValue("/")
        script["parent"]["in"].setInput(script["sphere"]["out"])
        script["parent"]["children"][0].setInput(script["cube"]["out"])

        script["cubeFilter"] = GafferScene.PathFilter()
        script["cubeFilter"]["paths"].setValue(
            IECore.StringVectorData(["/cube"]))

        script["aim"] = GafferScene.AimConstraint()
        script["aim"]["in"].setInput(script["parent"]["out"])
        script["aim"]["filter"].setInput(script["cubeFilter"]["out"])
        script["aim"]["target"].setValue("/sphere")

        # Translate in Z (parent space) and check that we moved to
        # where we expected.

        self.assertEqual(script["aim"]["out"].transform("/cube").translation(),
                         imath.V3f(0, 10, 0))

        view = GafferSceneUI.SceneView()
        view["in"].setInput(script["aim"]["out"])
        GafferSceneUI.ContextAlgo.setSelectedPaths(
            view.getContext(), IECore.PathMatcher(["/cube"]))

        tool = GafferSceneUI.TranslateTool(view)
        tool["active"].setValue(True)

        self.assertEqual(len(tool.selection()), 1)
        self.assertEqual(tool.selection()[0].path(), "/cube")
        self.assertEqual(tool.selection()[0].upstreamPath(), "/cube")
        self.assertEqual(tool.selection()[0].editTarget(),
                         script["cube"]["transform"])

        tool.translate(imath.V3f(0, 0, 10))
        self.assertEqual(script["aim"]["out"].transform("/cube").translation(),
                         imath.V3f(0, 10, 10))

        # Reset back to ( 0, 10, 0 ) and check the same thing works with
        # an EditScope.

        script["cube"]["transform"]["translate"].setValue(imath.V3f(0, 10, 0))

        script["editScope"] = Gaffer.EditScope()
        script["editScope"].setup(script["parent"]["out"])
        script["editScope"]["in"].setInput(script["parent"]["out"])
        script["aim"]["in"].setInput(script["editScope"]["out"])

        view["editScope"].setInput(script["editScope"]["out"])

        self.assertEqual(len(tool.selection()), 1)
        self.assertTrue(tool.selectionEditable())
        self.assertEqual(tool.selection()[0].path(), "/cube")
        self.assertEqual(tool.selection()[0].upstreamPath(), "/cube")
        self.assertEqual(tool.selection()[0].editTarget(), script["editScope"])

        tool.translate(imath.V3f(0, 0, 10))
        self.assertEqual(script["aim"]["out"].transform("/cube").translation(),
                         imath.V3f(0, 10, 10))
    def test(self):

        targetTranslate = imath.V3f(1, 2, 3)
        constrainedTranslate = imath.V3f(10, 11, 12)

        plane1 = GafferScene.Plane()
        plane1["transform"]["translate"].setValue(targetTranslate)
        plane1["name"].setValue("target")

        plane2 = GafferScene.Plane()
        plane2["transform"]["translate"].setValue(constrainedTranslate)
        plane2["name"].setValue("constrained")

        group = GafferScene.Group()
        group["in"][0].setInput(plane1["out"])
        group["in"][1].setInput(plane2["out"])

        self.assertSceneValid(group["out"])

        aim = GafferScene.AimConstraint()
        aim["target"].setValue("/group/target")
        aim["in"].setInput(group["out"])

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

        self.assertSceneValid(aim["out"])

        self.assertEqual(group["out"].fullTransform("/group/target"),
                         aim["out"].fullTransform("/group/target"))
        self.assertEqual(
            group["out"].fullTransform("/group/constrained").translation(),
            aim["out"].fullTransform("/group/constrained").translation())

        direction = aim["out"].fullTransform(
            "/group/constrained").multDirMatrix(aim["aim"].getValue())
        self.assertAlmostEqual(
            (targetTranslate - constrainedTranslate).normalized().dot(
                direction.normalized()), 1, 6)

        # Test behaviour for missing target
        plane1["name"].setValue("targetX")
        with six.assertRaisesRegex(
                self, RuntimeError,
                'AimConstraint.out.transform : Constraint target does not exist: "/group/target"'
        ):
            aim["out"].fullTransform("/group/constrained")

        aim["ignoreMissingTarget"].setValue(True)
        self.assertEqual(aim["out"].fullTransform("/group/constrained"),
                         aim["in"].fullTransform("/group/constrained"))

        # Constrain to root
        aim["target"].setValue("/")
        direction = aim["out"].fullTransform(
            "/group/constrained").multDirMatrix(aim["aim"].getValue())
        self.assertAlmostEqual(
            (-constrainedTranslate).normalized().dot(direction.normalized()),
            1, 6)

        # No op
        aim["target"].setValue("")
        self.assertEqual(aim["out"].fullTransform("/group/constrained"),
                         aim["in"].fullTransform("/group/constrained"))