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)
class UsdReader:
def __init__(self):
pm.loadPlugin("mayaUsdPlugin")
self.project = Project()
def go(self, quick=True):
self.quick = quick
shot_list = self.project.list_shots()
self.item_gui = sfl.SelectFromList(
l=shot_list, parent=maya_main_window(), title="Which shot is this layout in?")
self.item_gui.submitted.connect(self.shot_results)
def shot_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("This is real :'( (but the shot you picked isn't. talk to stephanie)")
self.element = self.shot.get_element(Asset.LAYOUT)
if self.element is None:
qd.warning("Nothing was cloned.")
return
if self.quick:
path = os.path.join(self.element._filepath, self.shot_name+".usda")
if os.path.exists(path):
self.open_scene_file(path)
return
else:
self.choose_layout()
return
self.publishes = self.element.list_publishes()
if not self.publishes:
self.choose_layout()
return
# make the list a list of strings, not tuples
self.sanitized_publish_list = []
for publish in self.publishes:
label = publish[0] + " " + publish[1] + " " + publish[2]
self.sanitized_publish_list.append(label)
self.item_gui =sfl.SelectFromList(
l=self.sanitized_publish_list, parent=maya_main_window(), title="Select publish to clone")
self.item_gui.submitted.connect(self.publish_selection_results)
def publish_selection_results(self, value):
selected_publish = None
for item in self.sanitized_publish_list:
if value[0] == item:
selected_publish = item
selected_scene_file = None
for publish in self.publishes:
label = publish[0] + " " + publish[1] + " " + publish[2]
if label == selected_publish:
selected_scene_file = publish[3]
# selected_scene_file is the one that contains the scene file for the selected commit
self.open_scene_file(selected_scene_file)
def open_scene_file(self, selected_scene_file):
if selected_scene_file is not None:
if not os.path.exists(selected_scene_file):
qd.error(
"That publish is missing. It may have been deleted to clear up space.")
return False
else:
# do the thing
command = "mayaUsd_createStageFromFilePath(\"" + selected_scene_file + "\")"
pm.Mel.eval(command)
return True
else:
return False
def choose_layout(self):
layout_list = self.project.list_layouts()
self.item_gui =sfl.SelectFromList(
l=layout_list, parent=maya_main_window(), title="Select layout to clone")
self.item_gui.submitted.connect(self.layout_results)
def layout_results(self, value):
layout_name = value[0]
layout = self.project.get_layout(layout_name)
layout_element = layout.get_element(Asset.LAYOUT)
src = os.path.join(layout_element._filepath, layout_name + "_ref.usda")
dst = os.path.join(self.element._filepath, self.shot_name + ".usda")
shutil.copy(src, dst)
pio.set_permissions(dst)
# basically set up a fake publish since we're not doing version control on this file
self.element._datadict[self.element.LATEST_VERSION] = 0
timestamp = pio.timestamp()
username = Environment().get_user().get_username()
self.element._datadict[self.element.PUBLISHES].append((username, timestamp, "initial publish", dst))
self.element._update_pipeline_file()
self.open_scene_file(dst)
class LayoutPublisher:
def __init__(self):
self.project = Project()
def publish(self):
if len(hou.selectedNodes()) != 1:
qd.error("Select only the last node in the network")
return
layout_list = Project().list_layouts()
self.item_gui = sfl.SelectFromList(l=layout_list, parent=hou.qt.mainWindow(), title="Which layout are you publishing?")
self.item_gui.submitted.connect(self.results)
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)
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.layout_name)
if self.element.get_last_version() == 0:
# if it is the first publish, we have to make the referencing file as well
# create a reference node
ref = hou.node("/stage").createNode("reference")
# set the values to reference the main publish file, etc.
ref.parm("primpath").set("/layout")
ref.parm("filepath1").set(self.element.get_last_publish()[3])
# create a USD ROP node and connect it to the ref node
refrop = hou.node("/stage").createNode("usd_rop")
refrop.setInput(0, ref)
# set the values in the ROP and save to disk alongside the main publish
refrop.parm("lopoutput").set(os.path.join(self.element._filepath, self.layout_name + "_ref.usda"))
refrop.parm("enableoutputprocessor_simplerelativepaths").set(0)
refrop.parm("execute").pressButton()
pio.set_permissions(os.path.join(self.element._filepath, self.layout_name + "_ref.usda"))
# this only needs to be done once since with every new publish, the file being referenced gets updated
ref.destroy()
refrop.destroy()
