# RFRM Autorig Python Documentation (Ver: 2025_04_06)

## Common Modules

### Global Control

            from rigging_framework.templates.humanoid_rig.modules import global_control

            def build(name, root_skeletal_joint, scale=1.0, up_vector=(0, 1, 0)):
                """
                Builds a global control and hierarchy of folders

                :param str name: Name of the global control
                :param str root_skeletal_joint: Name of the root skeletal joint
                :param float scale: Scale of the control
                :param float[3] up_vector: Up vector of the control

                :return dict:
                    result = {"Global_Ctrl": name of the global control
    						  "Geometry_Grp": name of the group containing geometry
                              "Skeleton_Grp": name of the group containing skeleton
                              "Modules_Grp": name of the group containing all the rig modules
                              "Do_Not_Touch_Grp": name of the group containing hidden rig elements
                              "Global_Scale": global scale of the control - for now always 1.0
                }
                """

### FK Chain

            from rigging_framework.templates.common.modules import fk_chain

            def build(list_of_objects, name_or_none="FK_Chain", replace_in_name=(), add_prefix="", add_suffix="", scale=1,
                      color="blue", point_constraint=True, orient_constraint=True, scale_constraint=False,
                      virtual_constraints=False):

                """
                Builds an fk chain based on given parameters

                :param list[str] list_of_objects: list of objects to build chain grom
                :param str or None name_or_none: if name is None then chain elements will be named after objects
                :param tuple replace_in_name: tuple of pairs (tuples) - it can replace substrings in the name
                :param str add_prefix: will add prefix to FK controls
                :param str add_suffix: will add suffix to FK controls
                :param float scale: scale of controls
                :param str color: string name for color (blue, red, yellow, etc...)
                :param bool point_constraint: does this chain control translation
                :param bool orient_constraint: does this chaing control rotation
                :param bool scale_constraint: does this chain control scale
                :param bool virtual_constraints: whether constraints will be built during the build or saved for later

                :return dict:
                    result = {"Controls": list of controls
                              "Control_Groups": list of control groups
                              "Module_Group": main module group name}
                """

### Ribbon

            from rigging_framework.templates.common.modules import ribbon

            def build(list_of_objects, name="Ribbon", attach_objects=True, sticky=False, make_controls=False, scale=1,
                      surface_up=(0, 1, 0), virtual_constraints=False):

                """
                Builds a ribbon based on selected objects positions, sticky or non sticky

                :param list[str] list_of_objects: list of objects or joints to build ribbon along
                :param str name: name of the ribbon module
                :param bool attach_objects: whether selected objects will be attached to the ribbon - (overriden by make controls)
                :param bool sticky: whether or not we want this ribbon to be sticky or sliding on the surface
                :param bool make_controls: whether or not we want to make offset controls on this ribbon (overrides attach objects)
                :param float scale: scale of the ribbon
                :param float[3] surface_up: we need this to determine up from the surface - perpendicular vector to it
                :param bool virtual_constraints: whether or not constraints are virtual (will be build after the tool executes)

                :return dict:
                result = {"Controls": list of controls
                          "Module_Group": main ribbon group name
                          "Control_Groups": list of control offset groups
                          "Ribbon_Surface": ribbon surface object}
                """

## Humanoid Rig Modules

### Finger Rig

            from rigging_framework.templates.humanoid_rig.modules import finger_rig

            def build(finger_joints, name_or_none, add_prefix=None, add_suffix="_Fk_Ctrl",
                      replace_in_name=(("FK_", ""), ("_Jnt", "")),
                      stretch_amount=10.0,
                      scale=1.0, virtual_constraints=False):

                """
                Builds a simple fk finger based on fk chain,

                Expects certain hard-coded conventions that will affect finger behaviour (will be updated):
                "thumb", "index", "middle", "ring", "pinky"
                "left", "right" or "_l", "_r"

                :param list[str] finger_joints: list of finger joints
                :param str or None name_or_none: name of the module or it will adopt name of the object for control names
                :param str add_prefix: adds prefix to control names
                :param str add_suffix: adds suffix to control names
                :param tuple replace_in_name: tuple of two strings - replace substring with another substring from object to control
                :param float scale: scale of controls
                :param float stretch_amount: allowed amount to stretch (10.0 - default)
                :param bool virtual_constraints: build constraints or leave them for later...

                :return dict:
                result = {"Module_Group": Module group name
                          "Main_Node": Main node - first finger control
                          "Controls": List of finger controls
                          "Control_Groups": List of finger control groups
                          "Finger_Pmas": dictionary of finger plus minus nodes with keys: bend, sway, curl etc... }
                """

### FK Foot Rig

            from rigging_framework.templates.humanoid_rig.modules import fk_foot_rig

            def build(fk_toe_base_bone, fk_toes_end_bone,
                      name_or_none=None, add_prefix="", add_suffix="",
                      replace_in_name=(("FK_", ""), ("_Jnt", "")),
                      scale=1, virtual_constraints=False):

                """
                Builds a simple fk foot rig base on fk joints

                For now has certain hardcoded features:
                removes substrings: FK_ and _Jnt in joint name
                adds suffix: FK_Ctrl

                :param str fk_toe_base_bone: FK toe base bone
                :param str fk_toes_end_bone: FK toes end bone
                :param str name_or_none: Name of the module - otherwise it will generate automatically
                :param str add_prefix: Prefix for the control names
                :param str add_suffix: Suffix for the control names
                :param tuple(str,str) replace_in_name: Replace substring in control name
                :param float scale: scale of controls
                :param bool virtual_constraints: Build constraints or not (if True)

                :return dict:
                    result = {"Module_Group": name of the main module group,
                              "Controls": list of controls,
                              "Control_Groups": list of control groups
                """

### Hand Rig

            from rigging_framework.templates.humanoid_rig.modules import hand_rig

            def build(name, cog_ctrl, ikfk_switch_ctrl, ik_main_node, hand_joint, thumb_joints, index_joints, middle_joints,
                      ring_joints, pinky_joints, scale):
                """
                Builds an hand rig

                :param str name: Name of the module
                :param str cog_ctrl: Cog control name in the rig (needed to parent hand under)
                :param str ikfk_switch_ctrl: Name of the ikfk switch control
                :param str ik_main_node: Name of the main ik node to attach the hand to
                :param str hand_joint: Name of the hand joint
                :param list[str] thumb_joints: List of thumb joints
                :param list[str] index_joints: List of index joints
                :param list[str] middle_joints: List of middle joints
                :param list[str] ring_joints: List of ring joints
                :param list[str] pinky_joints: List of pinky joint
                :param float scale: Scale of the controls

                :return str: Ik hand control name
                """

### Hips Rig

            from rigging_framework.templates.humanoid_rig.modules import hips_rig

            def build(name, pelvis_jnt, cog_ctrl,
                      left_hip_jnt, left_ik_hip_joint, left_hip_control_fk_grp, left_leg_ikfk_switch, left_ankle_jnt,
                      right_hip_jnt, right_ik_hip_joint, right_hip_control_fk_grp, right_leg_ikfk_switch, right_ankle_jnt,
                      scale):
                """
                Build hips rig for IKFK legs and pelvis

                :param str left_hip_jnt: left hip joint
                :param str left_ik_hip_joint: left ik hip joint
                :param str left_hip_control_fk_grp: left hip fk control offset group
                :param str left_leg_ikfk_switch: left leg ikfk switch
                :param str left_ankle_jnt: left ankle joint
                :param str right_hip_jnt: right hip joint
                :param str right_ik_hip_joint: right ik hip joint (assumes we have fk and ik joints)
                :param str right_hip_control_fk_grp: right hip fk control offset group
                :param str right_leg_ikfk_switch: right leg ikfk switch
                :param str right_ankle_jnt: right ankle joint
                :param str pelvis_jnt: pelvis joint
                :param str cog_ctrl: COG control
                :param str name: name of the module
                :param float scale: controls scale

                :return str: pelvis control name
                """

### IK Foot Rig

            from rigging_framework.templates.humanoid_rig.modules import ik_foot_rig

            def build(name, foot_ik, ik_ankle_bone, ik_toe_base_bone, ik_toes_end_bone, toe_pivot, rear_pivot, out_pivot, in_pivot,
                      ball_pivot, spin_pivot, mirror_foot=False, aim_vector=(1, 0, 0), up_vector=(0, 1, 0),
                      virtual_constraints=False):
                """
                Build ik foot rig for given foot joints - part of IKFK foot rig

                :param str foot_ik: this could be foot ik or locator driving the foot
                :param str ik_ankle_bone: IK ankle bone
                :param str ik_toe_base_bone: IK toe base bone
                :param str ik_toes_end_bone: IK toes end bone
                :param str toe_pivot: Transform for toe pivot
                :param str rear_pivot: Transform for rear pivot
                :param str out_pivot: Transform for outside foot pivot
                :param str in_pivot: Transform for inner foot pivot
                :param str ball_pivot: Transform for ball pivot
                :param str spin_pivot: Transform for foot spinning pivot
                :param str name: Module name
                :param bool mirror_foot: Do we want to mirror/flip the foot behaviour
                :param float[3] aim_vector: Where the rig should be aiming (vector)
                :param float[3] up_vector: Where is the rig up vector (vector)
                :param bool virtual_constraints: Do we want to constraint bones?

                :return dict:
                    result = {"Module_Group": Name of the module group
                              "Control_Groups": Foot control groups
                              "Controls": Foot controls}
                """

### IK Ribbon Spine

            from rigging_framework.templates.humanoid_rig.modules import ik_ribbon_spine

            def build(name, spine_joints, control_names=("Hip", "Abdomen", "Chest"), main_cog_control=True,
                      world_orientated_controls=True, middle_control_constrained=True, scale=1.0, up_vector=(0, 1, 0),
                      aim_vector=(1, 0, 0), virtual_constraints=False):
                """
                Builds IK ribbon spine for bipeds (part of IKFK spine)

                :param str name: Name of the rig module
                :param list[str] spine_joints: Spine joints starting from the hip, ending with the chest
                :param float scale: sScale of the controls
                :param list[str] control_names: Names of 3 ik controls
                :param bool main_cog_control: Whether or not to build main cog control
                :param bool world_orientated_controls: Whether or not we want the controls to be world orientated or object
                :param bool middle_control_constrained: Whether we want middle control to be constrained between outer ones
                :param float[3] up_vector: Determines the up of the control and the ribbon
                :param float[3] aim_vector: Determines the forward of the control and the ribbon
                :param bool virtual_constraints: Whether or not constrains are going to be built right away or virtually

                :return dict:
                    result = {"Main_Node": Main node in the module (Hips control)
                              "Controls": List of controls
                              "Module_Group": Main module group
                              "Scaling_Groups": Groups that require global scaling
                              "Controls_Grp": List of control offset groups
                              "Ribbon_Surface": Ribbon surface transform
                              "Ribbon_Tweak_Controls": List of ribbon tweaking controls
                """

### IKFK Foot Rig

            from rigging_framework.templates.humanoid_rig.modules import ikfk_foot_rig

            def build(name, ikfk_switch_control, ikfk_switch_attr, leg_ik, ik_ankle_bone, fk_ankle_bone, toe_base_bone,
                      toes_end_bone, toe_pivot, rear_pivot, out_pivot, in_pivot, ball_pivot, spin_pivot,
                      scale=1.0, aim_vector=(1, 0, 0), mirror_foot=False, up_vector=(0, 1, 0), virtual_constraints=False):
                """
                Builds ikfk footrig system

                :param str name: Name of the module
                :param str ikfk_switch_control: IKFK switch control
                :param str ikfk_switch_attr: IKFK attribute name
                :param str leg_ik: IK node for the leg (or locator driving IK)
                :param str ik_ankle_bone: Ik ankle joint
                :param str fk_ankle_bone: FK ankle joint
                :param str toe_base_bone: Toe base joint
                :param str toes_end_bone: Toes end joint
                :param str toe_pivot: Transform for toe pivot
                :param str rear_pivot: Transform for rear/heel pivot
                :param str out_pivot: Transform for outside pivot
                :param str in_pivot: Transform for inner/inside pivot
                :param str ball_pivot: Transform for ball/toebase pivot
                :param str spin_pivot: Transform for footspin pivot
                :param float scale: Scale for controls
                :param bool mirror_foot: Do we want to mirror the foot rig?
                :param float[3] aim_vector: Where there rig should be aiming? (Vector)
                :param float[3] up_vector: Where is the up direction for the footrig (Vector)
                :param bool virtual_constraints: Do we want to build constraints, or leave that for later.

                :return dict:
                    result = {"Module_Group": main module group
                              "IK_Foot_Control": ik foot control,
                              "Controls": ik foot controls and fk foot controls,
                              "Control_Groups": if foot control groups and fk foot control groups,
                              "IK_Curve": visibility curve (animCurve) for IK,
                              "FK_Curve": visibility curve (animCurve) for FK}
                """

### IKFK Limb

            from rigging_framework.templates.humanoid_rig.modules import ikfk_limb

            def build(name, start_joint, mid_joint, end_joint, scale=1.0, pole_vector_distance=1.0, virtual_constraints=False,
                      name_or_none=None,
                      replace_in_name=(("_Jnt", ""), ("FK_", "")),
                      add_prefix="",
                      add_suffix="_FK_Ctrl",
                      ):
                """
                Builds the module based on given parameters
                This module has to be build on almost straight limb - it will not straighten the bent limb...

                :param str name: Name of the module
                :param str start_joint: Upper arm or Upper leg
                :param str mid_joint: Knee or elbow
                :param str end_joint: Ankle or hand
                :param scale float scale: Scale of controls
                :param float pole_vector_distance: multiplier how far pole vector should land
                :param bool virtual_constraints: do we want to constraint right away or leave it for later
                :param str name_or_none: Name of the FK module - otherwise it will name after joints
                :param list(tuple) replace_in_name: Substrings in fk joints to be replaced default FK and JNT
                :param str add_prefix: add prefix to FK controls?
                :param str add_suffix:

                :return dict:
                    result = {"Main_Node": End locator of the limb system (Use this instead of IK)
                              "Controls": Pole vector control + FK controls
                              "Module_Group": Main module group
                              "Gizmos_Grp": Gizmos (Display stuff)
                              "Control_Groups": Offsets for all the controls above
                              "IKFK_Switch_Ctrl": IKFK switch control
                              "IK_Handle": IK handle node}
                """

### IKFK Limb Tweakable

            from rigging_framework.templates.humanoid_rig.modules import ikfk_limb_tweakable

            def build(name, start_joint, mid_joint, end_joint, scale=1.0, pole_vector_distance=1.0, aim_vector=(1, 0, 0),
                      up_vector=(0, 1, 0), virtual_constraints=False):
                """
                Builds the module based on given parameters
                This module has to be build on almost straight limb - it will not straighten the limb...

                :param str name: Name of the module
                :param str start_joint: Upper arm or upper leg
                :param str mid_joint: Middle joint like knee or elbow
                :param str end_joint: End joint like ankle or hand
                :param float scale: Scale of the controls
                :param float pole_vector_distance: Multiplier how far pole vector should land
                :param float[3] aim_vector: What is the aim vector for this system - where should it be aiming forward
                :param float[3] up_vector: Whats the up vector fir this system - what is up for it in the coordinate system
                :param bool virtual_constraints: Do we want to build constraints or leave that for later

                :return dict:
                    result = {"Main_Node": Main limb node - locator in the hand/ankle which can be used to attach things to,
                              "Controls": IKFK limb controls + tweaker control,
                              "Module_Group": Main module group,
                              "Gizmos_Grp": Gizmos - display elements (guide curves),
                              "Control_Groups": IKFK limb control groups and tweaker control group,
                              "IKFK_Switch_Ctrl": IKFK switch control name}

                """

### IKFK Spine

            from rigging_framework.templates.humanoid_rig.modules import ikfk_spine

            def build(name, spine_joints, ik_drives_fk=True, scale=1.0, up_vector=(0, 1, 0), aim_vector=(1, 0, 0),
                      virtual_constraints=False):
                """
                Builds ikfk ribbon spine with a switch for biped

                :param str name: Name of the module
                :param list[str] spine_joints: List of spine joints
                :param bool ik_drives_fk: Default build is IK driving FK, but there is opposite option if needed
                :param float scale: Scale of the controls
                :param float[3] up_vector: Determines the up of the control and the ribbon
                :param float[3] aim_vector: Determines the forward of the control and the ribbon
                :param bool virtual_constraints: Whether or not constrains are going to be built right away or virtually

                :return dict:
                    result = {"Main_Node": Main COG control node
                              "Controls": IK spine controls + FK spine controls
                              "Module_Group": Main module group
                              "Control_Groups": IK spine control groups + FK spine control groups,
                              "Ribbon_Surface": Name of the ribbon surface node,
                              "Ribbon_Tweak_Controls": Tweaker controls for the ribbon}
                """

### Neck And Head Rig

            from rigging_framework.templates.humanoid_rig.modules import neck_and_head

            def build(name, neck_joints, parent_joint, scale=1.0, neck_has_orientation=False, head_has_orientation=True,
                      aim_vector=(1, 0, 0), up_vector=(0, 1, 0), virtual_constraints=False):

                """
                Builds bipedal or quadrupedal ribbon neck (can handle 3 or more joints)

                :param str name: Name of the module
                :param list[str] neck_joints: Starting from the neck base, ending with the head
                :param str parent_joint: Parent joint - chest or so
                :param float scale: Scale of controls
                :param bool neck_has_orientation: Whether the neck controls will be orientated like the rig orientation or follow the joints
                :param bool head_has_orientation: Whether the head control will be orientated like the rig orientation or follow the joint
                :param float[3] aim_vector: The aim vector for this module
                :param float[3] up_vector: Up vector for the module
                :param bool virtual_constraints: When to build the constraints

                :return dict:
                    result = {"Main_Node": Neck base control - main node
                              "Controls": Neck base, neck mid, head - controls
                              "Module_Group": Main module group
                              "Control_Groups": Control groups - neck base, mid, head
                """

### Shoulder Rig

            from rigging_framework.templates.humanoid_rig.modules import shoulder_rig

            def build(name, cog_ctrl, chest_joint, shoulder_joint, ik_arm_joint, arm_fk_ctrl_grp, scale):
                """
                Builds a shoulder rig

                :param str name: Name of the module
                :param str cog_ctrl: Name of the COG control
                :param str chest_joint: Chest joint
                :param str shoulder_joint: Shoulder joint
                :param ik_arm_joint: IK arm joint (assumes we have IK chain and FK chain)
                :param str arm_fk_ctrl_grp: Arm FK control group
                :param float scale: Scale of rig controls

                :return str: Shoulder control
                """

## Quadruped Rig Modules

### Front IKFK Leg

            from rigging_framework.templates.quadruped_rig.modules import front_ikfk_leg

            def build(name, shoulder_joint, upper_knee_joint, lower_knee_joint, ankle_joint, scale=1.0, orientation=(0, 0, 0)):
                """
                Builds the front IKFK quadrupedal leg based on given parameters

                :param str name: Name of the module
                :param str shoulder_joint: Name of the shoulder bone
                :param str upper_knee_joint: Name of the upper knee joint (assumes quadruped would have upper and lower knee)
                :param lower_knee_joint: Name of the lower knee joint (assumes quaruped would have upper and lower knee)
                :param joint ankle_joint: Name of the ankle joint
                :param float scale: Scale of the controls
                :param float[3] orientation: Orientation of the system (default 0, 0, 0)

                :return dict:
                    result = {"Main_Node": Main node - a locator to which you can attach footrig and other elements, follows IK and FK
                              "Controls": List of controls - lower knee pv, ik shoulder, fk controls
                              "Do_Not_Touch_Grp": IK system group
                              "Gizmos_Grp": Group containing visual gizmos - guides
                              "Controls_Grp": Main controls group
                              "IKFK_Switch_Ctrl": ikfk_switch_ctrl}
                """

### IKFK Tail Rig

            from rigging_framework.templates.quadruped_rig.modules import ikfk_tail_rig

            def build(name, tail_joints, orientation=(0, 0, 0), scale=1.0, virtual_constraints=False):
                """
                Builds ikfk tail

                :param str name: Module name
                :param list[str] tail_joints: List of tail joints
                :param float[3] orientation: orientation of the rig (default 0 0 0)
                :param float scale: scale of the controls
                :param virtual_constraints: whether or not constraining will be executed in this script or saved for later

                :return dict:
                    result = {"Main_Node": main_tail_ctrl,
                              "Controls": [main_tail_ctrl] + fk_tail_data["Controls"] + ik_tail_data["Controls"],
                              "Do_Not_Touch_Grp": do_not_touch_grp,
                              "Scaling_Grp": scaling_jnt_grp,
                              "Controls_Grp": all_controls_grp}
                """

### Quad IK Ribbon Spine

            rigging_framework.templates.quadruped_rig.modules.quad_ik_ribbon_spine

            def build(name, spine_joints, control_names=("Hip", "Abdomen", "Chest"), main_cog_control=True,
                      world_orientated_controls=True, middle_control_constrained=True, scale=1.0, orientation=(0, 0, 0),
                      virtual_constraints=False):

                """
                Builds ribbon spine for quadruped rig

                :param str name: Name of the module
                :param list[str] spine_joints: Joints starting from the hip, ending with the chest
                :param float scale: Scale of controls
                :param list[str] control_names: Names of 3 ik controls
                :param str main_cog_control: Whether to build main cog control
                :param bool world_orientated_controls: Whether we want the controls to be world orientated or object
                :param bool middle_control_constrained: Whether we want middle control to be constrained between outer ones
                :param float[3] orientation: Default orientation of the ik ribbon spine (0, 0, 0) default
                :param bool virtual_constraints: Whether constrains are going to be built right away or virtually

                :return:
                     result = {"Main_Node": COG control - main rig node
                               "Controls": Controls - (COG), Hip, Abdomen, Chest,
                               "Do_Not_Touch_Grp": Rig elements that are supposed to be hidden,
                               "Scaling_Groups": Groups requiring individual scaling,
                               "Controls_Grp": Offset groups for controls above
                """

### Quad IKFK Spine

            from rigging_framework.templates.quadruped_rig.modules import quad_ikfk_spine

            def build(name, spine_joints, ik_drives_fk=True, scale=1.0, orientation=(0, 0, 0), skip_joints_missing_str=()):
                """
                Builds ikfk ribbon spine with a switch for quadruped

                :param str name: Name of the module
                :param list[str] spine_joints: List of spine joints
                :param bool ik_drives_fk: By default IK drives FK spine - but it could be opposite
                :param float scale: Scale of the controls
                :param float[3] orientation: Default orientation of IK controls (0, 0, 0) default
                :param skip_joints_missing_str: When duplicating chains to create IK and FK chains - deletes the joints that do not contain this string

                :return dict:
                    result = {"Main_Node": COG Control for the spine - Main Node,
                              "Controls": IK Spine controls and FK controls,
                              "Do_Not_Touch_Grp": Group containing hidden rig elements,
                              "Scaling_Groups": Group requiring individual scaling,
                              "Controls_Grp": Control offset groups for controls above}
                """

### Quad Neck And Head Rig

            from rigging_framework.templates.quadruped_rig.modules import quad_neck_and_head

            def build(name, neck_joints, scale=1.0, neck_has_orientation=False, head_has_orientation=True, orientation=(0, 0, 0)):

                """
                Builds quad ribbon neck and head system

                :param str name: Name of the module created
                :param list[str] neck_joints: Neck joints starting from the hip, ending with the chest
                :param float scale: Scale of controls
                :param bool neck_has_orientation: Whether the neck controls will be orientated like the rig orientation or follow the joints
                :param bool head_has_orientation: Whether the head control will be orientated like the rig orientation or follow the joint
                :param float[3] orientation: What is the default orientation for this rig

                :return dict:
                        result = {"Main_Node": ribbon_controls["Neck_Base"],
                                  "Controls": [ribbon_controls["Neck_Base"], ribbon_controls["Neck_Mid"], ribbon_controls["Head"]],
                                  "Do_Not_Touch_Grp": do_not_touch_grp,
                                  "Scaling_Groups": [ribbon_joints_scaling_grp],
                                  "Controls_Grp": ribbon_control_groups["Neck_Base"]}
                """

### Rear IKFK Leg

            from rigging_framework.templates.quadruped_rig.modules import rear_ikfk_leg

            def build(name, hip_joint, upper_knee_joint, lower_knee_joint, ankle_joint, scale=1.0, orientation=(0, 0, 0)):
                """
                Builds the rear leg module based on given parameters

                :param str name: Name of the module
                :param str hip_joint: Name of the hip joint
                :param str upper_knee_joint: Upper knee joint
                :param str lower_knee_joint: Lower knee joint
                :param str ankle_joint: Ankle joint
                :param float scale: Scale of the controls
                :param float[3] orientation: Default module/controls orientation (0, 0, 0) is default

                :return dict:
                    result = {"Main_Node": foot_locator,
                          "Controls": [lower_knee_pole_vec_ctrl, upper_knee_pole_vec_ctrl, hip_ik_control] + fk_controls,
                          "Do_Not_Touch_Grp": ik_system_grp,
                          "Gizmos_Grp": gizmo_group,
                          "Controls_Grp": control_group,
                          "IKFK_Switch_Ctrl": ikfk_switch_ctrl}
                """

## Common Functions

### Virtual Constraints

    		# For virtual constraints in your code steps use constraints module:

    		from rigging_framework.templates.common.utilities import constraints

    		# initialize mapping system so that we can start storing constraints created in individual code steps:
    		constraints.initialize_mapping()

    		# virtual point constraint
    		constraints.point_constraint(masters=["Master_Object"], slave=["Slave_Object"], maintain_offset=True, skip_translate=["x"], use_mapping_file=True)

    		# virtual orient constraint
    		constraints.orient_constraint(masters, slave, maintain_offset, skip_rotate, interp_type, use_mapping_file=True)

    		# virtual parent constraints
    		constraints.parent_constraint(masters, slave, maintain_offset, skip_translate, skip_rotate, interp_type, use_mapping_file=True)

    		# virtual scale constraint
    		constraints.scale_constraint(masters, slave, maintain_offset, skip_scale, use_mapping_file=True)

    		# This will build all the constraints stored in mapping file initialized earlier and clear out the mapping file:
    		constraints.build_constraints(flush_data=True, use_mapping_file=True)

### Global Variables

    		# import global variables module
    		from rigging_framework import global_variables

    		# set global variable value:
    		global_variables.set(variable_name, value)

    		# get variable value (even if it was saved in previous steps)
    		variable_value = global_variables.get(variable_name)

    		# gets folder path for currently running rig template:
    		global_variables.get_current_template_path()

    		# gets path to templates folder in the rigging framework:
    		global_variables.get_template_folder_path()

### Step Arguments

    		# import global variables module
    		from rigging_framework import global_variables

    		# accessing all arguments from the step
    		args = global_variables.get_step_arguments()

    		# accessing specific argument
    		root_joint = args["root_joint"]