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 reference(self, reference_all=False): items = self.get_list_view_items(self.include_list_view, reference_all) if not items: return reference_files = list() for item in items: publish_path = item.publish_path namespace = item.name if self.name_space_cbox.currentText( ) == "asset_name" else ":" reference_files.append([publish_path, namespace]) # add progress dialog progress_dialog = QProgressDialog('Referencing...', 'Cancel', 0, len(reference_files)) progress_dialog.setMinimumWidth(400) progress_dialog.setWindowModality(Qt.WindowModal) progress_dialog.show() for index, reference_file in enumerate(reference_files): progress_dialog.setValue(index) if progress_dialog.wasCanceled(): break reference_file_path, namespace = reference_file if not all((reference_file_path, namespace)): continue if reference_file_path.endswith(".abc"): self.import_env_gpu_cache(reference_file_path, namespace) else: create_reference.create_reference(reference_file_path, namespace, True, True) # put char in to char group, env to env group, prop to prop group self.organize_type_group()
def rebuild_asset(context): asset_info_file = pipeFile.get_task_file(context.project, context.sequence, context.shot, "Anim", "Anim", "maya_shot_assetInfo", "") if not os.path.isfile(asset_info_file): log.warning("%s is not an exist file." % asset_info_file) return asset_info_list = json_operation.get_json_data(asset_info_file) if not asset_info_list: log.warning("No data in the json file %s." % asset_info_file) return cache_dir = get_anim_cache_dir(context) for asset_info in asset_info_list: asset_type = asset_info.get("type") asset_name = asset_info.get("name") namespace = asset_info.get("namespace") # project, entity_type, asset_type_sequence, asset_name_shot, step, task, version="", engine="maya" asset_shd_file = pipeFile.get_task_publish_file( context.project, "Asset", asset_type, asset_name, "Shd", "Shd") if os.path.isfile(asset_shd_file): create_reference.create_reference(asset_shd_file, namespace, True) log.info("Reference in %s" % asset_shd_file) cache_file = "%s/%s" % (cache_dir, "%s.abc" % namespace) if os.path.isfile(cache_file): log.info("attaching...") try: import_exocortex_abc.import_exocortex_abc(cache_file) except: log.error("Can't attach %s." % cache_file) else: log.warning("Cache: %s is not an exist file" % cache_file) else: log.warning("Shd: %s is not an exist file")
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 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 reference_in_camera(context): cache_dir = get_anim_cache_dir(context) camera_abc_file = "%s/%s" % (cache_dir, "camera.abc") if os.path.isfile(camera_abc_file): create_reference.create_reference(camera_abc_file) else: log.warning("%s is not an exist file" % camera_abc_file)
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("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 do_create_reference(self, index): index = self.asset_list_view.model().mapToSource(index) item = self.asset_model.model_data[index.row()] publish_path = item.publish_path namespace = item.name if self.name_space_cbox.currentText( ) == "asset name" else ":" if os.path.isfile(publish_path): create_reference.create_reference(publish_path, namespace, True)
def reference_cloth(): context = pipeFile.PathDetails.parse_path() project = context.project template = Project(project).template("fx_cache_publish") cache_dir = template.format(project=project, sequence=context.sequence, shot=context.shot, step="Cfx") if not os.path.isdir(cache_dir): print "No cloth cache dir exist" return cloth_cache_path = glob.glob("%s/*/cloth/cloth.abc" % cache_dir) if cloth_cache_path: for cache in cloth_cache_path: create_reference.create_reference(cache, "cloth") else: print "No cloth cache found."
def reference_in(self): paths = self.get_selected_path() if not paths: return if self.run_app.endswith("maya.exe"): progress_dialog = QProgressDialog('Reference in,Please wait......', 'Cancel', 0, len(paths)) progress_dialog.setWindowModality(Qt.WindowModal) progress_dialog.show() for index, path in enumerate(paths): create_reference.create_reference(path) progress_dialog.setValue(index + 1) if progress_dialog.wasCanceled(): break
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 replace_gpu_to_shd(self, gpu_node, path_type): if path_type == "mdl": path = gpu_node.mdl_path else: path = gpu_node.shd_path namespace = gpu_node.name group_name = create_reference.create_reference(path, namespace_name=namespace, allow_repeat=True, get_group=True) print group_name self.build_group(group_name, gpu_node.parent) self.set_attr(gpu_node, group_name)
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 import_camera(project, sequence, step): db = db_api.DbApi(project).db_obj shots = db.get_all_shots(sequence) if not shots: print "No shot exist in this sequence" return shot_names = [shot.get("code") for shot in shots] for shot_name in shot_names: cache_template = Project(project).template("maya_shot_cache") cache_dir = cache_template.format(project=project, sequence=sequence, shot=shot_name.split("_")[-1], step=step, task=step) camera_cache_path = "%s/camera.abc" % cache_dir camera_cache_path = camera_cache_path.replace("\\", "/") if not os.path.isfile(camera_cache_path): print "%s is not exist." % camera_cache_path continue reference_files = mc.file(q=1, r=1, wcn=1) if camera_cache_path in reference_files: print "%s already exist" % camera_cache_path continue create_reference.create_reference(camera_cache_path) group_camera()
def create_reference_node(reference_node): model_group = get_model_group(reference_node) outliner_name = "%s:%s" % (reference_node.namespace, model_group) if mc.objExists(outliner_name): set_attr(reference_node) build_group(outliner_name, reference_node.parent) else: if not os.path.isfile(reference_node.mdl_path): logger.error("%s is not an exist path" % reference_node.mdl_path) return try: new_node = create_reference.create_reference(reference_node.mdl_path, reference_node.namespace, True, True) set_attr(reference_node, new_node) build_group(new_node, reference_node.parent) logger.info("Create reference: %s successful." % reference_node.mdl_path) except: logger.error("Create reference: %s failed." % reference_node.mdl_path)
def import_env_cache(abc_path): if os.path.isfile(abc_path): create_reference.create_reference(abc_path) logger.info("Import env cache done.") else: logger.warning("No env cache exists.")
def assign_shader(asset, shader_version): """ assign shader by json configuration :param asset: pymel short asset name :param shader_version: default or other shader version :return: """ not_exist_list = list() # get json path and data obj = pipeFile.PathDetails.parse_path() project = obj.project asset_short_name = asset.name() # below split(":") maybe some reference with namespace asset_type_simple = asset_short_name.split(":")[-1].split("_")[0] asset_type = ASSET_DICT[asset_type_simple] asset_name = asset_short_name.split(":")[-1].split("_")[1] json_dir = pipeFile.get_asset_step_dir(asset_type, asset_name, "shd", "_connection", project_name=project, shd_version=shader_version) json_path = join_path.join_path2( json_dir, "%s_%s_shd_v000.json" % (project, asset_name)) if not json_path: logger.error("No connection json file found.") return json_data = json_operation.get_json_data(json_path) # get shd path and reference in shd_dir = pipeFile.get_asset_step_dir(asset_type, asset_name, "shd", "_sg", project_name=project, shd_version=shader_version) shd_path = join_path.join_path2( shd_dir, "%s_%s_shd_v000.mb" % (project, asset_name)) if not shd_path: logger.error("No shading publish file found.") return # create reference create_reference.create_reference(shd_path) # assign shader asset_long_name = asset.longName() prefix = "|".join((asset_long_name.split("|")[:-1])) namespace_name = get_namespace.get_namespace(asset_short_name) namespace_name = namespace_name.strip(":") # has no parent group if not prefix: # -has no namespace if not namespace_name: not_exist = assign_shader_by_json_data(json_data) if not_exist: not_exist_list.extend(not_exist) # -has name space else: for mesh in json_data: mesh_list = mesh.split("|") final_mesh = ("|%s:" % namespace_name).join(mesh_list) if not mc.objExists(final_mesh): exist_warning(final_mesh) not_exist_list.append(final_mesh) continue pm.sets(json_data[mesh]["sg"], fe=final_mesh) set_arnold_attribute(json_data, mesh, final_mesh) # has prefix (has parent group) else: # -has no namespace if not namespace_name: for mesh in json_data: final_mesh = prefix + mesh if not mc.objExists(final_mesh): logger.warning("%s not exist." % final_mesh) not_exist_list.append(final_mesh) continue pm.sets(json_data[mesh]["sg"], fe=final_mesh) set_arnold_attribute(json_data, mesh, final_mesh) # -has namespace else: for mesh in json_data: mesh_list = mesh.split("|") final_mesh = ("|%s:" % namespace_name).join(mesh_list) final_mesh = prefix + final_mesh if not mc.objExists(final_mesh): logger.warning("%s not exist." % final_mesh) not_exist_list.append(final_mesh) continue pm.sets(json_data[mesh]["sg"], fe=final_mesh) set_arnold_attribute(json_data, mesh, final_mesh) return not_exist_list