def remove_camera_body_track_scale_rig(rigs_list): """ Bake and remove scale rig(s). :param rigs_list: Scale rig(s). :type rigs_list: list """ attrs = ['tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz'] for node in rigs_list: body_track_attr_value = _get_rig_node_identifier(node, const.SCALE_RIG_BODY_TRACK_CONTROLS_ATTR_NAME) if body_track_attr_value == None: LOG.warn('Please select scale rig(s) only.') return nodes_to_be_baked = body_track_attr_value.split(',') rig_type = _get_rig_node_identifier(node, const.SCALE_RIG_TYPE_ATTR_NAME) camera_attr_value = _get_rig_node_identifier(node, const.SCALE_RIG_SCENE_ATTR_NAME) if rig_type == const.SCALE_RIG_TYPE_CAMERA_TRACK: nodes_to_be_baked.append(camera_attr_value) fastbake_lib.bake_attributes(nodes_to_be_baked, attrs, frame_start, frame_end, smart_bake=False) cmds.delete(node)
def _world_bake(pivot, main, loc_grp, start, end, smart_bake=False): attrs = [] if "vtx" in pivot: current_time = cmds.currentTime(query=True) for frame in range(start, end + 1): cmds.currentTime(frame, edit=True) point_pos = cmds.pointPosition(pivot, world=True) cmds.xform(loc_grp, worldSpace=True, translation=point_pos) cmds.setKeyframe(loc_grp) cmds.currentTime(current_time, edit=True) else: # point constraint, parent is pivot and child is loc_grp point_con = cmds.pointConstraint(pivot, loc_grp, maintainOffset=False) fastbake_lib.bake_attributes(loc_grp, attrs, start, end, smart_bake=smart_bake) cmds.delete(point_con) # orient constraint, parent is main and child is loc_grp orient_con = cmds.orientConstraint(main, loc_grp, maintainOffset=False) fastbake_lib.bake_attributes(loc_grp, attrs, start, end, smart_bake) cmds.delete(orient_con) return loc_grp
def _create_main_driver(parent, main): start, end = time_utils.get_maya_timeline_range_inner() main_driver_loc = cmds.duplicate(parent) cmds.setAttr(main_driver_loc[0] + ".visibility", 0) cmds.parent(main_driver_loc, parent) parent_con = cmds.parentConstraint(main, main_driver_loc) # bake attributes attrs = [] fastbake_lib.bake_attributes(main_driver_loc, attrs, start, end, smart_bake=False) cmds.delete(parent_con) # hide in outliner cmds.setAttr(main_driver_loc[0] + ".hiddenInOutliner", 1) return main_driver_loc
def main(): nodes = maya.cmds.ls(selection=True) if len(nodes) == 0: LOG.warn("Please select at least 1 object.") return # Get configuration values frame_range_mode = configmaya.get_scene_option( const.CONFIG_FRAME_RANGE_MODE_KEY, const.DEFAULT_FRAME_RANGE_MODE) custom_start_frame = configmaya.get_scene_option( const.CONFIG_FRAME_START_KEY, const.DEFAULT_FRAME_START) custom_end_frame = configmaya.get_scene_option(const.CONFIG_FRAME_END_KEY, const.DEFAULT_FRAME_END) smart_bake_state = configmaya.get_scene_option( const.CONFIG_SMART_BAKE_KEY, const.DEFAULT_SMART_BAKE_STATE) from_channelbox_state = configmaya.get_scene_option( const.CONFIG_FROM_CHANNELBOX_KEY, const.DEFAULT_FROM_CHANNELBOX_STATE) frame_range = lib.get_bake_frame_range(frame_range_mode, custom_start_frame, custom_end_frame) attrs = _get_attributes(from_channelbox_state) # Bake attributes s = time.time() ctx = tools_utils.tool_context( use_undo_chunk=True, restore_current_frame=True, use_dg_evaluation_mode=True, disable_viewport=True, disable_viewport_mode=const_utils.DISABLE_VIEWPORT_MODE_VP1_VALUE) with ctx: try: lib.bake_attributes(nodes, attrs, frame_range.start, frame_range.end, smart_bake_state) except Exception as e: LOG.error(e) finally: e = time.time() LOG.warn('Bake attribute success. Time elapsed: %r secs', e - s) return
def remove_controller(controller_node, frame_start, frame_end): """ Bake the affects of the controller node, and delete the controller. :returns: The transform node that was controlled by the given controller. :rtype: str """ # Store the selection in advance copy_keys_node = controller_node is_node_controller_rig = False attr_list = cmds.listAttr(controller_node) if ATTRIBUTE_IDENTIFIER_NAME in attr_list: children = cmds.listRelatives(controller_node, fullPath=True, children=True, type="transform") if children: controller_node = str(children[0]) is_node_controller_rig = True # Get custom attribute value to indentify rig custom_attr_value = cmds.getAttr(controller_node + "." + ATTRIBUTE_IDENTIFIER_NAME) attrs = _get_selected_channel_box_attrs() constraints = _find_constraints_from_node(controller_node) if not constraints: LOG.warn("Selected controller is not driving any object.") return # Get Driven nodes driven_nodes = [] for constraint in constraints: driven_nodes += cmds.listConnections( constraint + '.constraintParentInverseMatrix', destination=False, source=True) or [] if driven_nodes and len(driven_nodes) > 0: # Bake attributes if is_node_controller_rig is True: for driven_node in driven_nodes: _copy_parent_keys_to_child(copy_keys_node, driven_node, frame_start, frame_end) else: fastbake_lib.bake_attributes(driven_nodes, attrs, frame_start, frame_end, smart_bake=True) cmds.delete(constraints) _remove_constraint_blend_attr_from_nodes(driven_nodes) # Delete controller node and its parents if is_node_controller_rig is True: delete_list = [] parent_nodes = cmds.pickWalk(controller_node, direction="Up", recurse=True) cmds.select(clear=True) for parent_node in parent_nodes: parent_node_attr_value = cmds.getAttr( parent_node + "." + ATTRIBUTE_IDENTIFIER_NAME) if parent_node_attr_value == custom_attr_value: delete_list.append(parent_node) cmds.delete(delete_list) if cmds.objExists(controller_node): cmds.delete(controller_node) return driven_nodes
def _create_controller_screen_space(name, pivot_node, main_node, loc_grp_node, start_frame, end_frame, smart_bake, current_frame, camera): skip_translate_attr = _skip_translate_attributes(main_node) if not len(skip_translate_attr) == 0: LOG.error(("Main object all translation attributes(tx,ty,tz)" " are not available.")) # TODO: Should the locator be deleted? cmds.delete(loc_grp_node) return # World bake loc_grp_node = _world_bake(pivot_node, main_node, loc_grp_node, start_frame, end_frame, smart_bake=False) screen_loc = cmds.duplicate(loc_grp_node) cmds.parent(screen_loc, loc_grp_node) cmds.xform(screen_loc, translation=(0.0, 0.0, 0.0), rotation=(0.0, 0.0, 0.0), objectSpace=True) # Bake attributes attrs = [] fastbake_lib.bake_attributes(screen_loc, attrs, start_frame, end_frame, smart_bake=False) aim_con = cmds.aimConstraint(camera, screen_loc, aimVector=(0.0, 0.0, 1.0)) # Bake attributes fastbake_lib.bake_attributes(screen_loc, attrs, start_frame, end_frame, smart_bake=False) cmds.delete(aim_con) zero_loc = cmds.duplicate(screen_loc) cmds.parent(zero_loc, screen_loc) cmds.xform(zero_loc, translation=(0.0, 0.0, 0.0), rotation=(0.0, 0.0, 0.0), objectSpace=True) main_driver_loc = _create_main_driver(zero_loc, main_node) # Smart bake if smart_bake is True: _copy_parent_keys_to_child(main_node, zero_loc, start_frame, end_frame) # Current frame if current_frame is True: cmds.setKeyframe(screen_loc, zero_loc, time=(start_frame, start_frame)) cmds.cutKey(loc_grp_node, screen_loc, zero_loc, time=(end_frame, end_frame)) cmds.pointConstraint(main_driver_loc, main_node, maintainOffset=True) # LOD visibility _set_lod_visibility(loc_grp_node, False) _set_lod_visibility(screen_loc, False) _set_lod_visibility(zero_loc, True) _set_lod_visibility(main_driver_loc, False) # Rename cmds.rename(screen_loc, name + SCREEN_SPACE_RIG_SUFFIX) cmds.rename(zero_loc, name + SCREEN_SPACE_RIG_ZERO_SUFFIX) cmds.rename(main_driver_loc, str(name) + MAIN_DRIVER_SUFFIX_NAME) return loc_grp_node
def bake_rig_clicked(self): bake_options = self.get_bake_options() selected_items = self.rigsList.selectedItems() start_frame, end_frame = time_utils.get_maya_timeline_range_inner() if len(selected_items) == 0: LOG.warn('Atleast one rig must be selected from UI.') return """ctx = tools_utils.tool_context( use_undo_chunk=True, restore_current_frame=True, use_dg_evaluation_mode=True, disable_viewport=False) with ctx:""" cmds.select(clear=True) for sel_item in selected_items: children = self.get_all_children(sel_item) for j in children: rigName = j.text(0) object = cmds.getAttr( rigName + '.' + const.ATTRIBUTE_IDENTIFIER_NAME) if const.FREEZE_RIG_SUFFIX_NAME in rigName: self.fullBakeRadioButton.setChecked(True) if const.RIG_SUFFIX_NAME in rigName: name = rigName.split(const.RIG_SUFFIX_NAME)[0] if const.FREEZE_RIG_SUFFIX_NAME in rigName: name = rigName.split(const.FREEZE_RIG_SUFFIX_NAME)[0] if bake_options == 'full_bake': # cmds.bakeResults(object, time=(start_frame, end_frame), simulation=True) fastbake_lib.bake_attributes([object], [], start_frame, end_frame, False) if bake_options == 'smart_bake': nodes_list = cmds.listConnections( name + const.SCREEN_Z_MASTER_NAME) for node in nodes_list: if 'screenX_condition' in node: x_node = node if 'screenY_condition' in node: y_node = node cmds.select(object) attrs = ['tx', 'ty', 'tz'] # First key on objects existing key frames for frame in self.get_prebake_frames_list_from_node( object): oma.MAnimControl.setCurrentTime(om.MTime(frame)) cmds.setKeyframe(attribute=attrs) # Key screen z depth attribute frames keys_list = cmds.keyframe( rigName + '.' + const.SCREEN_Z_DEPTH_ATTR_NAME, query=True) if keys_list: for frame in keys_list: oma.MAnimControl.setCurrentTime( om.MTime(frame)) cmds.setKeyframe(attribute=attrs) # Check condition result node and set keyframe for i in range(start_frame, end_frame + 1): oma.MAnimControl.setCurrentTime(om.MTime(i)) x_changed = \ cmds.getAttr(x_node + '.outColor')[0][0] y_changed = \ cmds.getAttr(y_node + '.outColor')[0][0] if x_changed or y_changed: cmds.setKeyframe(attribute=attrs) cmds.select(clear=True) self.delete_rig_clicked() self.refresh_rigsList() return
def create_freeze_rig_clicked(self): nameLineEdit = self.nameLineEdit.text() rigsList = self.rigsList cam_tfm = self.get_vp_camera() if cam_tfm is None: LOG.warn('Please select a camera.') return check_name = self.check_name_exists(const.FREEZE_RIG_SUFFIX_NAME, nameLineEdit, rigsList) valid_name_list, same_name_used = check_name if valid_name_list is not True or same_name_used is not False: LOG.warn('Invalid freeze rig name.') return do_camera_space = self.camera_space_action.isChecked() do_world_space = self.world_space_action.isChecked() use_anim_layer = self.animlayer_action.isChecked() # When making a freeze rig we always assume the full frame # range will be baked - NO smart bake. LOG.warn('Force full bake for Freeze Rig.') self.fullBakeRadioButton.setChecked(True) start_frame, end_frame = time_utils.get_maya_timeline_range_inner() sel = cmds.ls(orderedSelection=True, transforms=True) or [] names = nameLineEdit.split(',') """ctx = tools_utils.tool_context( use_undo_chunk=True, restore_current_frame=True, use_dg_evaluation_mode=True, disable_viewport=False) with ctx:""" for sel_item, name_item in zip(sel, names): freeze_rig_name = name_item + const.FREEZE_RIG_SUFFIX_NAME animLayerName = name_item + const.FREEZE_RIG_ANIM_LAYER # Check if object has existing point constraint already. has_constraints = transform_has_constraints(sel_item) if has_constraints is True: LOG.warn( 'Selected object(s) already have constraints: %r.', sel_item) continue # Get the selected item's depth, if we don't have # anything, we cannot continue. dlist = self.calc_distance(cam_tfm, sel_item, 0) if len(dlist) == 0: continue if do_camera_space: # Camera space bake self.create_rig( cam_tfm, sel_item, dlist, name_item, const.FREEZE_RIG_SUFFIX_NAME) cmds.cutKey( name_item + const.FREEZE_RIG_SUFFIX_NAME, clear=True, at=const.SCREEN_Z_DEPTH_ATTR_NAME) else: # World space bake # Create a static temp group temp_grp = cmds.group(empty=True) con = cmds.parentConstraint( sel_item, temp_grp, maintainOffset=False) cmds.delete(con) fastbake_lib.bake_attributes([temp_grp], [], start_frame, end_frame, False) self.create_rig(cam_tfm, sel_item, dlist, name_item, const.FREEZE_RIG_SUFFIX_NAME) # Calc full freeze list dlist = self.calc_distance(cam_tfm, temp_grp, 0) if use_anim_layer is False: # Set keyframes on screenzdepth attribute, # with no anim layer. set_z_depth_keyframes( freeze_rig_name, start_frame, end_frame, dlist) else: # Make the anim layer, and add our freeze rig # node to the layer. cmds.select(freeze_rig_name, replace=True) cmds.animLayer( animLayerName, addSelectedObjects=True) cmds.select(clear=True) set_z_depth_keyframes( freeze_rig_name, start_frame, end_frame, dlist, anim_layer_name=animLayerName) # Delete temp group cmds.delete(temp_grp) return
def create_rig(self, camera, object, dlist, name, rigName): """ctx = tools_utils.tool_context( use_undo_chunk=True, restore_current_frame=True, use_dg_evaluation_mode=True, disable_viewport=False) with ctx:""" start_frame, end_frame = time_utils.get_maya_timeline_range_inner() # Create main group main_grp = cmds.group(empty=True, n=name + rigName) # Delete all transform attributes attr_list = const.TRANSFORM_ATTR_LIST + ['visibility'] for attr in attr_list: cmds.setAttr(main_grp + '.' + attr, keyable=False, lock=True) # Add custom attributes cmds.addAttr(main_grp, ln='screenX', nn='Screen X', at='float', k=True) cmds.addAttr(main_grp, ln='screenY', nn='Screen Y', at='float', k=True) cmds.addAttr(main_grp, ln=const.SCREEN_Z_DEPTH_ATTR_NAME, nn='Screen Z depth', at='float', k=True) cmds.addAttr(main_grp, ln=const.ATTRIBUTE_IDENTIFIER_NAME, nn=const.ATTRIBUTE_IDENTIFIER_NICE_NAME, dt='string', k=False) cmds.setAttr(main_grp + '.' + const.ATTRIBUTE_IDENTIFIER_NAME, str(object), type='string') # Set keyframes on screezdepth attribute frames_list = self.get_prebake_frames_list_from_node(object) for i, frame in enumerate(frames_list): cmds.setKeyframe(main_grp, at=const.SCREEN_Z_DEPTH_ATTR_NAME, t=frame, v=dlist[i]) # Clear name text self.nameLineEdit.clear() self.nameLineEdit.clearFocus() # Create screez master group screenz_master_grp = cmds.group(em=True, n=name + const.SCREEN_Z_MASTER_NAME) cmds.setAttr(screenz_master_grp + '.visibility', 0) # Add screen X/Y copy attributes cmds.addAttr(screenz_master_grp, ln='copyScreenX', nn='Screen X copy', at='float') cmds.addAttr(screenz_master_grp, ln='copyScreenY', nn='Screen Y copy', at='float') cmds.setAttr(screenz_master_grp + '.copyScreenX', cb=False) cmds.setAttr(screenz_master_grp + '.copyScreenY', cb=False) cmds.parent(screenz_master_grp, main_grp) con = cmds.parentConstraint(self.get_vp_camera(), screenz_master_grp) fastbake_lib.bake_attributes([screenz_master_grp], [], start_frame, end_frame, False) cmds.delete(con) # Create screen Z-depth connections cmds.connectAttr(main_grp + '.' + const.SCREEN_Z_DEPTH_ATTR_NAME, screenz_master_grp + '.scaleX', f=True) cmds.connectAttr(main_grp + '.' + const.SCREEN_Z_DEPTH_ATTR_NAME, screenz_master_grp + '.scaleY', f=True) cmds.connectAttr(main_grp + '.' + const.SCREEN_Z_DEPTH_ATTR_NAME, screenz_master_grp + '.scaleZ', f=True) # Create screen X/Y master group screen_xy_master_grp = cmds.group(em=True, n=name + const.SCREEN_XY_MASTER_NAME) cmds.setAttr(screen_xy_master_grp + '.visibility', 0) attr_list = ['rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'visibility'] for attr in attr_list: cmds.setAttr(screen_xy_master_grp + '.' + attr, keyable=False, lock=True) cmds.parent(screen_xy_master_grp, screenz_master_grp, r=True) con = cmds.pointConstraint(object, screen_xy_master_grp) fastbake_lib.bake_attributes([screen_xy_master_grp], [], start_frame, end_frame, False) cmds.delete(con) cmds.setAttr(screen_xy_master_grp + '.translateZ', lock=True) # Create screen X/Y connections cmds.connectAttr(screen_xy_master_grp + '.translateX', main_grp + '.screenX', f=True) cmds.connectAttr(screen_xy_master_grp + '.translateY', main_grp + '.screenY', f=True) cmds.connectAttr(screen_xy_master_grp + '.translateX', screenz_master_grp + '.copyScreenX', f=True) cmds.connectAttr(screen_xy_master_grp + '.translateY', screenz_master_grp + '.copyScreenY', f=True) fastbake_lib.bake_attributes([main_grp], ['screenX', 'screenY'], start_frame, end_frame, False) fastbake_lib.bake_attributes([screenz_master_grp], ['copyScreenX', 'copyScreenY'], start_frame, end_frame, False) cmds.connectAttr(main_grp + '.screenX', screen_xy_master_grp + '.translateX', f=True) cmds.connectAttr(main_grp + '.screenY', screen_xy_master_grp + '.translateY', f=True) # Create condition node network screenx_condition_node = cmds.shadingNode( 'condition', au=True, n=name + '_screenX_condition') screeny_condition_node = cmds.shadingNode( 'condition', au=True, n=name + '_screenY_condition') cmds.connectAttr(main_grp + '.screenX', screenx_condition_node + '.firstTerm', f=True) cmds.connectAttr(screenz_master_grp + '.copyScreenX', screenx_condition_node + '.secondTerm', f=True) cmds.connectAttr(main_grp + '.screenY', screeny_condition_node + '.firstTerm', f=True) cmds.connectAttr(screenz_master_grp + '.copyScreenY', screeny_condition_node + '.secondTerm', f=True) attr_list = const.TRANSFORM_ATTR_LIST + ['visibility'] for attr in attr_list: cmds.setAttr(screenz_master_grp + '.' + attr, lock=True) cmds.pointConstraint(screen_xy_master_grp, object) # Select the master control. cmds.select(main_grp, replace=True) self.refresh_rigsList()
def bakeRigBtn(self): bake_options = self.bakeOptions() selected_items = self.rigs_list.selectedItems() start_frame, end_frame = time_utils.get_maya_timeline_range_inner() if len(selected_items) == 0: _display_warning_ui( 'at least one rig must be selected from Rigs list.') return try: cmds.refresh(suspend=True) mel.eval('paneLayout -e -manage false $gMainPane') ctx = tools_utils.tool_context( use_undo_chunk=True, restore_current_frame=True, use_dg_evaluation_mode=True, disable_viewport=False) with ctx: cmds.select(clear=True) for sel_item in selected_items: children = self.getAllChildren(sel_item) for j in children: rigName = j.text(0) object = cmds.getAttr( rigName + '.' + ATTRIBUTE_IDENTIFIER_NAME) if FREEZE_RIG_SUFFIX_NAME in rigName: self.full_bake_rdo_btn.setChecked(True) if RIG_SUFFIX_NAME in rigName: name = rigName.split(RIG_SUFFIX_NAME)[0] if FREEZE_RIG_SUFFIX_NAME in rigName: name = rigName.split(FREEZE_RIG_SUFFIX_NAME)[0] if bake_options == 'full_bake': # cmds.bakeResults(object, time=(start_frame, end_frame), simulation=True) fastbake_lib.bake_attributes([object], [], start_frame, end_frame, False) if bake_options == 'smart_bake': nodes_list = cmds.listConnections( name + SCREEN_Z_MASTER_NAME) for node in nodes_list: if 'screenX_condition' in node: x_node = node if 'screenY_condition' in node: y_node = node cmds.select(object) attrs = ['tx', 'ty', 'tz'] # First key on objects existing key frames for frame in self.getPreBakeFramesListFromNode( object): oma.MAnimControl.setCurrentTime(om.MTime(frame)) cmds.setKeyframe(attribute=attrs) # Key screen z depth attribute frames keys_list = cmds.keyframe( rigName + '.' + SCREEN_Z_DEPTH_ATTR_NAME, query=True) if keys_list: for frame in keys_list: oma.MAnimControl.setCurrentTime( om.MTime(frame)) cmds.setKeyframe(attribute=attrs) # Check condition result node and set keyframe for i in range(start_frame, end_frame + 1): oma.MAnimControl.setCurrentTime(om.MTime(i)) x_changed = \ cmds.getAttr(x_node + '.outColor')[0][0] y_changed = \ cmds.getAttr(y_node + '.outColor')[0][0] if x_changed or y_changed: cmds.setKeyframe(attribute=attrs) cmds.select(clear=True) self.deleteRigBtn() self.refreshRigsList() except(NameError, ValueError, TypeError) as e: print e finally: mel.eval('paneLayout -e -manage true $gMainPane') cmds.refresh(suspend=False) return
def create_camera_body_track_scale_rig(name, camera, scene, body_track_controls, scale_rig_type): """ Create a camera track scale rig. :param name: Scale rig name. :type name: str :param camera: Camera node. :type camera: Transform node :param scene: Scene node. :type scene: Transform node or None :param body_track_controls: Body track controls transforms. :type body_track_controls: Transforms list or [] :param scale_rig_type: Which type of scale rig to be created? mmSolver.tools.camerabodytrackscalerigbake.constant.SCALE_RIG_LIST. :type: str :rtype: [str] """ # Create camera witness attrs = ['tx', 'ty', 'tz', 'rx', 'ry', 'rz'] controller_type = createcontroller2_const.CONTROLLER_TYPE_WORLD_SPACE if scale_rig_type == const.SCALE_RIG_TYPE_BODY_TRACK: camera_witness = _create_scale_rig_main_grp(name+suffix+main_grp_suffix, str(scene), body_track_controls, const.SCALE_RIG_TYPE_BODY_TRACK) if scale_rig_type == const.SCALE_RIG_TYPE_CAMERA_TRACK: camera_witness = cmds.group(name=name+suffix, empty=True) parent_con = cmds.parentConstraint(camera, camera_witness, maintainOffset=False) camera_witness = cmds.ls(camera_witness) fastbake_lib.bake_attributes(camera_witness, attrs, frame_start, frame_end, smart_bake=False) cmds.delete(parent_con) # Create rig controls witness body_track_controls_witness = [] for control in body_track_controls: control_witness = createcontroller2_lib.create_controller(name, control, control, cmds.spaceLocator(), frame_start, frame_end, controller_type, smart_bake=False, camera=None) body_track_controls_witness.append(control_witness[0]) # Reparent children_nodes = [tfm_utils.TransformNode(node=n) for n in body_track_controls_witness] parent_node = tfm_utils.TransformNode(node=camera_witness[0]) reparent2_lib.reparent(children_nodes, parent_node, frame_range_mode='timeline_inner', start_frame=frame_start, end_frame=frame_end, bake_mode='full_bake', rotate_order_mode='use_existing', delete_static_anim_curves=False) _break_scale_attributes(children_nodes) # Body track scale rig if scale_rig_type == const.SCALE_RIG_TYPE_BODY_TRACK: # Break body track controls witness scale attributes body_track_control_nodes = [tfm_utils.TransformNode(node=n) for n in body_track_controls] _break_scale_attributes(body_track_control_nodes) # Scale constraint to body track controls for node in body_track_control_nodes: cmds.scaleConstraint(parent_node.get_node(), node.get_node(), maintainOffset=True) cmds.select(parent_node.get_node(), replace=True) # Camera track scale rig if scale_rig_type == const.SCALE_RIG_TYPE_CAMERA_TRACK: grand_parent = _create_scale_rig_main_grp(name+suffix+main_grp_suffix, str(scene), body_track_controls, const.SCALE_RIG_TYPE_CAMERA_TRACK) con = cmds.parentConstraint(parent_node.get_node(), grand_parent, maintainOffset=False) cmds.delete(con) grand_parent_node = tfm_utils.TransformNode(node=grand_parent) reparent2_lib.reparent([parent_node], grand_parent_node, frame_range_mode='timeline_inner', start_frame=frame_start, end_frame=frame_end, bake_mode='full_bake', rotate_order_mode='use_existing', delete_static_anim_curves=False) _break_scale_attributes([parent_node]) # Break scene scale attributes node = cmds.ls(scene, long=True, type='transform') scene_node = tfm_utils.TransformNode(node=node[0]) _break_scale_attributes([scene_node]) cmds.parentConstraint(grand_parent, scene, maintainOffset=True) cmds.scaleConstraint(grand_parent, scene, maintainOffset=True) # Create scale expression attrs = ['sx', 'sy', 'sz'] parent = parent_node.get_node() for attr in attrs: exp = str(str(parent)+'.'+attr)+'='+'1'+'/'+str(grand_parent)+'.'+attr cmds.expression(string=exp, object=str(parent), alwaysEvaluate=True, unitConversion='all') cmds.select(grand_parent, replace=True)
def remove_controller(controller_node, frame_start, frame_end, attrs=None): """ Bake the affects of the controller node, and delete the controller. :param controller_node: The controller node. :type controller_node: str :param frame_start: First frame to bake. :type frame_start: int :param frame_end: Last frame to bake. :type frame_end: int :param attrs: List of attributes to bake. If None, all transform, rotate and scale attributes are baked. :type attrs: [str, ..] or None :returns: The list of transform nodes that were controlled by the given controller. :rtype: [str, ..] """ assert isinstance(controller_node, pycompat.TEXT_TYPE) assert cmds.objExists(controller_node) assert isinstance(frame_start, int) assert isinstance(frame_end, int) if attrs is None: attrs = TRANSFORM_ATTRS assert isinstance(attrs, list) if len(attrs) == 0: attrs = TRANSFORM_ATTRS # Find controller nodes. controller_nodes = [] is_controller_rig = _is_rig_node(controller_node) if is_controller_rig is False: controller_nodes = [controller_node] else: children = cmds.ls( controller_node, dag=True, long=True, type='transform') or [] controller_nodes = [n for n in children if _is_rig_node(n)] # Sort nodes by depth, deeper nodes first, so we do do not # remove parents before children. controller_nodes = node_utils.sort_nodes_by_depth(controller_nodes, reverse=True) # Find constraints. constraints = [] for node in controller_nodes: constraints += _find_constraints_from_node(node) if len(constraints) == 0: LOG.warn('Selected controller is not driving any object(s).') return [] # Get Driven nodes. driven_nodes = [] for constraint in constraints: attr = constraint + '.constraintParentInverseMatrix' driven_nodes += cmds.listConnections( attr, destination=False, source=True) or [] if len(driven_nodes) == 0: LOG.warn('Selected controller is not driving any object(s).') return [] # Find nodes to be deleted. nodes_to_delete = [] for node in controller_nodes: controller_id = _get_rig_node_identifier(node) parent_nodes = node_utils.get_node_parents(node) parent_node_ids = [_get_rig_node_identifier(n) for n in parent_nodes] nodes_to_delete += [ n for n, id_ in zip(parent_nodes, parent_node_ids) if id_ == controller_id ] has_extra_parents = len(nodes_to_delete) == 0 # Bake driven attributes. if is_controller_rig is True and has_extra_parents is False: for driven_node in driven_nodes: # If the original top-level controller node was "smart # baked", then set keys on all the same frames, therefore # re-creating the original keyframe times. _set_keyframes_at_source_node_key_times(controller_node, driven_node, frame_start, frame_end) else: fastbake_lib.bake_attributes(driven_nodes, attrs, frame_start, frame_end, smart_bake=True) # Delete nodes and clean up. if len(constraints) > 0: cmds.delete(constraints) _remove_constraint_blend_attr_from_nodes(driven_nodes) nodes_to_delete = [n for n in nodes_to_delete if cmds.objExists(n)] if len(nodes_to_delete) > 0: cmds.delete(nodes_to_delete) return driven_nodes