Convert four simplest rig types to the new base class.

These types demonstrate the use of all callbacks, bone creation
and parenting utilities, constraint & driver creation tools,
and python script generation.

Author: angavrilov

rigs/basic/copy_chain.py

@@ -20,124 +20,83 @@
 
 import bpy
 
-from ...utils import MetarigError
-from ...utils import copy_bone
-from ...utils import connected_children_names
-from ...utils import strip_org, make_deformer_name
-from ...utils import create_bone_widget
+from ..chain_rigs import SimpleChainRig
 
+from ...utils.errors import MetarigError
+from ...utils.rig import connected_children_names
+from ...utils.naming import strip_org, make_deformer_name
+from ...utils.widgets_basic import create_bone_widget
+from ...utils.misc import map_list, map_apply
 
-class Rig:
+
+class Rig(SimpleChainRig):
     """ A "copy_chain" rig.  All it does is duplicate the original bone chain
         and constrain it.
         This is a control and deformation rig.
-
     """
-    def __init__(self, obj, bone_name, params):
+    def initialize(self):
+        super(Rig,self).initialize()
+
         """ Gather and validate data about the rig.
         """
-        self.obj = obj
-        self.org_bones = [bone_name] + connected_children_names(obj, bone_name)
-        self.params = params
-        self.make_controls = params.make_controls
-        self.make_deforms = params.make_deforms
+        self.make_controls = self.params.make_controls
+        self.make_deforms = self.params.make_deforms
 
-        if len(self.org_bones) <= 1:
-            raise MetarigError("RIGIFY ERROR: Bone '%s': input to rig type must be a chain of 2 or more bones" % (strip_org(bone_name)))
 
-    def generate(self):
-        """ Generate the rig.
-            Do NOT modify any of the original bones, except for adding constraints.
-            The main armature should be selected and active before this is called.
+    def generate_bones(self):
+        # Create the deformation and control bone chains.
+        if self.make_controls:
+            self.make_control_chain()
 
-        """
-        bpy.ops.object.mode_set(mode='EDIT')
+        if self.make_deforms:
+            self.make_deform_chain()
+
+
+    def parent_bones(self):
+        if self.make_controls:
+            self.parent_control_chain()
+
+        if self.make_deforms:
+            self.parent_deform_chain()
 
-        # Create the deformation and control bone chains.
-        # Just copies of the original chain.
-        def_chain = []
-        ctrl_chain = []
-        for i in range(len(self.org_bones)):
-            name = self.org_bones[i]
-
-            # Control bone
-            if self.make_controls:
-                # Copy
-                ctrl_bone = copy_bone(self.obj, name)
-                eb = self.obj.data.edit_bones
-                ctrl_bone_e = eb[ctrl_bone]
-                # Name
-                ctrl_bone_e.name = strip_org(name)
-                # Parenting
-                if i == 0:
-                    # First bone
-                    ctrl_bone_e.parent = eb[self.org_bones[0]].parent
-                else:
-                    # The rest
-                    ctrl_bone_e.parent = eb[ctrl_chain[-1]]
-                # Add to list
-                ctrl_chain += [ctrl_bone_e.name]
-            else:
-                ctrl_chain += [None]
-
-            # Deformation bone
-            if self.make_deforms:
-                # Copy
-                def_bone = copy_bone(self.obj, name)
-                eb = self.obj.data.edit_bones
-                def_bone_e = eb[def_bone]
-                # Name
-                def_bone_e.name = make_deformer_name(strip_org(name))
-                # Parenting
-                if i == 0:
-                    # First bone
-                    def_bone_e.parent = eb[self.org_bones[0]].parent
-                else:
-                    # The rest
-                    def_bone_e.parent = eb[def_chain[-1]]
-                # Add to list
-                def_chain += [def_bone_e.name]
-            else:
-                def_chain += [None]
-
-        bpy.ops.object.mode_set(mode='OBJECT')
-        pb = self.obj.pose.bones
-
-        # Constraints for org and def
-        for org, ctrl, defrm in zip(self.org_bones, ctrl_chain, def_chain):
-            if self.make_controls:
-                con = pb[org].constraints.new('COPY_TRANSFORMS')
-                con.name = "copy_transforms"
-                con.target = self.obj
-                con.subtarget = ctrl
-
-            if self.make_deforms:
-                con = pb[defrm].constraints.new('COPY_TRANSFORMS')
-                con.name = "copy_transforms"
-                con.target = self.obj
-                con.subtarget = org
 
+    def configure_bones(self):
+        if self.make_controls:
+            self.configure_control_chain()
+
+
+    def rig_bones(self):
+        # Create the deformation and control bone chain constraints.
+        if self.make_controls:
+            self.rig_org_chain()
+
+        if self.make_deforms:
+            self.rig_deform_chain()
+
+
+    def generate_widgets(self):
         # Create control widgets
         if self.make_controls:
-            for bone in ctrl_chain:
-                create_bone_widget(self.obj, bone)
+            self.make_control_widgets()
 
 
-def add_parameters(params):
-    """ Add the parameters of this rig type to the
-        RigifyParameters PropertyGroup
-    """
-    params.make_controls = bpy.props.BoolProperty(name="Controls", default=True, description="Create control bones for the copy")
-    params.make_deforms = bpy.props.BoolProperty(name="Deform", default=True, description="Create deform bones for the copy")
+    @classmethod
+    def add_parameters(self, params):
+        """ Add the parameters of this rig type to the
+            RigifyParameters PropertyGroup
+        """
+        params.make_controls = bpy.props.BoolProperty(name="Controls", default=True, description="Create control bones for the copy")
+        params.make_deforms = bpy.props.BoolProperty(name="Deform", default=True, description="Create deform bones for the copy")
 
 
-def parameters_ui(layout, params):
-    """ Create the ui for the rig parameters.
-    """
-    r = layout.row()
-    r.prop(params, "make_controls")
-    r = layout.row()
-    r.prop(params, "make_deforms")
+    @classmethod
+    def parameters_ui(self, layout, params):
+        """ Create the ui for the rig parameters.
+        """
+        r = layout.row()
+        r.prop(params, "make_controls")
+        r = layout.row()
+        r.prop(params, "make_deforms")
 
 
 def create_sample(obj):

rigs/basic/super_copy.py

@@ -20,107 +20,112 @@
 
 import bpy
 
-from ...utils import copy_bone
-from ...utils import strip_org, make_deformer_name
-from ...utils import create_bone_widget, create_circle_widget
+from ...base_rig import BaseRig
 
+from ...utils.naming import strip_org, make_deformer_name
+from ...utils.widgets_basic import create_bone_widget, create_circle_widget
 
-class Rig:
+
+class Rig(BaseRig):
     """ A "copy" rig.  All it does is duplicate the original bone and
         constrain it.
         This is a control and deformation rig.
 
     """
-    def __init__(self, obj, bone, params):
+    def find_org_bones(self, pose_bone):
+        return pose_bone.name
+
+
+    def initialize(self):
         """ Gather and validate data about the rig.
         """
-        self.obj          = obj
-        self.org_bone     = bone
-        self.org_name     = strip_org(bone)
-        self.params       = params
-        self.make_control = params.make_control
-        self.make_widget  = params.make_widget
-        self.make_deform  = params.make_deform
-
-    def generate(self):
-        """ Generate the rig.
-            Do NOT modify any of the original bones, except for adding constraints.
-            The main armature should be selected and active before this is called.
+        self.org_name     = strip_org(self.bones.org)
+
+        self.make_control = self.params.make_control
+        self.make_widget  = self.params.make_widget
+        self.make_deform  = self.params.make_deform
 
-        """
-        bpy.ops.object.mode_set(mode='EDIT')
+
+    def generate_bones(self):
+        bones = self.bones
 
         # Make a control bone (copy of original).
         if self.make_control:
-            bone = copy_bone(self.obj, self.org_bone, self.org_name)
+            bones.ctrl = self.copy_bone(bones.org, self.org_name, parent=True)
 
         # Make a deformation bone (copy of original, child of original).
         if self.make_deform:
-            def_bone = copy_bone(self.obj, self.org_bone, make_deformer_name(self.org_name))
+            bones.deform = self.copy_bone(bones.org, make_deformer_name(self.org_name), bbone=True)
 
-        # Get edit bones
-        eb = self.obj.data.edit_bones
-        # UNUSED
-        # if self.make_control:
-        #     bone_e = eb[bone]
-        if self.make_deform:
-            def_bone_e = eb[def_bone]
 
-        # Parent
+    def parent_bones(self):
+        bones = self.bones
+
         if self.make_deform:
-            def_bone_e.use_connect = False
-            def_bone_e.parent = eb[self.org_bone]
+            self.set_bone_parent(bones.deform, bones.org, use_connect=False)
+
+
+    def configure_bones(self):
+        bones = self.bones
 
-        bpy.ops.object.mode_set(mode='OBJECT')
-        pb = self.obj.pose.bones
+        if self.make_control:
+            self.copy_bone_properties(bones.org, bones.ctrl)
+
+
+    def rig_bones(self):
+        bones = self.bones
 
         if self.make_control:
             # Constrain the original bone.
-            con = pb[self.org_bone].constraints.new('COPY_TRANSFORMS')
-            con.name = "copy_transforms"
-            con.target = self.obj
-            con.subtarget = bone
+            self.make_constraint(bones.org, 'COPY_TRANSFORMS', bones.ctrl)
+
+
+    def generate_widgets(self):
+        bones = self.bones
 
+        if self.make_control:
             # Create control widget
             if self.make_widget:
-                create_circle_widget(self.obj, bone, radius=0.5)
+                create_circle_widget(self.obj, bones.ctrl, radius=0.5)
             else:
-                create_bone_widget(self.obj, bone)
+                create_bone_widget(self.obj, bones.ctrl)
 
 
-def add_parameters(params):
-    """ Add the parameters of this rig type to the
-        RigifyParameters PropertyGroup
-    """
-    params.make_control = bpy.props.BoolProperty(
-        name        = "Control",
-        default     = True,
-        description = "Create a control bone for the copy"
-    )
-
-    params.make_widget = bpy.props.BoolProperty(
-        name        = "Widget",
-        default     = True,
-        description = "Choose a widget for the bone control"
-    )
-
-    params.make_deform = bpy.props.BoolProperty(
-        name        = "Deform",
-        default     = True,
-        description = "Create a deform bone for the copy"
-    )
-
-
-def parameters_ui(layout, params):
-    """ Create the ui for the rig parameters.
-    """
-    r = layout.row()
-    r.prop(params, "make_control")
-    r = layout.row()
-    r.prop(params, "make_widget")
-    r.enabled = params.make_control
-    r = layout.row()
-    r.prop(params, "make_deform")
+    @classmethod
+    def add_parameters(self, params):
+        """ Add the parameters of this rig type to the
+            RigifyParameters PropertyGroup
+        """
+        params.make_control = bpy.props.BoolProperty(
+            name        = "Control",
+            default     = True,
+            description = "Create a control bone for the copy"
+        )
+
+        params.make_widget = bpy.props.BoolProperty(
+            name        = "Widget",
+            default     = True,
+            description = "Choose a widget for the bone control"
+        )
+
+        params.make_deform = bpy.props.BoolProperty(
+            name        = "Deform",
+            default     = True,
+            description = "Create a deform bone for the copy"
+        )
+
+
+    @classmethod
+    def parameters_ui(self, layout, params):
+        """ Create the ui for the rig parameters.
+        """
+        r = layout.row()
+        r.prop(params, "make_control")
+        r = layout.row()
+        r.prop(params, "make_widget")
+        r.enabled = params.make_control
+        r = layout.row()
+        r.prop(params, "make_deform")
 
 
 def create_sample(obj):