def populate_files(*args):
"""
clears the file list, then populates based on the phase and the selected asset in the asset TSL
"""
clear_file_list()
selTab = cmds.tabLayout(widgets["assetsTab"], q=True, st=True)
tab, phase, assetPath, assetFiles = [None, None, None, None]
if selTab != "STGS":
tab, phase, assetPath, assetFiles = get_asset_info()
else:
tab, phase, assetPath, assetFiles = get_stage_info()
if assetFiles:
for file in assetFiles:
cmds.textScrollList(widgets["filesTSL"],
e=True,
a=os.path.basename(file))
else:
cmds.textScrollList(widgets["filesTSL"], e=True, a="No Files")
currFile = cmds.file(q=True, sn=True)
if currFile:
fileObj = uf.PathParser(currFile)
if fileObj.compatible and (os.path.basename(currFile) in assetFiles):
cmds.textScrollList(widgets["filesTSL"],
e=True,
si=os.path.basename(currFile))
else:
# get the last file and select that
numItems = cmds.textScrollList(widgets["filesTSL"], q=True, ni=True)
cmds.textScrollList(widgets["filesTSL"], e=True, sii=numItems)
def publish_fbx_folder(origScene=None, *args):
"""
now go through the folder path and open each, open the gameexp, then populate the export path, then exportgo
ARGS:
path (string): the path to the folder that we need to parse through (path to mb files)
"""
pathP = uf.PathParser(origScene)
mbpubpath = pathP.phasePath + "/Publish/MB/{0}_v{1}".format(
pathP.variant, pathP.versionString)
fbxpubpath = pathP.phasePath + "/Publish/FBX/{0}_v{1}".format(
pathP.variant, pathP.versionString)
# get the maya files
mbFiles = fnmatch.filter(os.listdir(mbpubpath), "*.mb")
for mb in mbFiles:
mel.eval("gameFbxExporter;")
print "========= multiRefAnimExport.publish_fbx_folder: opening {0}/{1}".format(
mbpubpath, mb)
cmds.file("{0}/{1}".format(mbpubpath, mb), open=True, f=True)
# delete textures
shdEngines = cmds.ls(type="shadingEngine")
for sh in shdEngines:
shd = cmds.listConnections("{0}.surfaceShader".format(sh))
inCons = cmds.listConnections(shd, s=True, d=False)
if inCons:
print "multiRefAnimExport.publish_fbx_folder: deleting:", inCons
cmds.delete(inCons)
# find anything that is not lining up with the file we've opened (ie. came in via export selected connections)
lookfor = mb.split("_")[2]
# print "LOOK FOR: {0}".format(lookfor)
exclude = ["persp", "top", "side", "front"]
assemblies = cmds.ls(assemblies=True)
# print "ASSEMBLIES: ", assemblies
for a in assemblies:
if not a.startswith(lookfor) and (a not in exclude):
print "------ deleting: ", a
cmds.delete(a)
cmds.file(s=True, f=True)
filename = "{0}_{1}_{2}_{3}".format(pathP.name, pathP.variant,
"_".join(mb.split("_")[3:-1]),
"_".join(mb.split("_")[2:3]))
if not os.path.isdir(fbxpubpath):
os.makedirs(fbxpubpath)
node = cmds.ls(type="gameFbxExporter")[-1]
# set path and file name
uf.set_gameExport_info(node, fbxpubpath, filename)
# run exporter
print "========= multiRefAnimExport.publish_fbx_folder: trying to publish FBX {0}/{1}".format(
mbpubpath, mb)
mel.eval("gameExp_DoExport;")
return (True)
def __init__(self, ns, ref, deferred, status):
self.pathParse = uf.PathParser(ref)
self.compatible = self.pathParse.compatible
self.variant = None
self.ref = ref # the reference path
self.namespace = ns # the namespace
self.versionNums = [
] # list of strings of the version numberss (i.e. ["0001", "0003"])
self.versionNum = "" # astring of the version number (ie. "0005")
self.status = status # status = "current" or "pending"
self.killState = False # should this be killed?
self.loadState = not deferred # should this be loaded (vs. unloaded)?
self.state = False # False means it has NOT been changed
self.vchange = False # version change state
self.lchange = False # load change state
self.kchange = False # kill change state
self.varchange = False # variant change state
if self.status == "current":
ReferenceObject.currentObjList.append(self)
if self.status == "pending":
ReferenceObject.pendingObjList.append(self)
ReferenceObject.existingRefList.append(self.ref)
ReferenceObject.allObjectList.append(self)
# create a dictionary of all variants and their versions
self.variantDict = self.create_variant_dict()
self.create_UI()
def change_stage_tab(*args):
"""
when tab changes, just select first in the list
"""
currTab = cmds.tabLayout(widgets["assetsTab"], q=True, st=True)
currScene = cmds.file(q=True, sn=True)
if currTab == "CHARS":
tsl = "char"
if currTab == "PROPS":
tsl = "prop"
if currTab == "SETS":
tsl = "set"
if currTab == "STGS":
tsl = "stage"
if currScene:
# try to find in the current scene
pp = uf.PathParser(currScene)
if pp.compatible:
if pp.name in cmds.textScrollList(widgets["{0}TSL".format(tsl)],
q=True,
allItems=True):
cmds.textScrollList(widgets["{0}TSL".format(tsl)],
e=True,
si=pp.name)
else:
cmds.textScrollList(widgets["{0}TSL".format(tsl)],
e=True,
sii=1)
else:
cmds.textScrollList(widgets["{0}TSL".format(tsl)], e=True, sii=1)
else:
cmds.textScrollList(widgets["{0}TSL".format(tsl)], e=True, sii=1)
populate_files()
def finish_up(versionUp=True, origScene=None, *args):
"""
do final clean up stuff
ARGS:
pp (PathParser object)
"""
pp = uf.PathParser(origScene)
if versionUp:
verNum = int(pp.path[-7:-3])
pp.get_version_info()
nums = pp.versionNumbers
newNum = nums[-1]
verUpFile = "{0}{1}{2}".format(origScene[:-7], str(newNum).zfill(4),".mb")
if os.path.isfile(verUpFile):
print "multiRefAnimExport.finish_up: Opening version up file:", verUpFile
cmds.file(verUpFile, open=True, force=True)
else:
print "multiRefAnimExport.finish_up: Couldn't find version up, opening original file: ",pp.path
cmds.file(pp.path, open=True, force=True)
else:
print "multiRefAnimExport.finish_up: Opening original file: ",pp.path
cmds.file(pp.path, open=True, force=True)
if cmds.window("gameExporterWindow", exists=True):
cmds.deleteUI("gameExporterWindow")
# reload file win
fm.fileManager()
cmds.confirmDialog(m="Animation published successfully!", t="Stage Publish")
def create_namespace(filepath, *args):
"""
get a file path and trim that down to new namespace, which will be incremented based on existing namespaces
ex. instead of "Fish_Main_Rigging_Publish_v0002", will be "Fish_Main_Rig" or "Fish_Main_Rig1"
ARGS:
filepath (string): the filepath to derive the name from
RETURN:
string: the incremented namespace
"""
f = uf.PathParser(filepath)
phase = f.phase
if phase == "Modeling":
phase = "Mdl"
if phase == "Rigging":
phase = "Rig"
if phase == "Animation":
phase = "Anm"
if phase == "Lighting":
phase = "Lgt"
namespace = "{0}_{1}_{2}".format(f.name, f.variant, phase)
if namespace in namespaceList:
incrementedName = increment_namespace(namespace, namespaceList)
else:
incrementedName = namespace
print "creating Namespace {0} for {1}".format(incrementedName, filepath)
return(incrementedName)
def select_initial(*args):
"""
tries to select the first item in chars, if not, then props, etc. If no item, pass
!! finish this later
"""
# if we're in a scene with a name
filename = cmds.file(q=True, sn=True)
if filename:
fileObj = uf.PathParser(filename)
# if that scene is compatible
if fileObj.compatible:
# get the asset type - select the tab
if fileObj.assetType == "Character":
assType, assTab = "CHARS", "charTSL"
if fileObj.assetType == "Props":
assType, assTab = "PROPS", "propTSL"
if fileObj.assetType == "Sets":
assType, assTab = "SETS", "setTSL"
if fileObj.assetType == "Stages":
assType, assTab = "STGS", "stageTSL"
cmds.tabLayout(widgets["assetsTab"], e=True, st=assType)
# get the phase - select the menu
cmds.optionMenu(widgets["phaseOM"], e=True, value=fileObj.phase)
cmds.textScrollList(widgets[assTab], e=True, si=fileObj.name)
else:
cmds.textScrollList(widgets["charTSL"], e=True, sii=1)
else:
cmds.textScrollList(widgets["charTSL"], e=True, sii=1)
populate_files()
def assetPublish(versionUp=True, *args):
"""
checks the current scene if it's compatible, if not kick out
ARGS:
versionUp (bool): whether to version up the work file on publish
"""
origScene = cmds.file(q=True, sn=True)
pp = uf.PathParser(origScene)
# bail if current scene is not compatible
if not pp.compatible:
cmds.warning("assetPublish.publish_maya_scene: You're not in a project compatible scene! Sorry. See a TD")
return()
# if it's not a stage file or a publish file and it's either modeling or rigging phase
if pp.assetType != "Stages" and pp.phase in ["Rigging", "Modeling", "Texturing", "Lighting"] and pp.stage=="Work":
mayapub = publish_maya_scene(versionUp, origScene)
if not mayapub: # i.e. we've failed somewhere in the func
return()
else:
print "===== not doing standard maya asset publish, since you're in {0} phase and {1} stage of the pipeline".format(pp.phase, pp.stage)
# if it's modeling or texturing phase - fbx export
if pp.assetType != "Stages" and pp.phase in ["Modeling", "Texturing"] and pp.stage=="Work":
fbxPub = publish_fbx_model_file(versionUp, origScene)
if not fbxPub:
return()
# if it's a rig work file
if pp.assetType != "Stages" and pp.phase in ["Rigging"] and pp.stage=="Work":
fbxPub = publish_fbx_rig_file(versionUp, origScene)
if not fbxPub:
return()
# if it's an anm work file
if pp.assetType != "Stages" and pp.phase in ["Animation"] and pp.stage=="Work":
fbxPub = publish_fbx_anim_file(versionUp, origScene)
if not fbxPub:
return()
print "----- freezing so you can export anim"
return()
if versionUp:
verNum = int(pp.path[-7:-3])
pp.get_version_info()
nums = pp.versionNumbers
newNum = nums[-1]
verUpFile = "{0}{1}{2}".format(origScene[:-7], str(newNum).zfill(4),".mb")
if os.path.isfile(verUpFile):
print "assetPublish.assetPublish: Opening version up file:", verUpFile
cmds.file(verUpFile, open=True, force=True)
else:
print "assetPublish.assetPublish: Couldn't find version up, opening original file: ",pp.path
cmds.file(pp.path, open=True, force=True)
else:
print "assetPublish.assetPublish: Opening original file: ",pp.path
cmds.file(pp.path, open=True, force=True)
def stagePublish(versionUp=True, *args):
"""
checks the current scene if it's compatible, if not kick out
ARGS:
versionUp (bool): whether to version up the work file on publish
"""
origScene = cmds.file(q=True, sn=True)
pp = uf.PathParser(origScene)
# bail if current scene is not compatible
if not pp.compatible:
cmds.warning(
"assetPublish.publish_maya_scene: You're not in a project compatible scene! Sorry. See a TD"
)
return ()
# # publish the current maya scene to Publish folder
# if pp.phase in ["Animation"] and pp.stage=="Work":
# mayapub = publish_maya_scene(versionUp, origScene)
# if not mayapub: # i.e. we've failed somewhere in the func
# return()
# else:
# print "===== not doing standard maya anim publish, since you're in {0} phase and {1} stage of the pipeline".format(pp.phase, pp.stage)
# if it's an anm work file
if pp.phase in ["Animation"] and pp.stage == "Work":
get_reference_list_UI(versionUp, origScene)
if not publishState:
cmds.warning(
"There was an issue publishing the assets somewhere. Leaving multiref publishing!"
)
return ()
publish_fbx_folder(origScene)
if versionUp:
verNum = int(pp.path[-7:-3])
pp.get_version_info()
nums = pp.versionNumbers
newNum = nums[-1]
verUpFile = "{0}{1}{2}".format(origScene[:-7],
str(newNum).zfill(4), ".mb")
if os.path.isfile(verUpFile):
print "assetPublish.assetPublish: Opening version up file:", verUpFile
cmds.file(verUpFile, open=True, force=True)
else:
print "assetPublish.assetPublish: Couldn't find version up, opening original file: ", pp.path
cmds.file(pp.path, open=True, force=True)
else:
print "assetPublish.assetPublish: Opening original file: ", pp.path
cmds.file(pp.path, open=True, force=True)
if cmds.window("gameExporterWindow", exists=True):
cmds.deleteUI("gameExporterWindow")
def publish_maya_scene(versionUp=True, origScene=None, *args):
"""
only do for rigging and modeling phase of assets
ARGS:
versionUp (bool): whether to version up the maya scene
origScene (string): the full path to the file to publish
"""
if not origScene:
cmds.warning("assetPublish.publish_maya_scene: You haven't passed in a scene path!")
return(False)
pp = uf.PathParser(origScene)
cmds.file(s=True)
sel = cmds.ls(sl=True)
if not sel:
cmds.warning("assetManager.publish_maya_scene: You haven't selected anything in your scene. Please select what you wish to publish. (hint: for models, your geo/geo grp. For rigs, usually it will be your char group and ctrl set)")
return(False)
if versionUp:
verNum = int(origScene[-7:-3])
pp.get_version_info()
nums = pp.versionNumbers
newNum = nums[-1]+1
verUpFile = "{0}{1}{2}".format(origScene[:-7], str(newNum).zfill(4),".mb")
# parse the new path/name for publish(current scene)
pubPath = uf.fix_path(os.path.join(pp.phasePath, "Publish/MB/"))
tokens = pp.fileName.split("_")
tokens[-2] = "Publish"
pubFileName = "_".join(tokens)
pubFilePath = uf.fix_path(os.path.join(pubPath, pubFileName))
if os.path.isfile(pubFilePath):
overwrite = cmds.confirmDialog(title="Overwrite Confirmation", message = "A publish MB already exists for this file.\nShould we overwrite?", button = ("Overwrite", "Cancel"), defaultButton = "Overwrite", cancelButton = "Cancel", dismissString = "Cancel")
if overwrite == "Cancel":
print "Publish skipped (no overwrite) for maya file (.mb) stage of {0}".format(pubFilePath)
return(True)
if versionUp:
# in background copy the orig to the new version
# (essentially just versioning up while staying in old version)
copy2(origScene, verUpFile)
print "===== Versioned up {0} to {1}!".format(origScene, verUpFile)
else:
print "===== Not versioning up publish of {0}".format(origScene)
# export selection to publish file
print "===== AssetPublish.publish_maya_scene: Preparing to export items to publish file: {0}".format(sel)
export = cmds.file(pubFilePath, exportSelected=True, type="mayaBinary")
if export==pubFilePath:
print "===== AssetPublish.publish_maya_scene: Succesfully published file to: {0}".format(pubFilePath)
return(True)
def get_version_up_name(origScene, *args):
"""
from orig scene (assuming it's compatible with pipe) will return the fullpath to next version
"""
pp2 = uf.PathParser(origScene)
verNum = int(origScene[-7:-3])
pp2.get_version_info()
nums = pp2.versionNumbers
newNum = nums[-1] + 1
verUpFile = "{0}{1}{2}".format(origScene[:-7], str(newNum).zfill(4), ".mb")
return (verUpFile)
def select_initial(proj, counter, *args):
"""
tries to select the first item in chars, if not, then props, etc. If no item, pass
!! finish this later
ARGS:
proj (AssetInfo object)
counter (string)
"""
# if we're in a scene with a name
filename = cmds.file(q=True, sn=True)
if filename:
fileObj = uf.PathParser(filename)
# if that scene is compatible
if fileObj.compatible and fileObj.stage == "Work":
# get the asset type - select the tab
if fileObj.assetType == "Character":
assType, assTab = "CHARS", "charTSL"
if fileObj.assetType == "Props":
assType, assTab = "PROPS", "propTSL"
if fileObj.assetType == "Sets":
assType, assTab = "SETS", "setTSL"
if fileObj.assetType == "Stages":
assType, assTab = "STGS", "stageTSL"
cmds.tabLayout(widgets["assetsTab"], e=True, st=assType)
# get the phase - select the menu
cmds.optionMenu(widgets["phaseOM"], e=True, value=fileObj.phase)
cmds.textScrollList(widgets[assTab], e=True, si=fileObj.name)
else:
#get current tab, select the first item in the corresponding tsl
tab = cmds.tabLayout(widgets["assetsTab"], q=True, st=True)
if tab == "CHARS":
asstab = "charTSL"
if tab == "PROPS":
asstab = "propTSL"
if tab == "SETS":
asstab = "setTSL"
if tab == "STGS":
asstab = "stageTSL"
cmds.textScrollList(widgets[asstab], e=True, sii=1)
else:
cmds.tabLayout(widgets["assetsTab"], e=True, st="CHARS")
cmds.textScrollList(widgets["charTSL"], e=True, sii=1)
if counter:
load = load_layout()
if load:
cmds.optionMenu(widgets["phaseOM"], e=True, v=load)
counter = None
populate_files(proj)
def publish_fbx_model_file(versionUp=True, origScene=None, *args):
"""
publishes fbx for model and texture files
ARGS:
versionUp (bool): whether we should version up the Maya scene after publish or not
origScene (string): the full to the original Maya scene file
RETURN:
bool: whether we've successfully published or not
"""
# all happens in current:
if not origScene:
cmds.warning(
"assetPublish.publish_fbx_rig_file: You haven't passed in a scene path!"
)
return (False)
pp = uf.PathParser(origScene)
sel = cmds.ls(sl=True)
if not sel:
cmds.warning("You need to select the objects to export! Try again.")
return (False)
pubFbxPath = uf.fix_path(os.path.join(pp.phasePath, "Publish/FBX/"))
tokens = pp.fileName.split("_")
tokens[-2] = "Publish"
pubFileName = "_".join(tokens)[:-3] + ".fbx"
pubFilePath = uf.fix_path(os.path.join(pubFbxPath, pubFileName))
# check for references in selection? Or just import references from the fbx exporter?
if os.path.isfile(pubFilePath):
overwrite = cmds.confirmDialog(
title="Overwrite Confirmation",
message=
"A publish FBX already exists for this file.\nShould we overwrite?",
button=("Overwrite", "Cancel"),
defaultButton="Overwrite",
cancelButton="Cancel",
dismissString="Cancel")
if overwrite == "Cancel":
print "Publish skipped for FBX file (.fbx) called {0}".format(
pubFilePath)
return (True)
mel.eval('FBXLoadExportPresetFile -f "{0}";'.format(modelPreset))
mel.eval(
'FBXExport -f "{0}" -s'.format(pubFilePath)) # f-> force, s->selected
return (True)
def __init__(self, filePath=None, selectionBased=False, *args):
self.dict = {}
self.projEnvPath = os.environ["MAYA_PROJECT_PATH"]
self.selBased = selectionBased
self.filePath = filePath
print "filePath: ", self.filePath
self.proj = ai.AssetInfo()
self.pp = uf.PathParser(filePath)
if not self.pp.compatible:
# dummy check that the folders exist
files = self.proj.get_asset_contents(self.proj.charsPath[0])
self.filepath = "{0}{1}".format(self.proj.charsPath[0], files[0])
self.assetList = self.proj.get_asset_name_list()
self.saveAs_UI()
def create_variant_dict(self):
self.pathParse.get_variants_list()
phase = "/".join(self.pathParse.path.split("/")[:7])
varDict = {}
for variant in self.pathParse.variantList:
varFile = self.pathParse.fileName.split("_")
varFile[-4] = variant
varName = "_".join(varFile)
varPath = "{0}/{1}".format(self.pathParse.stagePath, varName)
tempPath = uf.PathParser(varPath)
tempPath.get_version_info()
versions = tempPath.versionNumbersString
varDict[variant] = versions
return (varDict)
def stagePublish(versionUp=True, *args):
"""
checks the current scene if it's compatible, if not kick out
ARGS:
versionUp (bool): whether to version up the work file on publish
"""
origScene = cmds.file(q=True, sn=True)
pp = uf.PathParser(origScene)
# bail if current scene is not compatible
if not pp.compatible:
cmds.warning("assetPublish.publish_maya_scene: You're not in a project compatible scene! Sorry. See a TD")
return()
# if it's an anm work file
if pp.phase in ["Animation"] and pp.stage=="Work":
get_reference_list_UI(versionUp, origScene)
def populate_files(proj, *args):
"""
clears the file list, then populates based on the phase and the selected asset in the asset TSL
"""
proj = ai.AssetInfo()
clear_file_list()
selTab = cmds.tabLayout(widgets["assetsTab"], q=True, st=True)
tab, phase, assetPath, assetFiles = [None, None, None, None]
if selTab != "STGS":
tab, phase, assetPath, assetFiles = get_asset_info(proj)
else:
tab, phase, assetPath, assetFiles = get_stage_info(proj)
if assetFiles:
for file in assetFiles:
a = cmds.textScrollList(widgets["filesTSL"],
e=True,
a=os.path.basename(file))
else:
cmds.textScrollList(widgets["filesTSL"], e=True, a="No Files")
# add popmenu to the list object to go to explorer
cmds.popupMenu(p=widgets["filesTSL"])
cmds.menuItem(l="Open Folder in Explorer", c=get_path_explorer)
# try to line up the current scene in the file list
currFile = cmds.file(q=True, sn=True)
if currFile:
fileObj = uf.PathParser(currFile)
if fileObj.compatible and (os.path.basename(currFile) in assetFiles):
cmds.textScrollList(widgets["filesTSL"],
e=True,
si=os.path.basename(currFile))
else:
# get the last file and select that
numItems = cmds.textScrollList(widgets["filesTSL"], q=True, ni=True)
cmds.textScrollList(widgets["filesTSL"], e=True, sii=numItems)
def update_all_references(*args):
# if scene is modded, should we save?
mod = cmds.file(q=True, modified=True)
if mod:
test = save_current_dialog()
if not test:
return ()
# get all refs
refs = cmds.file(q=True, r=True)
# # for each ref file
for ref in refs:
# make path object
print "updateAllReferences: checking: {0}".format(ref)
rfn = cmds.file(ref, q=True, rfn=True)
path = None
pathparse = uf.PathParser(ref)
if pathparse.compatible:
brackets = ""
if fnmatch.fnmatch(ref, "*{*}"):
parts = ref.partition("{")
brackets = parts[1] + parts[2]
# get current version string
thisVer = pathparse.versionString
# get the version list for that file
pathparse.get_version_info()
print "Current: {0} vs. {1}".format(
thisVer, pathparse.versionNumbersString[-1])
if thisVer != pathparse.versionNumbersString[-1]:
print "----- updating {1} to version {1}".format(
rfn, pathparse.versionNumbersString[-1])
path = pathparse.pathNoNum + pathparse.versionNumbersString[
-1] + ".mb" + brackets
cmds.file(path, loadReference=rfn, type="mayaBinary")
else:
print "Not a pipeline compatible ref. Skipping! -- {0}".format(ref)
pathparse = None
def publish_fbx_folder(path, *args):
"""
now go through the folder path and open each, open the gameexp, then populate the export path, then exportgo
"""
pathP = uf.PathParser(path)
mbpubpath = pathP.phasePath + "/Publish/MB/{0}_v{1}".format(
pathP.variant, pathP.versionString)
fbxpubpath = pathP.phasePath + "/Publish/FBX/{0}_v{1}".format(
pathP.variant, pathP.versionString)
# get the maya files
mbFiles = fnmatch.filter(os.listdir(mbpubpath), "*.mb")
for mb in mbFiles:
mel.eval("gameFbxExporter;")
print "========= multiRefAnimExport.publish_fbx_folder: opening {0}/{1}".format(
mbpubpath, mb)
cmds.file("{0}/{1}".format(mbpubpath, mb), open=True, f=True)
filename = "{0}_{1}_{2}".format(pathP.name, pathP.variant,
"_".join(mb.split("_")[3:-1]))
# check if there is more than two assemblies
# excludeAss = ["persp", "front", "side", "top"]
# assemblies = [x for x in cmds.ls(assemblies=True) if x not in excludeAss]
# if len(assemblies)>2:
# # grab pairs and export
if not os.path.isdir(fbxpubpath):
os.makedirs(fbxpubpath)
node = cmds.ls(type="gameFbxExporter")[-1]
# set path and file name
uf.set_gameExport_info(node, fbxpubpath, filename)
# run exporter
print "========= multiRefAnimExport.publish_fbx_folder: trying to publish FBX {0}/{1}".format(
mbpubpath, mb)
mel.eval("gameExp_DoExport;")
def publish_fbx_anim_file(versionUp=True, origScene=None, *args):
# THIS IS FOR ANIM EXPORTING
# save current scene
# check whether gameexport plug in is loaded
mel.eval("gameFbxExporter;")
# version up
if versionUp:
verUpFile = get_version_up_name(origScene)
copy2(origScene, verUpFile)
print "===== Versioned up {0} to {1}!".format(origScene, verUpFile)
else:
print "===== Not versioning up publish of {0}".format(origScene)
if not origScene:
cmds.warning(
"assetPublish.publish_fbx_anim_file: You haven't passed in a scene path!"
)
return (False)
# assuming references
refs = cmds.file(q=True, r=True)
if not refs:
cmds.warning("There are no references in this scene. . .")
return (False)
if len(refs) > 1:
cmds.warning("There are too many references in this scene. . .")
return (False)
# below would all be under a for loop for each reference in the stages?
pp = uf.PathParser(origScene)
# assuming a namespace
geoGrp = cmds.ls("*:GEO")
jntGrp = cmds.ls("*:EXPORT_JNT_Grp")
# check for geo grps
if not geoGrp or len(geoGrp) > 1:
cmds.warning(
"AssetPublish.publish_fbx_anim_file:You either have no grp called 'GEO' -IN A NAMESPACE-, or too many objects called 'GEO'.\n fbx export aborted!"
)
return (False)
geos = child_match_check(geoGrp[0], "*_Geo_Grp")
if not geos:
return (False)
# check for jnt grps
if not jntGrp or len(jntGrp) > 1:
cmds.warning(
"AssetPublish.publish_fbx_anim_file:You either have no grp called 'EXPORT_JNT_Grp' -IN A NAMESPACE-, or too many objects called 'EXPORT_JNT_Grp'.\n fbx export aborted!"
)
return (False)
roots = child_match_check(jntGrp[0], "*_Root_Jnt")
if not roots:
return (False)
# check correspondence of geo and root jnts
correspond = check_correspondence(geos, roots)
if not correspond:
return (False)
cmds.file(refs[0], ir=True)
pubFbxPath = uf.fix_path(os.path.join(pp.phasePath, "Publish/FBX/"))
tokens = pp.fileName.split("_")
tokens[-2] = "Publish"
pubFileName = "_".join(tokens)[:-3] + ".fbx"
pubFilePath = uf.fix_path(os.path.join(pubFbxPath, pubFileName))
start, end = uf.get_frame_range()
# bake joints
for r in roots:
# get child roots if joints
allD = cmds.listRelatives(r, allDescendents=True)
jnts = [x for x in allD if cmds.objectType(x, isa="joint")]
# function to bake selected on all jnts under this root
bake_selected(jnts, start, end)
namespace = cmds.file(refs[0], q=True, ns=True)
uf.remove_namespaces()
# delete constraints
cmds.delete(cmds.ls(type="constraint"))
cmds.select(cl=True)
# move jnts and geo into world parent
for root in roots:
rootremove = "{0}:".format(namespace)
basename = root.split(":")[1].split("_Root_Jnt")[0]
geo = "{0}_Geo_Grp".format(basename)
root = "{0}_Root_Jnt".format(basename)
cmds.parent([geo, root], w=True)
tokens[-2] = basename
pubFileName = "_".join(tokens)[:-3]
pubFilePath = uf.fix_path(os.path.join(pubFbxPath, pubFileName))
rootremove = "{0}:".format(namespace)
cmds.select([root, geo], r=True)
# do this the cmds way
nodes = mel.eval("gameExp_GetGameFbxExporterNodeList()")
cmds.select(nodes, add=True)
keep = [root, geo]
for node in nodes:
keep.append(node)
# delete all other top level nodes
delete_other_top_level_nodes(keep)
# if this exists, should we overwrite?
if os.path.isfile(pubFilePath):
overwrite = cmds.confirmDialog(
title="Overwrite Confirmation",
message=
"A publish FBX already exists for this file.\nShould we overwrite?",
button=("Overwrite", "Cancel"),
defaultButton="Overwrite",
cancelButton="Cancel",
dismissString="Cancel")
if overwrite == "Cancel":
print "Publish skipped for FBX file (.fbx) called {0}".format(
pubFilePath)
return (True)
# get path for maya publish
pubsplits = pubFilePath.split("/")
pubsplits[-2] = "MB"
mayapubpath = "/".join(pubsplits)
# just export maya scene here. . . to publish (need to get mb path)
# get the latest "gameExporterPreset*" for export (not sure if latest what we want?)
if not nodes:
cmds.warning(
"You don't have any game export nodes in your scene. Just exporting a straight fbx clip!"
)
mel.eval('FBXLoadExportPresetFile -f "{0}";'.format(anmPreset))
mel.eval('FBXExport -f "{0}" -s'.format(pubFilePath + ".fbx"))
else:
print "===== anim publish:\n- saving {0}".format(mayapubpath +
".mb")
cmds.file(mayapubpath + ".mb", es=True, f=True, type="mayaBinary")
print "- opening {0}".format(mayapubpath + ".mb")
hold = cmds.file(mayapubpath + ".mb", o=True, f=True)
print "-formatting and exporting"
# check that we're doing all we can here. . . .
# uf.set_gameExport_info(gnodes[-1], filepath, filename)
ge.set_and_export(pubFilePath + ".fbx")
return (True)
def publish_fbx_rig_file(versionUp=True, origScene=None, *args):
"""
requires an EXPORT_JNT_Grp group with one root for each export rig named: 'name_Root_Jnt'
requires a GEO group with one folder for each export rig named: 'name_Geo_Grp'
names should correspond ("fish_Root_Jnt", "fish_Geo_Grp")
"""
# all happens in current:
if not origScene:
cmds.warning(
"assetPublish.publish_fbx_rig_file: You haven't passed in a scene path!"
)
return (False)
pp = uf.PathParser(origScene)
geoGrp = cmds.ls("GEO")
jntGrp = cmds.ls("EXPORT_JNT_Grp")
# check for geo grps
if not geoGrp or len(geoGrp) > 1:
cmds.warning(
"AssetPublish.publish_fbx_rig_file:You either have no grp called 'GEO', or too many objects called 'GEO'.\n fbx export aborted!"
)
return (False)
geos = child_match_check(geoGrp, "*_Geo_Grp")
if not geos:
return (False)
# check for jnt grps
if not jntGrp or len(jntGrp) > 1:
cmds.warning(
"AssetPublish.publish_fbx_rig_file:You either have no grp called 'EXPORT_JNT_Grp', or too many objects called 'EXPORT_JNT_Grp'.\n fbx export aborted!"
)
return (False)
roots = child_match_check(jntGrp, "*_Root_Jnt")
if not roots:
cmds.warning(
"AssetPublish.publish_fbx_rig_file: Couldn't find anything under {0} called '*_Root_Jnt'"
.format(jntGrp))
return (False)
# check correspondence
correspond = check_correspondence(geos, roots)
if not correspond:
return (False)
pubFbxPath = uf.fix_path(os.path.join(pp.phasePath, "Publish/FBX/"))
tokens = pp.fileName.split("_")
tokens[-2] = "Publish"
pubFileName = "_".join(tokens)[:-3] + ".fbx"
pubFilePath = uf.fix_path(os.path.join(pubFbxPath, pubFileName))
# check if there's any animation in the file (time based), abort if there is
# check for references, etc. .
# delete constraints
cmds.delete(cmds.ls(type="constraint"))
cmds.select(cl=True)
# move jnts and geo into world parent
for root in roots:
basename = root.split("_Root_Jnt")[0]
geo = "{0}_Geo_Grp".format(basename)
cmds.parent([geo, root], w=True)
# create filename
tokens[-2] = basename
pubFileName = "_".join(tokens)[:-3] + ".fbx"
pubFilePath = uf.fix_path(os.path.join(pubFbxPath, pubFileName))
cmds.select([root, geo], r=True)
# if this exists, should we overwrite?
if os.path.isfile(pubFilePath):
overwrite = cmds.confirmDialog(
title="Overwrite Confirmation",
message=
"A publish FBX already exists for this file.\nShould we overwrite?",
button=("Overwrite", "Cancel"),
defaultButton="Overwrite",
cancelButton="Cancel",
dismissString="Cancel")
if overwrite == "Cancel":
print "Publish skipped for FBX file (.fbx) called {0}".format(
pubFilePath)
return (True)
mel.eval('FBXLoadExportPresetFile -f "{0}";'.format(rigPreset))
mel.eval('FBXExport -f "{0}" -s'.format(pubFilePath))
return (True)
def publish_fbx_anim_file(versionUp=True, origScene=None, *args):
"""
This is for asset anim exporting. File requires ONE AND ONLY ONE reference
"""
# save current scene
# check whether gameexport plug in is loaded
mel.eval("gameFbxExporter;")
# version up
if versionUp:
verUpFile = get_version_up_name(origScene)
copy2(origScene, verUpFile)
print "===== Versioned up {0} to {1}!".format(origScene, verUpFile)
else:
print "===== Not versioning up publish of {0}".format(origScene)
if not origScene:
cmds.warning(
"assetPublish.publish_fbx_anim_file: You haven't passed in a scene path!"
)
return (False)
refs = cmds.file(q=True, r=True)
if not refs:
cmds.warning("There are no references in this scene. . .")
return (False)
if len(refs) > 1:
cmds.warning("There are too many references in this scene. . .")
return (False)
pp = uf.PathParser(origScene)
# assuming a namespace
geoGrp = cmds.ls("*:GEO")
jntGrp = cmds.ls("*:EXPORT_JNT_Grp")
# check for geo grps
if not geoGrp or len(geoGrp) > 1:
cmds.warning(
"AssetPublish.publish_fbx_anim_file:You either have no grp called 'GEO' -IN A NAMESPACE-, or too many objects called 'GEO'.\n fbx export aborted!"
)
return (False)
geos = child_match_check(geoGrp[0], "*_Geo_Grp")
if not geos:
return (False)
# check for jnt grps
if not jntGrp or len(jntGrp) > 1:
cmds.warning(
"AssetPublish.publish_fbx_anim_file:You either have no grp called 'EXPORT_JNT_Grp' -IN A NAMESPACE-, or too many objects called 'EXPORT_JNT_Grp'.\n fbx export aborted!"
)
return (False)
roots = child_match_check(jntGrp[0], "*_Root_Jnt")
if not roots:
return (False)
# check correspondence of geo and root jnts
correspond = check_correspondence(geos, roots)
if not correspond:
return (False)
cmds.file(refs[0], ir=True)
pubFbxPath = uf.fix_path(
os.path.join(
pp.phasePath,
"Publish/FBX/{0}_v{1}".format(pp.variant, pp.versionString)))
print pubFbxPath
if not os.path.isdir(pubFbxPath):
os.makedirs(pubFbxPath)
tokens = pp.fileName.split("_")[:3]
pubFileName = "_".join(tokens) + ".fbx"
pubFilePath = uf.fix_path(os.path.join(pubFbxPath, pubFileName))
start, end = uf.get_frame_range()
# bake joints
for r in roots:
# get child roots if joints
allD = cmds.listRelatives(r, allDescendents=True)
jnts = [x for x in allD if cmds.objectType(x, isa="joint")]
# function to bake selected on all jnts under this root
bake_selected(jnts, start, end)
namespace = cmds.file(refs[0], q=True, ns=True)
uf.remove_namespaces()
# delete constraints
cmds.delete(cmds.ls(type="constraint"))
cmds.select(cl=True)
# move jnts and geo into world parent
for root in roots:
rootremove = "{0}:".format(namespace)
basename = root.split(":")[1].split("_Root_Jnt")[0]
geo = "{0}_Geo_Grp".format(basename)
root = "{0}_Root_Jnt".format(basename)
cmds.parent([geo, root], w=True)
tokens[-1] = basename
pubFileName = "_".join(tokens)
pubFilePath = uf.fix_path(os.path.join(pubFbxPath, pubFileName))
rootremove = "{0}:".format(namespace)
cmds.select([root, geo], r=True)
nodes = cmds.ls(type="gameFbxExporter")
if not nodes:
cmds.warning(
"AssetPublish.publish_fbx_anim_files: You don't have any game exporter nodes in your scene! Aborting!"
)
return ()
cmds.select(nodes, add=True)
keep = [root, geo]
for node in nodes:
keep.append(node)
# delete all other top level nodes
delete_other_top_level_nodes(keep)
# if this exists, should we overwrite?
if os.path.isfile(pubFilePath):
overwrite = cmds.confirmDialog(
title="Overwrite Confirmation",
message=
"A publish FBX already exists for this file.\nShould we overwrite?",
button=("Overwrite", "Cancel"),
defaultButton="Overwrite",
cancelButton="Cancel",
dismissString="Cancel")
if overwrite == "Cancel":
print "Publish skipped for FBX file (.fbx) called {0}".format(
pubFilePath)
return (True)
# get path for maya publish
pubsplits = pubFilePath.split("/")
pubsplits[-3] = "MB"
mayapubpath = "/".join(pubsplits)
# if there's not a game export node, just export an fbx, otherwise do the game export all to one clip
if not nodes:
cmds.warning(
"You don't have any game export nodes in your scene. Just exporting a straight fbx animation!"
)
mel.eval('FBXLoadExportPresetFile -f "{0}";'.format(anmPreset))
mel.eval('FBXExport -f "{0}" -s'.format(pubFilePath + ".fbx"))
else:
print "===== anim publish:\n- saving {0}".format(mayapubpath +
".mb")
cmds.file(mayapubpath + ".mb", es=True, f=True, type="mayaBinary")
print "multiRefAnimExport.publish_fbx_anim_file: opening {0}".format(
mayapubpath + ".mb")
hold = cmds.file(mayapubpath + ".mb", o=True, f=True)
# set the export parameters
uf.set_gameExport_info(nodes[-1], pubFbxPath, pubFileName)
print "========= multiRefAnimExport.publish_fbx_anim_file: trying to publish FBX {0}/{1}".format(
pubFbxPath, pubFileName + ".fbx")
#game export
mel.eval("gameExp_DoExport;")
return (True)
def publish_fbx_anim_file(versionUp=True, origScene=None, references=None, *args):
"""
Assumes we're in an anim assembly scene that contains referenced rigs (only one namespace)
This will spit out maya scenes that are ready for fbx export. One maya scene per reference object in the current scene, each of which contains only the mesh and joint groups that need to be exported. These scenes contain all available 'rigs' from that asset.
Args:
versionup (bool): whether we should version up the current scene
origscene (string): the full path to the original scene we're trying to publish
references (list): list of the reference paths in the scene to deal with
Returns:
bool: whether we've run through all successfully
"""
cmds.file(s=True)
# check whether game exporter plugin is loaded, load if not
uf.plugin_load("gameFbxExporter")
# check if there are any gmae export nodes, bail if not? or bail in the later stage - calling function
# version up
if versionUp:
verUpFile = get_version_up_name(origScene)
copy2(origScene, verUpFile)
print "===== Versioned up {0} to {1}!".format(origScene, verUpFile)
else:
print "===== Not versioning up publish of {0}".format(origScene)
if not origScene:
cmds.warning("assetPublish.publish_fbx_anim_file: You haven't passed in a scene path!")
publishState = False
return()
# assuming references
refs = references
if not refs:
cmds.warning("There are no references in this scene. . .")
publishState = False
return()
# cull out the bad references from our input list
goodRefs = cull_bad_references(refs)
# bake all jnts THEN do all the rest
for ref in goodRefs:
namespace = cmds.file(ref, q=True, ns=True)
print "BAKING JOINTS FOR: {0}".format(namespace)
geoGrp = cmds.ls("{0}:GEO".format(namespace))
jntGrp = cmds.ls("{0}:EXPORT_JNT_Grp".format(namespace))
geos = child_match_check(geoGrp[0], "*_Geo_Grp")
roots = child_match_check(jntGrp[0], "*_Root_Jnt")
start, end = uf.get_frame_range()
# bake joints
for r in roots:
# get child roots if joints
allD = cmds.listRelatives(r, allDescendents=True)
jnts = [x for x in allD if cmds.objectType(x, isa="joint")]
# function to bake selected on all jnts under this root
bake_selected(jnts, start, end)
for ref in goodRefs:
pp = uf.PathParser(origScene)
namespace = cmds.file(ref, q=True, ns=True)
geoGrp = cmds.ls("{0}:GEO".format(namespace))
jntGrp = cmds.ls("{0}:EXPORT_JNT_Grp".format(namespace))
# imports the reference
cmds.file(ref, ir=True)
geos = child_match_check(geoGrp[0], "*_Geo_Grp")
roots = child_match_check(jntGrp[0], "*_Root_Jnt")
# here's where we'd do the folder (figure out path stuff) - add the variant name
pubFbxPath = uf.fix_path(os.path.join(pp.phasePath, "Publish/MB/{0}_v{1}".format(pp.variant, pp.versionString)))
print "------- trying to make directory: {0}".format(pubFbxPath)
if not os.path.exists(pubFbxPath):
os.makedirs(pubFbxPath)
tokens = pp.fileName.split("_")
tokens[-2] = namespace
start, end = uf.get_frame_range()
# delete constraints
cmds.delete(cmds.ls("{0}:*".format(namespace), type="constraint"))
cmds.select(cl=True)
# get list of roots in this ref
fullKeepList = []
for root in roots:
basename = root.split(":")[1].split("_Root_Jnt")[0]
geo = "{0}:{1}_Geo_Grp".format(namespace, basename)
root = "{0}:{1}_Root_Jnt".format(namespace, basename)
cmds.parent([geo, root], w=True)
fullKeepList.append(geo)
fullKeepList.append(root)
cmds.select(fullKeepList, r=True)
delete_other_top_level_nodes(cmds.ls(sl=True))
try:
cmds.namespace(mv=[namespace, ":"], f=True)
cmds.namespace(rm=namespace)
except:
cmds.warning("NAMESPACE PROBLEM!", namespace)
# collect the roots to export
for root in roots:
exportList = []
basename = root.split(":")[1].split("_Root_Jnt")[0]
geo = "{0}_Geo_Grp".format(basename)
root = "{0}_Root_Jnt".format(basename)
nodes = cmds.ls(type="gameFbxExporter")
exportList.append(root)
exportList.append(geo)
for node in nodes:
exportList.append(node)
cmds.select(exportList, r=True)
print "multiRefAnimExport.publish_fbx_anim_file: exporting -- \n {0}".format(exportList)
# strip away namespace (if it's there)
tokens[2] = basename
pubFileName = "_".join(tokens)
pubFilePath = uf.fix_path(os.path.join(pubFbxPath, pubFileName))
# if this exists, should we overwrite?
if os.path.isfile(pubFilePath):
overwrite = cmds.confirmDialog(title="Overwrite Confirmation", message = "A publish FBX already exists for this file.\nShould we overwrite?", button = ("Overwrite", "Cancel"), defaultButton = "Overwrite", cancelButton = "Cancel", dismissString = "Cancel")
if overwrite == "Cancel":
print "multiRefAnimExport.publish_fbx_anim_file:Publish skipped for FBX file (.fbx) called {0}".format(pubFilePath)
return()
print "===== anim publish:\n- saving {0}".format(pubFilePath)
cmds.file(pubFilePath + ".mb", es=True, f=True, type="mayaBinary")
return(True)
def assetPublish(versionUp=True, *args):
"""
checks the current scene if it's compatible, if not kick out
ARGS:
versionUp (bool): whether to version up the work file on publish
"""
origScene = cmds.file(q=True, sn=True)
print "-------ORIG SCENE line 414", origScene
pp = uf.PathParser(origScene)
# bail if current scene is not compatible
if not pp.compatible:
cmds.warning(
"assetPublish.assetPublish: You're not in a project compatible scene! Sorry. See a TD"
)
return ()
# if it's not a stage file or a publish file and it's either modeling or rigging phase
if pp.assetType != "Stages" and pp.phase in [
"Rigging", "Modeling", "Texturing", "Lighting"
] and pp.stage == "Work":
mayapub = publish_maya_scene(versionUp, origScene)
if not mayapub: # i.e. we've failed somewhere in the func
return ()
else:
print "===== not doing standard maya asset publish, since you're in {0} phase and {1} stage of the pipeline".format(
pp.phase, pp.stage)
# lets check if the fbx plugin is loaded
uf.plugin_load("fbxmaya")
# if it's modeling or texturing phase - fbx export
if pp.assetType != "Stages" and pp.phase in ["Modeling", "Texturing"
] and pp.stage == "Work":
fbxPub = publish_fbx_model_file(versionUp, origScene)
if not fbxPub:
return ()
# if it's a rig work file
if pp.assetType != "Stages" and pp.phase in ["Rigging"
] and pp.stage == "Work":
fbxPub = publish_fbx_rig_file(versionUp, origScene)
if not fbxPub:
return ()
# if it's an anm work file
if pp.assetType != "Stages" and pp.phase in ["Animation"
] and pp.stage == "Work":
fbxPub = publish_fbx_anim_file(versionUp, origScene)
if not fbxPub:
return ()
if versionUp:
verNum = int(pp.path[-7:-3])
pp.get_version_info()
nums = pp.versionNumbers
newNum = nums[-1]
verUpFile = "{0}{1}{2}".format(origScene[:-7],
str(newNum).zfill(4), ".mb")
if os.path.isfile(verUpFile):
print "assetPublish.assetPublish: Opening version up file:", verUpFile
cmds.file(verUpFile, open=True, force=True)
else:
print "assetPublish.assetPublish: Couldn't find version up, opening original file: ", pp.path
cmds.file(pp.path, open=True, force=True)
else:
print "assetPublish.assetPublish: Opening original file: ", pp.path
cmds.file(pp.path, open=True, force=True)
# close the game export window
if cmds.window("gameExporterWindow", exists=True):
cmds.deleteUI("gameExporterWindow")
# reload file win
fm.fileManager()
cmds.confirmDialog(m="Asset Publish Sucessful!", t="AssetPublish")
def publish_fbx_anim_file(versionUp=True, origScene=None, *args):
# THIS IS FOR ANIM EXPORTING
if not origScene:
cmds.warning("assetPublish.publish_fbx_anim_file: You haven't passed in a scene path!")
return(False)
# assuming references
refs = cmds.file(q=True, r=True)
if not refs:
cmds.warning("There are no references in this scene. . .")
return(False)
if len(refs) > 1:
cmds.warning("There are too many references in this scene. . .")
return(False)
# below would all be under a for loop for each reference in the stages?
pp = uf.PathParser(origScene)
# assuming a namespace
geoGrp = cmds.ls("*:GEO")
jntGrp = cmds.ls("*:EXPORT_JNT_Grp")
# check for geo grps
if not geoGrp or len(geoGrp)>1:
cmds.warning("AssetPublish.publish_fbx_anim_file:You either have no grp called 'GEO' -IN A NAMESPACE-, or too many objects called 'GEO'.\n fbx export aborted!")
return(False)
geos = child_match_check(geoGrp[0], "*_Geo_Grp")
if not geos:
return(False)
# check for jnt grps
if not jntGrp or len(jntGrp)>1:
cmds.warning("AssetPublish.publish_fbx_anim_file:You either have no grp called 'EXPORT_JNT_Grp' -IN A NAMESPACE-, or too many objects called 'EXPORT_JNT_Grp'.\n fbx export aborted!")
return(False)
roots = child_match_check(jntGrp[0], "*_Root_Jnt")
if not roots:
return(False)
cmds.file(refs[0], ir=True)
# check correspondence of geo and root jnts
correspond = check_correspondence(geos, roots)
if not correspond:
return(False)
pubFbxPath = uf.fix_path(os.path.join(pp.phasePath, "Publish/FBX/"))
tokens = pp.fileName.split("_")
tokens[-2] = "Publish"
pubFileName = "_".join(tokens)[:-3] + ".fbx"
pubFilePath = uf.fix_path(os.path.join(pubFbxPath, pubFileName))
# bake joints
for r in roots:
# get child roots if joints
allD = cmds.listRelatives(r, allDescendents=True)
jnts = [x for x in allD if cmds.objectType(x, isa="joint")]
# function to bake selected
for j in jnts:
attr=["t","r","s"]
co=["x","y","z"]
attrLs=[]
for at in attr:
for c in co:
attrLs.append("%s.%s%s"%(j,at,c))
for x in attrLs:
try:
mc.setAttr(x, k=1)
except:
pass
namespace = cmds.file(refs[0], q=True, ns=True)
uf.remove_namespaces()
# delete constraints
cmds.delete(cmds.ls(type="constraint"))
cmds.select(cl=True)
# move jnts and geo into world parent
for root in roots:
basename = root.split("_Root_Jnt")[0]
geo = "{0}_Geo_Grp".format(basename)
cmds.parent([geo, root], w=True)
# create filename
tokens[-2] = basename
pubFileName = "_".join(tokens)[:-3] + ".fbx"
pubFilePath = uf.fix_path(os.path.join(pubFbxPath, pubFileName))
cmds.select([root, geo], r=True)
# if this exists, should we overwrite?
if os.path.isfile(pubFilePath):
overwrite = cmds.confirmDialog(title="Overwrite Confirmation", message = "A publish FBX already exists for this file.\nShould we overwrite?", button = ("Overwrite", "Cancel"), defaultButton = "Overwrite", cancelButton = "Cancel", dismissString = "Cancel")
if overwrite == "Cancel":
print "Publish skipped for FBX file (.fbx) called {0}".format(pubFilePath)
return(True)
mel.eval('FBXLoadExportPresetFile -f "{0}";'.format(preset))
mel.eval('FBXExport -f "{0}" -s'.format(pubFilePath))
return(True)
# loop through namespaces/references:
# import reference
# delete namespace
# loop through joint grps, geo grps:
# bake jnts
# clean up joints shit
# "CloudStage_Tree_main_Rig1_A_v0001.fbx"
# stage asset ns subgrp version
# check for version folder, create it if it doesn't exist
pass
def publish_fbx_anim_file(versionUp=True, origScene=None, *args):
"""
Assumes we're in an anim assembly scene that contains referenced rigs (only one namespace)
This will spit out maya scenes that are ready for fbx export. One maya scene per reference object in the current scene, each of which contains only the mesh and joint groups that need to be exported. These scenes contain all available 'rigs' from that asset.
Args:
versionup (bool): whether we should version up the current scene
origscene (string): the full path to the original scene we're trying to publish
Returns:
bool: whether we've run through all successfully
"""
cmds.file(s=True)
# check whether game exporter plugin is loaded, load if not
uf.plugin_load("gameFbxExporter")
# version up
if versionUp:
verUpFile = get_version_up_name(origScene)
copy2(origScene, verUpFile)
print "===== Versioned up {0} to {1}!".format(origScene, verUpFile)
else:
print "===== Not versioning up publish of {0}".format(origScene)
if not origScene:
cmds.warning(
"assetPublish.publish_fbx_anim_file: You haven't passed in a scene path!"
)
return (False)
# assuming references
refs = cmds.file(q=True, r=True)
if not refs:
cmds.warning("There are no references in this scene. . .")
return (False)
for ref in refs:
pp = uf.PathParser(origScene)
namespace = cmds.file(ref, q=True, ns=True)
# assuming a namespace
geoGrp = cmds.ls("{0}:GEO".format(namespace))
jntGrp = cmds.ls("{0}:EXPORT_JNT_Grp".format(namespace))
# check for geo grps
if not geoGrp:
cmds.warning(
"AssetPublish.publish_fbx_anim_file:You have no grp called 'GEO' -IN A NAMESPACE-.\n fbx export aborted!"
)
return (False)
geos = child_match_check(geoGrp[0], "*_Geo_Grp")
if not geos:
return (False)
# check for jnt grps
if not jntGrp:
cmds.warning(
"AssetPublish.publish_fbx_anim_file:You either have no grp called 'EXPORT_JNT_Grp' -IN A NAMESPACE-.\n fbx export aborted!"
)
return (False)
roots = child_match_check(jntGrp[0], "*_Root_Jnt")
if not roots:
return (False)
# imports the reference
cmds.file(ref, ir=True)
# check correspondence of geo and root jnts
correspond = check_correspondence(geos, roots)
if not correspond:
return (False)
# here's where we'd do the folder (figure out path stuff) - add the variant name
pubFbxPath = uf.fix_path(
os.path.join(
pp.phasePath,
"Publish/MB/{0}_v{1}".format(pp.variant, pp.versionString)))
print "------- trying to make dirctory: {0}".format(pubFbxPath)
if not os.path.exists(pubFbxPath):
os.mkdir(pubFbxPath)
tokens = pp.fileName.split("_")
tokens[-2] = namespace
start, end = uf.get_frame_range()
# bake joints
for r in roots:
# get child roots if joints
allD = cmds.listRelatives(r, allDescendents=True)
jnts = [x for x in allD if cmds.objectType(x, isa="joint")]
# function to bake selected on all jnts under this root
bake_selected(jnts, start, end)
# delete constraints
cmds.delete(cmds.ls("{0}:*".format(namespace), type="constraint"))
cmds.select(cl=True)
# list for what to keep in this reference
keepList = []
# parent each root to world
for root in roots:
basename = root.split(":")[1].split("_Root_Jnt")[0]
geo = "{0}:{1}_Geo_Grp".format(namespace, basename)
root = "{0}:{1}_Root_Jnt".format(namespace, basename)
cmds.parent([geo, root], w=True)
# make this a more generic way to get the game nodes!! (search for type)
nodes = cmds.ls(type="gameFbxExporter")
keepList.append(root)
keepList.append(geo)
for node in nodes:
keepList.append(node)
cmds.select(keepList, r=True)
# strip away namespace
cmds.namespace(mv=[namespace, ":"], f=True)
cmds.namespace(rm=namespace)
# delete all other top level nodes
delete_other_top_level_nodes(cmds.ls(sl=True))
pubFileName = "_".join(tokens)
pubFilePath = uf.fix_path(os.path.join(pubFbxPath, pubFileName))
# if this exists, should we overwrite?
if os.path.isfile(pubFilePath):
overwrite = cmds.confirmDialog(
title="Overwrite Confirmation",
message=
"A publish FBX already exists for this file.\nShould we overwrite?",
button=("Overwrite", "Cancel"),
defaultButton="Overwrite",
cancelButton="Cancel",
dismissString="Cancel")
if overwrite == "Cancel":
print "Publish skipped for FBX file (.fbx) called {0}".format(
pubFilePath)
return (True)
# else:
print "===== anim publish:\n- saving {0}".format(pubFilePath + ".mb")
cmds.file(pubFilePath + ".mb", es=True, f=True, type="mayaBinary")
return (True)
def publish_fbx_anim_file(versionUp=True, origScene=None, *args):
# THIS IS FOR ANIM EXPORTING
# save current scene
# move this to end and use Zed's script to version up afterwards? ? maybe?
# version up
if versionUp:
verUpFile = get_version_up_name(origScene)
copy2(origScene, verUpFile)
print "===== Versioned up {0} to {1}!".format(origScene, verUpFile)
else:
print "===== Not versioning up publish of {0}".format(origScene)
if not origScene:
cmds.warning(
"assetPublish.publish_fbx_anim_file: You haven't passed in a scene path!"
)
return (False)
# assuming references
refs = cmds.file(q=True, r=True)
if not refs:
cmds.warning("There are no references in this scene. . .")
return (False)
if len(refs) > 1:
cmds.warning("There are too many references in this scene. . .")
return (False)
# below would all be under a for loop for each reference in the stages?
pp = uf.PathParser(origScene)
# assuming a namespace
geoGrp = cmds.ls("*:GEO")
jntGrp = cmds.ls("*:EXPORT_JNT_Grp")
# check for geo grps
if not geoGrp or len(geoGrp) > 1:
cmds.warning(
"AssetPublish.publish_fbx_anim_file:You either have no grp called 'GEO' -IN A NAMESPACE-, or too many objects called 'GEO'.\n fbx export aborted!"
)
return (False)
geos = child_match_check(geoGrp[0], "*_Geo_Grp")
if not geos:
return (False)
# check for jnt grps
if not jntGrp or len(jntGrp) > 1:
cmds.warning(
"AssetPublish.publish_fbx_anim_file:You either have no grp called 'EXPORT_JNT_Grp' -IN A NAMESPACE-, or too many objects called 'EXPORT_JNT_Grp'.\n fbx export aborted!"
)
return (False)
roots = child_match_check(jntGrp[0], "*_Root_Jnt")
if not roots:
return (False)
cmds.file(refs[0], ir=True)
# check correspondence of geo and root jnts
correspond = check_correspondence(geos, roots)
if not correspond:
return (False)
pubFbxPath = uf.fix_path(os.path.join(pp.phasePath, "Publish/FBX/"))
tokens = pp.fileName.split("_")
tokens[-2] = "Publish"
pubFileName = "_".join(tokens)[:-3] + ".fbx"
pubFilePath = uf.fix_path(os.path.join(pubFbxPath, pubFileName))
start, end = uf.get_frame_range()
# bake joints
for r in roots:
# get child roots if joints
allD = cmds.listRelatives(r, allDescendents=True)
jnts = [x for x in allD if cmds.objectType(x, isa="joint")]
# function to bake selected on all jnts under this root
bake_selected(jnts, start, end)
namespace = cmds.file(refs[0], q=True, ns=True)
uf.remove_namespaces()
# delete constraints
cmds.delete(cmds.ls(type="constraint"))
cmds.select(cl=True)
# move jnts and geo into world parent
for root in roots:
rootremove = "{0}:".format(namespace)
basename = root.split(":")[1].split("_Root_Jnt")[0]
geo = "{0}_Geo_Grp".format(basename)
root = "{0}_Root_Jnt".format(basename)
cmds.parent([geo, root], w=True)
tokens[-2] = basename
pubFileName = "_".join(tokens)[:-3] + ".fbx"
pubFilePath = uf.fix_path(os.path.join(pubFbxPath, pubFileName))
rootremove = "{0}:".format(namespace)
cmds.select([root, geo], r=True)
# if this exists, should we overwrite?
if os.path.isfile(pubFilePath):
overwrite = cmds.confirmDialog(
title="Overwrite Confirmation",
message=
"A publish FBX already exists for this file.\nShould we overwrite?",
button=("Overwrite", "Cancel"),
defaultButton="Overwrite",
cancelButton="Cancel",
dismissString="Cancel")
if overwrite == "Cancel":
print "Publish skipped for FBX file (.fbx) called {0}".format(
pubFilePath)
return (True)
mel.eval('FBXLoadExportPresetFile -f "{0}";'.format(anmPreset))
mel.eval('FBXExport -f "{0}" -s'.format(pubFilePath))
return (True)
