def execute(self, context): obj = context.object for m in obj.modifiers: if m.type == 'ARMATURE': rig = m.object if rig in context.selected_objects: bone_name = rig.data.bones.active.name bone = rig.pose.bones[bone_name] break keys = obj.data.shape_keys.key_blocks if self.active: key = obj.active_shape_key if key == keys[0]: self.report({'WARNING'}, "Active shape key is the base shape") return {'CANCELLED'} if Get.driver(key, 'value'): key.driver_remove('value') # if key.name in bone: # del bone[key.name] self.add_driver(key, bone) else: for key in keys[1:]: if (self.filter and (self.filter not in key.name)): continue if not (self.overwrite or (not Get.driver(key, 'value'))): continue self.add_driver(key, bone) return {'FINISHED'}
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'}
def transfer_by_pos2(context, obj, selobj, ob_key, precision, scale): if (selobj.data.shape_keys is None): selobj.shape_key_add(from_mix=False).name = "Basis" selobj.active_shape_key_index = 0 selobj_keys = selobj.data.shape_keys.key_blocks index = 0 for (del_index, del_key) in enumerate(selobj_keys): if ob_key.name == del_key.name: index = del_index selobj.shape_key_remove(del_key) break selob_key = selobj.shape_key_add(name=ob_key.name, from_mix=False) if index: active = selobj.active_shape_key_index selobj.active_shape_key_index = len(selobj_keys) - 1 while selobj_keys[index] != selob_key: bpy.ops.object.shape_key_move((dict(object=selobj)), type='UP') selobj.active_shape_key_index = active # find matches using a rounding precision of 5 and a scale of 1 ddict = find_doubles_with_other(obj, selobj) nomatch = ddict[1] ddict = ddict[0] copydoublesco(ob_key, selob_key, ddict) # set precision and scale to use for the second pass # generates a dictionary which archives verts in active obj:matching vert in selected obj pass2 = generate_rounded_pos_dict(obj, precision, scale) round_pass(obj, selobj, ob_key, selob_key, nomatch, scale, precision, pass2) selob_key.vertex_group = ob_key.vertex_group selob_key.relative_key = ob_key.relative_key selob_key.slider_min = ob_key.slider_min selob_key.slider_max = ob_key.slider_max selob_key.value = ob_key.value driver = Get.driver(ob_key, 'value') if driver: utils.copy_driver(driver, selob_key, 'value')
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'}
def set_influence(): def get_src(constraint): for src in srcs: for con in src.constraints: if con == constraint: return src for constraint in constraints: driver = Get.driver(constraint, 'influence') if driver: (constraint, prop) = Get.controls_from_driver(driver)[0] src = constraint else: prop = 'influence' src = get_src(constraint) if src is None: continue if influence is None: # mode = 'apply' pass elif influence is False: # mode = 'invert' setattr(constraint, prop, not getattr(constraint, prop)) else: # mode = 'set' setattr(constraint, prop, influence) # key_con = prefs.get("Keyframe Constraints Inf") # if key_con: if insert_key: keyframe.prop( context, constraint, prop, group=keyframe.group_name(src), options={'INSERTKEY_NEEDED'}, )
def driver(src, path, **kargs): driver_type = kargs.get('driver_type', None) # 'AVERAGE', 'Sum Values', 'SCRIPTED', 'Minimum Value', 'Maximum Value expression = kargs.get('expression', None) frames = kargs.get('frames', list()) # keyframe.co for the driver's fcurve name = kargs.get('name', "var") # Name of the variable added to the driver overwrite = kargs.get('overwrite', False) # Delete the existing driver rotation_mode = kargs.get('rotation_mode', 'AUTO') target = kargs.get('target', None) target_path = kargs.get('target_path', '') transform_space = kargs.get('transform_space', 'LOCAL_SPACE') transform_type = kargs.get('transform_type', 'LOC_X') var_type = kargs.get('var_type', None) # 'SINGLE_PROP', 'TRANSFORMS', 'Rotational Difference', 'Distance' if var_type is None: if target and (not target_path): var_type = 'TRANSFORMS' else: var_type = 'SINGLE_PROP' Driver = Get.driver(src, path) if not Driver: Driver = src.driver_add(path) overwrite = True if overwrite: while Driver.keyframe_points: Driver.keyframe_points.remove(Driver.keyframe_points[0]) if frames: if overwrite: Driver.extrapolation = 'LINEAR' while Driver.modifiers: Driver.modifiers.remove(Driver.modifiers[0]) Driver.keyframe_points.add(len(frames)) for key, co in zip(Driver.keyframe_points[:], frames): key.interpolation = 'LINEAR' key.co = co driver = Driver.driver if overwrite: if (expression is None): if (driver_type is None): driver_type = 'AVERAGE' elif (driver.type == 'SCRIPTED'): driver.expression = name while driver.variables: driver.variables.remove(driver.variables[0]) if expression is not None: driver.expression = expression if driver_type: driver.type = driver_type var = driver.variables.new() var.name = name var.type = var_type var_target = var.targets[0] if target: is_pose = Is.posebone(target) is_bone = Is.bone(target) or Is.editbone(target) is_obj = Is.object(target) if is_obj: var_target.id = target elif (is_pose or is_bone): var_target.id = target.id_data var_target.bone_target = target.name if target_path and (not target_path.startswith( ('pose.bones', 'bones'))): if is_pose: text = f'pose.bones["{target.name}"]' else: text = f'bones["{target.name}"]' if (target_path[0] != '['): text += '.' target_path = text + target_path else: try: var_target.id = target except: var_target.id = target.id_data var_target.data_path = target_path var_target.rotation_mode = rotation_mode var_target.transform_space = transform_space var_target.transform_type = transform_type return Driver
def pose_func(self, context, bone): rig = bone.id_data bones = rig.pose.bones bbones = ('bbone', 'bbone_start', 'bbone_end', 'bbone_head', 'bbone_in', 'bbone_out') def parse(bbone): self.bones[bbone] = rig # Prep the widget for removal wgt = bbone.custom_shape if wgt: self.widgets.add(wgt) # Remove stretch constraints for con in list(bone.constraints): if (getattr(con, 'target', None) == rig) and (con.subtarget == bbone.name): bone.constraints.remove(con) # Remove Custom Handle if bone.bbone_custom_handle_start == bbone: bone.bone.bbone_custom_handle_start = None bone.bone.bbone_handle_type_start = 'AUTO' if bone.bbone_custom_handle_end == bbone: bone.bone.bbone_custom_handle_end = None bone.bone.bbone_handle_type_end = 'AUTO' for bbone_name in bbones: bbone = bones.get(get_name(bone, bbone_name)) if not bbone: continue parse(bbone) if bbone_name in ('bbone_start', 'bbone_end') and Get.mirror_bone(bbone): (prefix, replace, suffix, number) = utils.flip_name(bone.name, only_split=True) center_name = prefix + suffix + number center = bones.get(center_name) if center: parse(center) # Remove BBone drivers if bbone_name in ('bbone_in', 'bbone_out'): in_out = bbone_name.split('_')[1] in_outs = ( f'bbone_curve{in_out}x', f'bbone_curve{in_out}y', f'bbone_roll{in_out}', f'bbone_scale{in_out}x', f'bbone_scale{in_out}y', f'bbone_ease{in_out}', ) for bbone_in_out in in_outs: Driver = Get.driver(bone, bbone_in_out) try: target = Driver.driver.variables[0].targets[0] except: continue if (target.bone_target == bbone.name) and (target.id == rig): bone.driver_remove(bbone_in_out)