def bs_importShaders(shaderPath, jsonPath):
"""
@ import shaders and apply on geometries.
@ apply data read from json file.
Args:
shaderPath (str): shader path where shaders are stored.
jsonPath (str): json path where all information about shaders is stored.
Returns:
bool.
"""
# import shaders.
bs_mayaFile.bs_importFile(shaderPath)
# read shader data from json file.
with open(jsonPath) as json_data:
shaderData = json.load(json_data)
print shaderData
# apply shaders.
for each in shaderData.keys():
# for x in shaderData[each]:
# pm.select(shaderData[each][x],r=True)
pm.select(shaderData[each], r=True)
pm.windows.hyperShade(a=each)
bs_qui.bs_displayMessage('success', 'shader import success.')
return True
def bs_makeGpuMayaFile():
"""
@ make gpu maya file.
Returns:
"""
# Make Gpu File
# query current set.
dept, assetType, assetName, uid = bs_pathGenerator.bs_getAssetDetails()
if dept == 'Not Exist' or assetType == 'Not Exist' or assetName == 'Not Exist':
bs_qui.bs_displayMessage('error', 'No Set Found in Scene.....')
return False
# get asset grade in current scene
geoGrp = pm.PyNode('geo')
assetGrade = geoGrp.assetGrade.get()
# create file path.
cacheDir = bs_pathGenerator.bs_getAssetDir(
astType=assetType, astName=assetName, astDept=dept)['dept'] + 'gpu/'
fileName = bs_pathGenerator.bs_getMainFileName().split('.')[0][:-3] + 'gpu'
# check gpu maya file is exist or not.
filePath = cacheDir + fileName + '.ma'
if os.path.isfile(cacheDir + fileName + '.ma'):
return True
bs_runner.bs_blast(astPath=filePath,
astName=assetName,
astGrade=assetGrade,
astUID=uid)
def bs_getAllFileTexturePathIfValid():
"""
@ query all file texture path and,
@ return if all are coming from same valid path.
Returns:
sourceimages directory (str).
"""
# get env details and sourceimage directory.
envRoot = bs_pathGenerator.bs_getEnvDetails()['rootPath']
assetDept, assetType, assetName, uid = bs_pathGenerator.bs_getAssetDetails(
)
sourceImageDir = bs_pathGenerator.bs_getAssetDir(
astType=assetType, astDept=assetDept,
astName=assetName)['dept'] + 'sourceimages/'
allFileTextures = pm.ls(type='file')
validPath = list()
invalidPath = list()
for each in allFileTextures:
ftn = each.ftn.get()
filtSourceImageDir = sourceImageDir.replace(envRoot, '')
if ftn.find(filtSourceImageDir) != -1:
validPath.append(each)
else:
invalidPath.append(each)
if not invalidPath:
return sourceImageDir
bs_qui.bs_displayMessage('error', 'all path not from same path..')
return False
def exportGPU(self):
# query current set.
dept, assetType, assetName, uid = bs_pathGenerator.bs_getAssetDetails()
if dept == 'Not Exist' or assetType == 'Not Exist' or assetName == 'Not Exist':
bs_qui.bs_displayMessage('error', 'No Set Found in Scene.....')
return False
bs_setManager.bs_makeGpuCacheFile()
self.addGpuPath()
def _addNewAssets(self):
assetsPath = bs_shot.bs_getItemsFromLwFilterAndReturnPath(
self.bsshm_selectedAsset_LW)
bs_shot.bs_referenceAssetsInCurrentShot(assetsPath)
bs_qui.bs_displayMessage('success', 'new assets added success')
self._addCurrentReference()
self._fillElementsInCurrentAsset()
self.bsshm_selectedAsset_LW.clear()
def openGpuDirectory(self):
path = self.bssm_GPUfilePath_LE.text()
if not path.startswith('gpu '):
gpuDir = str()
for each in path.split('/')[:-1]:
gpuDir += each + '/'
bs_os.bs_openDirInExplorer(gpuDir)
else:
bs_qui.bs_displayMessage('error', 'not valid directory...')
def bswExtract(sel):
if not sel:
bs_qui.bs_displayMessage('error', 'Please select geometries.')
return False
mainGrp = pm.createNode('transform', n='blendshapeMain_grp', ss=True)
for each in bsLS:
shapeGrp = pm.createNode('transform', n=each + '_BSGrp', ss=True)
for eachGeo in sel:
dupShape = pm.duplicate(eachGeo, rr=True, n=each + '__' + eachGeo)
pm.parent(dupShape, shapeGrp)
pm.parent(shapeGrp, mainGrp)
def bs_playblast():
"""
@ create playblast with headsUpDisplays.
Returns:
playblastPath.
"""
bs_addHeadsUpDisplay()
epi, seq, shot, stage = bs_pathGenerator.bs_shotDetailsCheckAndReturn()
outPath = bs_pathGenerator.bs_animFilePath(epi, seq, shot)[stage][:-3]
shotCam = pm.PyNode('shot_cam')
# add resolution gates.
pm.camera(shotCam, e=True, filmFit='overscan')
pm.camera(shotCam,
e=True,
dsa=True,
dfc=False,
displayFilmGate=False,
displayResolution=True,
displaySafeTitle=False)
pm.setAttr(shotCam + '.displayGateMaskOpacity', 1)
pm.setAttr(shotCam + '.displayGateMaskColor', [0, 0, 0], type='double3')
pm.setAttr(shotCam + '.displayGateMask', 1)
# get Sound File.
soundFile = pm.windows.timeControl('timeControl1', q=True, s=True)
# playblast.
if soundFile:
vidPath = pm.playblast(f=outPath,
format='avi',
s=soundFile,
sequenceTime=0,
forceOverwrite=True,
clearCache=1,
viewer=1,
showOrnaments=1,
fp=4,
percent=100,
quality=70,
widthHeight=[960, 540])
else:
vidPath = pm.playblast(f=outPath,
format='avi',
sequenceTime=0,
forceOverwrite=True,
clearCache=1,
viewer=1,
showOrnaments=1,
fp=4,
percent=100,
quality=70,
widthHeight=[960, 540])
bs_removeHeadsUpDisplay()
bs_qui.bs_displayMessage('success', '{0}'.format(vidPath))
return vidPath
def openSourceImageDir(self):
urp = self.bstm_convertPath_le.text()
if urp.startswith('$BSW_PROD_SERVER/'):
resolvedPath = urp.replace(
'$BSW_PROD_SERVER/',
bs_pathGenerator.bs_getEnvDetails()['rootPath'])
bs_os.bs_openDirInExplorer(resolvedPath)
bs_qui.bs_displayMessage(
'success', 'sourceimage directory opened in your os explorer.')
return True
bs_qui.bs_displayMessage('error', 'directory not found..')
return False
def openExportedShaderPathDir(self):
exportedPath = self.bstm_exportPath_le.text()
expDir = str()
for each in exportedPath.split('/')[:-1]:
expDir += each + '/'
if os.path.isdir(expDir):
bs_os.bs_openDirInExplorer(expDir)
bs_qui.bs_displayMessage(
'success', 'Shader directory opened in your os explorer.')
return True
bs_qui.bs_displayMessage('error', 'Invalid Shader Directory.')
return False
def addItemInTable(self):
self.bsap_prevVers_tableWidget.setRowCount(0)
dept, assetType, assetName, uid, episode = bs_pathGenerator.bs_getAssetDetails(
)
if dept == 'Not Exist' or assetType == 'Not Exist' or assetName == 'Not Exist':
bs_qui.bs_displayMessage('warning',
'No Assets Found in Scene.....')
return False
if self.projectType == 'series':
mainFi, verFi = bs_pathGenerator.bs_getAssetFileAndVersions(
assetType, dept, assetName, episode=episode)
else:
mainFi, verFi = bs_pathGenerator.bs_getAssetFileAndVersions(
assetType, dept, assetName)
# add version details in table widget.
for each in mainFi:
rowPosition = self.bsap_prevVers_tableWidget.rowCount()
self.bsap_prevVers_tableWidget.insertRow(rowPosition)
fileName = each.split('/')[-1]
fileTime = bs_os.bs_getFileDateTime(each)
fileOwner = bs_os.bs_getFileOwner(each)
fileSize = bs_os.bs_getFileSize(each)
fileComment = 'NUll'
self.bsap_prevVers_tableWidget.setItem(
rowPosition, 0, QtGui.QTableWidgetItem(fileName))
self.bsap_prevVers_tableWidget.setItem(
rowPosition, 1, QtGui.QTableWidgetItem(fileTime))
self.bsap_prevVers_tableWidget.setItem(
rowPosition, 2, QtGui.QTableWidgetItem(fileOwner))
self.bsap_prevVers_tableWidget.setItem(
rowPosition, 3, QtGui.QTableWidgetItem(fileSize))
self.bsap_prevVers_tableWidget.setItem(
rowPosition, 4, QtGui.QTableWidgetItem(fileComment))
for each in verFi:
rowPosition = self.bsap_prevVers_tableWidget.rowCount()
self.bsap_prevVers_tableWidget.insertRow(rowPosition)
fileName = each.split('/')[-1]
fileTime = bs_os.bs_getFileDateTime(each)
fileOwner = bs_os.bs_getFileOwner(each)
fileSize = bs_os.bs_getFileSize(each)
fileComment = 'NUll'
self.bsap_prevVers_tableWidget.setItem(
rowPosition, 0, QtGui.QTableWidgetItem(fileName))
self.bsap_prevVers_tableWidget.setItem(
rowPosition, 1, QtGui.QTableWidgetItem(fileTime))
self.bsap_prevVers_tableWidget.setItem(
rowPosition, 2, QtGui.QTableWidgetItem(fileOwner))
self.bsap_prevVers_tableWidget.setItem(
rowPosition, 3, QtGui.QTableWidgetItem(fileSize))
self.bsap_prevVers_tableWidget.setItem(
rowPosition, 4, QtGui.QTableWidgetItem(fileComment))
self.bsap_prevVers_tableWidget.resizeColumnsToContents()
def runInitialStartup():
"""
@ run this function on maya start.
Returns:
None.
"""
# load plugings.
# pm.loadPlugin('mtoa')
# set fps.
pm.currentUnit(time='pal')
print('SUCCESS MAYA OPEN WITH PRE LOADED SETTING...............'),
bs_qui.bs_displayMessage(
'success', 'SUCCESS MAYA OPEN WITH PRE LOADED SETTING...............')
def addGpuPath(self):
# query current set.
dept, assetType, assetName, uid = bs_pathGenerator.bs_getAssetDetails()
if dept == 'Not Exist' or assetType == 'Not Exist' or assetName == 'Not Exist':
bs_qui.bs_displayMessage('error', 'No Set Found in Scene.....')
return False
cacheDir = bs_pathGenerator.bs_getAssetDir(
astType=assetType, astName=assetName,
astDept=dept)['dept'] + 'gpu/'
fileName = bs_pathGenerator.bs_getMainFileName().split(
'.')[0][:-3] + 'gpu'
if os.path.isfile(cacheDir + fileName + '.ma'):
self.bssm_GPUfilePath_LE.setText(cacheDir + fileName + '.ma')
else:
self.bssm_GPUfilePath_LE.setText('gpu maya file is not found...')
if os.path.isfile(cacheDir + fileName + '.abc'):
self.bssm_GPUcachePath_LE.setText(cacheDir + fileName + '.abc')
else:
self.bssm_GPUcachePath_LE.setText('gpu cache file is not found...')
def referenceElements(self):
# get environments.
serverPath = bs_pathGenerator.bs_getEnvDetails()['rootPath']
# query current set.
dept, assetType, assetName, uid = bs_pathGenerator.bs_getAssetDetails()
if dept == 'Not Exist' or assetType == 'Not Exist' or assetName == 'Not Exist':
bs_qui.bs_displayMessage('error', 'No Set Found in Scene.....')
return False
elements = list()
for x in range(self.bssm_selectedItems_LW.count()):
elements.append(self.bssm_selectedItems_LW.item(x).text())
# reference and parent all selected setElements.
for each in elements:
mainFile, verFiles = bs_pathGenerator.bs_getAssetFileAndVersions(
'SetElement', 'Rig', each)
if len(mainFile.keys()) == 1:
filePath = mainFile[mainFile.keys()[0]]['path']
filePath = filePath.replace(serverPath, '$BSW_PROD_SERVER/')
ns = bs_reference.bs_createReference(filePath,
prefixStyle='fileName')
pm.parent(ns.namespace + ':rig_grp', 'setElements_grp')
self.refresh()
def bs_exportShaders(shaderExpPath, jsonPath):
"""
@ export shaders on shader exp path.
@ export shader applied details on json file.
Args:
shaderExpPath (str): path where shader will be exported.
jsonPath (str): path where shader information will store.
Returns:
exported Shader path. (str)
"""
# get all shading engines.
allShdEngines = pm.ls(type='shadingEngine')
allShdEng = list()
[allShdEng.append(each.name()) for each in allShdEngines]
filtShdEng = list(
set(allShdEng) - {'initialParticleSE', 'initialShadingGroup'})
# convert shading engines in PyNode.
shadingEngines = list()
[shadingEngines.append(pm.PyNode(each)) for each in filtShdEng]
# get geometries where shading engine is applied.
shadingInformation = dict()
for each in shadingEngines:
appliedMesh = list()
[
appliedMesh.append(x.name())
for x in each.listConnections(type='mesh')
]
shadingInformation[each.name()] = appliedMesh
# export applied data in json file.
with open(jsonPath, 'w') as outfile:
json.dump(shadingInformation, outfile, indent=4)
# select and export all shading engines.
pm.select(shadingInformation.keys(), r=True, ne=True)
pm.cmds.file(shaderExpPath, op="v=0;", typ='mayaAscii', pr=False, es=True)
bs_qui.bs_displayMessage('success', 'Shaders exported successful')
def bs_convertAllFileTexturePathInEnvVariable():
"""
@ convert all file texture path in environment variable.
@ it is run if all path is valid.
Returns:
None.
"""
if bs_getAllFileTexturePathIfValid():
allFileTextures = pm.ls(type='file')
for each in allFileTextures:
ftn = each.ftn.get()
if not ftn.startswith('$'):
newPath = '$BSW_PROD_SERVER/'
for x in ftn.split('/')[1:-2]:
newPath += x + '/'
splitPath = ''
for x in ftn.split('/')[1:-2]:
splitPath += x + '/'
finalPath = newPath + ftn.split(splitPath)[-1]
each.ftn.set(finalPath)
bs_qui.bs_displayMessage('success', 'all paths converted success..')
else:
bs_qui.bs_displayMessage(
'error', 'all file texture root directory is not same....')
def buildShot(self):
getEpi = self.bssb_episode_LE.text()
getSeq = self.bssb_sequence_LE.text()
getShot = self.bssb_shot_LE.text()
if not getEpi.startswith('ep'):
bs_qui.bs_displayMessage('error', 'wrong episode entered')
return False
if not getSeq.startswith('sq'):
bs_qui.bs_displayMessage('error', 'wrong sequence entered')
return False
if not getShot.startswith('sh'):
bs_qui.bs_displayMessage('error', 'wrong shot entered')
return False
startTime = self.bssb_startFrame_spinBox.value()
endTime = self.bssb_endFrame_spinBox.value()
# get all paths.
environPaths = bs_shot.bs_getItemsFromLwFilterAndReturnPath(
self.bssb_selectedAsset_LW)
bs_shot.bs_shotBuild(getEpi, getSeq, getShot, startTime, endTime,
environPaths)
self.close()
bs_qui.bs_displayMessage('success', 'Shot Created..')
def bs_makeGpuCacheFile():
"""
@ make a gpu cache file and if gpu maya file is not exist then auto run bs_makeGpuMayaFile method.
Returns:
None.
"""
# query current set.
dept, assetType, assetName, uid = bs_pathGenerator.bs_getAssetDetails()
if dept == 'Not Exist' or assetType == 'Not Exist' or assetName == 'Not Exist':
bs_qui.bs_displayMessage('error', 'No Set Found in Scene.....')
return False
pm.loadPlugin('gpuCache')
ct = pm.currentTime()
cacheDir = bs_pathGenerator.bs_getAssetDir(
astType=assetType, astName=assetName, astDept=dept)['dept'] + 'gpu/'
fileName = bs_pathGenerator.bs_getMainFileName().split('.')[0][:-3] + 'gpu'
# create gpu directory if not exist.
if not os.path.isdir(cacheDir):
os.makedirs(cacheDir)
# export gpu cache.
pm.gpuCache(st=ct,
et=ct,
o=True,
ot=40000,
wm=True,
df='ogawa',
dir=cacheDir,
fileName=fileName,
ado=True)
# check gpu maya file is exist or not.
if not os.path.isfile(cacheDir + fileName + '.ma'):
bs_makeGpuMayaFile()
bs_qui.bs_displayMessage(
'success', 'Gpu Cache Exported And Gpu Maya File also Created..')
else:
bs_qui.bs_displayMessage('success', 'Gpu Cache Exported..')
def removeSelectedReferences(self):
removeRef = bs_qui.bs_removeSelectedReferenceFromQLW(
self.bssm_currentSetElem_LW)
self.refresh()
bs_qui.bs_displayMessage(
'success', '%d set elements removed from scene...' % removeRef)
def bs_publishCurrentAsset(comment=None):
"""
@ publish current opened asset.
Args:
comment (str): comment on publish.
Returns:
mainFilePath And versionFilePath.
"""
# get environments.
projectType = bs_pathGenerator.bs_getEnv()['projectType']
assetDept, assetType, assetName, uid, episode = bs_pathGenerator.bs_getAssetDetails(
)
if assetDept == 'Not Exist' or assetType == 'Not Exist' or assetName == 'Not Exist' or uid == 'Not Exist':
bs_qui.bs_displayMessage('error', 'Asset not found To Publish.....')
return False
# get asset directories and create directories if not exist.
if projectType == 'series':
mainDir = bs_pathGenerator.bs_getAssetDeptDirs(
assetType, assetName, episode=episode)[assetDept]
verDir = bs_pathGenerator.bs_getAssetDeptDirs(
assetType, assetName, episode=episode)[assetDept + 'Version']
bs_pathGenerator.bs_createAssetDirectories(assetType,
assetName,
episode=episode)
else:
mainDir = bs_pathGenerator.bs_getAssetDeptDirs(assetType,
assetName)[assetDept]
verDir = bs_pathGenerator.bs_getAssetDeptDirs(
assetType, assetName)[assetDept + 'Version']
bs_pathGenerator.bs_createAssetDirectories(assetType, assetName)
# get file paths to save the file.
mainFilePath = mainDir + bs_pathGenerator.bs_getCurrentAssetMainFileName()
versionFileName = bs_pathGenerator.bs_versionUpPath(verDir)
# create new version file name if no version exist.
if not versionFileName:
versionFileName = bs_pathGenerator.bs_getCurrentAssetMainFileName(
)[:-3] + '_v001.ma'
versionFilePath = verDir + versionFileName
# save version File.
pm.saveAs(versionFilePath)
# copy main version file and save as main File if fail then save manually.
try:
shutil.copy2(versionFilePath, mainFilePath)
except:
pm.saveAs(mainFilePath)
# get version screenshot.
imageFilePath = verDir + 'screenshot/' + versionFileName[:-3] + '.jpg'
bs_screenshot.bs_getScreenShot(imageFilePath)
# copy screenshot for main file.
try:
shutil.copy2(imageFilePath, imageFilePath[:-9] + '.jpg')
except:
pass
# add entry in database.
try:
tableName = str(mainFilePath.split('/')[-1][:-3])
# mainFile entries.
mainFileName = str(mainFilePath.split('/')[-1])
mainFileOwner = bs_os.bs_getFileOwner(mainFilePath)
mainFileSize = bs_os.bs_getFileSize(mainFilePath)
mainFileTime = bs_os.bs_getFileDateTime(mainFilePath)
addInfoDB = bs_database.Bs_Database()
addInfoDB.bs_databaseAssetPublish(tableName, mainFileName,
mainFileOwner, mainFileSize,
mainFileTime, comment)
# version File entries.
verFileName = str(versionFilePath.split('/')[-1])
verFileOwner = bs_os.bs_getFileOwner(mainFilePath)
verFileSize = bs_os.bs_getFileSize(mainFilePath)
verFileTime = bs_os.bs_getFileDateTime(mainFilePath)
addInfoDB = bs_database.Bs_Database()
addInfoDB.bs_databaseAssetPublish(tableName, verFileName, verFileOwner,
verFileSize, verFileTime, comment)
# print message.
bs_qui.bs_displayMessage('success', 'Asset Publish Successfully...')
except:
bs_qui.bs_displayMessage(
'success',
'Asset Publish Successfully... But database is not not connected')
return mainFilePath, versionFilePath
def bs_createTextureBase(assetName, assetGrade, assetType, episode=None):
"""
@ create Texture Base group in reference model file in rig.
Args:
assetName (str): Model Name.
assetGrade (str): Character Grade (Primary, Secondary, Tertiary).
assetType (str): Asset Type Character, Prop, Set, Vehicle
episode (str): asset Name dodo is like (dod).
Returns:
top Texture group.
"""
# raise popup window for current scene will be discarded if maya is not in batch mode.
if not pm.about(batch=True):
confirmation = pm.windows.confirmDialog(
title='Confirm',
message="Don't Save Current Scene\nAnd Load New Scene?",
button=['Yes', 'No'],
defaultButton='Yes')
if confirmation == 'Yes':
pm.newFile(f=True)
else:
print 'process cancelled',
return False
# get environments.
serverPath = bs_pathGenerator.bs_getEnv()['projectDir']
# get model directory.
if bs_pathGenerator.bs_getEnv()['projectType'] == 'series':
modelFile = bs_pathGenerator.bs_getOnlyFinalFileOfDept(assetType,
'Model',
assetName,
episode=episode)
else:
modelFile = bs_pathGenerator.bs_getOnlyFinalFileOfDept(
assetType, 'Model', assetName)
# create path using environment variable.
modelFile = modelFile.replace(serverPath, '$BSW_PROJECT_DIR')
bs_reference.bs_createReference(modelFile,
prefixStyle='withoutNamespace',
prefixName='')
# create Texture Group.
topGrp = pm.createNode('transform', n='Texture_Group', ss=True)
# add asset uid.
astTypShortCode = {
'Character': 'ch',
'Prop': 'pr',
'Set': 'bg',
'Vehicle': 'vh',
'SetElement': 'se'
}
if bs_pathGenerator.bs_getEnv()['projectType'] == 'series':
uid = 'bsw_' + astTypShortCode[
assetType] + '_' + assetName + '_tex_' + episode
else:
uid = 'bsw_' + astTypShortCode[assetType] + '_' + assetName + '_tex'
# add attributes.
pm.addAttr(topGrp, ln='assetBase', dt='string', k=True)
pm.addAttr(topGrp, ln='assetType', dt='string', k=True)
pm.addAttr(topGrp, ln='assetName', dt='string', k=True)
pm.addAttr(topGrp, ln='assetGrade', dt='string', k=True)
if bs_pathGenerator.bs_getEnv()['projectType'] == 'series':
pm.addAttr(topGrp, ln='assetEpisode', dt='string', k=True)
pm.addAttr(topGrp, ln='assetUID', dt='string', k=True)
# set Values.
pm.setAttr(topGrp + '.assetBase', 'Asset')
pm.setAttr(topGrp + '.assetBase', l=True)
pm.setAttr(topGrp + '.assetType', assetType)
pm.setAttr(topGrp + '.assetType', l=True)
pm.setAttr(topGrp + '.assetName', assetName)
pm.setAttr(topGrp + '.assetName', l=True)
pm.setAttr(topGrp + '.assetGrade', assetGrade)
pm.setAttr(topGrp + '.assetGrade', l=True)
if bs_pathGenerator.bs_getEnv()['projectType'] == 'series':
pm.setAttr(topGrp + '.assetEpisode', episode)
pm.setAttr(topGrp + '.assetEpisode', l=True)
pm.setAttr(topGrp + '.assetUID', uid)
pm.setAttr(topGrp + '.assetUID', l=True)
# parent referenced model top group in texture group.
pm.parent('geo', topGrp)
if bs_pathGenerator.bs_getEnv()['projectType'] == 'series':
bs_pathGenerator.bs_createAssetDirectories(assetType,
assetName,
episode=episode)
else:
bs_pathGenerator.bs_createAssetDirectories(assetType, assetName)
bs_qui.bs_displayMessage(
'success', 'asset Created success and created sourceimages directory')
return topGrp
def bs_createModelBase(topGroup,
assetName,
assetGrade,
assetType,
episode=None,
makeGroups=True):
"""
@ create asset model
@ make modeling base hierarchy and add attributes on top group for query purpose.
Args:
topGroup (str): Hierarchy Top Group Name.
assetName (str): Asset Name.
assetGrade (str): Character Grade (Primary, Secondary, Tertiary).
assetType (str): Asset Type Character, Prop, Set, Vehicle.
episode (str): episode number like (ep000,ep001,ep002) format.
makeGroups (bool): make groups if value is True
Returns:
topGrp.
"""
# raise popup window for current scene will be discarded if maya is not in batch mode.
if not pm.about(batch=True):
confirmation = pm.windows.confirmDialog(
title='Confirm',
message="Don't Save Current Scene\nAnd Load New Scene?",
button=['Yes', 'No'],
defaultButton='Yes')
if confirmation == 'Yes':
pm.newFile(f=True)
else:
print 'process cancelled',
return False
# create group if make hierarchy is True.
astTypShortCode = {
'Character': 'ch',
'Prop': 'pr',
'Set': 'bg',
'Vehicle': 'vh',
'SetElement': 'se'
}
if bs_pathGenerator.bs_getEnv()['projectType'] == 'series':
uid = 'bsw_' + astTypShortCode[
assetType] + '_' + assetName + '_mod_' + episode
else:
uid = 'bsw_' + astTypShortCode[assetType] + '_' + assetName + '_mod'
pm.select(cl=True)
if makeGroups:
# make groups.
topGrp = pm.createNode('transform', n=topGroup, ss=True)
modelGrp = pm.createNode('transform', n=assetName + '_grp', ss=True)
if assetType == 'Character':
bodyGrp = pm.createNode('transform', n='body_grp', ss=True)
eyeGrp = pm.createNode('transform', n='eye_grp', ss=True)
eyeBrowGrp = pm.createNode('transform', n='eyeBrow_grp', ss=True)
innerMouthGrp = pm.createNode('transform',
n='innerMouth_grp',
ss=True)
hairGrp = pm.createNode('transform', n='hair_grp', ss=True)
clothGrp = pm.createNode('transform', n='cloth_grp', ss=True)
propsGrp = pm.createNode('transform', n='props_grp', ss=True)
shoeGrp = pm.createNode('transform', n='shoe_grp', ss=True)
# make parent.
pm.parent(bodyGrp, clothGrp, propsGrp, shoeGrp, modelGrp)
pm.parent(eyeGrp, eyeBrowGrp, innerMouthGrp, hairGrp, bodyGrp)
elif assetType == 'Set':
setElementGrp = pm.createNode('transform', n='setElements_grp')
pm.parent(modelGrp, setElementGrp, topGrp)
pm.parent(modelGrp, topGrp)
else:
topGrp = topGroup
# add attributes for query asset details purpose.
pm.addAttr(topGrp, ln='assetBase', dt='string', k=True)
pm.addAttr(topGrp, ln='assetType', dt='string', k=True)
pm.addAttr(topGrp, ln='assetName', dt='string', k=True)
pm.addAttr(topGrp, ln='assetGrade', dt='string', k=True)
if bs_pathGenerator.bs_getEnv()['projectType'] == 'series':
pm.addAttr(topGrp, ln='assetEpisode', dt='string', k=True)
pm.addAttr(topGrp, ln='assetUID', dt='string', k=True)
# add asset details in top group attributes.
pm.setAttr(topGrp + '.assetBase', 'Asset')
pm.setAttr(topGrp + '.assetBase', l=True)
pm.setAttr(topGrp + '.assetType', assetType)
pm.setAttr(topGrp + '.assetType', l=True)
pm.setAttr(topGrp + '.assetName', assetName)
pm.setAttr(topGrp + '.assetName', l=True)
pm.setAttr(topGrp + '.assetGrade', assetGrade)
pm.setAttr(topGrp + '.assetGrade', l=True)
if bs_pathGenerator.bs_getEnv()['projectType'] == 'series':
pm.setAttr(topGrp + '.assetEpisode', episode)
pm.setAttr(topGrp + '.assetEpisode', l=True)
pm.setAttr(topGrp + '.assetUID', uid)
pm.setAttr(topGrp + '.assetUID', l=True)
pm.select(topGrp, r=True)
if bs_pathGenerator.bs_getEnv()['projectType'] == 'series':
bs_pathGenerator.bs_createAssetDirectories(assetType,
assetName,
episode=episode)
else:
bs_pathGenerator.bs_createAssetDirectories(assetType, assetName)
bs_qui.bs_displayMessage('success', 'Asset Created Successfully....')
return topGrp