def group_cloth():
top_ = mc.ls(assemblies=1)
clothes = [i for i in top_ if i.startswith("cloth:")]
if clothes:
create_group.create_group("Cloth")
for cloth in clothes:
create_group.create_group(cloth, "Cloth")
def group_camera():
create_group.create_group("Camera")
exclude_grp = ['frontShape', 'perspShape', 'sideShape', 'topShape']
for camera in mc.ls(cameras=1):
if camera not in exclude_grp:
transform = mc.listRelatives(camera, p=1)[0]
mc.parent(transform, "Camera")
def main(file_name, local):
logger = logging.getLogger("Hair start")
new_file.new_file()
# copy low mdl publish file as mdl file
context = pipeFile.PathDetails.parse_path(file_name)
project = context.project
entity_type = context.entity_type
asset_type = context.asset_type
asset_name = context.asset_name
# reference in mdl publish file
asset_type_short_name = context.asset_type_short_name
mdl_publish_file = pipeFile.get_task_publish_file(project, entity_type,
asset_type, asset_name,
"HighMdl", "HighMdl")
if not os.path.isfile(mdl_publish_file):
logger.warning("No mdl file published.")
quit_maya.quit_maya()
return
create_reference.create_reference(mdl_publish_file)
# create sculp group
sculp_group = "%s_%s_SCULP" % (asset_type_short_name, asset_name)
create_group.create_group(sculp_group)
if local:
create_project.create_project(os.path.dirname(file_name))
# create project
save_as.save_as(file_name)
logger.info("%s publish successful!" % file_name)
if not local:
quit_maya.quit_maya()
def create_camera(seq, shot):
create_group.create_group("Camera")
camera_name = "cam_%s_%s" % (seq, shot)
cam = mc.camera()
mc.rename(cam[1], "%sShape" % camera_name)
camera = mc.rename(cam[0], camera_name)
mc.parent(camera, "Camera")
def group_vfx():
top_ = mc.ls(assemblies=1)
vfxes = [i for i in top_ if i.startswith("vfx:")]
if vfxes:
create_group.create_group("Vfx")
for vfx in vfxes:
create_group.create_group(vfx, "Vfx")
def import_lights(context):
light_file = pipeFile.get_task_file(context.project, context.sequence,
"c000", "MainLgt", "MainLgt",
"maya_shot_light", "")
if os.path.isfile(light_file):
maya_import.maya_import(light_file)
else:
create_group.create_group("Lights")
def create_yeti_node(asset_type, asset_name):
# load yeti plugin
load_plugin.load_plugin("pgYetiMaya.mll")
yeti_name = "%s_%s_body_pgYetiMaya" % (asset_type, asset_name)
node = mc.createNode("pgYetiMaya")
transform_node = mc.listRelatives(node, p=1)[0]
mc.rename(transform_node, yeti_name)
yeti_group_name = "%s_%s_yetiNode" % (asset_type, asset_name)
create_group.create_group(yeti_group_name)
create_group.create_group(yeti_name, yeti_group_name)
def create_hair_group(asset_type, asset_name):
hair_grp_name = "%s_%s_HAIR" % (asset_type, asset_name)
hair_system_name = "%s_%s_hairsystem_grp" % (asset_type, asset_name)
hair_rig_name = "%s_%s_hair_rig_grp" % (asset_type, asset_name)
hair_curve_name = "%s_%s_hair_curve_grp" % (asset_type, asset_name)
hair_render_name = "%s_%s_hair_render_grp" % (asset_type, asset_name)
create_group.create_group(hair_grp_name)
for grp in [
hair_system_name, hair_rig_name, hair_curve_name, hair_render_name
]:
create_group.create_group(grp, hair_grp_name)
def main(file_name, local):
logger = logging.getLogger("Set start")
new_file.new_file()
context = pipeFile.PathDetails.parse_path(file_name)
sequence = context.sequence
create_group.create_group("%s_env" % sequence)
# create network node
save_as.save_as(file_name)
logger.info("%s publish successful!" % file_name)
if not local:
quit_maya.quit_maya()
def group_assets():
char_assets = get_assets.get_assets("char")
if char_assets:
create_group.create_group("Char")
mc.parent(char_assets, "Char")
prop_assets = get_assets.get_assets("prop") + get_assets.get_assets(
"cprop")
if prop_assets:
create_group.create_group("Prop")
mc.parent(prop_assets, "Prop")
log.info("group assets done.")
def import_my_ass(ass_path):
load_plugin.load_plugin("mtoa.mll")
base_name = os.path.basename(ass_path)
base_name = base_name.strip("@")
name_list = base_name.split("@")
for index, i in enumerate(name_list[:-1]):
parent = "standin" if index == 0 else name_list[index - 1]
create_group.create_group(i, parent)
ass_shape_name = os.path.splitext(name_list[-1])[0]
ass_shape = mc.createNode("aiStandIn",
name=ass_shape_name,
parent=name_list[-2])
mc.setAttr("%s.dso" % ass_shape, ass_path, type="string")
def reference_in_env(context):
set_ad_path = pipeFile.get_task_file(context.project, context.sequence,
"c000", "Set", "Set",
"maya_shot_definition", "")
if not os.path.isfile(set_ad_path):
print "%s is not an exist file" % set_ad_path
return
assemb = Assembly.Assembly()
node_name = "%s_%s_set" % (context.sequence, "c000")
node = assemb.reference_ad(node_name, set_ad_path)
create_group.create_group("Env")
mc.parent(node, "Env")
return node
def rebuild_scene():
# get logger
logger = logging.getLogger(__name__)
# get conf data
anim_edit_data = get_anim_edit_data()
name = anim_edit_data.get("owner")
def_path = anim_edit_data.get("definition")
# create AR node
assemb = Assembly.Assembly()
ar_node = assemb.reference_ad(name, def_path)
logger.info("Create %s done." % ar_node)
# edit
edit(anim_edit_data)
logger.info("anim edit done.")
# set parent
create_group.create_group("Env")
mc.parent(ar_node, "Env")
logger.info("Set parent done.")
def main(file_name, local):
logger = logging.getLogger("MainLgt start")
new_file.new_file()
create_group.create_group("Lights")
# AR set AD file
context = pipeFile.PathDetails.parse_path(file_name)
project = context.project
sequence = context.sequence
set_ad_file = pipeFile.get_task_file(project, sequence, "c000", "Set", "Set", "maya_shot_definition", "")
assemb = Assembly.Assembly()
node = assemb.reference_ad("%s_c000_set" % sequence, set_ad_file)
create_group.create_group("Env")
mc.parent(node, "Env")
# set Shd active
assemb.set_active("Shd")
save_as.save_as(file_name)
logger.info("%s publish successful!" % file_name)
if not local:
quit_maya.quit_maya()
def import_ass(self, import_all=True):
items = self.get_selected_items(import_all)
if not items:
return
model_group = items[0].path.split("@")[1]
if not mc.objExists("standin"):
create_group.create_group("standin")
pd = QProgressDialog("Ass Importing...", 'Cancel', 0, len(items))
pd.setWindowModality(Qt.WindowModal)
pd.setMinimumWidth(350)
pd.show()
for index, item in enumerate(items):
pd.setValue(index)
if pd.wasCanceled():
break
ass_path = item.path
import_ass.import_my_ass(ass_path)
# add namespace
asset_name = model_group.split("_")[1]
add_namespace.add_namespace(asset_name, model_group)
def main(file_name, local):
logger = logging.getLogger("MidMdl start")
new_file.new_file()
context = pipeFile.PathDetails.parse_path(file_name)
asset_type = context.asset_type
asset_name = context.asset_name
asset_type_short_name = context.asset_type_short_name
model_name = "%s_%s_MODEL" % (asset_type_short_name, asset_name)
# create default group
mc.group(name=model_name, empty=1)
poly_group = "%s_%s_POLY" % (asset_type_short_name, asset_name)
create_group.create_group(poly_group, model_name)
backup_group = "%s_%s_BACKUP" % (asset_type_short_name, asset_name)
create_group.create_group(backup_group, model_name)
if asset_type == "Character":
hair_mdl_grp = "hair_model_grp"
create_group.create_group(hair_mdl_grp, backup_group)
brow_grp = "brow_grp"
create_group.create_group(brow_grp, backup_group)
left_brow_grp = "left_brow_grp"
create_group.create_group(left_brow_grp, brow_grp)
right_brow_grp = "right_brow_grp"
create_group.create_group(right_brow_grp, brow_grp)
eyelash_grp = "eyelash_grp"
create_group.create_group(eyelash_grp, backup_group)
left_eyelash_grp = "left_eyelash_grp"
create_group.create_group(left_eyelash_grp, eyelash_grp)
right_eyelash_grp = "right_eyelash_grp"
create_group.create_group(right_eyelash_grp, eyelash_grp)
cloth_low_grp = "cloth_low_grp"
create_group.create_group(cloth_low_grp, backup_group)
body_group = "body_grp"
create_group.create_group(body_group, poly_group)
mouth_group = "mouth_grp"
create_group.create_group(mouth_group, poly_group)
gums_grp = "gums_grp"
create_group.create_group(gums_grp, mouth_group)
up_gums_grp = "up_gums_grp"
create_group.create_group(up_gums_grp, gums_grp)
down_gums_grp = "down_gums_grp"
create_group.create_group(down_gums_grp, gums_grp)
eye_group = "eye_grp"
create_group.create_group(eye_group, poly_group)
left_eyeball_grp = "left_eyeball_grp"
create_group.create_group(left_eyeball_grp, eye_group)
right_eyeball_grp = "right_eyeball_grp"
create_group.create_group(right_eyeball_grp, eye_group)
left_eyeball_inside_grp = "left_eyeball_inside_grp"
create_group.create_group(left_eyeball_inside_grp, eye_group)
right_eyeball_inside_grp = "right_eyeball_inside_grp"
create_group.create_group(right_eyeball_inside_grp, eye_group)
cloth_up_grp = "cloth_up_grp"
create_group.create_group(cloth_up_grp, poly_group)
cloth_down_grp = "cloth_down_grp"
create_group.create_group(cloth_down_grp, poly_group)
shoe_grp = "shoe_grp"
create_group.create_group(shoe_grp, poly_group)
left_shoe_grp = "left_shoe_grp"
create_group.create_group(left_shoe_grp, shoe_grp)
right_shoe_grp = "right_shoe_grp"
create_group.create_group(right_shoe_grp, shoe_grp)
other_grp = "other_grp"
create_group.create_group(other_grp, poly_group)
# create network node
save_as.save_as(file_name)
logger.info("%s publish successful!" % file_name)
if not local:
quit_maya.quit_maya()
def create_references_group():
create_group.create_group("Char")
create_group.create_group("Prop")
create_group.create_group("Temp")
def main(file_name, local):
logger = logging.getLogger("HighRig start")
new_file.new_file()
context = pipeFile.PathDetails.parse_path(file_name)
project = context.project
entity_type = context.entity_type
asset_type = context.asset_type
asset_type_short_name = context.asset_type_short_name
asset_name = context.asset_name
task = context.task
MidRig_publish_file = pipeFile.get_task_publish_file(
project, entity_type, asset_type, asset_name, "MidRig", task)
if not os.path.isfile(MidRig_publish_file):
MidRig_publish_file = pipeFile.get_task_publish_file(
project, entity_type, asset_type, asset_name, "MidRig", "MidRig")
HighMdl_publish_file = pipeFile.get_task_publish_file(
project, entity_type, asset_type, asset_name, "HighMdl", "HighMdl")
if not (os.path.isfile(MidRig_publish_file)
and os.path.isfile(HighMdl_publish_file)):
logger.warning(
"No HighMdl file published or No MidRig file published.")
if not local:
quit_maya.quit_maya()
return
create_reference.create_reference(HighMdl_publish_file)
if asset_type in ["Character", "Cprop"]:
create_reference.create_reference(MidRig_publish_file, "MidRig")
model_name = "%s_%s_MODEL" % (asset_type_short_name, asset_name)
# create root group
root_group_name = "%s_%s_ROOT" % (asset_type_short_name, asset_name)
create_group.create_group(root_group_name)
# create _BLENDS group
blends_group = "_BLENDS"
create_group.create_group(blends_group)
if asset_type == "Character":
rig_group_name = "Grp_Master_Ctl"
create_group.create_group("Others", root_group_name)
create_group.create_group("Geometry", root_group_name)
create_group.create_group(model_name, "Geometry")
elif asset_type in ["Prop", "Cprop", "Building"]:
rig_group_name = "%s_%s_RIG" % (asset_type_short_name, asset_name)
create_group.create_group(model_name, root_group_name)
create_group.create_group(rig_group_name)
if asset_type in ["Prop", "Building"]:
bounding = mc.xform(model_name, q=1, bb=1)
max_value = max(abs(bounding[0]), abs(bounding[2]),
abs(bounding[3]), abs(bounding[5]))
radius = max_value * 1.1
center = mc.xform(model_name, q=1, sp=1, ws=1)
circle_list = mc.circle(c=center,
nr=[0, 1, 0],
r=radius,
name="%s_%s_Ctl" %
(asset_type_short_name, asset_name))
circle_name = circle_list[0]
constraint_parent = mc.parentConstraint(circle_name,
model_name,
maintainOffset=True)
constraint_scale = mc.scaleConstraint(circle_name,
model_name,
maintainOffset=True)
mc.parent(constraint_parent, rig_group_name)
mc.parent(constraint_scale, rig_group_name)
mc.parent(circle_name, rig_group_name)
create_group.create_group(rig_group_name, root_group_name)
save_as.save_as(file_name)
logger.info("%s publish successful!" % file_name)
if not local:
quit_maya.quit_maya()
def group_camera(file_path):
camera = get_valid_camera.get_valid_camera(file_path)
if camera:
create_group.create_group("Camera")
mc.parent(camera, "Camera")
print "group camera done."