def results(self, value): type = value[0] name = self.name # determine if asset was created or not. created = True if name is None or type is None: created = False if created: project = Project() body = project.create_asset(name, asset_type=type) if body == None: qd.error("Asset with name " + name + " already exists in pipeline.") elif self.type == AssetType.SHOT: qd.info("Asset created successfully.", "Success") else: #assembler = Assembler() #assembler.create_hda(name, body=body) qd.info("Asset created successfully.", "Success") else: qd.error("Asset creation failed.")
class AssetPublisher: def __init__(self): self.project = Project() def publish(self): asset_list = self.project.list_assets() self.item_gui = sfl.SelectFromList( l=asset_list, parent=hou.ui.mainQtWindow(), title="Select an asset to publish") self.item_gui.submitted.connect(self.results) def results(self, value): self.asset_name = value[0] body = Project().get_asset(self.asset_name) if not body: body = self.project.create_asset(self.asset_name) if not body: qd.error("Something broke :'(") return self.element = body.get_element(Asset.USD) self.path = os.path.join(self.element._filepath, "temp.usda") selection = hou.selectedNodes() if len(selection) != 1: qd.error("Please select the last node in the network and try again.") return out = selection[0] rop = hou.node("/stage").createNode("usd_rop") rop.setInput(0, out) rop.parm("lopoutput").set(self.path) rop.parm("enableoutputprocessor_simplerelativepaths").set(0) rop.parm("execute").pressButton() rop.destroy() publishes = self.element.list_publishes() publishes_string_list = "" for publish in publishes: label = publish[0] + " " + publish[1] + " " + publish[2] + "\n" publishes_string_list += label self.input = qd.HoudiniInput(parent=hou.qt.mainWindow(), title="Comment ", info=publishes_string_list) self.input.submitted.connect(self.comment_results) def comment_results(self, value): comment = str(value) username = Environment().get_user().get_username() name = self.asset_name self.element.update_app_ext(".usda") self.element.publish(username, self.path, comment, name)
def results(self, value): type = value[0] name = self.name # determine if asset was created or not. created = True if name is None or type is None: created = False if created: project = Project() body = project.create_asset(name, asset_type=type) selectedNodes = [] for node in hou.selectedNodes(): if node.type().category() == hou.sopNodeTypeCategory(): selectedNodes.append(node) elif node.type().category() == hou.objNodeTypeCategory(): if selectedNodes: qd.error( "Selected nodes for asset must be inside a geo node or a single geo node." ) selectedNodes = node.children() break if body == None: qd.error("Asset with name " + name + " already exists in pipeline.") elif self.type == AssetType.SHOT: qd.info("Shot created successfully.", "Success") else: assembler = Assembler() HDA = assembler.create_hda(name, body=body, selected_nodes=selectedNodes) HDA.type().definition().updateFromNode(HDA) #HDA.updateFromNode(HDA) qd.info("Asset created successfully.", "Success") else: qd.error("Asset creation failed.")
class UpdateAssets: def __init__(self): self.project = Project() def update_assets(self): lists = ShotgunReader().getAssetLists() asset_list = lists[0] assets = lists[1] #update .asset_list list_file = open( os.path.join(self.project.get_assets_dir(), ".asset_list.txt"), "w") list_file.truncate(0) for name in asset_list: list_file.write(name + "\n") list_file.close() #update .short_asset_list list_file = open( os.path.join(self.project.get_assets_dir(), ".short_asset_list"), "w") list_file.truncate(0) for asset in assets: name = asset["name"] variants = asset["children"][:] print("name: " + name) print("variants: ", variants) self.build_asset(name, variants) list_file.write(name + "\n") list_file.close() qd.message("Assets updated successfully.") def build_asset(self, main_name, variants): stage = hou.node("/stage") self.primpath = "/" + main_name prim = stage.createNode("primitive") prim.setName("base_prim", 1) prim.parm("primpath").set(self.primpath) config = stage.createNode("configurelayer") config.setName("set_default_prim", 1) config.setInput(0, prim) config.parm("defaultprim").set(self.primpath) config.parm("setdefaultprim").set(1) add_var = stage.createNode("addvariant") add_var.parm("primpath").set(self.primpath) in_count = 1 for var in variants: self.add_variant(var, config, add_var, in_count) in_count += 1 out_label = stage.createNode("null") out_label.setName(main_name + "_OUT", 1) out_label.setInput(0, add_var) #our asset is now assembled, and just needs to be published body = self.project.get_asset(main_name) if not body: qd.error("Error publishing asset " + main_name + ". Continuing to next asset.") return element = body.get_element(Asset.USD) element.update_app_ext(".usda") path = os.path.join(element._filepath, "temp.usda") rop = hou.node("/stage").createNode("usd_rop") rop.setInput(0, out_label) rop.parm("lopoutput").set(path) rop.parm("enableoutputprocessor_simplerelativepaths").set(0) rop.parm("execute").pressButton() stage.layoutChildren() comment = "Automatic publish" username = "******" name = main_name element.publish(username, path, comment, name) for child in stage.children(): child.destroy() def add_variant(self, var, config, add_var, in_count): stage = hou.node("/stage") ref1 = stage.createNode("reference") ref1.setName(var + "_geo", 1) ref1.parm("primpath").set(self.primpath) geo_path = self.getGeoPath(var) ref1.parm("filepath1").set(geo_path) disp = stage.createNode("rendergeometrysettings") disp.parm("xn__primvarsdisplacementboundsphere_control_n4br").set( "set") disp.parm("xn__primvarsdisplacementboundsphere_mrbr").set(1) disp.setInput(0, ref1) lib1 = stage.createNode("reference") lib1.setInput(0, disp) lib1.parm("primpath").set("/materials/") mat_path = self.getMatPath(var) lib1.parm("filepath1").set(mat_path) mat_asgn = stage.createNode("assignmaterial") mat_asgn.setInput(0, lib1) mat_asgn.parm("primpattern1").set(self.primpath) usd_stage = mat_asgn.stage() mat_prim = usd_stage.GetPrimAtPath("/materials") shader_path = mat_prim.GetChildren()[0].GetPath() #print("SHADER PATH: " + str(shader_path)) mat_asgn.parm("matspecpath1").set(str(shader_path)) label = stage.createNode("null") label.setName(var + "_OUT", 1) label.setInput(0, mat_asgn) graft = stage.createNode("graftstages") graft.setName(var, 1) graft.parm("primpath").set(self.primpath) graft.parm("destpath").set("/") graft.setInput(0, config) graft.setInput(1, label) add_var.setInput(in_count, graft) def getGeoPath(self, var): body = self.project.get_asset(var) if not body: body = self.project.create_asset(var) element = body.get_element(Asset.GEO) if element.get_last_version() >= 0: return element.get_last_publish()[3] else: #copy over the blank usda file src = self.project.get_project_dir() src = os.path.join(src, "blank.usda") dst = os.path.join(element._filepath, var + "_main.usda") shutil.copyfile(src, dst) pio.set_permissions(dst) return dst def getMatPath(self, var): body = self.project.get_asset(var) if not body: body = self.project.create_asset(var) element = body.get_element(Asset.MATERIALS) myPath = os.path.join(element._filepath, var + "_main.usda") if os.path.exists(myPath): return myPath else: #create and publish a basic material, return the path dst = os.path.join(element._filepath, var + "_main.usda") mat_lib = hou.node("/stage").createNode("materiallibrary") pink = mat_lib.createNode("usdpreviewsurface") pink.setName(var) pink.parm("diffuseColorr").set(.6) pink.parm("diffuseColorg").set(.6) pink.parm("diffuseColorb").set(.6) rop = hou.node("/stage").createNode("usd_rop") rop.setInput(0, mat_lib) rop.parm("lopoutput").set(dst) rop.parm("enableoutputprocessor_simplerelativepaths").set(0) rop.parm("execute").pressButton() mat_lib.destroy() rop.destroy() pio.set_permissions(dst) return dst
class MaterialPublisher: def __init__(self): self.project = Project() def publish(self): asset_list = self.project.list_assets() self.item_gui = sfl.SelectFromList(l=asset_list, parent=hou.ui.mainQtWindow(), title="Select an asset to publish") self.item_gui.submitted.connect(self.results) def results(self, value): self.asset_name = value[0] body = Project().get_asset(self.asset_name) if not body: body = self.project.create_asset(self.asset_name) if not body: qd.error("Something broke :'(") return self.element = body.get_element(Asset.MATERIALS) self.path = os.path.join(self.element._filepath, "temp.usda") selection = hou.selectedNodes() if len(selection) != 1: qd.error("Please select only the material node and try again.") return shader = selection[0] if shader.type().name == "materiallibrary": qd.error( "Changes have been made to this publishing tool. Now you must select the material node itself, NOT the material library, to publish it. Please try again." ) return #check where we are and move shader node accordingly deleteLib = False path = shader.path() first = path.split("/")[1] if first != "stage": lib = hou.node("/stage").createNode("materiallibrary") deleteLib = True shader = hou.copyNodesTo([shader], lib)[0] else: lib = shader.parent() lib.setInput(0, None) lib.parm("matpath1").set(value[0]) #create and save material hda if shader.canCreateDigitalAsset(): hdaPath = os.path.join(self.element._filepath, self.asset_name + "_main.hda") shader = shader.createDigitalAsset(name=re.sub( r'\W+', '', self.asset_name), description=self.asset_name, hda_file_name=hdaPath, min_num_inputs=0, max_num_inputs=0) shaderDef = shader.type().definition() shaderOptions = shaderDef.options() shaderOptions.setUnlockNewInstances(True) shaderOptions.setSaveInitialParmsAndContents(True) shaderDef.setOptions(shaderOptions) shaderDef.save(hdaPath, shader, shaderOptions) elif shader.type().name() == re.sub(r'\W+', '', self.asset_name): shader.type().definition().updateFromNode(shader) shader.type().definition().save( shader.type().definition().libraryFilePath()) else: qd.error("Error creating/saving hda. Continuing to save USDA...") shader.setName(value[0]) rop = hou.node("/stage").createNode("usd_rop") rop.setInput(0, lib) rop.parm("lopoutput").set(self.path) rop.parm("enableoutputprocessor_simplerelativepaths").set(0) rop.parm("execute").pressButton() rop.destroy() if deleteLib: lib.destroy() publishes = self.element.list_publishes() publishes_string_list = "" for publish in publishes: label = publish[0] + " " + publish[1] + " " + publish[2] + "\n" publishes_string_list += label self.input = qd.HoudiniInput(parent=hou.qt.mainWindow(), title="Comment ", info=publishes_string_list) self.input.submitted.connect(self.comment_results) def comment_results(self, value): comment = str(value) username = Environment().get_user().get_username() name = self.asset_name self.element.update_app_ext(".usda") self.element.publish(username, self.path, comment, name)
class ObjPublisher: def __init__(self): self.project = Project() def publish(self): asset_list = self.project.list_assets() self.item_gui = sfl.SelectFromList(l=asset_list, parent=hou.ui.mainQtWindow(), title="Select an asset to publish") self.item_gui.submitted.connect(self.results) def results(self, value): self.asset_name = value[0] body = Project().get_asset(self.asset_name) if not body: body = self.project.create_asset(self.asset_name) if not body: qd.error("Something broke :'(") return self.element = body.get_element(Asset.GEO) self.usdElem = body.get_element(Asset.GEO) path = self.element._filepath selectedNodes = hou.selectedNodes() if len(selectedNodes) != 1: qd.error("Select one node to publish its geometry") return geo = selectedNodes[0] if geo.type().name() != "geo": qd.error("You can only publish from geo nodes") return for child in geo.children(): if child.isDisplayFlagSet(): #print("hello there from " + child.name()) cache = geo.createNode("filecache") cache.setInput(0, child) usd = geo.createNode("usdexport") usd.setInput(0, child) cache.parm("filemode").set(2) cache.parm("file").set(os.path.join(path, "temp.obj")) cache.parm("trange").set(0) cache.parm("execute").pressButton() usd.parm("authortimesamples").set("Never") usd.parm("lopoutput").set(os.path.join(path, "temp.usda")) usd.parm("execute").pressButton() usd.destroy() cache.destroy() publishes = self.element.list_publishes() publishes_string_list = "" for publish in publishes: label = publish[0] + " " + publish[1] + " " + publish[ 2] + "\n" publishes_string_list += label self.input = qd.HoudiniInput(parent=hou.qt.mainWindow(), title="Comment ", info=publishes_string_list) self.input.submitted.connect(self.comment_results) def comment_results(self, value): comment = str(value) username = Environment().get_user().get_username() name = self.asset_name basePath = self.element._filepath #usdElem = self.element.deepcopy() path = os.path.join(basePath, "temp.obj") self.element.update_app_ext(".obj") self.element.publish(username, path, comment, name) path = os.path.join(basePath, "temp.usda") self.usdElem.update_app_ext(".usda") self.usdElem.publish(username, path, comment, name)
class Exporter: def __init__(self): pass def go(self, alembic=False, usd=False, obj=False, mb=False, camera=False): self.alembic = alembic self.usd = usd self.obj = obj self.mb = mb self.camera = camera self.project = Project() self.chosen_asset = None if self.camera and self.alembic: #previs publish case shot_list = self.project.list_shots() self.item_gui = sfl.SelectFromList( l=shot_list, parent=maya_main_window(), title="What shot is this camera in?") self.item_gui.submitted.connect(self.shot_results) else: asset_list = self.project.list_assets() self.item_gui = sfl.SelectFromList( l=asset_list, parent=maya_main_window(), title="Select an asset to export to") self.item_gui.submitted.connect(self.asset_results) def export(self): publish_info = [] if self.obj: #modeling publish case publish_info.append(ObjExporter().exportSelected( self.chosen_asset)) #self.publish(publish_info) if self.usd: #modeling publish case publish_info.append(USDExporter().exportSelected( self.chosen_asset)) self.publish(publish_info) if self.alembic: #animation publish case shot_list = self.project.list_shots() self.item_gui = sfl.SelectFromList( l=shot_list, parent=maya_main_window(), title="What shot is this animation in?") self.item_gui.submitted.connect(self.shot_results) if self.mb: #rigging publish case publish_info.append(MbExporter().export(self.chosen_asset)) self.publish(publish_info) def asset_results(self, value): self.chosen_asset = value[0] #check if asset already exists #if not, create it self.project.create_asset(name=self.chosen_asset) self.export() def shot_results(self, value): self.chosen_shot = value[0] print(self.chosen_shot) shot = self.project.create_shot(self.chosen_shot) #if the shot didn't exist already, set the frame range if shot is not None: pass else: print("we're here") shot = self.project.get_shot(self.chosen_shot) if shot is None: print("uh oh stinky") return #pre-vis publish publish_info = [] if self.camera: camera_num = int(shot.get_camera_number()) if camera_num == 1: #only one camera in the shot self.chosen_asset = "camera1" publish_info.append(AlembicExporter().exportSelected( asset_name=self.chosen_asset, shot_name=self.chosen_shot, camera=self.camera)) self.publish(publish_info) else: #pick which camera to publish cam_list = [] for number in range(1, camera_num + 1): camera_name = "camera" + str(number) cam_list.append(camera_name) self.item_gui = sfl.SelectFromList( l=cam_list, parent=maya_main_window(), title="Which camera are you publishing?") self.item_gui.submitted.connect(self.camera_results) #animation publish else: publish_info.append(AlembicExporter().exportSelected( asset_name=self.chosen_asset, shot_name=self.chosen_shot, camera=self.camera)) self.publish(publish_info) def camera_results(self, value): publish_info = [] self.chosen_asset = value[0] publish_info.append(AlembicExporter().exportSelected( asset_name=self.chosen_asset, shot_name=self.chosen_shot, camera=self.camera)) self.publish(publish_info) def publish(self, publishes): publish_info = publishes[0] element = publish_info[0] path = publish_info[1] self.publishes = element.list_publishes() publishes_string_list = "" for publish in self.publishes: label = publish[0] + " " + publish[1] + " " + publish[2] + "\n" publishes_string_list += label # get comment and update element file with publish info comment = qd.input(title="Comment for publish", label=publishes_string_list) if comment is None or comment == "": comment = "No comment." username = Environment().get_user().get_username() for pub_info in publishes: element = pub_info[0] path = pub_info[1] element.publish(username, path, comment, self.chosen_asset)