Uploading work on refactor

At this point, all components can build their skeletons. Next steps are to get components building their rigs.

1 files changed, 170 insertions, 0 deletions

diff --git a/tests/test_joint_component.py b/tests/test_joint_component.py
new file mode 100644
index 0000000..28b3e1d
--- /dev/null
+++ b/tests/test_joint_component.py
@@ -0,0 +1,170 @@
+import unittest
+import maya.cmds as cmds
+import artv2.components.base_components.rig_asset as rig_asset
+import artv2.components.root as root
+import artv2.components.joint as joint
+
+def format_position(pos):
+    return [float("{0:.3f}".format(pos[0])), float("{0:.3f}".format(pos[1])), float("{0:.3f}".format(pos[2]))]
+
+
+class Joint_Component_Tests(unittest.TestCase):
+    """
+    Class containing tests for joint module creation and manipulation.
+    """
+
+    def _create_asset(self):
+        new_asset = rig_asset.RigAsset()
+        self.assertEquals(new_asset.name, "asset")
+        self.assertEquals(new_asset.network_node, "asset_metadata")
+        return new_asset
+
+    def _create_joint_inst(self, prefix):
+
+        root.Root()
+        jnt_inst = joint.Joint(prefix=prefix)
+        jnt_inst.parent = "root"
+        return jnt_inst
+
+    def test_create_joint(self):
+
+        self._create_asset()
+        jnt_inst = self._create_joint_inst("test")
+        self.assertEquals(len(jnt_inst.joint_mover.get_created_joints()), 1)
+
+    def test_delete_root(self):
+
+        self._create_asset()
+        jnt_inst = self._create_joint_inst("test")
+
+        component_containers = jnt_inst.joint_mover.get_containers()
+        guide_nodes = component_containers[1].getNodeList()
+        utility_nodes = component_containers[2].getNodeList()
+
+        jnt_inst.delete()
+        self.assertFalse(cmds.objExists("test_joint_metadata"))
+
+        for each in guide_nodes:
+            self.assertFalse(cmds.objExists(each.nodeName()))
+        for each in utility_nodes:
+            self.assertFalse(cmds.objExists(each.nodeName()))
+
+    def test_bake_offsets(self):
+
+        self._create_asset()
+        jnt_inst = self._create_joint_inst("test")
+        cmds.setAttr("test_joint_jnt_mover_offset.translateY", 30)
+
+        pre_offset_position = format_position(cmds.xform("test_joint_jnt_mover_offset", q=True, ws=True, t=True))
+        pre_main_position = format_position(cmds.xform("test_joint_jnt_mover", q=True, ws=True, t=True))
+        self.assertNotEquals(pre_main_position, pre_offset_position)
+        jnt_inst.joint_mover.bake_offsets()
+
+        post_offset_position = format_position(cmds.xform("test_joint_jnt_mover_offset", q=True, ws=True, t=True))
+        post_main_position = format_position(cmds.xform("test_joint_jnt_mover", q=True, ws=True, t=True))
+        self.assertEquals(post_main_position, post_offset_position)
+
+    def test_duplicate(self):
+
+        self._create_asset()
+        jnt_inst = self._create_joint_inst("test")
+
+        cmds.setAttr("test_joint_jnt_mover.translateZ", -65)
+        cmds.setAttr("test_joint_jnt_mover.rotateX", -3)
+        cmds.setAttr("test_joint_jnt_mover.rotateY", -8)
+        cmds.setAttr("test_joint_jnt_mover.rotateZ", 42)
+        cmds.setAttr("test_joint_jnt_mover.scaleX", .319)
+        cmds.setAttr("test_joint_jnt_mover.scaleY", .319)
+        cmds.setAttr("test_joint_jnt_mover.scaleZ", .319)
+
+        duplicate_inst = jnt_inst.duplicate()
+
+        self.assertEquals(duplicate_inst.parent, "root")
+        self.assertEquals(cmds.getAttr("test_joint_01_jnt_mover.tz"), cmds.getAttr("test_joint_jnt_mover.tz"))
+        self.assertEquals(cmds.getAttr("test_joint_01_jnt_mover.rx"), cmds.getAttr("test_joint_jnt_mover.rx"))
+        self.assertEquals(cmds.getAttr("test_joint_01_jnt_mover.ry"), cmds.getAttr("test_joint_jnt_mover.ry"))
+        self.assertEquals(cmds.getAttr("test_joint_01_jnt_mover.rz"), cmds.getAttr("test_joint_jnt_mover.rz"))
+        self.assertEquals(cmds.getAttr("test_joint_01_jnt_mover.sx"), cmds.getAttr("test_joint_jnt_mover.sx"))
+        self.assertEquals(cmds.getAttr("test_joint_01_jnt_mover.sy"), cmds.getAttr("test_joint_jnt_mover.sy"))
+        self.assertEquals(cmds.getAttr("test_joint_01_jnt_mover.sz"), cmds.getAttr("test_joint_jnt_mover.sz"))
+
+        dupe2 = jnt_inst.duplicate()
+        dupe3 = jnt_inst.duplicate()
+        self.assertEquals(dupe2.suffix, "_02")
+        self.assertEquals(dupe3.suffix, "_03")
+
+    def test_pin_component(self):
+
+        self._create_asset()
+        jnt_inst = self._create_joint_inst("test")
+
+        pre_position = format_position(cmds.xform("test_joint_jnt_mover", q=True, ws=True, t=True))
+        jnt_inst.joint_mover.toggle_pin_component()
+        self.assertTrue(jnt_inst.network_node.pinned.get())
+
+        cmds.setAttr("master_root_mover.translateX", 100)
+        post_position = format_position(cmds.xform("test_joint_jnt_mover", q=True, ws=True, t=True))
+        self.assertEquals(pre_position, post_position)
+
+        jnt_inst.joint_mover.toggle_pin_component()
+        cmds.setAttr("master_root_mover.translateX", 0)
+        new_position = format_position(cmds.xform("test_joint_jnt_mover", q=True, ws=True, t=True))
+        self.assertNotEquals(post_position, new_position)
+
+    def test_create_mirror(self):
+
+        self._create_asset()
+        jnt_inst = self._create_joint_inst("test")
+
+        cmds.setAttr("test_joint_jnt_mover.translateX", 30)
+        cmds.setAttr("master_root_mover.scaleX", 2.5)
+        cmds.setAttr("master_root_mover.scaleY", 2.5)
+        cmds.setAttr("master_root_mover.scaleZ", 2.5)
+        cmds.setAttr("master_root_mover.translateZ", 60)
+
+        right_jnt_inst = jnt_inst.create_mirror(prefix="r", suffix="", parent="root")
+
+        left_movers = jnt_inst.joint_mover.get_movers()
+        left_global_movers = sorted(left_movers.get("global"))
+        right_movers = right_jnt_inst.joint_mover.get_movers()
+        right_global_movers = sorted(right_movers.get("global"))
+
+        self.assertEquals(cmds.getAttr("r_joint_jnt_mover.translateX"), -30)
+        self.assertEquals(cmds.getAttr("r_joint_jnt_mover_grp.scaleX"), 2.5)
+
+        for mover in left_global_movers:
+            index = left_global_movers.index(mover)
+            loc = cmds.spaceLocator(name=mover+"_loc")[0]
+            cmds.delete(cmds.parentConstraint(mover.nodeName(), loc)[0])
+            group = cmds.group(empty=True)
+            cmds.parent(loc, group)
+            cmds.setAttr(group + ".scaleX", -1)
+
+            loc_pos = format_position(cmds.xform(loc, q=True, ws=True, t=True))
+            mirror_pos = format_position(cmds.xform(right_global_movers[index].nodeName(), q=True, ws=True, t=True))
+            self.assertEquals(loc_pos, mirror_pos)
+
+    def test_delete_mirror(self):
+
+        self._create_asset()
+        jnt_inst = self._create_joint_inst("test")
+        right_jnt_inst = jnt_inst.create_mirror(prefix="r", suffix="", parent="root")
+
+        jnt_inst.delete()
+
+        self.assertEquals(right_jnt_inst.network_node.has_mirror.get(), False)
+        self.assertEquals(len(right_jnt_inst.network_node.mirror_component.connections()), 0)
+
+    def test_mirror_transforms(self):
+
+        self._create_asset()
+        jnt_inst = self._create_joint_inst("test")
+        jnt_inst.create_mirror(prefix="r", suffix="", parent="root")
+
+        cmds.setAttr("test_joint_jnt_mover.translateX", 20)
+        cmds.setAttr("test_joint_jnt_mover.rotateX", 40)
+
+        jnt_inst.joint_mover.mirror_transforms()
+
+        self.assertEquals(cmds.getAttr("r_joint_jnt_mover.translateX"), -20)
+        self.assertEquals(cmds.getAttr("r_joint_jnt_mover.rotateX"), 40)
\ No newline at end of file