@tushar-br/editing-pack 1.0.188 → 1.0.190

package/staging_area/Blender/5.0/scripts/addons_core/rigify/utils/switch_parent.py

@@ -1,533 +0,0 @@
-# SPDX-FileCopyrightText: 2019-2022 Blender Foundation
-#
-# SPDX-License-Identifier: GPL-2.0-or-later
-
-import json
-
-from .naming import strip_prefix, make_derived_name
-from .bones import set_bone_orientation
-from .mechanism import MechanismUtilityMixin
-from .rig import rig_is_child
-from .misc import OptionalLazy, force_lazy, Lazy
-
-from ..base_rig import BaseRig
-from ..base_generate import GeneratorPlugin, BaseGenerator
-
-from typing import Optional, Any
-from collections import defaultdict
-from itertools import chain
-from mathutils import Matrix
-
-
-class SwitchParentBuilder(GeneratorPlugin, MechanismUtilityMixin):
-    """
-    Implements centralized generation of switchable parent mechanisms.
-    Allows all rigs to register their bones as possible parents for other rigs.
-    """
-
-    global_parents: list[dict[str, Any]]
-    local_parents: dict[int, list[dict[str, Any]]]
-    parent_list: list[dict[str, Any]]
-
-    child_list: list[dict[str, Any]]
-    child_map: dict[str, dict[str, Any]]
-
-    def __init__(self, generator: BaseGenerator):
-        super().__init__(generator)
-
-        self.child_list = []
-        self.global_parents = []
-        self.local_parents = defaultdict(list)
-        self.child_map = {}
-        self.frozen = False
-
-        self.register_parent(None, 'root', name='Root', is_global=True)
-
-    ##############################
-    # API
-
-    def register_parent(self, rig: Optional[BaseRig], bone: Lazy[str], *,
-                        name: Optional[str] = None,
-                        is_global=False, exclude_self=False,
-                        inject_into: Optional[BaseRig] = None,
-                        tags: Optional[set[str]] = None):
-        """
-        Registers a bone of the specified rig as a possible parent.
-
-        Parameters:
-          rig:             Owner of the bone (can be None if is_global).
-          bone:            Actual name of the parent bone.
-          name:            Name of the parent for mouse-over hint.
-          is_global:       The parent is accessible to all rigs, instead of just children of owner.
-          exclude_self:    The parent is invisible to the owner rig itself.
-          inject_into:     Make this parent available to children of the specified rig.
-          tags:            Set of tags to use for default parent selection.
-
-        Lazy creation:
-          The bone parameter may be a function creating the bone on demand and
-          returning its name. It is guaranteed to be called at most once.
-        """
-
-        assert not self.frozen
-        assert is_global or rig
-        assert isinstance(bone, str) or callable(bone)
-        assert callable(bone) or rig_is_child(rig, self.generator.bone_owners[bone])
-        assert rig_is_child(rig, inject_into)
-
-        real_rig = rig
-
-        if inject_into and inject_into is not rig:
-            rig = inject_into
-            tags = (tags or set()) | {'injected'}
-
-        entry = {
-            'rig': rig, 'bone': bone, 'name': name, 'tags': tags,
-            'is_global': is_global, 'exclude_self': exclude_self,
-            'real_rig': real_rig, 'used': False,
-        }
-
-        if is_global:
-            self.global_parents.append(entry)
-        else:
-            self.local_parents[id(rig)].append(entry)
-
-    def build_child(self, rig: BaseRig, bone: str, *,
-                    use_parent_mch: bool = True,
-                    mch_orientation: Optional[str | Matrix] = None,
-                    # Options below must be in child_option_table and can be used in amend_child
-                    extra_parents: OptionalLazy[list[str | tuple[str, str]]] = None,
-                    select_parent: OptionalLazy[str] = None,
-                    select_tags: OptionalLazy[list[str | set[str]]] = None,
-                    ignore_global: bool = False,
-                    exclude_self: bool = False,
-                    allow_self: bool = False,
-                    context_rig: Optional[BaseRig] = None,
-                    no_implicit: bool = False,
-                    only_selected: bool = False,
-                    prop_bone: OptionalLazy[str] = None,
-                    prop_id: Optional[str] = None,
-                    prop_name: Optional[str] = None,
-                    controls: OptionalLazy[list[str]] = None,
-                    ctrl_bone: Optional[str] = None,
-                    no_fix_location: bool = False,
-                    no_fix_rotation: bool = False,
-                    no_fix_scale: bool = False,
-                    copy_location: OptionalLazy[str] = None,
-                    copy_rotation: OptionalLazy[str] = None,
-                    copy_scale: OptionalLazy[str] = None,
-                    inherit_scale: str = 'AVERAGE'):
-        """
-        Build a switchable parent mechanism for the specified bone.
-
-        Parameters:
-          rig:              Owner of the child bone.
-          bone:             Name of the child bone.
-          extra_parents:    List of bone names or (name, user_name) pairs to use as
-                            additional parents.
-          use_parent_mch:   Create an intermediate MCH bone for the constraints and
-                            parent the child to it.
-          mch_orientation:  Orientation matrix or bone name to align the MCH bone to;
-                            defaults to world.
-          select_parent:    Select the specified bone instead of the last one.
-          select_tags:      List of parent tags to try for default selection.
-          ignore_global:    Ignore the is_global flag of potential parents.
-          exclude_self:     Ignore parents registered by the rig itself.
-          allow_self:       Ignore the 'exclude_self' setting of the parent.
-          context_rig:      Rig to use for selecting parents; defaults to rig.
-          no_implicit:      Only use parents listed as extra_parents.
-          only_selected:    Like no_implicit, but allow the 'default' selected parent.
-
-          prop_bone:        Name of the bone to add the property to.
-          prop_id:          Actual name of the control property.
-          prop_name:        Name of the property to use in the UI script.
-          controls:         Collection of controls to bind property UI to.
-
-          ctrl_bone:        User visible control bone that depends on this parent
-                            (for switch & keep transform)
-          no_fix_location:  Disable "Switch and Keep Transform" correction for location.
-          no_fix_rotation:  Disable "Switch and Keep Transform" correction for rotation.
-          no_fix_scale:     Disable "Switch and Keep Transform" correction for scale.
-          copy_location:    Override the location by copying from another bone.
-          copy_rotation:    Override the rotation by copying from another bone.
-          copy_scale:       Override the scale by copying from another bone.
-          inherit_scale:    Inherit scale mode for the child bone (default: AVERAGE).
-
-        Lazy parameters:
-          'extra_parents', 'select_parent', 'prop_bone', 'controls', 'copy_*'
-          may be a function returning the value. They are called in the configure_bones stage.
-        """
-        assert self.generator.stage == 'generate_bones' and not self.frozen
-        assert rig is not None
-        assert isinstance(bone, str)
-        assert bone not in self.child_map
-
-        # Create MCH proxy
-        if use_parent_mch:
-            mch_bone = rig.copy_bone(bone, make_derived_name(bone, 'mch', '.parent'), scale=1 / 3)
-
-            set_bone_orientation(rig.obj, mch_bone, mch_orientation or Matrix.Identity(4))
-
-        else:
-            mch_bone = bone
-
-        child = {
-            'rig': rig, 'bone': bone, 'mch_bone': mch_bone,
-            'is_done': False, 'is_configured': False,
-        }
-        self.assign_child_options(child, self.child_option_table, locals())
-        self.child_list.append(child)
-        self.child_map[bone] = child
-
-    def amend_child(self, rig: BaseRig, bone: str, **options):
-        """
-        Change parameters assigned in a previous build_child call.
-
-        Provided to make it more convenient to change rig behavior by subclassing.
-        """
-        assert self.generator.stage == 'generate_bones' and not self.frozen
-        child = self.child_map[bone]
-        assert child['rig'] == rig
-        self.assign_child_options(child, set(options.keys()), options)
-
-    def rig_child_now(self, bone: str):
-        """Create the constraints immediately."""
-        assert self.generator.stage == 'rig_bones'
-        child = self.child_map[bone]
-        assert not child['is_done']
-        self.__rig_child(child)
-
-    ##############################
-    # Implementation
-
-    child_option_table = {
-        'extra_parents',
-        'prop_bone', 'prop_id', 'prop_name', 'controls',
-        'select_parent', 'ignore_global',
-        'exclude_self', 'allow_self',
-        'context_rig', 'select_tags',
-        'no_implicit', 'only_selected',
-        'ctrl_bone',
-        'no_fix_location', 'no_fix_rotation', 'no_fix_scale',
-        'copy_location', 'copy_rotation', 'copy_scale',
-        'inherit_scale',
-    }
-
-    def assign_child_options(self, child, names: set[str], options: dict[str, Any]):
-        if 'context_rig' in names:
-            assert rig_is_child(child['rig'], options['context_rig'])
-
-        for name in names:
-            if name not in self.child_option_table:
-                raise AttributeError('invalid child option: ' + name)
-
-            child[name] = options[name]
-
-    def get_rig_parent_candidates(self, rig: Optional[BaseRig]):
-        candidates = []
-
-        # Build a list in parent hierarchy order
-        while rig:
-            candidates.append(self.local_parents[id(rig)])
-            rig = rig.rigify_parent
-
-        candidates.append(self.global_parents)
-
-        return list(chain.from_iterable(reversed(candidates)))
-
-    def generate_bones(self):
-        self.frozen = True
-        self.parent_list = (self.global_parents +
-                            list(chain.from_iterable(self.local_parents.values())))
-
-        # Link children to parents
-        for child in self.child_list:
-            child_rig = child['context_rig'] or child['rig']
-            parents = []
-
-            for parent in self.get_rig_parent_candidates(child_rig):
-                parent_rig = parent['rig']
-
-                # Exclude injected parents
-                if parent['real_rig'] is not parent_rig:
-                    if rig_is_child(parent_rig, child_rig):
-                        continue
-
-                if parent['rig'] is child_rig:
-                    if (parent['exclude_self'] and not child['allow_self'])\
-                            or child['exclude_self']:
-                        continue
-                elif parent['is_global'] and not child['ignore_global']:
-                    # Can't use parents from own children, even if global (cycle risk)
-                    if rig_is_child(parent_rig, child_rig):
-                        continue
-                else:
-                    # Required to be a child of the parent's rig
-                    if not rig_is_child(child_rig, parent_rig):
-                        continue
-
-                parent['used'] = True
-                parents.append(parent)
-
-            child['parents'] = parents
-
-        # Call lazy creation for parents
-        for parent in self.parent_list:
-            if parent['used']:
-                parent['bone'] = force_lazy(parent['bone'])
-
-    def parent_bones(self):
-        for child in self.child_list:
-            rig = child['rig']
-            mch = child['mch_bone']
-
-            # Remove real parent from the child
-            rig.set_bone_parent(mch, None)
-            self.generator.disable_auto_parent(mch)
-
-            # Parent child to the MCH proxy
-            if mch != child['bone']:
-                rig.set_bone_parent(child['bone'], mch, inherit_scale=child['inherit_scale'])
-
-    def configure_bones(self):
-        for child in self.child_list:
-            self.__configure_child(child)
-
-    def __configure_child(self, child):
-        if child['is_configured']:
-            return
-
-        child['is_configured'] = True
-
-        bone = child['bone']
-
-        # Build the final list of parent bone names
-        parent_map = dict()
-        parent_tags = defaultdict(set)
-
-        for parent in child['parents']:
-            if parent['bone'] not in parent_map:
-                parent_map[parent['bone']] = parent['name']
-            if parent['tags']:
-                parent_tags[parent['bone']] |= parent['tags']
-
-        last_main_parent_bone = child['parents'][-1]['bone']
-        extra_parents = set()
-
-        for parent in force_lazy(child['extra_parents'] or []):
-            if not isinstance(parent, tuple):
-                parent = (parent, None)
-            extra_parents.add(parent[0])
-            if parent[0] not in parent_map:
-                parent_map[parent[0]] = parent[1]
-
-        for parent in parent_map:
-            if parent in self.child_map:
-                parent_tags[parent] |= {'child'}
-
-        parent_bones = list(parent_map.items())
-
-        # Find which bone to select
-        select_bone = force_lazy(child['select_parent']) or last_main_parent_bone
-        select_tags = force_lazy(child['select_tags']) or []
-
-        if child['no_implicit']:
-            assert len(extra_parents) > 0
-            parent_bones = [item for item in parent_bones if item[0] in extra_parents]
-            if last_main_parent_bone not in extra_parents:
-                last_main_parent_bone = parent_bones[-1][0]
-
-        for tag in select_tags:
-            tag_set = tag if isinstance(tag, set) else {tag}
-            matching = [
-                bone for (bone, _) in parent_bones
-                if not tag_set.isdisjoint(parent_tags[bone])
-            ]
-            if len(matching) > 0:
-                select_bone = matching[-1]
-                break
-
-        if select_bone not in parent_map:
-            print(f"RIGIFY ERROR: Can't find bone '{select_bone}' "
-                  f"to select as default parent of '{bone}'\n")
-            select_bone = last_main_parent_bone
-
-        if child['only_selected']:
-            filter_set = {select_bone, *extra_parents}
-            parent_bones = [item for item in parent_bones if item[0] in filter_set]
-
-        try:
-            select_index = 1 + next(i for i, (bone, _) in enumerate(parent_bones)
-                                    if bone == select_bone)
-        except StopIteration:
-            select_index = len(parent_bones)
-            print("RIGIFY ERROR: Invalid default parent '%s' of '%s'\n" % (select_bone, bone))
-
-        child['parent_bones'] = parent_bones
-
-        # Create the controlling property
-        prop_bone = child['prop_bone'] = force_lazy(child['prop_bone']) or bone
-        prop_name = child['prop_name'] or child['prop_id'] or 'Parent Switch'
-        prop_id = child['prop_id'] = child['prop_id'] or 'parent_switch'
-
-        parent_names = [parent[1] or strip_prefix(parent[0])
-                        for parent in [('None', 'None'), *parent_bones]]
-        parent_items = [(f"P{i}", name, "") for i, name in enumerate(parent_names)]
-
-        ctrl_bone = child['ctrl_bone'] or bone
-
-        self.make_property(
-            prop_bone, prop_id, select_index,
-            min=0, max=len(parent_bones),
-            description=f"Switch parent of {ctrl_bone}",
-            items=parent_items,
-        )
-
-        # Find which channels don't depend on the parent
-
-        no_fix = [child[n] for n in ['no_fix_location', 'no_fix_rotation', 'no_fix_scale']]
-
-        child['copy'] = [force_lazy(child[n])
-                         for n in ['copy_location', 'copy_rotation', 'copy_scale']]
-
-        locks = tuple(bool(n_fix or copy) for n_fix, copy in zip(no_fix, child['copy']))
-
-        # Create the script for the property
-        controls = force_lazy(child['controls']) or {prop_bone, bone}
-
-        script = self.generator.script
-        panel = script.panel_with_selected_check(child['rig'], controls)
-
-        panel.use_bake_settings()
-        script.add_utilities(SCRIPT_UTILITIES_OP_SWITCH_PARENT)
-        script.register_classes(SCRIPT_REGISTER_OP_SWITCH_PARENT)
-
-        op_props = {
-            'bone': ctrl_bone, 'prop_bone': prop_bone, 'prop_id': prop_id,
-            'parent_names': json.dumps(parent_names), 'locks': locks,
-        }
-
-        row = panel.row(align=True)
-        left_split = row.split(factor=0.65, align=True)
-        left_split.operator('pose.rigify_switch_parent_{rig_id}', text=prop_name,
-                            icon='DOWNARROW_HLT', properties=op_props)
-        left_split.custom_prop(prop_bone, prop_id, text='')
-        row.operator('pose.rigify_switch_parent_bake_{rig_id}', text='',
-                     icon='ACTION_TWEAK', properties=op_props)
-
-    def rig_bones(self):
-        for child in self.child_list:
-            self.__rig_child(child)
-
-    def __rig_child(self, child):
-        if child['is_done']:
-            return
-
-        child['is_done'] = True
-
-        # Implement via an Armature constraint
-        mch = child['mch_bone']
-        con = self.make_constraint(
-            mch, 'ARMATURE', name='SWITCH_PARENT',
-            targets=[(parent, 0.0) for parent, _ in child['parent_bones']]
-        )
-
-        prop_var = [(child['prop_bone'], child['prop_id'])]
-
-        for i, (_parent, _parent_name) in enumerate(child['parent_bones']):
-            expr = 'var == %d' % (i + 1)
-            self.make_driver(con.targets[i], 'weight', expression=expr, variables=prop_var)
-
-        # Add copy constraints
-        copy = child['copy']
-
-        if copy[0]:
-            self.make_constraint(mch, 'COPY_LOCATION', copy[0])
-        if copy[1]:
-            self.make_constraint(mch, 'COPY_ROTATION', copy[1])
-        if copy[2]:
-            self.make_constraint(mch, 'COPY_SCALE', copy[2])
-
-
-SCRIPT_REGISTER_OP_SWITCH_PARENT = ['POSE_OT_rigify_switch_parent',
-                                    'POSE_OT_rigify_switch_parent_bake']
-
-SCRIPT_UTILITIES_OP_SWITCH_PARENT = ['''
-################################
-## Switchable Parent operator ##
-################################
-
-class RigifySwitchParentBase:
-    bone:         StringProperty(name="Control Bone")
-    prop_bone:    StringProperty(name="Property Bone")
-    prop_id:      StringProperty(name="Property")
-    parent_names: StringProperty(name="Parent Names")
-    locks:        bpy.props.BoolVectorProperty(name="Locked", size=3, default=[False,False,False])
-
-    parent_items = [('0','None','None')]
-
-    selected: bpy.props.EnumProperty(
-        name='Selected Parent',
-        items=lambda s,c: RigifySwitchParentBase.parent_items
-    )
-
-    def save_frame_state(self, context, obj):
-        return get_transform_matrix(obj, self.bone, with_constraints=False)
-
-    def apply_frame_state(self, context, obj, old_matrix):
-        # Change the parent
-        set_custom_property_value(
-            obj, self.prop_bone, self.prop_id, int(self.selected),
-            keyflags=self.keyflags_switch
-        )
-
-        context.view_layer.update()
-
-        # Set the transforms to restore position
-        set_transform_from_matrix(
-            obj, self.bone, old_matrix, keyflags=self.keyflags,
-            no_loc=self.locks[0], no_rot=self.locks[1], no_scale=self.locks[2]
-        )
-
-    def init_invoke(self, context):
-        pose = context.active_object.pose
-
-        if (not pose or not self.parent_names
-            or self.bone not in pose.bones
-            or self.prop_bone not in pose.bones
-            or self.prop_id not in pose.bones[self.prop_bone]):
-            self.report({'ERROR'}, "Invalid parameters")
-            return {'CANCELLED'}
-
-        parents = json.loads(self.parent_names)
-        parent_items = [(str(i), name, name) for i, name in enumerate(parents)]
-
-        RigifySwitchParentBase.parent_items = parent_items
-
-        self.selected = str(pose.bones[self.prop_bone][self.prop_id])
-
-
-class POSE_OT_rigify_switch_parent(RigifySwitchParentBase, RigifySingleUpdateMixin, bpy.types.Operator):
-    bl_idname = "pose.rigify_switch_parent_" + rig_id
-    bl_label = "Switch Parent (Keep Transform)"
-    bl_options = {'REGISTER', 'UNDO', 'INTERNAL'}
-    bl_description = "Switch parent, preserving the bone position and orientation"
-
-    def draw(self, _context):
-        col = self.layout.column()
-        col.prop(self, 'selected', expand=True)
-
-
-class POSE_OT_rigify_switch_parent_bake(RigifySwitchParentBase, RigifyBakeKeyframesMixin, bpy.types.Operator):
-    bl_idname = "pose.rigify_switch_parent_bake_" + rig_id
-    bl_label = "Apply Switch Parent To Keyframes"
-    bl_description = "Switch parent over a frame range, adjusting keys to preserve the bone position and orientation"
-
-    def execute_scan_curves(self, context, obj):
-        return self.bake_add_bone_frames(self.bone, transform_props_with_locks(*self.locks))
-
-    def execute_before_apply(self, context, obj, range, range_raw):
-        self.bake_replace_custom_prop_keys_constant(self.prop_bone, self.prop_id, int(self.selected))
-
-    def draw(self, context):
-        self.layout.prop(self, 'selected', text='')
-''']