def publish(
self,
selectedHDA=None
): #, departments=[Department.HDA, Department.ASSEMBLY, Department.MODIFY, Department.MATERIAL, Department.HAIR, Department.CLOTH]):
project = Project()
self.selectedHDA = selectedHDA
if selectedHDA is None:
nodes = hou.selectedNodes()
if len(nodes) == 1:
selectedHDA = nodes[0]
self.selectedHDA = selectedHDA
elif len(nodes) > 1:
qd.error(
'Too many nodes selected. Please select only one node.')
return
else:
qd.error('No nodes selected. Please select a node.')
return
if selectedHDA.type().definition() is not None:
self.src = selectedHDA.type().definition().libraryFilePath()
asset_list = project.list_props_and_characters()
self.item_gui = sfl.SelectFromList(
l=asset_list,
parent=houdini_main_window(),
title="Select an asset to publish to")
self.item_gui.submitted.connect(self.asset_results)
else:
qd.error('The selected node is not a digital asset')
return
def post_publish(element, user, published=True, comment="No comment."):
scene_file, created_new_file = get_scene_file()
if published:
if not mc.file(q=True, sceneName=True) == '':
mc.file(save=True, force=True) #save file
scene_prep()
username = user.get_username()
dst = element.publish(username, scene_file, comment)
#Ensure file has correct permissions
try:
os.chmod(dst, 0660)
except:
print("Setting file permissions failed badly.")
# Export JSON
print('Publish Complete. Begin Exporting JSON if set.')
body = Project().get_body(element.get_parent())
if body and body.is_asset():
if body.get_type() == AssetType.SET or body.get_type(
) == AssetType.SHOT:
json_export = JSONExporter()
json_export.go(body, body.get_type())
convert_to_education()
def shot_results(self, value):
shot_name = value[0]
project = Project()
body = project.get_body(shot_name)
element = body.get_element("lighting")
self.publishes = element.list_publishes()
print("publishes: ", self.publishes)
if not self.publishes:
# has not been imported. Import it first.
importer = Importer()
importer.import_shot([shot_name])
return
# make the list a list of strings, not tuples
self.sanitized_publish_list = []
for publish in self.publishes:
path = publish[3]
file_ext = path.split('.')[-1]
if not file_ext == "hip" and not file_ext == "hipnc":
continue
label = publish[0] + " " + publish[1] + " " + publish[2]
self.sanitized_publish_list.append(label)
self.item_gui = sfl.SelectFromList(l=self.sanitized_publish_list,
parent=houdini_main_window(),
title="Select publish to clone")
self.item_gui.submitted.connect(self.publish_selection_results)
def tab_in(self,
parent,
asset_name,
already_tabbed_in_node=None,
excluded_departments=[]):
print "Creating node for {0}".format(asset_name)
body = Project().get_body(asset_name)
if body is None or not body.is_asset():
qd.error(
"Pipeline error: This asset either doesn't exist or isn't an asset."
)
return
if body.get_type() == AssetType.CHARACTER:
return self.dcc_character(parent, asset_name,
already_tabbed_in_node,
excluded_departments)
elif body.get_type() == AssetType.PROP:
return self.dcc_geo(parent, asset_name, already_tabbed_in_node,
excluded_departments)
elif body.get_type() == AssetType.SET:
return self.dcc_set(parent, asset_name, already_tabbed_in_node)
else:
qd.error(
"Pipeline error: this asset isn't a character, prop or set.")
return
def results(self, value):
print("Final value: ", value[0])
filename = value[0]
project = Project()
body = project.get_body(filename)
element = body.get_element("model")
filepath = body.get_filepath()
self.publishes = element.list_publishes()
print("publishes: ", self.publishes)
print("path: ", filepath)
# make the list a list of strings, not tuples
self.sanitized_publish_list = []
for publish in self.publishes:
path = publish[3]
file_ext = path.split('.')[-1]
if not file_ext == "mb":
continue
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_utils.maya_main_window(),
title="Select publish to clone")
self.item_gui.submitted.connect(self.publish_selection_results)
def asset_results(self, value):
chosen_asset = value[0]
project = Project()
self.frame_range = qd.input("Enter frame range (as numeric input) or leave blank if none:")
if self.frame_range is None or self.frame_range == u'':
self.frame_range = 1
self.frame_range = str(self.frame_range)
if not self.frame_range.isdigit():
qd.error("Invalid frame range input. Setting to 1.")
self.body = project.get_body(chosen_asset)
self.body.set_frame_range(self.frame_range)
department_list = []
asset_type = self.body.get_type()
if str(asset_type) == 'prop':
department_list = self.body.prop_export_departments()
self.department_results(department_list)
elif str(asset_type) == 'character':
department_list = self.body.char_export_departments()
elif str(asset_type) == 'set':
department_list = self.body.set_export_departments()
elif str(asset_type) == 'shot':
department_list = self.body.shot_export_departments()
self.item_gui = sfl.SelectFromList(l=department_list, multiple_selection=True, parent=maya_main_window(), title="Select department(s) for this export: ")
self.item_gui.submitted.connect(self.department_results)
def dcc_character(self,
parent,
asset_name,
already_tabbed_in_node=None,
excluded_departments=[],
mode=UpdateModes.CLEAN,
shot=None):
# Set up the body/elements and make sure it's a character
body = Project().get_body(asset_name)
if not body.is_asset() or not body.get_type() == AssetType.CHARACTER:
qd.error("Must be a character.")
return None
# If there's an already tabbed in node, set it to that node
node = already_tabbed_in_node if already_tabbed_in_node else parent.createNode(
"dcc_character")
try:
node.setName(asset_name.title())
except:
node.setName(asset_name.title() + "_1", unique_name=True)
node.parm("asset_name").set(asset_name)
# Set the asset_name data tag
data = node.parm("data").evalAsJSONMap()
data["asset_name"] = asset_name
node.parm("data").set(data)
# Set the contents to the character's nodes
self.update_contents_character(node, asset_name, excluded_departments,
mode, shot)
return node
def confirmWritePropReference(self, body=None):
filepath = pm.sceneName()
fileDir = os.path.dirname(filepath)
project = Project()
if not body:
checkout = project.get_checkout(fileDir)
bodyName = checkout.get_body_name()
body = project.get_body(bodyName)
if body.is_asset() and body.get_type() == AssetType.PROP:
element = body.get_element(Department.MODEL)
filepath = os.path.join(project.get_assets_dir(),
element.get_cache_dir())
assemblies = pm.ls(assemblies=True)
pm.select(pm.listCameras(), replace=True)
cameras = pm.selected()
pm.select([])
non_cameras = [
assembly for assembly in assemblies if assembly not in cameras
]
self.exportPropJSON(filepath,
non_cameras[0],
isReference=False,
name=body.get_name())
print("JSON references written successfully.")
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:
# print a message about failure/duplicate
qd.error("Asset with name " + name +
" already exists in pipeline.")
else:
assembler = Assembler()
assembler.create_hda(name, body=body)
qd.info("Asset created successfully.", "Success")
else:
qd.error("Asset creation failed.")
def shot_comment(self, value):
comment = value
if comment is None:
comment = "publish by " + str(
user.get_username()) + " in department " + str(department)
chosen_asset = self.chosen_asset
project = Project()
self.body = project.get_body(chosen_asset)
department = Department.LIGHTING
element = self.body.get_element(department) #, Element.DEFAULT_NAME)
hou.hipFile.save()
src = hou.hipFile.name()
#Publish
user = Environment().get_user()
pipeline_io.set_permissions(src)
dst = self.publish_element(element, user, src, comment)
pipeline_io.set_permissions(dst)
message = "Successfully published " + str(self.body.get_name()) + "!"
self.print_success_message(message)
def import_shot(self):
shots = Project().list_shots()
self.item_gui = sfl.SelectFromList(l=shots,
parent=utils.get_main_window(),
title="Select a shot to import:")
self.item_gui.submitted.connect(self.results)
def results(self, values):
selection = str(values[0])
shot = Project().get_body(selection)
comp_element = shot.get_element(Department.COMP)
self.publishes = comp_element.list_publishes()
os.environ["DCC_NUKE_ASSET_NAME"] = selection
if not self.publishes:
# has not been imported. Import it first.
shot_importer = importer.NukeImporter()
shot_importer.shot_results([selection])
return
else:
# get the latest publish
username = Environment().get_current_username()
try:
filepath = comp_element.checkout(username)
except:
filepath = comp_element.get_last_publish()[3]
if os.path.exists(filepath):
qd.info("Opening file, please wait.")
nuke.scriptOpen(filepath)
else:
qd.error("Couldn't find the file.")
def rollback_element(self, node, department, name):
self.node = node
self.department = department
project = Project()
body = project.get_body(name)
element = body.get_element(department)
self.publishes = element.list_publishes()
print("publishes: ", self.publishes)
if not self.publishes:
qd.error("There have been no publishes for this department. Rollback failed.")
return
# make the list a list of strings, not tuples
self.sanitized_publish_list = []
for publish in self.publishes:
path = publish[3]
file_ext = path.split('.')[-1]
if not file_ext == "hda" and not file_ext =="hdanc":
continue
label = publish[0] + " " + publish[1] + " " + publish[2]
self.sanitized_publish_list.append(label)
self.item_gui = sfl.SelectFromList(l=self.sanitized_publish_list, parent=houdini_main_window(), title="Select publish to clone")
self.item_gui.submitted.connect(self.publish_selection_results)
def has_parent_set(rootNode):
project = Project()
parent_is_set = False
parent_node = rootNode.getParent()
while parent_node is not None:
print("parent node: ", parent_node)
parent_body = get_body_from_reference(parent_node)
print("parent body: ", parent_body)
if parent_body is not None and parent_body.is_asset(
) and parent_body.get_type() == AssetType.SET:
parent_is_set = True
break
try:
parent_node = parent_node.parent_node()
except:
print(str(parent_node) + " is top level")
parent_node = None
if parent_is_set:
return True
return False
def export(self, element, selection=None, startFrame=None, endFrame=None):
project = Project()
bodyName = element.get_parent()
body = project.get_body(bodyName)
abcFilePath = element.get_cache_dir()
self.element = element
if startFrame is None:
startFrame = pm.playbackOptions(q=True, animationStartTime=True)
if endFrame is None:
endFrame = pm.playbackOptions(q=True, animationEndTime=True)
if body.is_shot():
startFrame -= 1
endFrame = int(endFrame)
endFrame += 1
endFrame = str(endFrame)
files = self.exportReferences(abcFilePath,
tag='DCC_Alembic_Export_Flag',
startFrame=startFrame,
endFrame=endFrame)
if self.cameras:
files.extend(self.export_cameras(body, startFrame, endFrame))
elif body.is_asset():
if body.get_type() == AssetType.SET:
files = self.exportReferences(abcFilePath)
else:
files = self.exportAll(abcFilePath,
tag='DCC_Alembic_Export_Flag',
element=element)
elif body.is_crowd_cycle():
files = self.exportAll(abcFilePath,
tag='DCC_Alembic_Export_Flag',
startFrame=startFrame,
endFrame=endFrame,
element=element)
if not files:
#Maybe this is a bad distinction but None is if it was canceled or something and empty is if it went but there weren't any alembics
if files is None:
return
qd.error(
'No alembics were exported. Make sure the top-level group is tagged.'
)
return
for abcFile in files:
os.system('chmod 774 ' + abcFile)
exported_asset_names = ""
for file in files:
asset_file_name = str(file).rpartition('/')[2]
exported_asset_names += asset_file_name + '\n'
qd.info("Alembics exported successfully: " + '\n' +
exported_asset_names)
return files
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)
def publish(
self,
selectedHDA=None
): #, departments=[Department.HDA, Department.ASSEMBLY, Department.MODIFY, Department.MATERIAL, Department.HAIR, Department.CLOTH]):
project = Project()
self.selectedHDA = selectedHDA
if self.selectedHDA is None:
self.selectedHDA = get_selected_node()
if self.selectedHDA is None:
return
if self.selectedHDA.type().definition() is not None:
self.src = self.selectedHDA.type().definition().libraryFilePath()
if self.node_name:
self.asset_results([self.node_name])
return
asset_list = project.list_props_and_actors()
self.item_gui = sfl.SelectFromList(
l=asset_list,
parent=houdini_main_window(),
title="Select an asset to publish to")
self.item_gui.submitted.connect(self.asset_results)
else:
qd.error('The selected node is not a digital asset')
return
def asset_results(self, value):
chosen_asset = value[0]
project = Project()
self.body = project.get_body(chosen_asset)
self.comment = qd.HoudiniInput(parent=houdini_main_window(),
title="Any comments?")
self.comment.submitted.connect(self.publish_hda)
def clone_set(self):
project = Project()
asset_list = project.list_sets()
self.asset_gui = sfl.SelectFromList(l=asset_list,
parent=houdini_main_window(),
title="Select a set to clone")
self.asset_gui.submitted.connect(self.asset_results)
def playblast(self):
asset_list = Project().list_assets()
self.item_gui = sfl.SelectFromList(
l=asset_list,
parent=maya_main_window(),
title="Select an asset to playblast")
self.item_gui.submitted.connect(self.asset_results)
def clone_shot(self):
self.quick = True
project = Project()
asset_list = project.list_shots()
self.item_gui = sfl.SelectFromList(l=asset_list,
parent=maya_main_window(),
title="Select a shot to clone")
self.item_gui.submitted.connect(self.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
def confirmWriteShotReferences(self, body=None):
filePath = pm.sceneName()
filDir = os.path.dirname(filePath)
proj = Project()
if not body:
checkout = proj.get_checkout(fileDir)
bodyName = checkout.get_body_name()
body = proj.get_body(bodyName)
if body.is_shot():
print("SHOT OK")
element = body.get_element(Department.ANIM)
refsFilePath = os.path.join(Project().get_assets_dir(), element.get_cache_dir())
self.export_shot(refsFilePath)
else:
print("NOT A SHOT")
qd.error('No set found in current scene.')
def clone_hda(self, hda=None):
project = Project()
asset_list = project.list_props_and_actors()
self.item_gui = sfl.SelectFromList(l=asset_list,
parent=houdini_main_window(),
title="Select an asset to clone")
self.item_gui.submitted.connect(self.asset_results)
def clone_tool(self, node=None):
self.project = Project()
hda_list = self.project.list_hdas()
self.item_gui = sfl.SelectFromList(l=hda_list,
parent=houdini_main_window(),
title="Select a tool to clone")
self.item_gui.submitted.connect(self.tool_results)
def publish_set(self, node=None):
self.departments = [Department.ASSEMBLY]
project = Project()
set_list = project.list_sets()
self.item_gui = sfl.SelectFromList(l=set_list,
parent=houdini_main_window(),
title="Select a set to publish")
self.item_gui.submitted.connect(self.set_results)
def go(self):
project = Project()
asset_list = project.list_shots()
self.item_gui = sfl.SelectFromList(
l=asset_list,
parent=maya_main_window(),
title="Select shots to clear Ribs/IFDs",
multiple_selection=True)
self.item_gui.submitted.connect(self.results)
def generateGeometry(self, path='',element=None):
'''
Function for generating geometry for Maya files.
Creates the following output formats:
.obj
@return: True if all files were created successfully
False if some files were not created
@post: Missing filenames are printed out to both the Maya terminal as well
as presented in a Maya confirm dialog.
'''
path = os.path.dirname(mc.file(q=True, sceneName=True))
if not os.path.exists (os.path.join(path, 'cache')):
os.makedirs(os.path.join(path, 'cache'))
ABCPATH = os.path.join(path, 'cache', 'abcFiles')
if os.path.exists(ABCPATH):
shutil.rmtree(ABCPATH)
filePath = mc.file(q=True, sceneName=True)
fileDir = os.path.dirname(filePath)
abcFilePath = self.getElementCacheDirectory(fileDir, element)
if abcFilePath is None:
return False
selection = mc.ls(geometry=True, visible=True)
selection_long = mc.ls(geometry=True, visible=True, long=True)
project = Project()
if element is None:
checkout = project.get_checkout(path)
if checkout is None:
qd.error('There was a problem exporting the alembic to the correct location. Checkout the asset again and try one more time.')
return None
body = project.get_body(checkout.get_body_name())
element = body.get_element(checkout.get_department_name(), checkout.get_element_name())
else:
body = project.get_body(element.get_parent())
# We decided to try exporting all the geo into one alembic file instead of many. This is the line that does many
# abcs = abcExport(selection_long, ABCPATH)
# if body.is_asset():
# if body.get_type() == AssetType.SET:
# abcs = self.abcExportLoadedReferences(ABCPATH)
# else:
# abcs = self.abcExportAll(element.get_long_name(), ABCPATH)
# else:
abcs = self.abcExportAll(element.get_long_name(), ABCPATH)
if not len(self.checkFiles(abcs)) == 0:
return False
return True
def publish_shot(self):
scene = hou.hipFile.name()
self.departments = [Department.HDA, Department.LIGHTING, Department.FX]
project = Project()
asset_list = project.list_shots()
self.item_gui = sfl.SelectFromList(l=asset_list,
parent=houdini_main_window(),
title="Select a shot to publish to")
self.item_gui.submitted.connect(self.shot_results)
def confirmWriteSetReferences(self, body=None):
filePath = pm.sceneName()
fileDir = os.path.dirname(filePath)
proj = Project()
if not body:
checkout = proj.get_checkout(fileDir)
bodyName = checkout.get_body_name()
body = proj.get_body(bodyName)
if body.is_asset():
if body.get_type() == AssetType.SET:
print("SET OK")
element = body.get_element(Department.MODEL)
refsFilePath = os.path.join(Project().get_assets_dir(), element.get_cache_dir())
self.exportReferences(refsFilePath)
qd.info("JSON references written successfully.")
else:
print("NOT A SET")
qd.error('No set found in current scene.')