def execute(self, context):
        active = Get.active(context)
        active_select = Is.selected(active)
        selected = Get.selected(context)
        is_pose = bool(context.mode == 'POSE')
        arg = dict(only_selected=bool(selected))

        if is_pose:
            clear = bpy.ops.pose.paths_clear

            # Operator only runs on active rig, so repeat for all in pose mode
            if selected:
                obs = {b.id_data for b in selected}
            else:
                obs = {ob for ob in Get.objects(context) if ob.mode == 'POSE'}

            for ob in obs:
                Set.active(context, ob)
                clear(**arg)
            else:
                Set.active(context, active)
                Set.select(active, active_select)
        elif bpy.ops.object.paths_clear.poll(context.copy()):
            bpy.ops.object.paths_clear(**arg)

        return {'FINISHED'}
Example #2
0
    def add_bones_bone(self, context, rig):
        # Add bones then set their defaults
        root = self.get_root(rig)
        prev_bones = self.get_prev_bones(rig)
        bone = rig.data.edit_bones.new('Bone')
        bone.parent = root

        bone.translate(
            Vector(
                utils.multiply_list(
                    Get.cursor(context).location,
                    rig.matrix_world.inverted().to_scale(
                    ),  # Get the transforms for the unscaled rig
                )) - rig.matrix_world.to_translation())

        # Use the original bone size (unscaled by the rig)
        bone.tail = bone.head + Vector(
            utils.multiply_list(
                Vector((0, 0, 0.1)),
                rig.matrix_world.inverted().to_scale(),
            )) - rig.matrix_world.to_translation()

        bone = str(bone.name)

        # Switch back to Pose mode and setup pose bones
        Set.mode(context, 'POSE', rig)

        bone = rig.data.bones[bone]
        rig.data.bones.active = bone
        Set.select(bone)
Example #3
0
def returnToArmature(context, widget):
    bone = fromWidgetFindBone(widget)
    armature = bone.id_data

    # Unhide collection if it was hidden in a previous run
    if widget.users_collection:  # Try to use the widget's collection
        collection = widget.users_collection[0]
    else:  # otherwise use default
        collection = get_collection(context)
    Set.visible(context, collection)

    Set.mode(context, 'OBJECT', widget)

    # collection = get_collection(context)
    if [x for x in armature.users_collection if x != collection]:
        # Don't hide the active collection
        collection.hide_viewport = True
    "New version doesn't have this"
    # get_collection_view_layer(collection).hide_viewport = True

    if getattr(context.space_data, 'local_view', None):
        bpy.ops.view3d.localview()

    Set.active(context, armature)
    Set.select(armature, True)

    Set.mode(context, 'POSE', armature)
    # Set.select(bone, True)
    # Set.active(context, bone)
    armature.data.bones[bone.name].select = True
    armature.data.bones.active = armature.data.bones[bone.name]
Example #4
0
def editWidget(context, active_bone):
    widget = active_bone.custom_shape

    armature = active_bone.id_data
    Set.mode(context, 'OBJECT', armature)
    Set.select(armature, False)
    '''  # 2.7
    if context.space_data.lock_camera_and_layers == False :
        visibleLayers = numpy.array(bpy.context.space_data.layers)+widget.layers-armature.layers
        bpy.context.space_data.layers = visibleLayers.tolist()

    else :
        visibleLayers = numpy.array(bpy.context.scene.layers)+widget.layers-armature.layers
        bpy.context.scene.layers = visibleLayers.tolist()
    '''

    "Commented because the new version only uses get_collection"
    if widget.users_collection:
        collection = widget.users_collection[0]
    else:
        collection = get_collection(context)
        collection.objects.link(widget)
    Set.in_scene(context, collection)
    Set.visible(context, collection)
    "Commented because new version uses operator"
    # get_collection_view_layer(collection).hide_viewport = False
    if getattr(context.space_data, 'local_view', None):
        bpy.ops.view3d.localview()

    # select object and make it active
    Set.select(widget, True)
    Set.active(context, widget)
    Set.mode(context, 'EDIT', widget)
Example #5
0
    def get_prev_bones(rig):
        prev_bones = []

        for b in rig.data.bones:
            if b.select:
                prev_bones.append(b.name)
            Set.select(b, False)
            Set.select(rig.data.edit_bones[b.name], False)

        return prev_bones
Example #6
0
    def invoke(self, context, event):
        target = context.active_target

        if event.alt:
            Set.select(target, False)
        elif event.shift:
            Set.active_select(context, target, isolate=False)
        elif event.ctrl:
            Set.active_select(context, target, isolate=True)
        else:
            return self.execute(context)

        return {'FINISHED'}
Example #7
0
    def add_bones_mch(self, context, rig, mch_parent=False):
        # Add bones then set their defaults
        root = self.get_root(rig)
        prev_bones = self.get_prev_bones(rig)
        pose_bones = []

        # Get MCH Prefix
        parent_name = context.scene.mch_bone
        if parent_name == "":
            parent_name = "MCH-parent_"

        for bone_name in prev_bones:
            prev = rig.data.edit_bones[bone_name]

            # Replace bone prefixes with MCH instead of inserting keeping both
            name = parent_name + (prev.name.replace("DEF-", "", 1)).replace(
                "CTRL-", "", 1)

            bone = rig.data.edit_bones.new(name)
            pose_bones.append([bone.name, prev.name])
            self.reset(bone, prev)

            bone.use_deform = False
            bone.use_connect = prev.use_connect
            bone.parent = prev.parent

            prev.use_connect = False
            prev.parent = bone
            # prev.select = False
            # prev.hide = True
            if not mch_parent:
                for c in prev.children:
                    c.parent = bone

            Set.select(bone, False)

        # Switch back to Pose mode and setup pose bones
        Set.mode(context, 'POSE', rig)

        for bone, prev in pose_bones:
            bone = rig.pose.bones[bone]
            prev = rig.pose.bones[prev]
            rig.data.bones.active = bone.bone
            # self.widget(bone, 'Box')
            ...

            # Retarget drivers
            if not mch_parent:
                for tar in self.mch_driver_targets:
                    if (tar.id is rig) and (tar.bone_target == prev.name):
                        tar.bone_target = bone.name
Example #8
0
    def execute(self, context):
        active = Get.active(context)
        mode = context.mode
        pose = list()

        for rig in context.selected_objects:
            (rig, meta) = self.poll_parse(context, rig)
            if None in (rig, meta):
                continue

            rigify_to_meta(rig, meta)
            pose.append((meta, rig))
        else:
            if mode == 'POSE':
                Set.mode(context, 'OBJECT')
            for (meta, rig) in pose:
                Set.select(rig, False)
                Set.select(meta, True)
                if rig == active:
                    Set.active(context, meta)
            if mode == 'POSE':
                Set.mode(context, 'POSE')

        return {'FINISHED'}
        def pose_mch(pbone):
            Set.select(bone, False)
            Set.select(pbone, True)
            rig.data.bones.active = pbone.bone

            mats = (pbone.matrix.copy(), bone.matrix.copy())
            (bone.matrix, pbone.matrix) = mats

            pbone.rotation_mode = bone.rotation_mode
            pbone.lock_location = bone.lock_location
            pbone.lock_rotation = bone.lock_rotation
            pbone.lock_rotation_w = bone.lock_rotation_w
            pbone.lock_rotations_4d = bone.lock_rotations_4d
            pbone.lock_scale = (True, False, True)
            pbone.custom_shape_transform = bone
            if not pbone.custom_shape:
                self.bone_widgets['mch'].append(pbone)
            con = bone.constraints.new('COPY_ROTATION')
            con.target = rig
            con.subtarget = pbone.name
            con = bone.constraints.new('COPY_SCALE')
            con.target = rig
            con.subtarget = pbone.name
            con.use_x = con.use_z = False
Example #10
0
    def execute(self, context):
        if (self.type == 'IN_OBJECT'):
            rigs = set()
            for b in context.selected_pose_bones:
                rigs.add(b.id_data)
            for rig in rigs:
                for b in rig.data.bones:
                    if Is.visible(context, b) and (not b.hide_select):
                        Set.select(b, True)
                    elif not self.extend:
                        Set.select(b, False)
            return {'FINISHED'}
        elif (self.type == 'PSEUDO_LAYERS'):
            rigs = dict()
            for b in context.selected_pose_bones:
                rig = b.id_data
                if rig not in rigs:
                    rigs[rig] = list()
                try:
                    selected_layers = eval(b.layers_extra)
                    rigs[rig].extend(selected_layers)
                    rigs[rig] = list(set(rigs[rig]))
                except:
                    pass
            for (rig, selected_layers) in rigs.items():
                visible_layers = [
                    i for i, l in enumerate(rig.data.layers_extra.layers)
                    if l.visible
                ]
                for b in rig.pose.bones:
                    try:
                        bone_layers = eval(b.layers_extra)
                    except:
                        continue

                    if Is.visible(context, b):
                        for b_layer in bone_layers:
                            if (b_layer in selected_layers) and (
                                    b_layer in visible_layers):
                                Set.select(b, True)
                                break
                        else:
                            if not self.extend:
                                Set.select(b, False)
                    elif not self.extend:
                        Set.select(b, False)
            return {'FINISHED'}

        if self.type == 'GROUP':
            active_group = set()
            for b in context.selected_pose_bones:
                rig = b.id_data
                if (rig not in active_group) and b.bone_group:
                    rig.pose.bone_groups.active = b.bone_group
                    active_group.add(rig)

        try:
            return bpy.ops.pose.select_grouped(type=self.type,
                                               extend=self.extend)
        except RuntimeError as ex:
            self.report({'ERROR'}, str(ex).split('Error: ', 1)[-1])
            return {'CANCELLED'}
Example #11
0
    def convert(self, context, obj):
        scn = context.scene
        Set.active_select(context, obj, isolate=True)

        coll_instanced = False  # Whether or not to instance collection in full macro

        head = self.head
        group = obj.name + '-Mannequin'

        coll = bpy.data.collections.get(group)
        if coll:
            # Regenerating mannequin
            coll_instanced = True

            for ob in coll.objects.values():
                if Is.mesh(ob) and ob.DazMannequin:
                    bpy.data.objects.remove(ob)
        else:
            coll = bpy.data.collections.new(group)
            scn.collection.children.link(coll)

        # "temporarily" unhide collection if hidden
        in_view = Is.in_view(context, coll)
        if not in_view:
            Set.visible(context, coll, view_layer=True)
        visible = Is.visible(context, coll)
        if not visible:
            Set.visible(context, coll)

        # Add mannequin objects for current mesh
        self.generate(context, obj, obj.parent, coll)

        if self.macro:
            has_mann = False
            for ob in coll.objects.values():
                if Is.mesh(ob):
                    Set.select(ob)
                    has_mann = True

            if has_mann:
                bpy.ops.object.data_transfer_mannequin_preset()
                # if obj.data.materials:
                # bpy.ops.object.data_transfer_materials()

            # Hide the collection and create an instancer of it
            # if coll:
            # # Set.visible(context, obj, value=False)
            # Set.visible(context, coll, value=False, view_layer=True)
            # if not coll_instanced:
            # inst = New.object(context, name=coll.name)
            # inst.instance_type = 'COLLECTION'
            # inst.instance_collection = coll
            # Set.empty_size(inst, 0)
            # return inst

            for ob in coll.objects.values():
                Set.select(ob, value=False)

        if not visible:
            Set.visible(context, coll, False)
        if not in_view:
            Set.visible(context, coll, False, view_layer=True)

        return obj