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()