def results(self, value): print("Selected asset: " + value[0]) filename = value[0] self.body = Project().get_body(filename) self.element = self.body.get_element(Asset.GEO) if self.element: #just reference in the asset, make sure we're referencing the usda geo path = self.element.get_last_publish()[3] parts = path.split(".") path = parts[0] + ".usda" ref = hou.node("/stage").createNode("reference") ref.setName(filename + "_geo", 1) ref.parm("filepath1").set(path) #also clone into the geo context from the obj file parts = path.split(".") path = parts[0] + ".obj" geo = hou.node("/obj").createNode("geo") geo.setName(filename + "_geoRef", 1) geo.parm("scale").set(0.01) fileNode = geo.createNode("file") fileNode.parm("file").set(path) else: qd.error("Nothing was cloned")
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 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.")
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 results(self, value): print("Selected shot: " + value[0]) shot_name = value[0] self.body = Project().get_body(shot_name) self.element = self.body.get_element(Asset.HIP) if self.element.get_last_version() >= 0: #check if checked out if self.element.is_assigned(): assigned_user = self.element.get_assigned_user() username = Environment().get_user().get_username() if not assigned_user == username: qd.error("This shot is currently checked out by " + assigned_user) return else: username = Environment().get_user().get_username() self.element.update_assigned_user(username) path = self.element.get_last_publish()[3] if path: hou.hipFile.load(path) else: qd.error("Nothing was cloned")
class AssetCloner: def __init__(self): self.project = Project() def clone(self): asset_list = self.project.list_assets_short() self.item_gui = sfl.SelectFromList(l=asset_list, parent=hou.ui.mainQtWindow(), title="Select an asset to clone") self.item_gui.submitted.connect(self.results) def results(self, value): print("Selected asset: " + value[0]) filename = value[0] self.body = Project().get_body(filename) self.element = self.body.get_element(Asset.USD) if self.element: path = self.element.get_last_publish()[3] if path: ref = hou.node("/stage").createNode("reference") ref.setName(filename + "_ref", 1) ref.parm("filepath1").set(path) ref.parm("primpath").set("/layout/" + filename) else: qd.error("Nothing was cloned")
def go(self): project = Project() asset_list = project.list_assets() self.item_gui = sfl.SelectFromList(l=asset_list, parent=maya_main_window(), title="Select an asset to clone") self.item_gui.submitted.connect(self.results)
class LayoutCloner: def __init__(self): self.project = Project() def clone(self): shot_list = self.project.list_shots() self.item_gui = sfl.SelectFromList(l=shot_list, parent=hou.ui.mainQtWindow(), title="Select a shot to clone from") self.item_gui.submitted.connect(self.results) def results(self, value): self.shot_name = value[0] self.shot = self.project.get_shot(self.shot_name) if not self.shot: self.shot = self.project.create_shot(self.shot_name) if not self.shot: qd.error("Something's wrong here. Talk to Stephanie") self.layout_element = self.shot.get_element(Asset.LAYOUT) path = os.path.join(self.layout_element._filepath, self.shot_name + ".usda") if not os.path.exists(path): # no layout is associated with this shot yet layouts = self.project.list_existing_layouts() self.item_gui = sfl.SelectFromList( l=layouts, parent=hou.ui.mainQtWindow(), title="Select a layout for this shot") self.item_gui.submitted.connect(self.layout_results) return self.load(path) def layout_results(self, value): layout_name = value[0] # copy ref file into the shot layout_body = self.project.get_layout(layout_name) element = layout_body.get_element(Asset.LAYOUT) src = os.path.join(element._filepath, layout_name + "_ref.usda") dst = os.path.join(self.layout_element._filepath, self.shot_name + ".usda") shutil.copy(src, dst) pio.set_permissions(dst) self.load(dst) def load(self, file): ref = hou.node("/stage").createNode("loadlayer") ref.setName("layout_ref", 1) ref.parm("filepath").set(file) ref.setDisplayFlag(True) rop = hou.node("/stage").createNode("usd_rop") rop.setInput(0, ref) rop.parm("enableoutputprocessor_simplerelativepaths").set(0) rop.parm("lopoutput").set(file) rop.setName("save_layout", 1)
def layout_results(self, value): self.layout_name = value[0] self.layout = Project().get_layout(self.layout_name) if self.layout is None: self.layout = Project().create_layout(self.layout_name) if self.layout is None: qd.error("Stephanie done messed up") return self.element = self.layout.get_element(Asset.LAYOUT) # make a USD ROP node rop = hou.node("/stage").createNode("usd_rop") # connect the selected node to the ROP out = hou.selectedNodes()[0] rop.setInput(0, out) # set the necessary values in the ROP self.savePath = os.path.join(self.element._filepath, self.layout_name + ".usda") rop.parm("lopoutput").set(self.savePath) rop.parm("enableoutputprocessor_simplerelativepaths").set(0) # save to disk rop.parm("execute").pressButton() #add attributes to stage reqired for proper unpacking later self.create_attributes(out) # publish :) self.comment = qd.HoudiniInput(parent=hou.qt.mainWindow(), title="Comment for publish?") self.comment.submitted.connect(self.layout_comment)
def solaris_asset_results(self, value): self.asset_name = value[0] body = Project().get_asset(self.asset_name) if not body: body = 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()
def results(self, value): self.layout_name = value[0] self.layout = self.project.get_layout(self.layout_name) if self.layout is None: self.layout = Project().create_layout(self.layout_name) if self.layout is None: qd.error("Stephanie done messed up") return self.element = self.layout.get_element(Asset.LAYOUT) rop = hou.node("/stage").createNode("usd_rop") out = hou.selectedNodes()[0] rop.setInput(0, out) self.savePath = os.path.join(self.element._filepath, self.layout_name + ".usda") rop.parm("lopoutput").set(self.savePath) 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.comment = qd.HoudiniInput( parent=hou.qt.mainWindow(), title="Comment for publish?", info=publishes_string_list) self.comment.submitted.connect(self.comment_results)
class CameraCreator: def __init__(self): self.project = Project() def go(self): #get shot to add camera to shotList = self.project.list_existing_shots( ) #we shouldn't be adding cameras to shots that haven't been created yet anyway self.item_gui = sfl.SelectFromList( l=shotList, parent=maya_main_window(), title="Select shot to add extra camera to") self.item_gui.submitted.connect(self.shot_results) def shot_results(self, value): shot_name = value[0] shot = self.project.get_shot(shot_name) if shot is None: qd.error("There was a problem loading the shot.") return prevNum = shot.get_camera_number() newNum = prevNum + 1 shot.set_camera_number(newNum) message = "There are now " + str( newNum) + " cameras in shot " + shot_name qd.message(message)
def results(self, value): print("Selected asset: " + value[0]) filename = value[0] self.body = Project().get_body(filename) self.element = self.body.get_element(Asset.MATERIALS) if self.element.get_last_version() >= 0: path = self.element.get_last_publish()[3] if path: createNewRef = True for child in hou.node("/stage").children(): if child.name( ) == filename + "_material_ref" and child.parm( "filepath1").eval() == path: child.parm("reload").pressButton() createNewRef = False if createNewRef: ref = hou.node("/stage").createNode("reference") ref.setName(filename + "_material_ref", 1) ref.parm("filepath1").set(path) ref.parm("primpath").set("/materials/") panes = self.getCurrentNetworkEditorPane() paths = [] for pane in panes: paths.append(pane.pwd()) hdaPath = path.split(".")[0] + ".hda" hou.hda.installFile(hdaPath) success = False for p in paths: try: for child in p.children(): if child.type().name() == re.sub( r'\W+', '', filename): child.destroy() newMat = p.createNode(re.sub(r'\W+', '', filename)) newMat.setName(filename, 1) newMat.setMaterialFlag(True) success = True except: pass if not success: for child in hou.node("/mat").children(): if child.type().name() == re.sub(r'\W+', '', filename): child.destroy() newMat = hou.node("/mat").createNode( re.sub(r'\W+', '', filename)) newMat.setName(filename, 1) newMat.setMaterialFlag(True) qd.message( "Material successfully cloned into /mat context.") else: qd.error("Nothing was cloned")
class LightPublisher: def __init__(self): self.project = Project() def go(self): sequence_list = self.project.list_sequences() self.item_gui = sfl.SelectFromList( l=sequence_list, parent=hou.ui.mainQtWindow(), title="Select a sequence to publish to") self.item_gui.submitted.connect(self.publish) def publish(self, value): self.name = value[0] sequence = self.project.get_sequence(self.name) if not sequence: sequence = self.project.create_sequence(self.name) if not sequence: qd.error("Bro, Stephanie really fumbled this one. No such sequence exists.") return self.element = sequence.get_element(Asset.LIGHTS) selection = hou.selectedNodes() if len(selection) != 1: qd.error( 'Please select a single Houdini Digital Asset node to publish.') return if not selection[0].type().definition(): qd.error( 'Please select a Houdini Digital Asset node to publish.') return hda = selection[0] definition = hda.type().definition() definition.updateFromNode(hda) self.nodeName = "sequence_" + self.name + "_lights" menuName = "Sequence " + self.name + " Lights" self.savePath = os.path.join(self.element._filepath, self.nodeName + "_main.hda") definition.copyToHDAFile(self.savePath, new_name=self.nodeName, new_menu_name=menuName) 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() self.element.update_app_ext(".hda") self.element.publish(username, self.savePath, comment, self.nodeName)
def create_asset(self): project = Project() asset_list = project.list_existing_assets() self.item_gui = sfl.SelectFromList(l=asset_list, parent=hou.ui.mainQtWindow(), title="Select an asset to create") self.item_gui.submitted.connect(self.asset_results)
def export(self): project = Project() asset_list = 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(passAlong)
def clone(self, quick=True): self.quick = quick self.project = Project() type_list = ["Model", "Rig", "Animation", "Camera"] self.item_gui = sfl.SelectFromList( l=type_list, parent=maya_main_window(), title="Select a type of asset to clone") self.item_gui.submitted.connect(self.type_results)
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)
class LightPublisher: def __init__(self): self.project = Project() def publish(self): shot_list = self.project.list_shots() self.item_gui = sfl.SelectFromList(l=shot_list, parent=hou.ui.mainQtWindow(), title="Select a shot to publish to") self.item_gui.submitted.connect(self.results) def results(self, value): self.shot_name = value[0] shot = self.project.get_shot(self.shot_name) if not shot: shot = self.project.create_shot(self.shot_name) if not shot: qd.error("Get Stephanie, because something broke bad.") self.element = shot.get_element(Asset.LIGHTS) if len(hou.selectedNodes()) != 1: qd.error("Only select the last node in the network of lights.") return last = hou.selectedNodes()[0] rop = hou.node("/stage").createNode("usd_rop") rop.setInput(0, last) self.savePath = os.path.join(self.element._filepath, "temp.usda") rop.parm("lopoutput").set(self.savePath) 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.comment = qd.HoudiniInput(parent=hou.qt.mainWindow(), title="Comment for publish?", info=publishes_string_list) self.comment.submitted.connect(self.comment_results) def comment_results(self, value): comment = str(value) username = Environment().get_user().get_username() self.element.update_app_ext(".usda") self.element.publish(username, self.savePath, comment, self.shot_name)
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 getFilePath(self, name): asset = Project().get_asset(name) path = asset.get_filepath() path = os.path.join(path, Asset.RIG) self.element = asset.get_element(Asset.RIG) path = os.path.join(path, name) last_version = self.element.get_last_version() current_version = last_version + 1 path = path + "_v" + str(current_version).zfill(3) + ".mb" print(path) return path
def getFilePath(self, name): asset = Project().get_asset(name) path = asset.get_filepath() path = os.path.join(path, Asset.GEO) self.element = Element(path) self.element.update_app_ext(".obj") path = os.path.join(path, name) last_version = self.element.get_last_version() current_version = last_version + 1 path = path + "_v" + str(current_version).zfill(3) + ".obj" # print(path) return path
def publish_asset(self, solaris): ''' this is what's called when the button is pushed. ''' project = Project() asset_list = project.list_assets() self.item_gui = sfl.SelectFromList(l=asset_list, parent=hou.ui.mainQtWindow(), title="Select an asset to publish") # call asset results function here to be used once selected if solaris: self.item_gui.submitted.connect(self.solaris_asset_results) else: self.item_gui.submitted.connect(self.asset_results)
def publish_shot(self): ''' publishes shot (entire .hip file). Nothing needs to be selected for this to work. ''' scene = hou.hipFile.name() print('file name is ' + scene) project = Project() # get project and its shots asset_list = project.list_shots() self.item_gui = sfl.SelectFromList( l=asset_list, parent=hou.qt.mainWindow(), title="Select a shot to publish to, my friend.") self.item_gui.submitted.connect(self.shot_results)
def results(self, value): print("Selected asset: " + value[0]) filename = value[0] self.body = Project().get_body(filename) self.element = self.body.get_element(Asset.USD) if self.element: path = self.element.get_last_publish()[3] if path: ref = hou.node("/stage").createNode("reference") ref.setName(filename + "_ref", 1) ref.parm("filepath1").set(path) ref.parm("primpath").set("/layout/" + filename) else: qd.error("Nothing was cloned")
class MatUpdater: def __init__(self): self.project = Project() def updateAll(self): obj = hou.node("/obj") mat = hou.node("/mat") for node in obj.allSubChildren(): if node.isMaterialManager(): for material in node.children(): self.updateOne(material) for node in mat.children(): self.updateOne(node) qd.message("Updated all materials") def updateOne(self, mat): assetList = self.project.list_assets() for asset in assetList: asset = re.sub(r'\W+', '', asset) typeName = mat.type().name() if typeName not in assetList: return #not a material from the pipe, move on if mat.isLockedHDA(): mat.allowEditingOfContents() mat.matchCurrentDefinition() mat.allowEditingOfContents() print(mat.name())
class ShotPublisher: def __init__(self): self.project = Project() def publish(self): shot_list = self.project.list_shots() self.item_gui = sfl.SelectFromList(l=shot_list, parent=hou.ui.mainQtWindow(), title="Select a shot to publish") self.item_gui.submitted.connect(self.results) def results(self, value): self.shot_name = value[0] shot = self.project.get_shot(self.shot_name) if not shot: shot = self.project.create_shot(self.shot_name) if not shot: qd.error("Get Stephanie, because something broke bad.") self.element = shot.get_element(Asset.HIP) self.path = os.path.join(self.element._filepath, "temp.hipnc") hou.hipFile.setName(self.shot_name) hou.hipFile.save(file_name=self.path, save_to_recent_files=False) 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.shot_name self.element.update_app_ext(".hipnc") self.element.publish(username, self.path, comment, name) self.element.update_assigned_user("")
def asset_results(self, value): self.fileName = value[0] selection = hou.selectedNodes() # If it is more than one or none, abort if len(selection) != 1: qd.error( 'Please select a single Houdini Digital Asset node to save and update version on.' ) return # If it is not a Houdini Digital Asset, abort if not selection[0].type().definition(): qd.error( 'Please select a single Houdini Digital Asset node to save and update version on.' ) return #add code to force node name/node type name hda_node = selection[0] definition = hda_node.type().definition() libraryFilePath = definition.libraryFilePath() self.filepath = libraryFilePath '''current_full_name = hda_node.type().name() # last index is current version current_version_string = hda_node.type().nameComponents()[-1] #current_major = current_version_string.split('.')[0] #print('major version is ' + current_major) #current_minor = current_version_string.split('.')[1] # Set the 3 digit revision number to 0 if the HDA is only using the single float versioning (1.0 and not 1.0.005) current_revision = 0 if len(current_version_string.split( '.')) < 3 else current_version_string.split('.')[2] all_definitions = hou.hda.definitionsInFile(libraryFilePath) # This sets the node to the latest version of those stored hda_node.changeNodeType(all_definitions[-1].nodeTypeName())''' definition.updateFromNode(hda_node) self.body = Project().create_asset(self.fileName) if self.body is None: self.body = Project().get_asset(self.fileName) if self.body is None: print("Stephanie did an oopsie whoopsie :'(") return self.input = qd.HoudiniInput(parent=hou.qt.mainWindow(), title="Comment ") self.input.submitted.connect(self.comment_results)
def get_body_from_reference(ref): try: body = Project().get_body(extract_reference_data(ref)[0]) return body except: print(str(ref) + " is not a body") return None
class UpdateShots: def __init__(self): self.project = Project() def update_shots(self): shot_list = ShotgunReader().getShotList() #print(shot_list) list_file = open( os.path.join(self.project.get_shots_dir(), ".shot_list"), "w") list_file.truncate(0) for shot in shot_list: #print("shot " + shot) list_file.write(shot + "\n") self.create_shot(shot) list_file.close() qd.message("Shots updated successfully.") def create_shot(self, shot): stage = hou.node("/stage") #print(shot) #check if there's already a shot hip file, and if so, don't do anything body = self.project.get_shot(shot) if not body: body = self.project.create_shot(shot) element = body.get_element(Asset.HIP) file_name = os.path.join(element._filepath, shot + "_main.hipnc") if os.path.exists(file_name) or element.get_last_version() >= 0: #don't save over work already done return #copy over the template file and publish it src = os.path.join(self.project.get_project_dir(), "template.hipnc") dst = os.path.join(element._filepath, "temp.hipnc") shutil.copyfile(src, dst) comment = "blank shot file" username = "******" element.update_app_ext(".hipnc") element.publish(username, dst, comment, shot)