Ejemplo n.º 1
0
    def execute(self, context):
        (rig, mesh) = self.get_rig_mesh(context)

        # Switch to object mode first, to prevent sending rig to empty mode
        # happens when switching from Armature Edit to Weight Paint (warning but no error)
        # from there, trying to change the armature mode gives error after fixing the mode
        bpy.ops.object.mode_set(mode='OBJECT')

        if self.mode == 'POSE':
            Set.active(context, rig)
            return bpy.ops.object.mode_set(mode='POSE')
        elif self.mode == 'EDIT_ARMATURE':
            Set.active(context, rig)
            return bpy.ops.object.mode_set(mode='EDIT')
        elif self.mode == 'WEIGHT_PAINT':
            Set.active(context, mesh)
            return bpy.ops.object.mode_set(mode='WEIGHT_PAINT')
        elif self.mode == 'EDIT_MESH':
            Set.active(context, mesh)
            return bpy.ops.object.mode_set(mode='EDIT')
        elif self.mode == 'SCULPT':
            Set.active(context, mesh)
            return bpy.ops.object.mode_set(mode='SCULPT')

        return {'PASS_THROUGH'}
Ejemplo n.º 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)
    def execute(self, context):
        def close_rigify(meta):
            """Close Rigify Layers panel by default"""
            text = meta.data.rigify_rig_ui
            for (index, line) in enumerate(text.lines):
                if (line.body == "class RigLayers(bpy.types.Panel):"):
                    text.cursor_set(index + 6)  # bl_category = 'Item'
                    text.write("    bl_options = {'DEFAULT_CLOSED'}\n")
                    return True

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

            layers_extra = get_layers_extra(meta)

            Set.active(context, meta)
            bpy.ops.pose.rigify_generate()
            close_rigify(meta)

            rig = context.active_object
            meta_to_rigify(daz, rig)

            adjust_rigify(rig)
            set_layers_extra(rig, layers_extra)

        return {'FINISHED'}
Ejemplo n.º 4
0
    def add_bones_root(self, context, rig):
        # Add bones then set their defaults
        root = self.get_root(rig)
        prev_bones = self.get_prev_bones(rig)
        new_root = not bool(root)
        if root is None:
            root = rig.data.edit_bones.new('root')
            root.tail = Vector((0, 1, 0))
            root.bbone_x = 0.5
            root.bbone_z = 0.01
            root.layers = self.layer(27)
        for eb in rig.data.edit_bones:
            if eb.parent is None:
                eb.use_connect = False
                eb.parent = root
        root = str(root.name)

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

        root = rig.pose.bones[root]

        if new_root:
            self.widget(root, 'Blenrig - Root')
        rig.data.bones.active = root.bone
        rig.data.layers[27] = True
Ejemplo n.º 5
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]
Ejemplo n.º 6
0
Archivo: New.py Proyecto: Irmitya/zpy
def empty(context, name="Empty", type='PLAIN_AXES', size=1.0, link=True):
    "Create a new empty object"

    empty = New.object(context, name, None, link)
    Set.empty_type(empty, type)
    Set.empty_size(empty, size)

    return empty
Ejemplo n.º 7
0
    def add_bones_ik(self, context, rig):
        # Add bones then set their defaults
        root = self.get_root(rig)
        prev_bones = self.get_prev_bones(rig)
        pose_bones = []

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

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

            bone.parent = root
            bone.use_deform = 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
            bone.custom_shape_transform = prev
            self.widget(bone, 'Circle', slide=(0, 0.5, 1))

            bone['IK_FK'] = prev.name
            prev['IK_FK'] = prev.name

            bone['IK_IK'] = bone.name
            prev['IK_IK'] = bone.name

            bone.rotation_mode = 'QUATERNION'
            bone.matrix = prev.matrix

            # for ct in ['COPY_LOCATION', 'COPY_ROTATION', 'COPY_SCALE']:
            # con = deform.constraints.new(ct)
            # con.name = 'DEF-'+con.name
            # con.target = rig
            # con.subtarget = stretch.name
            # con.target_space = 'LOCAL'
            # con.owner_space = 'LOCAL'
            # con.use_offset = True
            # con.show_expanded = False
            # con				=	deform.constraints.new('STRETCH_TO')
            # con.name = 'DEF-'+con.name
            # con.target		=	rig
            # con.subtarget = tail.name
            # con.rest_length = deform.bone.length
            # con.head_tail = 0

            if prev.bone_group:
                bone.bone_group = self.bgroup(rig,
                                              'IK-' + prev.bone_group.name)
            else:
                bone.bone_group = self.bgroup(rig, 'IK')
                prev.bone_group = self.bgroup(rig, 'FK')
Ejemplo n.º 8
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
Ejemplo n.º 9
0
Archivo: New.py Proyecto: Irmitya/zpy
def armature(context, name="Armature", display_type=None, link=True):
    "Create and return a rig object"

    data = bpy.data.armatures.new(name)
    # armature.show_in_front = True

    if display_type is not None:
        Set.armature_display_type(data, display_type)

    return New.object(context, name, data, link)
Ejemplo n.º 10
0
    def execute(self, context):
        rig = context.active_object
        active = None

        if context.mode == 'PAINT_WEIGHT':
            for obj in context.selected_objects:
                if obj.type == 'ARMATURE':
                    active = rig
                    rig = obj
                    Set.active(context, rig)

        # if rig.type =='ARMATURE' and context.mode != 'EDIT_ARMATURE':

        meshes = self.get_meshes(context, rig)

        bone1 = context.active_pose_bone
        # bone2 = context.selected_pose_bones[1]
        for bone2 in context.selected_pose_bones:
            if bone2 == bone1:
                continue
            found = None

            for mesh in meshes:
                utils.merge_vertex_groups(
                    mesh,
                    bone1.name,
                    bone2.name,
                    # If remove is False, and the bone stayed, it would be equivalent to transferring only partial weights
                    remove=(self.mode == 'remove'))
                found = True

            # if found:
            # if self.mode == 'hide':
            #     bone2.hide = True
            # elif self.mode == 'show':
            #     bone2.hide = False
            # elif self.mode == 'remove':
            if (found and self.mode == 'remove'):
                for ch in bone2.id_data.children:
                    if (ch.parent_type == 'BONE') and (ch.parent_bone
                                                       == bone2.name):
                        mat = Get.matrix(ch)
                        ch.parent_bone = bone1.name
                        Set.matrix(ch, mat)
                name2 = bone2.name
                Set.mode(context, mode='EDIT')
                bone2 = rig.data.edit_bones[name2]
                rig.data.edit_bones.remove(bone2)
                Set.mode(context, mode='POSE')

        if active:
            Set.active(context, active)

        return {'FINISHED'}
Ejemplo n.º 11
0
    def execute(self, context):
        (rigs, __) = get_rig_bones(context)

        for (rig, bones) in rigs.items():
            for bone in bones:
                self.pose_func(context, rig.pose.bones[bone.name])

        for rig in rigs:
            Set.mode(context, 'EDIT', rig)

        # Reparent soon-to-be orphans
        for (pbone, rig) in self.bones.items():
            bone = rig.data.edit_bones[pbone.name]

            for parent in bone.parent_recursive:
                if (parent not in self.bones):
                    break
            else:
                parent = None

            for child in bone.children:
                if (child not in self.bones):
                    child.parent = parent

        # Remove the bbone constrollers
        for (pbone, rig) in self.bones.items():
            ebones = rig.data.edit_bones
            ebones.remove(ebones[pbone.name])

        for rig in rigs:
            Set.mode(context, 'POSE', rig)

            # remove unused groups
            groups = (rig.pose.bone_groups[bg]
                      for bg in ("BBone FK", "BBone Stretch", "BBone Curve",
                                 "BBone Stretch [Hidden]")
                      if rig.pose.bone_groups.get(bg))
            for bg in list(groups):
                for bone in rig.pose.bones:
                    if bone.bone_group == bg:
                        break
                else:
                    rig.pose.bone_groups.remove(bg)

        # Remove unused widgets
        for wgt in self.widgets:
            if (wgt.users < 2):  # 1) mesh  2+) objects
                wgt_col = list(wgt.users_collection)
                bpy.data.objects.remove(wgt)
                for col in wgt_col:
                    if not col.all_objects:
                        bpy.data.collections.remove(col)

        return {'FINISHED'}
Ejemplo n.º 12
0
 def invoke(self, context, event):
     if event.alt:
         active = context.object
         for ob in context.selected_objects:
             if Is.mesh(ob) and (ob.data.shape_keys):
                 Set.active(context, ob)
                 self.purge(ob)
         Set.active(context, active)
     else:
         self.purge(context.object)
     return {'FINISHED'}
Ejemplo n.º 13
0
def rigify_to_meta(rigify, metarig):
    """Retarget Rigify meshes to Metarig"""

    pose = (metarig.data.pose_position, rigify.data.pose_position)
    (metarig.data.pose_position, rigify.data.pose_position) = ('REST', 'REST')
    utils.update(bpy.context)

    for obj in bpy.data.objects:
        if Is.curve(obj) and obj.name.startswith(rigify.name + '-MCH-'):
            # Splines from angavrilov's spline rig
            continue
        for mod in obj.modifiers:
            if hasattr(mod, 'object') and mod.object == rigify:
                mod.object = metarig
                metafy_vgroups(rigify, obj, metarig)

        if (obj.parent == rigify):
            rigify_bone = obj.parent_bone

            if rigify_bone:
                if rigify_bone.startswith('DEF-'):
                    meta_bone = rigify_bone[4:]
                else:
                    meta_bone = rigify_bone

                if meta_bone in metarig.data.bones:
                    mat = Get.matrix(obj)
                    # pmat = obj.matrix_parent_inverse.copy()
                    obj.parent = metarig
                    obj.parent_bone = meta_bone
                    # obj.matrix_parent_inverse = pmat
                    Set.matrix(obj, mat)
            else:
                obj.parent = metarig

        if Is.mesh(obj):
            meshes = {obj.data}
            if hasattr(obj, 'variants'):
                # The LoDs store the mesh datas and drivers without an object
                for layer in obj.variants.layers:
                    if layer.mesh:
                        meshes.add(layer.mesh)
                    for lod in layer.lods:
                        meshes.add(lod.mesh)

            for mesh in meshes:
                if mesh:
                    rigify_drivers(rigify, metarig, mesh.shape_keys)
    for mat in bpy.data.materials:
        rigify_drivers(rigify, metarig, mat)
        rigify_drivers(rigify, metarig, mat.node_tree)

    (metarig.data.pose_position, rigify.data.pose_position) = pose
Ejemplo n.º 14
0
    def execute(self, context):
        active = obj = context.object
        transfer = bpy.ops.object.data_transfer

        if (not Is.mesh(obj)) or getattr(obj, 'DazMannequin', False):
            # redesignate obj
            obj = None

            for o in context.selected_objects:
                if Is.mesh(o) and (not getattr(o, 'DazMannequin', False)):
                    obj = o
                    Set.active(context, o)
                    break

        if not all((
                obj,
                obj.data.polygons,
                transfer.poll(context.copy()),
        )):
            self.report({'INFO'}, "Only Mannequins Selected")
            return {'CANCELLED'}

        mesh = obj.data

        if mesh.polygons[0].use_smooth:
            # only check one face, rather than all
            bpy.ops.object.shade_smooth()

        if mesh.use_auto_smooth:
            transfer(data_type='CUSTOM_NORMAL')
            for o in context.selected_objects:
                if Is.mesh(o):
                    o.data.use_auto_smooth = True

        if obj.vertex_groups:
            # Vertex groups add to file size, so don't keep them for everything
            transfer(data_type='VGROUP_WEIGHTS',
                     layers_select_src='ALL',
                     layers_select_dst='NAME')

        if mesh.vertex_colors:
            transfer(data_type='VCOL',
                     layers_select_src='ALL',
                     layers_select_dst='NAME')

        if mesh.uv_layers:
            transfer(data_type='UV',
                     layers_select_src='ALL',
                     layers_select_dst='NAME')

        Set.active(context, active)

        return {'FINISHED'}
Ejemplo n.º 15
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
Ejemplo n.º 16
0
    def execute(self, context):
        mannequin.head = f" ({self.head.title()})"

        objects = list()

        for obj in context.selected_objects:
            if Is.mesh(obj) and Is.armature(obj.parent):
                inst = self.convert(context, obj)
                objects.append(inst)

        for obj in reversed(objects):
            Set.active_select(context, obj, isolate=False)

        return {'FINISHED'}
Ejemplo n.º 17
0
    def execute(self, context):
        obj = context.object

        in_edit = (obj.mode == 'EDIT')
        if in_edit:
            Set.mode(context, 'OBJECT')

        active = obj.active_shape_key
        vg = active.vertex_group
        index = obj.active_shape_key_index
        pin = obj.show_only_shape_key

        obj.show_only_shape_key = True
        active.vertex_group = ''
        bpy.ops.object.shape_key_add(from_mix=True)
        while obj.active_shape_key_index > (index + 1):
            bpy.ops.object.shape_key_move(type='UP')
        active.vertex_group = vg

        shape = obj.active_shape_key

        if self.mirror:
            shape.name = utils.flip_name(active.name)
            shape.vertex_group = utils.flip_name(vg)
        else:
            shape.vertex_group = vg
            shape.name = active.name

        for var in ('interpolation', 'mute', 'relative_key', 'slider_max',
                    'slider_min', 'value'):
            setattr(shape, var, getattr(active, var))
            driver = Get.driver(active, var)
            if not driver:
                continue
            newdriver = utils.copy_driver(driver, shape, var)

            if self.mirror:
                for v in newdriver.driver.variables:
                    for t in v.targets:
                        t.bone_target = utils.flip_name(t.bone_target)

        # obj.active_shape_key_index = index
        obj.show_only_shape_key = pin

        if in_edit:
            Set.mode(context, 'EDIT')

        return {'FINISHED'}
Ejemplo n.º 18
0
    def add_bones_vis(self, context, rig):
        # Add bones then set their defaults
        root = self.get_root(rig)
        prev_bones = self.get_prev_bones(rig)
        pose_bones = []

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

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

            bone.use_deform = False

            bone.parent = prev

        # 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
            bone.custom_shape = prev.custom_shape
            bone.custom_shape_transform = prev.custom_shape_transform

            bone.bone.show_wire = True
            prev.custom_shape = None

            bone.bone.hide_select = True

            bone.matrix = prev.matrix

            driver = bone.bone.driver_add('hide')
            var = driver.driver.variables.new()
            var.name = 'var'
            driver.driver.expression = 'not var'
            var.type = 'SINGLE_PROP'
            vt = var.targets[0]
            vt.id = rig

            # vt.bone_target = target.name
            # vt.transform_space = 'LOCAL_SPACE'
            # vt.transform_type = transform
            # # if transform == 'SINGLE_PROP':

            vt.data_path = prev.bone.path_from_id('select')
Ejemplo n.º 19
0
    def execute(self, context):
        (rigs, self.selected) = get_rig_bones(context)

        for rig in rigs:
            Set.mode(context, 'EDIT', rig)
            self.hide_bones[rig] = list()
            self.center_bones[rig] = list()
        for (rig, bones) in rigs.items():
            for bone in bones:
                self.edit_func(context, rig.data.edit_bones[bone.name])
        for (ebones, ebone, tbone) in self.delayed_parenting:
            ebones[ebone].parent = ebones[tbone]
        (do_mch, do_start_end, do_in_out) = self.do()
        if do_start_end:
            self.edit_mirror_center(context)

        if self.warning:
            self.report({'WARNING'}, self.warning)

        for rig in rigs:
            Set.mode(context, 'POSE', rig)
        for (rig, bones) in rigs.items():
            for bone in bones:
                self.pose_func(context, rig.pose.bones[bone.name])

        def widget(ctrl_type,
                   wgt='Sphere',
                   global_size=6,
                   scale=(1, 1, 1),
                   slide=None):
            from mathutils import Vector
            bpy.ops.bonewidget.create_widget(
                global_size=global_size,
                slide=Vector(slide) if slide else Vector(),
                scale=scale,
                bones='%r' % self.bone_widgets[ctrl_type],
                widget=wgt,
            )

        widget('mch', wgt='Box', global_size=1, scale=(0.75, 0.75, 1))
        # widget('start', slide=(0, -0.5, 0))
        widget('start', wgt='Blenrig - Box', global_size=3)
        # widget('end', slide=(0, 0.5, 0))
        widget('end', wgt='Blenrig - Box', global_size=3)
        widget('in_out', global_size=7.5, slide=(0, 0.5, 0))

        return {'FINISHED'}
Ejemplo n.º 20
0
def meta_to_rigify(metarig, rigify):
    """Retarget Metarig meshes to Rigify rig"""

    pose = (metarig.data.pose_position, rigify.data.pose_position)
    (metarig.data.pose_position, rigify.data.pose_position) = ('REST', 'REST')
    utils.update(bpy.context)

    for obj in bpy.data.objects:
        for mod in obj.modifiers:
            if hasattr(mod, 'object') and mod.object == metarig:
                mod.object = rigify
                rigify_vgroups(metarig, rigify, obj)

        if obj.parent == metarig:
            if obj.parent_bone:
                rigify_bone = vg_names.get(obj.parent_bone, False)
                if rigify_bone is False:
                    rigify_bone = 'DEF-' + obj.parent_bone
                if rigify_bone and rigify_bone in rigify.data.bones:
                    mat = Get.matrix(obj)
                    # pmat = obj.matrix_parent_inverse.copy()
                    obj.parent = rigify
                    obj.parent_bone = rigify_bone
                    # obj.matrix_parent_inverse = pmat
                    Set.matrix(obj, mat)
            else:
                obj.parent = rigify

        if Is.mesh(obj):
            meshes = {obj.data}
            if hasattr(obj, 'variants'):
                # The LoDs store the mesh datas and drivers without an object
                for layer in obj.variants.layers:
                    if layer.mesh:
                        meshes.add(layer.mesh)
                    for lod in layer.lods:
                        meshes.add(lod.mesh)

            for mesh in meshes:
                if mesh:
                    rigify_drivers(metarig, rigify, mesh.shape_keys)
    for mat in bpy.data.materials:
        rigify_drivers(metarig, rigify, mat)
        rigify_drivers(metarig, rigify, mat.node_tree)

    (metarig.data.pose_position, rigify.data.pose_position) = pose
Ejemplo n.º 21
0
    def add_bones_dupli(self, context, rig):
        # Add bones then set their defaults
        root = self.get_root(rig)
        prev_bones = self.get_prev_bones(rig)
        pose_bones = []
        flip_bones = []

        def add_bone(bone_name):
            prev = rig.data.edit_bones[bone_name]

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

            bone.parent = prev.parent
            bone.use_deform = prev.use_deform

        for bone_name in prev_bones:
            add_bone(bone_name)

            if rig.pose.use_mirror_x:
                flip = utils.flip_name(bone_name)
                if (flip in rig.data.edit_bones) and (flip not in (
                        *prev_bones, *(p for (b, p) in pose_bones))):
                    # Mirrored bone exists but not selected
                    add_bone(flip)
                    flip_bones.append(flip)

        # 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]
            if (prev.name not in flip_bones):
                rig.data.bones.active = bone.bone
            bone.custom_shape = prev.custom_shape
            bone.custom_shape_transform = prev.custom_shape_transform
            bone.bone.show_wire = prev.bone.show_wire
            bone.matrix = prev.matrix
            bone.bone_group = prev.bone_group
            for lock in [
                    'location', 'rotations_4d', 'rotation_w', 'rotation',
                    'scale'
            ]:
                setattr(bone, 'lock_' + lock, getattr(prev, 'lock_' + lock))
Ejemplo n.º 22
0
    def execute(self, context):
        area = context.area
        view = area.spaces.active
        reg = view.region_3d

        # Create new camera object, add to scene, and select it
        camo = New.camera(context, name="Viewport", size=0.5)
        cam = camo.data
        Set.active(context, camo)
        # Set.active_select(camo)

        # Set Lock viewport to the camera
        view.camera = camo
        view.use_local_camera = True
        view.lock_camera = True

        # Send camera object to the current viewport rotation/location
        Set.matrix(camo, reg.view_matrix.inverted())

        # Switch to camera view
        if reg.view_perspective != 'CAMERA':
            bpy.ops.view3d.view_camera()
            # run op to prevent changing the (actual) viewport's position
        # reg.view_perspective = 'CAMERA'

        # Mirror viewport properties to the camera
        cam.lens = view.lens / 2
        cam.clip_start = view.clip_start
        cam.clip_end = view.clip_end

        # Re-center the camera view window if it was changed
        bpy.ops.view3d.view_center_camera()
        # reg.view_camera_offset = [0.0, 0.0]
        # reg.view_camera_zoom = 28

        # Setup Deph of Field
        cam.dof.use_dof = True
        # cam.dof.aperture_fstop = 0.5  # Blur amount
        # cam.dof.aperture_fstop = 2.8
        # cam.dof.focus_distance = reg.view_distance
        bpy.ops.ui.eyedropper_depth('INVOKE_DEFAULT')

        return {'FINISHED'}
Ejemplo n.º 23
0
    def execute(self, context):
        obj = context.object

        in_edit = (obj.mode == 'EDIT')
        if in_edit:
            Set.mode(context, 'OBJECT')

        active = obj.active_shape_key
        index = obj.active_shape_key_index
        pin = obj.show_only_shape_key

        obj.show_only_shape_key = True
        bpy.ops.object.shape_key_add(from_mix=True)
        while obj.active_shape_key_index > (index + 1):
            bpy.ops.object.shape_key_move(type='UP')

        shape = obj.active_shape_key
        for var in ('interpolation', 'mute', 'relative_key', 'slider_max', 'slider_min', 'value'):
            setattr(shape, var, getattr(active, var))
        # if self.keep_vertex_group:
            # shape.vertex_group = active.vertex_group

        # Redirect drivers, so that they auto update after operation
        for var in ('slider_max', 'slider_min', 'value'):
            driver = Get.driver(active, var)
            if driver:
                driver.data_path = f'key_blocks["{shape.name}"].{var}'
                # driver.data_path = driver.data_path.replace(active.name, shape.name, 1)

        name = active.name
        active.name += ".masked"
        shape.name = name

        obj.active_shape_key_index = index
        bpy.ops.object.shape_key_remove(all=False)
        obj.active_shape_key_index = index
        obj.show_only_shape_key = pin

        if in_edit:
            Set.mode(context, 'EDIT')

        return {'FINISHED'}
Ejemplo n.º 24
0
def add_placeholder_bones(rigify, obj, metarig):
    context = bpy.context

    rigify_mode = rigify.mode
    meta_mode = metarig.mode
    Set.mode(context, 'EDIT', metarig)
    Set.mode(context, 'EDIT', rigify)

    for rigify_bone in rigify.data.edit_bones.keys():
        if not rigify_bone.startswith('DEF-'):
            # Not a DEF group, so...
            continue

        meta_bone = rigify_bone[4:]
        if obj.vertex_groups.get(meta_bone):
            # Both DEF and regular name in vertex groups
            continue

        if (meta_bone in metarig.data.edit_bones):
            continue

        rbone = rigify.data.edit_bones[rigify_bone]
        mbone = metarig.data.edit_bones.new(meta_bone)
        for attr in (
            # 'bbone_curveinx', 'bbone_curveiny',
            # 'bbone_curveoutx', 'bbone_curveouty',
            # 'bbone_custom_handle_end', 'bbone_custom_handle_start',
            # 'bbone_easein', 'bbone_easeout',
            # 'bbone_handle_type_end', 'bbone_handle_type_start',
            # 'bbone_rollin', 'bbone_rollout',
            # 'bbone_scaleinx', 'bbone_scaleiny',
            # 'bbone_scaleoutx', 'bbone_scaleouty',
            # 'bbone_segments',
            'bbone_x', 'bbone_z',
            'envelope_distance', 'envelope_weight',
            'head', 'head_radius', 'tail', 'tail_radius',
            'roll',
            'inherit_scale', 'use_inherit_rotation', 'use_inherit_scale',
            'use_endroll_as_inroll',
            'use_envelope_multiply',
            'use_local_location',
            'use_relative_parent',
            ):
            setattr(mbone, attr, getattr(rbone, attr))
        if rbone.parent:
            mbone.parent = metarig.data.edit_bones.get(rbone.parent.name[4:])
            if mbone.parent:
                mbone.layers = mbone.parent.layers

    Set.mode(context, meta_mode, metarig)
    Set.mode(context, rigify_mode, rigify)
Ejemplo n.º 25
0
    def add_bones_stretch_tail(self, context, rig):
        # Add bones then set their defaults
        root = self.get_root(rig)
        prev_bones = self.get_prev_bones(rig)
        pose_bones = []

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

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

            bone.parent = prev.parent
            bone.use_deform = 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]
    def fix_toe_roll():
        """
        The Toe controller bone may have a bad automated roll, so recalculate it
        """
        mode = Get.mode(rig)
        Set.mode(bpy.context, 'EDIT', rig)
        bones = rig.data.edit_bones

        ebones = bpy.context.selected_bones
        for ebone in ebones:
            ebone.select = False

        bone = tweak = None

        def get(name):
            nonlocal bone, tweak
            bone = bones.get(name)
            tweak = bones.get(name.replace('_master', ''))
            return (bone and tweak)

        def roll(name):
            if get(name):
                bone.select = True
                bones.active = tweak
                bpy.ops.armature.calculate_roll(type='ACTIVE')
                bone.select = False

        for lr in ('L', 'R'):
            for ind in range(1, 6):
                roll(f'toe{ind}.01_master.{lr}')
            roll(f'thumb.01_master.{lr}')
            roll(f'f_index.01_master.{lr}')
            roll(f'f_middle.01_master.{lr}')
            roll(f'f_ring.01_master.{lr}')
            roll(f'f_pinky.01_master.{lr}')

        for ebone in ebones:
            ebone.select = True

        Set.mode(bpy.context, mode, rig)
Ejemplo n.º 27
0
    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'}
Ejemplo n.º 28
0
def metafy_rigify(context, rig):
    """Isolate Org bones in rig, then mimic the likely original bone layers"""

    Set.mode(context, 'EDIT', rig)

    bones = rig.data.edit_bones
    for bone in bones.values():
        bone.inherit_scale = 'ALIGNED'
        if bone.name.startswith('ORG-'):
            bone.layers = utils.layer(0)
        else:
            bones.remove(bone)

    Set.mode(context, 'POSE', rig)

    for bone in rig.pose.bones:
        bone.lock_rotation_w = False
        for index in range(3):
            bone.lock_location[index] = False
            bone.lock_rotation[index] = False
            bone.lock_scale[index] = False

    rig.data.layers = utils.layer(0)
Ejemplo n.º 29
0
        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
Ejemplo n.º 30
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'}