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)
