def main(file_name, local):
logger = logging.getLogger("LgtLay start")
new_file.new_file()
context = pipeFile.PathDetails.parse_path(file_name)
save_as.save_as(file_name)
# create Light group
import_lights(context)
logger.info("Import light done.")
# AR set
rebuild_scene()
logger.info("Rebuild scene done.")
# switch to midmdl
assemb = Assembly.Assembly()
assemb.set_active("MidMdl")
# get the AnimLay cache
abc_files = get_cache_files(context)
if abc_files:
for abc_file in abc_files:
if abc_file.endswith("env.abc"):
continue
namespace = os.path.splitext(os.path.basename(abc_file))[0]
create_reference.create_reference(abc_file, namespace)
logger.info("Reference cache done.")
# fix frame range
fix_frame_range.fix_frame_range(context)
logger.info("Fix frame range done.")
# set resolution
resolution = Project(context.project).resolution
set_image_size.set_image_size(*resolution)
save_as.save_as(file_name)
logger.info("%s publish successful!" % file_name)
if not local:
quit_maya.quit_maya()
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 main(file_name, local):
logger = logging.getLogger("Hair publish")
if not local:
open_file.open_file(file_name)
# get paths
context = pipeFile.PathDetails.parse_path(file_name)
hair_cache_path = context.abc_cache_path
hair_path = context.hair_path
delta_path = context.delta_path
asset_name = context.asset_name
# import reference
publish.reference_opt()
# copy image
publish.copy_image_and_video(context)
logger.info("Copy image done.")
# export SCULP group to abc
model_name = get_model_name.get_model_name("hair")
export_abc.export_abc(1, 1, hair_cache_path, model_name)
logger.info("Export abc done.")
# export xgen file
collection_node = str("%s_collection" % asset_name)
xgen = Xgen.Xgen()
xgen.export_palette(collection_node, hair_path)
xgen.create_delta(collection_node, delta_path)
logger.info("Export .xgen file done.")
# export shd
export_shd(context)
logger.info("Export shader done.")
save_as.save_as(context.publish_path)
if not local:
quit_maya.quit_maya()
def main(file_name, local):
logger = logging.getLogger("Lookdev 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_name = context.asset_name
# reference in Shd
shd_publish_file = pipeFile.get_task_publish_file(project, entity_type,
asset_type, asset_name,
"Shd", "Shd")
if not os.path.isfile(shd_publish_file):
logger.info("%s is not an exist file" % shd_publish_file)
return
create_reference.create_reference(shd_publish_file, asset_name)
logger.info("reference shd done.")
# import hair
load_plugin.load_plugin("xgenToolkit.mll")
mel.eval("XgCreateDescriptionEditor;")
publish_file = pipeFile.get_task_file(project, asset_type, asset_name,
"Hair", "Hair", "maya_asset_publish",
"")
context = pipeFile.PathDetails.parse_path(publish_file)
import_xgen_hair(context, "hair")
logger.info("import hair done.")
# reference turn table
reference_turntable()
logger.info("reference turntable done.")
save_as.save_as(file_name)
logger.info("%s publish successful!" % file_name)
if not local:
quit_maya.quit_maya()
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
asset_type_short_name = context.asset_type_short_name
yeti_name = "%s_%s_pgYetiMaya" % (asset_type_short_name, asset_name)
create_yeti_node(asset_type_short_name, asset_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_hair_group(asset_type_short_name, asset_name)
save_as.save_as(file_name)
logger.info("%s publish successful!" % file_name)
if not local:
quit_maya.quit_maya()
def save_as_next_version_file(path, padding=3):
next_version_file = get_next_version.get_next_version(path, padding)
if os.path.isfile(next_version_file):
new_version_file = get_new_version_by_dir.get_new_version_by_dir(os.path.dirname(next_version_file))
next_version_file = new_version_file[0]
save_as.save_as(next_version_file)
return next_version_file
def main(file_name, local):
logger = logging.getLogger("MidRig 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
MidMdl_publish_file = pipeFile.get_task_publish_file(
project, entity_type, asset_type, asset_name, "MidMdl", "MidMdl")
if not os.path.isfile(MidMdl_publish_file):
logger.warning("No MidMdl file published.")
quit_maya.quit_maya()
return
create_reference.create_reference(MidMdl_publish_file)
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, blends_group)
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 upload_movie(description):
logger = logging.getLogger(__name__)
# get scene name
scene_name = get_scene_name.get_scene_name()
if not scene_name:
QMessageBox.warning(None, "Warning", "Save scene first")
return
context = pipeFile.PathDetails.parse_path(scene_name)
next_edition_file = context.next_edition_file
save_as.save_as(next_edition_file)
context = pipeFile.PathDetails.parse_path(next_edition_file)
project = context.project
entity_type = context.entity_type
step = context.step
task = context.task
if entity_type == "Asset":
asset_type_or_sequence = context.asset_type
asset_or_shot = context.asset_name
local_video_path = playblast_turntable.playblast_turntable(
submit=False)
else:
asset_type_or_sequence = context.sequence
asset_or_shot = context.shot
local_video_path = playblast_shot.playblast_shot(submit=False)
logger.info("Playblast done")
if local_video_path and os.path.isfile(local_video_path):
# save_as.save_as(next_version_file)
db = db_api.DbApi(project).db_obj
# entity_type, asset_type_or_sequence, asset_or_shot, step, task_name
current_task = db.get_current_task(entity_type, asset_type_or_sequence,
asset_or_shot, step, task)
logger.info("Current Task: %s" % current_task)
if not current_task:
logger.warning("Task is None")
return
if db.typ == "shotgun":
project_info = db.get_project_by_name()
user = db.get_current_user()
code = os.path.splitext(os.path.basename(local_video_path))[0]
data = {
'project': project_info,
'code': code,
'description': description,
'sg_status_list': 'rev',
'entity': current_task["entity"],
'sg_task': current_task,
'user': user
}
result = db.create('Version', data)
db.upload("Version", result["id"], local_video_path,
"sg_uploaded_movie")
return True
elif db.typ == "strack":
db.upload_version(current_task, local_video_path,
next_edition_file)
return True
else:
logger.warning("May playblast wrong.")
return False
def save_as(file_name=None):
engine = get_engine.get_engine()
if engine == "maya":
from miraLibs.mayaLibs import save_as
elif engine == "nuke":
from miraLibs.nukeLibs import save_as
else:
return
save_as.save_as(file_name)
def main():
logger = logging.getLogger(__name__)
# save to QCPublish path
context = pipeFile.PathDetails.parse_path()
work_path = context.work_path
if os.path.isfile(work_path):
raise RuntimeError("File exist. Permission defined.")
else:
save_as.save_as(work_path)
logger.info("Save to %s done." % work_path)
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 main(file_name, local):
logger = logging.getLogger("Lookdev publish")
if not local:
open_file.open_file(file_name)
# get paths
context = pipeFile.PathDetails.parse_path()
publish.copy_image_and_video(context)
logger.info("copy image and video done.")
save_as.save_as(context.publish_path)
# quit maya
if not local:
quit_maya.quit_maya()
def main(file_name, local):
logger = logging.getLogger("Group start")
new_file.new_file()
# copy low mdl publish file as mdl file
context = pipeFile.PathDetails.parse_path(file_name)
asset_name = context.asset_name
asset_type_short_name = context.asset_type_short_name
model_name = "%s_%s_GROUP" % (asset_type_short_name, asset_name)
# create default group
mc.group(name=model_name, empty=1)
save_as.save_as(file_name)
logger.info("%s publish successful!" % file_name)
if not local:
quit_maya.quit_maya()
def main(file_name, local):
logger = logging.getLogger("HairRig start")
context = pipeFile.PathDetails.parse_path(file_name)
# reference HighRig
high_rig_file = pipeFile.get_task_publish_file(context.project, context.entity_type, context.asset_type,
context.asset_name, "HighRig", "HighRig")
if not os.path.isfile(high_rig_file):
logger.error("HighRig not publish file yet.")
if not local:
quit_maya.quit_maya()
return
create_reference.create_reference(high_rig_file)
# save file
save_as.save_as(file_name)
logger.info("%s publish successful!" % file_name)
if not local:
quit_maya.quit_maya()
def auto_publish(context, change_task_status):
# copy image
publish.copy_image_and_video(context)
logger.info("Copy image and video done.")
# import all reference
publish.reference_opt()
logger.info("Import reference done.")
# export needed
if context.step in ["MidRig", "HighRig"]:
publish.export_need_to_publish(context)
logger.info("Export to publish path done.")
else:
save_as.save_as(context.publish_path)
# post publish
post_publish(context, change_task_status)
# open current file
new_file.new_file()
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 main(file_name, local):
logger = logging.getLogger("Lgt start")
load_plugin.load_plugin("AbcImport.mll")
load_plugin.load_plugin("MayaExocortexAlembic.mll")
new_file.new_file()
context = pipeFile.PathDetails.parse_path(file_name)
save_as.save_as(file_name)
# create Light group
import_lights(context)
logger.info("Import light done.")
# rebuild scene
rebuild_scene()
logger.info("Rebuild scene done.")
# edit shd
edit_shd(context)
logger.info("Edit shd done.")
# rebuild asset
rebuild_asset(context)
logger.info("Rebuild asset done.")
# transfer attribute
transfer_attribute.transfer_attribute()
logger.info("Transfer attribute done.")
# break visibility connections
break_visibility_connections.break_visibility_connections()
# reference camera
reference_in_camera(context)
# group assets
group_assets()
group_camera(file_name)
# # assembly switch to shd
# assembly = Assembly.Assembly()
# assembly.set_active("Shd")
# fix frame range
fix_frame_range.fix_frame_range(context)
logger.info("Fix frame range done.")
# set resolution
resolution = Project(context.project).resolution
set_image_size.set_image_size(*resolution)
save_as.save_as(file_name)
logger.info("Publish done.")
if not local:
quit_maya.quit_maya()
def main(file_name, local):
logger = logging.getLogger("shd 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_name = context.asset_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 model file published.")
quit_maya.quit_maya()
return
create_reference.create_reference(mdl_publish_file)
save_as.save_as(file_name)
logger.info("%s publish successful!" % file_name)
if not local:
quit_maya.quit_maya()
def main(file_name, local):
logger = logging.getLogger("AnimLay start")
new_file.new_file()
context = pipeFile.PathDetails.parse_path(file_name)
seq = context.sequence
shot = context.shot
# create camera
create_camera(seq, shot)
logger.info("Create camera done.")
# reference env
reference_in_env(context)
logger.info("Reference env done.")
# create_references_group
create_references_group()
logger.info("Create reference group done.")
# fix frame range
fix_frame_range.fix_frame_range(context)
save_as.save_as(file_name)
logger.info("%s publish successful!" % file_name)
if not local:
quit_maya.quit_maya()
def main(file_name):
logger = logging.getLogger("hair publish")
open_file.open_file(file_name)
obj = pipeFile.PathDetails.parse_path(file_name)
asset_type_short_name = obj.asset_type_short_name
asset_name = obj.asset_name
publish_path = obj.publish_path
hair_path = obj.hair_path
yeti_group = "%s_%s_yetiNode" % (asset_type_short_name, asset_name)
# import mdl reference
import_load_remove_unload_ref.import_load_remove_unload_ref()
# export yeti group to _hair group
delete_layer.delete_layer()
mc.select(yeti_group, r=1)
export_selected.export_selected(hair_path)
logger.info("export yeti node to _hair done.")
mc.delete(yeti_group)
# save to publish path
save_as.save_as(publish_path)
# quit maya
quit_maya.quit_maya()
def version_up():
obj = pipeFile.PathDetails.parse_path()
if not obj:
return
if not obj.is_local_file():
print "This file is not a local file."
return
next_edition_file = obj.next_edition_file
if os.path.isfile(next_edition_file):
ret = QMessageBox.information(None, "Save As",
"%s \nalready exists.Do you want to replace it?" % next_edition_file,
QMessageBox.Yes, QMessageBox.No)
if ret.name == "Yes":
save_as.save_as(next_edition_file)
else:
try:
new_version_file = get_new_version_by_dir.get_new_version_by_dir(os.path.dirname(next_edition_file))
save_as.save_as(new_version_file[0])
except:
mel.eval("SaveSceneAs;")
else:
ret = QMessageBox.information(None, "Version up", "Save as %s?" % next_edition_file,
QMessageBox.Yes, QMessageBox.No)
if ret.name == "Yes":
save_as.save_as(next_edition_file)
def main():
if not mc.objExists("Env"):
logger.info("Env group not exist.")
return
if check_no_shd_in_reps():
return
assemb = Assembly.Assembly()
assemb.set_active("Shd")
context = pipeFile.PathDetails.parse_path()
cache_dir = context.cache_dir
abc_path = "%s/env.abc" % cache_dir
# export Env group as abc to cache dir
export_env_cache(abc_path)
# delete Env group
mc.delete("Env")
logger.info("Delete Env group done.")
# import abc
import_env_cache(abc_path)
# save as next edition file
next_edition_file = context.next_edition_file
save_as.save_as(next_edition_file)
logger.info("Save as next edition file done.")
def main(file_name, local):
logger = logging.getLogger("HighMdl 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
MidMdl_publish_file = pipeFile.get_task_publish_file(
project, entity_type, asset_type, asset_name, "MidMdl", "MidMdl")
logger.info("MidMdl publish file: %s" % MidMdl_publish_file)
if not os.path.isfile(MidMdl_publish_file):
logger.warning("No MidMdl file published.")
if not local:
quit_maya.quit_maya()
return
open_file.open_file(MidMdl_publish_file)
save_as.save_as(file_name)
logger.info("%s publish successful!" % file_name)
if not local:
quit_maya.quit_maya()
def main():
message_box = QMessageBox.information(None, "Warming Tip",
"Do you want to publish this task.",
QMessageBox.Yes | QMessageBox.No)
if message_box.name == "No":
return
try:
context = pipeFile.PathDetails.parse_path()
except:
logger.warning("Name Error.")
return
# check is local file
if not context.is_local_file():
QMessageBox.warning(
None, "Warning",
"This file is not a local work file.\n Permission defined.")
return
# check if work file
if not context.is_working_file():
QMessageBox.warning(None, "Warning", "This file is not a work file.")
return
progress_dialog = ProgressDialog(maya_window)
progress_dialog.show_up()
# preflight
progress_dialog.set_text("Preflight checking...")
result, cg = check_gui.main_for_publish()
if result:
cg.close()
cg.deleteLater()
else:
logger.error("Some checks can not be passed.")
progress_dialog.close()
return
progress_dialog.set_value(30)
# save as next version file
next_version_file = context.next_version_file
save_as.save_as(next_version_file)
logger.info("Save to %s" % next_version_file)
progress_dialog.set_value(40)
# get path
context = pipeFile.PathDetails.parse_path(next_version_file)
entity_type = context.entity_type
work_image_path = context.work_image_path
local_image_path = context.local_image_path
step = context.step
other_dir = context.other_dir
# copy to _other
od = OtherDialog(other_dir, maya_window)
od.exec_()
progress_dialog.set_value(50)
logger.info("Copy to others")
# screen shot
progress_dialog.set_text("Screen shot")
qcpublish_screen_shot(entity_type, local_image_path)
Copy.copy(local_image_path, work_image_path)
logger.info("PreQCPublish successful.")
progress_dialog.set_value(60)
# post publish
progress_dialog.set_text("%s_QCPublish" % step)
qcpublish(step)
logger.info("QCPublish successful.")
progress_dialog.set_value(85)
# write root task id to database
progress_dialog.set_text("Add to database.")
post_qcpublish(context)
logger.info("PostQCPublish successful.")
# pop message
progress_dialog.set_value(100)
QMessageBox.information(maya_window, "Warming Tip",
"QC publish successful.")
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()
