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
