def setAnimationFPS(self, fps, changeType=constants.FPSChangeType.Seconds, callback=None): """ Updates the scene's fps to the provided value and scales existing keys as specified. StudioMax Note: If you have any code that you need to run after changing the fps and plan to use it in 3dsMax you will need to pass that code into the callback argument. Maya Note: Maya only supports specific fps settings. If you provide it with a value it doesn't understand, it will be set to the closest matching value. See MayaScene._timeUnitToFPS for valid values. :param fps: The FPS value to set. :param changeType: <constants.FPSChangeType> Defaults to constants.FPSChangeType.Frames :param callback: <funciton> Code called after the fps is changed. :return: bool success """ # Maya doesn't appear to allow you to set the fps to a specific value, # so we attempt to find a exact match in our _timeUnitToConst dictonary name = self._timeUnitToConst.get(fps) if not name: # If there isn't a exact match, find the value closest to the requested fps. closest = min(self._timeUnitToConst, key=lambda x: abs(x - fps)) name = self._timeUnitToConst[closest] # Only update the fps if the value is different if name != self._currentTimeUnit(): # Only update animation if Seconds is specified updateAnimation = changeType == constants.FPSChangeType.Seconds cmds.currentUnit(time=name, updateAnimation=updateAnimation) if callback: callback() return True
def pressFunction(self):
self.attribute = self.history[-1] + Cache.currentAttribute # re-init the attribute in case cached has been switched
self.modifier = cmds.draggerContext( 'dragTool', query=True, modifier=True)
self.button = cmds.draggerContext('dragTool', query = True, button=True)
self.attributeValue = cmds.getAttr( self.attribute )
if cmds.currentUnit( query=True, linear=True ) == 'cm':
self.speed = .01 # modifier for speed traveled through values while dragging
elif cmds.currentUnit( query=True, linear=True ) == 'm':
self.speed = .001 # modifier for speed traveled through values while dragging
else:
self.speed = .0001
self.space = 'screen' # initialize the variable
if isinstance(self.attributeValue, list): # only edit the space based on button if the attribute is a list value
# If left click is used, then the space is set to (X,Y,Z) world based
# If middle click is used, space is set to (X, Y) screen based
if self.button == 1: # left button
self.space = 'world' # tracking space used
cmds.draggerContext( 'dragTool', edit=True, space = 'world')
elif self.button == 2: # middle button
self.space = 'screen' # tracking space used
cmds.draggerContext( 'dragTool', edit=True, space = 'screen')
else: # set to 'screen' as default if the attr isn't a list value
cmds.draggerContext( 'dragTool', edit=True, space = 'screen')
if self.modifier == 'ctrl':
self.speed = self.speed * .01
if self.modifier == 'shift':
self.speed = self.speed * 10
if len(self.dragDirection) > 0:
self.dragDirection = []
def test_bwav_handler(self):
'''
test the bwav handler and formatting of the data
'''
assert self.audioNode.isBwav()
# print self.audioNode.bwav_timecodeFormatted()
cmds.currentUnit(time='ntscf')
assert r9General.getCurrentFPS() == 60
print 'ntscf' , self.audioNode.bwav_timecodeFormatted()
assert self.audioNode.bwav_timecodeFormatted() == '01:26:04:11'
cmds.currentUnit(time='pal')
assert r9General.getCurrentFPS() == 25
# print 'pal : ', self.audioNode.bwav_timecodeFormatted()
assert self.audioNode.bwav_timecodeFormatted() == '01:26:04:05'
# print self.audioNode.bwav_timecodeFormatted(smpte=False)
assert self.audioNode.bwav_timecodeFormatted(smpte=False) == '01:26:04:172'
assert self.audioNode.bwav_timecodeReference() == 227739993
assert self.audioNode.bwav_timecodeMS() == 5164172.1768707484
# need to get the bWav header to bind it to the var
self.audioNode.bwav_getHeader()
assert self.audioNode.bwav_HeaderData == {'AudioFormat': 0,
'BextVersion': 0,
'BitsPerSample': 0,
'ChunkSize': 732516,
'Description': 'This is a unitTest file for validating the Red9 broadcast wav extraction of metaData',
'Format': 'WAVE',
'InternalFormat': 'fmt ',
'OriginationDate': '2014-03-03',
'OriginationTime': '10:00:00',
'Originator': 'Pro Tools',
'OriginatorReference': 'ffgDDffdhgff',
'Subchunk1Size': 16,
'TimeReference': 227739993,
'TimeReferenceHigh': 0}
def restoreSettings(self):
'''
restore all UI settings
'''
cmds.autoKeyframe(state=self.dataStore['autoKey'])
# timeline management
cmds.currentTime(self.dataStore['currentTime'])
cmds.playbackOptions(min=self.dataStore['minTime'])
cmds.playbackOptions(max=self.dataStore['maxTime'])
cmds.playbackOptions(ast=self.dataStore['startTime'])
cmds.playbackOptions(aet=self.dataStore['endTime'])
cmds.playbackOptions(ps=self.dataStore['playSpeed'])
cmds.playbackOptions(loop=self.dataStore['playLoop'])
# unit management
cmds.currentUnit(time=self.dataStore['timeUnit'])
cmds.currentUnit(linear=self.dataStore['sceneUnits'])
if not cmds.upAxis(axis=True, q=True) == self.dataStore['upAxis']:
cmds.upAxis(axis=self.dataStore['upAxis'])
log.debug('Restored PlayBack / Timeline setup')
# viewport colors
cmds.displayPref(displayGradient=self.dataStore['displayGradient'])
cmds.displayRGBColor(resetToSaved=True)
# objects colors
cmds.displayColor("curve", self.dataStore['curvecolor'], dormant=True)
# panel management
for panel, data in self.dataStore['panelStore'].items():
try:
cmdString = data['settings'].replace('$editorName', panel)
mel.eval(cmdString)
log.debug("Restored Panel Settings Data >> %s" % panel)
mel.eval('lookThroughModelPanel("%s","%s")' % (data['activeCam'], panel))
log.debug("Restored Panel Active Camera Data >> %s >> cam : %s" % (panel, data['activeCam']))
except:
log.debug("Failed to fully Restore ActiveCamera Data >> %s >> cam : %s" % (panel, data['activeCam']))
# camera management
for cam, settings in self.dataStore['cameraTransforms'].items():
try:
cmds.setAttr('%s.translate' % cam, settings[0][0][0], settings[0][0][1], settings[0][0][2])
cmds.setAttr('%s.rotate' % cam, settings[1][0][0], settings[1][0][1], settings[1][0][2])
cmds.setAttr('%s.scale' % cam, settings[2][0][0], settings[2][0][1], settings[2][0][2])
log.debug('Restored Default Camera Transform Data : % s' % cam)
except:
log.debug("Failed to fully Restore Default Camera Transform Data : % s" % cam)
# sound management
if self.dataStore['displaySound']:
cmds.timeControl(self.gPlayBackSlider, e=True, ds=1, sound=self.dataStore['activeSound'])
log.debug('Restored Audio setup')
else:
cmds.timeControl(self.gPlayBackSlider, e=True, ds=0)
log.debug('Scene Restored fully')
return True
def run(*args, **kwargs):
""" prepare the scene for the tests
converts scene to use centimeters
set the grid to the default
"""
valid_kwargs = ['verbose']
for k, v in kwargs.iteritems():
if k not in valid_kwargs:
raise TypeError("Invalid keyword argument %s" % k)
# verbose defaults to False if verbose option not set in menu or set
# as cmdline argument
try:
verbose = kwargs['verbose']
except KeyError:
verbose = False
if cmds.optionVar(exists='checkmateVerbosity'):
verbose = cmds.optionVar(query='checkmateVerbosity')
else:
verbose = False
batch = cmds.about(batch=True)
# get the name of the script Editor's output control
from maya import mel as mel
# Turn off Echo All Commands in the Script Editor
# Disable Stack Tracevin the Script Editor
# Turn off Line Numbers in errors in the Script Editor
# Reset the grid
# Set the background color
# Turn off the heads-up displays
# Switch to wrireframe mode
# Close all windows (except main)
# Close ChannelBox, Attribute Editor and Outliner ()
if not batch:
try:
gCommandReporter = mel.eval("proc string f(string $g){return $g;}f($gCommandReporter);")
except RuntimeError:
gCommandReporter = ''
pass
try:
cmds.cmdScrollFieldReporter(gCommandReporter,
edit=True,
echoAllCommands=False,
lineNumbers=True,
stackTrace=True,
suppressResults=False,
suppressInfo=False,
suppressWarnings=False,
suppressErrors=False,
suppressStackTrace=False,
)
except RuntimeError:
if verbose:
print 'No Script Editor'
pass
# convert scene to cm to fix crashes in nearestnormal
cmds.currentUnit(linear='cm')
def currentUnits():
# ex: {'angle': 'degree', 'linear': 'centimeter', 'time': 'pal'}
currentUnitsDict = {
'linear': MC.currentUnit(query=True, linear=True, fullName=True),
'angle': MC.currentUnit(query=True, angle=True, fullName=True),
'time': MC.currentUnit(query=True, time=True)
}
return currentUnitsDict
def importScene( evt=0 ):
rootPath = cmds.textField( Window_global.txf_rootPath, q=1, tx=1 )
abcPath = rootPath + '/' + cmds.textField( Window_global.txf_abcPath, q=1, tx=1 )
sceneInfoPath = rootPath + '/' + cmds.textField( Window_global.txf_sceneInfoPath, q=1, tx=1 )
cmds.AbcImport( abcPath, mode='import' )
def getBBCenter( targetTransform ):
bbmin = cmds.getAttr( targetTransform + '.boundingBoxMin' )[0]
bbmax = cmds.getAttr( targetTransform + '.boundingBoxMax' )[0]
bbcenter = OpenMaya.MPoint( (bbmin[0] + bbmax[0])/2.0, (bbmin[1] + bbmax[1])/2.0, (bbmin[2] + bbmax[2])/2.0 )
pmtx = cmds.getAttr( targetTransform + '.parentMatrix' )
mtx = OpenMaya.MMatrix()
OpenMaya.MScriptUtil.createMatrixFromList( pmtx, mtx )
bbcenter *= mtx
return [bbcenter.x, bbcenter.y,bbcenter.z]
def addNamespaceToChildren( namespace, rootNode ):
import pymel.core
children = pymel.core.listRelatives( rootNode, c=1, ad=1, type='transform' )
if not children: children = []
for child in children:
child.rename( namespace + ':' + child.name().split( '|' )[-1] )
f = open( sceneInfoPath, 'r' )
data = json.load( f )
f.close()
cmds.currentUnit( time=data['timeUnit'] )
cmds.playbackOptions( min=data['minFrame'], max=data['maxFrame'] )
cmds.currentTime( data['exportFrame'] )
cmds.refresh()
namespaceRoots = data['namespaceRoots']
rootCenters = data['rootCenters']
for i in range( len( namespaceRoots ) ):
namespaceRoot = namespaceRoots[i]
localName = namespaceRoot.split( '|' )[-1]
namespace = ':'.join( localName.split( ':' )[:-1] )
try:cmds.namespace( add=namespace )
except:pass
target = '|'.join( namespaceRoot.split( '|' )[:-1] ) + '|' + localName.replace( namespace+':', '' ) + '*'
targets = cmds.ls( target, type='transform' )
if len( targets ) == 1:
target = targets[0]
addNamespaceToChildren( namespace, target )
cmds.rename( target, namespaceRoot.split( '|' )[-1] )
else:
for target in targets:
targetCenter = OpenMaya.MPoint( *getBBCenter( target ) )
rootCenter = OpenMaya.MPoint( *rootCenters[i] )
if targetCenter.distanceTo( rootCenter ) < 0.0001:
addNamespaceToChildren( namespace, target )
cmds.rename( target, namespaceRoot.split( '|' )[-1] )
def setLinearUnit(unit):
validUnits = ["mm", "millimeter", "cm", "centimeter", "m", "meter", "km", "kilometer", "in", "inch", "ft", "foot", "yd", "yard", "mi", "mile"]
if unit in validUnits:
cmds.optionVar(sv = ["workingUnitLinear", unit])
cmds.optionVar(sv = ["workingUnitLinearDefault", unit])
cmds.currentUnit(linear=unit)
else:
cmds.warning('Please specify a valid unit.')
def set_fps(fps = None):
fps_string = "pal"
if fps == 25:
fps_string = "pal"
if fps == 24:
fps_string = "film"
if fps == 30:
fps_string = "ntsc"
cmds.currentUnit(t=fps_string)
def __init__( self):
self._saved = cmds.file( query = True, exists = True)
if self._saved:
self._modified = cmds.file( query = True, anyModified = True)
self._versionDigits = 3
self._fullName = cmds.file( query = True, expandName = True)
self._fileName = cmds.file( query = True, sceneName = True, shortName = True)
self._fileType = cmds.file( query = True, type = True)[0]
self._extension = '.' + mm.eval( 'fileExtension("' + self._fileName + '")')
self._path = self._fullName[:self._fullName.rfind(self._fileName)]
self._sceneName = self._fileName[:self._fileName.rfind(self._extension)]
self._shotName = self._sceneName[:-(self._versionDigits+2)]
self._sceneVersion = self._sceneName[-self._versionDigits:]
self._resolutionWidth = cmds.getAttr( 'defaultResolution.width')
self._resolutionHeight = cmds.getAttr( 'defaultResolution.height')
self._format = str( self._resolutionWidth) + ' x ' + str( self._resolutionHeight)
self._renderStartFrame = int( cmds.getAttr( 'defaultRenderGlobals.startFrame'))
self._renderEndFrame = int( cmds.getAttr( 'defaultRenderGlobals.endFrame'))
_rawDate = os.stat( self._fullName)
_rawDate = time.localtime( _rawDate[8])
self._lastModified = str( _rawDate[0]) + '. ' \
+ str( _rawDate[1]) + '. ' \
+ str( _rawDate[2]) + ' - ' \
+ str( _rawDate[3]) + ':' \
+ str( _rawDate[4]) + ':' \
+ str( _rawDate[5])
self._unitLinear = cmds.currentUnit( query = True, linear = True, fullName = True)
self._unitAngle = cmds.currentUnit( query = True, angle = True, fullName = True)
self._unitTime = cmds.currentUnit( query = True, time = True, fullName = True)
self._references = cmds.file (query = True, reference = True)
else:
_empty = 'scene not saved'
self._modified = _empty
self._versionDigits = _empty
self._fullName = _empty
self._fileName = _empty
self._fileType = _empty
self._extension = _empty
self._path = _empty
self._sceneName = _empty
self._shotName = _empty
self._sceneVersion = _empty
self._resolutionWidth = _empty
self._resolutionHeight = _empty
self._format = _empty
self._renderStartFrame = _empty
self._renderEndFrame = _empty
_rawDate = _empty
_rawDate = _empty
self._lastModified = _empty
self._unitLinear = _empty
self._unitAngle = _empty
self._unitTime = _empty
self._references = _empty
def setup(self):
cmds.file(os.path.join(r9Setup.red9ModulePath(), 'tests', 'testFiles', 'MetaRig_anim_jump.mb'), open=True, f=True)
self.mRig = r9Meta.getMetaNodes(mTypes=r9Meta.MetaRig)[0]
self.poseFolder = getPoseFolder()
# make our PoseData object with the unitTest config loaded
filterNode = r9Core.FilterNode_Settings()
filterNode.read(red9MetaRigConfig)
self.poseData = r9Pose.PoseData(filterNode)
cmds.currentUnit(time='ntscf')
def copyTimeSettings(self): """copy time settings from selected scene""" asset = self.getAssetFromTaks() if not asset: return tim = asset.time mc.currentUnit( time=tim['tim'], linear = tim['lin'], angle = tim[ 'angle' ] ) mc.playbackOptions( min = tim[ 'min' ], ast = tim[ 'ast' ], max = tim[ 'max' ], aet = tim[ 'aet' ] )
def import_transformsBake( fileName=None ):
import sgBFunction_fileAndPath
import sgFunctionDag
import cPickle
if not fileName:
defaultExportTransformBakePath = sgBFunction_fileAndPath.getMayaDocPath() + '/defaultExportTransformsBake.txt'
f = open( defaultExportTransformBakePath, 'r' )
fileName = cPickle.load( f )
f = open( fileName, 'r' )
datas = cPickle.load( f )
f.close()
unit, minFrame, maxFrame = datas[:3]
imTargets = datas[3:]
cmds.currentUnit( time= unit )
for imTarget, targetMtxs in imTargets:
if not cmds.objExists( imTarget ):
sgFunctionDag.makeTransform( imTarget )
for imTarget, targetMtxs in imTargets:
attrs = cmds.listAttr( imTarget, k=1 )
animCurves = []
for k in range( len( attrs ) ):
targetAttr = imTarget + '.' + attrs[k]
at = cmds.attributeQuery( attrs[k], node=imTarget, at=1 )
animCurveType='animCurveTU'
if at == 'doubleLinear':
animCurveType = 'animCurveTL'
elif at == 'doubleAngle':
animCurveType = 'animCurveTA'
animCurve = cmds.createNode( animCurveType, n=targetAttr.split( '|' )[-1].replace( '.', '_' ) )
animCurves.append( animCurve )
for time in range( int( minFrame ), int( maxFrame+1 ) ):
i = time - int( minFrame )
cmds.xform( imTarget, os=1, matrix= targetMtxs[i] )
for k in range( len( attrs ) ):
targetAttr = imTarget + '.' + attrs[k]
targetAttrValue= cmds.getAttr( targetAttr )
animCurve = animCurves[k]
cmds.setKeyframe( animCurves[k], t=i, v=targetAttrValue )
for k in range( len( attrs ) ):
targetAttr = imTarget + '.' + attrs[k]
cmds.connectAttr( animCurves[k]+'.output', targetAttr )
cmds.select( imTargets[-1][0] )
def setup(self):
cmds.file(os.path.join(r9Setup.red9ModulePath(), 'tests', 'testFiles', 'MetaRig_anim_jump.mb'), open=True, f=True)
self.rootNode = '|World_Ctrl'
self.poseFolder = getPoseFolder()
cmds.currentUnit(time='ntscf')
# make our PoseData object with the unitTest config loaded
filterNode = r9Core.FilterNode_Settings()
filterNode.nodeTypes = 'nurbsCurve'
filterNode.incRoots = False
filterNode.filterPriority = ['COG__Ctrl', 'Hips_Ctrl', 'Chest_Ctrl', 'R_Wrist_Ctrl', 'L_Wrist_Ctrl', 'L_Foot_Ctrl', 'R_Foot_Ctrl', 'L_Knee_Ctrl', 'R_Knee_Ctrl']
self.poseData = r9Pose.PoseData(filterNode)
def simpleEmitter():
cmds.file (force=True, newFile=True)
cmds.currentUnit (linear='centimeter', angle='degree', time='film')
# Load the plug-in emitter and create an emitter node
cmds.loadPlugin ('simpleEmitter.py')
cmds.createNode ('spSimpleEmitter', name='simpleEmitter')
# Create particle object and connect to the plugin emitter node
cmds.particle (name='particles')
cmds.connectDynamic ('particles', em='simpleEmitter')
cmds.setAttr ('simpleEmitter.rate', 200 )
cmds.setAttr ('simpleEmitter.speed', 25 )
cmds.playbackOptions (minTime=0.00, maxTime=60.0)
cmds.currentTime (0)
cmds.play (wait=True, forward=True)
# make some keyframes on emitter
cmds.currentTime (0)
cmds.select ('simpleEmitter', replace=True)
cmds.setKeyframe ('simpleEmitter.tx')
cmds.setKeyframe ('simpleEmitter.ty')
cmds.setKeyframe ('simpleEmitter.tz')
cmds.setKeyframe ('simpleEmitter.rx')
cmds.setKeyframe ('simpleEmitter.ry')
cmds.setKeyframe ('simpleEmitter.rz')
cmds.currentTime (30)
cmds.move (-2.011944, 6.283524, -2.668834, relative=True)
cmds.move (0, 0, 12.97635, relative=True, localSpace=True, worldSpaceDistance=True)
cmds.rotate (0, -75.139762, 0, relative=True, objectSpace=True)
cmds.setKeyframe ('simpleEmitter.tx')
cmds.setKeyframe ('simpleEmitter.ty')
cmds.setKeyframe ('simpleEmitter.tz')
cmds.setKeyframe ('simpleEmitter.rx')
cmds.setKeyframe ('simpleEmitter.ry')
cmds.setKeyframe ('simpleEmitter.rz')
cmds.currentTime (60)
cmds.move (0, 0, -14.526107, relative=True)
cmds.move (0, -8.130523, 0, relative=True)
cmds.rotate (0, 0, 78.039751, relative=True, objectSpace=True)
cmds.rotate (0, 0, 53.86918, relative=True, objectSpace=True)
cmds.setKeyframe ('simpleEmitter.tx')
cmds.setKeyframe ('simpleEmitter.ty')
cmds.setKeyframe ('simpleEmitter.tz')
cmds.setKeyframe ('simpleEmitter.rx')
cmds.setKeyframe ('simpleEmitter.ry')
cmds.setKeyframe ('simpleEmitter.rz')
cmds.playbackOptions (minTime=0.00, maxTime=60.0)
cmds.currentTime (0)
cmds.play (wait=True, forward=True)
def storeSettings(self):
'''
main work function, store all UI settings
'''
self.dataStore['autoKey'] = cmds.autoKeyframe(query=True, state=True)
# timeline management
self.dataStore['currentTime'] = cmds.currentTime(q=True)
self.dataStore['minTime'] = cmds.playbackOptions(q=True, min=True)
self.dataStore['maxTime'] = cmds.playbackOptions(q=True, max=True)
self.dataStore['startTime'] = cmds.playbackOptions(q=True, ast=True)
self.dataStore['endTime'] = cmds.playbackOptions(q=True, aet=True)
self.dataStore['playSpeed'] = cmds.playbackOptions(query=True, playbackSpeed=True)
self.dataStore['playLoop'] = cmds.playbackOptions(query=True, loop=True)
# unit management
self.dataStore['timeUnit'] = cmds.currentUnit(q=True, fullName=True, time=True)
self.dataStore['sceneUnits'] = cmds.currentUnit(q=True, fullName=True, linear=True)
self.dataStore['upAxis'] = cmds.upAxis(q=True, axis=True)
# viewport colors
self.dataStore['displayGradient'] = cmds.displayPref(q=True, displayGradient=True)
# objects colors
self.dataStore['curvecolor'] = cmds.displayColor("curve", q=True, dormant=True)
# panel management
self.dataStore['panelStore'] = {}
for panel in ['modelPanel1', 'modelPanel2', 'modelPanel3', 'modelPanel4']:
if not cmds.modelPanel(panel, q=True, exists=True):
continue
self.dataStore['panelStore'][panel] = {}
self.dataStore['panelStore'][panel]['settings'] = cmds.modelEditor(panel, q=True, sts=True)
activeCam = cmds.modelPanel(panel, q=True, camera=True)
if not cmds.nodeType(activeCam) == 'camera':
activeCam = cmds.listRelatives(activeCam, f=True)[0]
self.dataStore['panelStore'][panel]['activeCam'] = activeCam
# camera management
# TODO : store the camera field of view etc also
self.dataStore['cameraTransforms'] = {}
for cam in ['persp', 'top', 'side', 'front']:
try:
self.dataStore['cameraTransforms'][cam] = [cmds.getAttr('%s.translate' % cam),
cmds.getAttr('%s.rotate' % cam),
cmds.getAttr('%s.scale' % cam)]
except:
log.debug("Camera doesn't exists : %s" % cam)
# sound management
self.dataStore['activeSound'] = cmds.timeControl(self.gPlayBackSlider, q=True, s=1)
self.dataStore['displaySound'] = cmds.timeControl(self.gPlayBackSlider, q=True, ds=1)
def checkUnit(self , assetRoot, *args, **kws):
"""
# check maya working units:
# Linear: centimeter
# Angular: degrees
# Time: Film(24fps)
"""
if mc.currentUnit(q=True, l=True) != "cm" or mc.currentUnit(q=True, a=True) != "deg" or mc.currentUnit(q=True, t=True) != "film":
return self.checkResult(allowPublish=False, msg="Maya working unit should be: Linear: centimeter, Angular: degrees, Time: Film(24fps)", nodes=list())
else:
return self.checkResult(allowPublish=True, msg="Everything is OK")
def FrameratePrompt():
framerate = cmds.currentUnit(q=True, time=True)
if framerate != 'pal':
message = 'Maya session is not working with 25 fps.\n'
message += 'Do you want to switch to 25 fps?'
result = cmds.confirmDialog(title='FRAMERATE', message=message,
icon='warning', backgroundColor=(0.5, 0, 0))
if result == 'Confirm':
cmds.currentUnit(time='pal')
def setupScene(*args):
cmds.currentUnit(time = 'ntsc')
cmds.playbackOptions(min = 0, max = 100, animationStartTime = 0, animationEndTime = 100)
cmds.currentTime(0)
#check for skeleton builder or animation UIs
if cmds.dockControl("skeletonBuilder_dock", exists = True):
print "Custom Maya Menu: SetupScene"
channelBox = cmds.formLayout("SkelBuilder_channelBoxFormLayout", q = True, childArray = True)
if channelBox != None:
channelBox = channelBox[0]
#reparent the channelBox Layout back to maya's window
cmds.control(channelBox, e = True, p = "MainChannelsLayersLayout")
channelBoxLayout = mel.eval('$temp1=$gChannelsLayersForm')
channelBoxForm = mel.eval('$temp1 = $gChannelButtonForm')
#edit the channel box pane's attachment to the formLayout
cmds.formLayout(channelBoxLayout, edit = True, af = [(channelBox, "left", 0),(channelBox, "right", 0), (channelBox, "bottom", 0)], attachControl = (channelBox, "top", 0, channelBoxForm))
#print "deleting dock and window and shit"
cmds.deleteUI("skeletonBuilder_dock")
if cmds.window("SkelBuilder_window", exists = True):
cmds.deleteUI("SkelBuilder_window")
if cmds.dockControl("artAnimUIDock", exists = True):
channelBox = cmds.formLayout("ART_cbFormLayout", q = True, childArray = True)
if channelBox != None:
channelBox = channelBox[0]
#reparent the channelBox Layout back to maya's window
cmds.control(channelBox, e = True, p = "MainChannelsLayersLayout")
channelBoxLayout = mel.eval('$temp1=$gChannelsLayersForm')
channelBoxForm = mel.eval('$temp1 = $gChannelButtonForm')
#edit the channel box pane's attachment to the formLayout
cmds.formLayout(channelBoxLayout, edit = True, af = [(channelBox, "left", 0),(channelBox, "right", 0), (channelBox, "bottom", 0)], attachControl = (channelBox, "top", 0, channelBoxForm))
#print "deleting dock and window and shit"
cmds.deleteUI("artAnimUIDock")
if cmds.window("artAnimUI", exists = True):
cmds.deleteUI("artAnimUI")
def setSceneFromSceneBakeInfo( sceneBakeInfoPath, importCachebody = False ):
import os
import cPickle
import sgBFunction_mesh
import sgBFunction_shader
import sgBModel_fileAndPath
f = open( sceneBakeInfoPath, 'r' )
shaderInfo = cPickle.load( f )
f.close()
unit, minFrame, maxFrame, namespaces, filePaths = shaderInfo
cmds.currentUnit( time= unit )
cmds.playbackOptions( min=minFrame, max=maxFrame )
"""
buildShadingInfoData( filePaths )
for i in range( len( filePaths ) ):
folderPath = '/'.join( filePaths[i].split( '/' )[:-1] ) + '/' + sgBModel_fileAndPath.cacheBodyUvFolderName
namespace = namespaces[i]
if not namespace:
sgBFunction_mesh.assignUvFiles( folderPath , '' )
else:
sgBFunction_mesh.assignUvFiles( folderPath, namespace +'_' )
for i in range( len( namespaces ) ):
filePath = filePaths[i]
folderPath = '/'.join( filePath.split( '/' )[:-1] )
fileName = filePath.split( '/' )[-1]
onlyFileName = fileName.split( '.' )[0]
if onlyFileName.lower().find( 'cachebody' ) == -1: onlyFileName += '_cachebody'
shadingInfoFile = folderPath + '/' + onlyFileName + '.shadingInfo'
if not os.path.exists( shadingInfoFile ): continue
sgBFunction_shader.assignReferenceShader( shadingInfoFile, namespaces[i] )
"""
if importCachebody:
for i in range( len( namespaces ) ):
namespace = namespaces[i]
filePath = filePaths[i]
folderPath = '/'.join( filePath.split( '/' )[:-1] )
fileName = filePath.split( '/' )[-1]
onlyFileNameAndExtension = fileName.split( '.' )
if onlyFileNameAndExtension[0].lower().find( 'cachebody' ) == -1: onlyFileNameAndExtension[0] += '_cachebody'
cachebodyPath = folderPath + '/' + '.'.join( onlyFileNameAndExtension )
print "cachebodyPath : ", cachebodyPath
if not os.path.exists( cachebodyPath ): continue
cmds.file( cachebodyPath, i=1, ignoreVersion=True, ra=True, mergeNamespacesOnClash = False, rpr=namespace, options="v=0;", pr=1 )
def mImportTimeInfo(timeInfoFile):
"""
"""
with open(timeInfoFile, 'r') as timeInfoTxt:
timeInfo = timeInfoTxt.read().split('\n')
cmds.currentUnit(t= timeInfo[0])
logger.info('TimeInfo [Unit] ' + timeInfo[0])
cmds.playbackOptions(min= float(timeInfo[1].split(':')[0]))
cmds.playbackOptions(max= float(timeInfo[1].split(':')[1]))
logger.info('TimeInfo [Range] ' + timeInfo[1])
exec(timeInfo[2])
logger.info('TimeInfo [Static] ' + str(isStatic))
return [isStatic, float(timeInfo[1].split(':')[1])]
def copyTimeSettings(self): """copy time settings from selected scene""" tab = self._getCurrentTab() item = tab.currentItem() if uiH.USEPYQT: asset = item.data(32).toPyObject() else: asset = item.data(32) tim = asset.time mc.currentUnit( time=tim['tim'], linear = tim['lin'], angle = tim[ 'angle' ] ) mc.playbackOptions( min = tim[ 'min' ], ast = tim[ 'ast' ], max = tim[ 'max' ], aet = tim[ 'aet' ] )
def referenceCamera(self): """docstring for reference""" sht = self._selectedShot if INMAYA: sht.poolCam.reference() tim = self._selectedShot.animPath.time mc.currentUnit( time=tim['tim'], linear = tim['lin'], angle = tim[ 'angle' ] ) mc.playbackOptions( min = tim[ 'min' ], ast = tim[ 'ast' ], max = tim[ 'max' ], aet = tim[ 'aet' ] ) elif INHOU: hu.loadCamera(sht.project.name, sht.sequence.name, sht.name, self.connectToGlobalScale_chb.isChecked() ) hu.copyTimeSettings( sht.project.name, sht.sequence.name, sht.name )
def process(self, context):
# Get the current linear units
units = cmds.currentUnit(q=1, linear=1)
# Get the current angular units ('deg' or 'rad')
units_angle = cmds.currentUnit(q=1, angle=1)
# Get the current time units
fps = mel.eval('currentTimeUnitToFPS()')
context.set_data('linearUnits', units)
context.set_data('angularUnits', units_angle)
context.set_data('fps', fps)
def __init__(self, uioptions, transformoptions, sourcelist, targetlist):
'''
initial setup
'''
#create the tool context
if (mc.draggerContext(spPaint3dContextID, exists=True)):
mc.deleteUI(spPaint3dContextID);
mc.draggerContext(spPaint3dContextID, pressCommand=self.onPress, dragCommand=self.onDrag, releaseCommand=self.onRelease, name=spPaint3dContextID, cursor='crossHair', undoMode='step')
#create context local options
self.runtimeUpdate(uioptions, transformoptions, sourcelist, targetlist)
#debug purpose
self.reentrance = 0
#initialise world up vector
if ( (mc.upAxis(q=True, axis=True)) == "y" ):
self.worldUp = om.MVector (0,1,0);
elif ( (mc.upAxis(q=True, axis=True)) == "z" ):
self.worldUp = om.MVector (0,0,1);
else:
#can't figure out up vector
mc.confirmDialog(title='Weird stuff happening', message='Not getting any proper info on what the current up vector is. Quitting...')
sys.exit()
#fetch current scene unit
self.unit = mc.currentUnit(query=True, linear=True)
def exportDeformAnimation(folder):
'''Use MDD file to export defrom animation.'''
minframe = int( mc.playbackOptions(q = True, min = True) )
maxframe = int( mc.playbackOptions(q = True, max = True) )
totalframes = maxframe - minframe + 1
t = mc.currentUnit(q = True, t = True)
fps = _mfps[t]
parts = []
selectionList = mo.MSelectionList()
mo.MGlobal.getActiveSelectionList(selectionList)
itList = mo.MItSelectionList(selectionList, mo.MFn.kTransform)
while not itList.isDone():
path = mo.MDagPath()
itList.getDagPath(path)
partialName = str(path.partialPathName())
name = partialName.split(":")[-1]
part = MDD(name, mo.MFnMesh(path), totalframes, fps)
parts.append(part)
itList.next()
# add animation
for frame in range(minframe, maxframe + 1):
mc.currentTime(frame, edit = True)
for p in parts:
p.addFrame()
# write files
for p in parts:
p.writeToFile(folder)
print "write %s done." % p.name
print "All is done."
return True
def getFps():
'''
returns the current fps as a number
'''
timebases = {'ntsc': 30, 'pal': 25, 'film': 24, 'game': 15, 'show': 48, 'palf': 50, 'ntscf': 60}
base = cmd.currentUnit(q=True, time=True)
return timebases[base]
def check_units(expected="cm"):
"""
check to make sure scene working units are in expected units
"""
current_units = mc.currentUnit(query=True, linear=True)
if current_units != expected:
notify_wrong_units(expected, current_units)
def getCurrent(self):
self.minframe = int( mc.playbackOptions(q = True, min = True) )
self.maxframe = int( mc.playbackOptions(q = True, max = True) )
self.totalframes = self.maxframe - self.minframe + 1
t = mc.currentUnit(q = True, t = True)
self.fps = self._mfps[t]
return True
def __init__(self):
''' os '''
self.sep = self.pathSep()
''' maya basic '''
# project root
self.workspaceRoot = cmds.workspace(q= 1, rd= 1)
# project folder path dict
self.dirRule = self.getDirRules()
# scene full path
self.sceneFullPath = mGeneral.sceneName(shn= 0, ext= 1)
# scene name with ext
self.sceneFullName = mGeneral.sceneName(ext= 1)
# scene name without ext
self.sceneSplitExt = mGeneral.sceneName()
''' scene data '''
# project abbreviation
self.prjAbbr = ''
# scene file version
self.ver = self.getVerSN(self.sceneSplitExt)
# the one who last saved this scene
self.artist = ''
# shot number
self.shotNum = self.getShotNum(self.sceneSplitExt)
# camera list
self.cam = []
# palybackRange
self.palybackStart = cmds.playbackOptions(q= 1, min= 1)
self.palybackEnd = cmds.playbackOptions(q= 1, max= 1)
# frameRate
self.fps = mel.eval('currentTimeUnitToFPS')
self.timeUnit = cmds.currentUnit(q= 1, t= 1)
def getFPSValue():
"""Get time units title.
Returns:
str
"""
fps = dict(game=15, film=24, pal=25, ntsc=30, show=48, palf=50,
ntscf=60)[cmds.currentUnit(query=True, time=True)]
return '{0} FPS'.format(fps)
def frameRate_set(arg, fixFractionalSlider=True):
_str_func = 'frameRate_set'
log.debug(cgmGEN.logString_start(_str_func))
if VALID.valueArg(arg):
_arg = '{0}fps'.format(arg)
else:
d_validArgs = {
'ntsc': ['n', 'ntsc'],
'pal': ['p', 'pal'],
'film': ['f', 'film'],
'game': ['g', 'game'],
'ntscf': ['ntscf']
}
_arg = VALID.kw_fromDict(arg,
d_validArgs,
calledFrom=_str_func,
noneValid=True)
if not _arg:
_arg = arg
log.debug(
cgmGEN.logString_msg(_str_func,
"| arg: {0} | validated: {1}".format(arg, _arg)))
mc.currentUnit(time=_arg)
if fixFractionalSlider:
log.debug(cgmGEN.logString_msg(_str_func, 'fixFractionalSlider...'))
_current = mc.currentTime(q=True)
mc.playbackOptions(
animationStartTime=int(
mc.playbackOptions(q=True, animationStartTime=True)),
animationEndTime=int(
mc.playbackOptions(q=True, animationEndTime=True)),
max=int(mc.playbackOptions(q=True, max=True)),
min=int(mc.playbackOptions(q=True, min=True)),
)
mc.currentTime(int(_current))
def updateUI(command, *args):
if command == 'units_text':
#'Maya Units' text in settings.
mc.text('unitText',
edit=True,
label='Working Units: %s' % mc.currentUnit(q=True, f=True))
mc.text('ratio_unit',
edit=True,
label='Pixels per %s:' % mc.currentUnit(q=True))
command = 'ratio_value'
elif 'angle' in command:
# Straighten Edges Angle dials
if command.split(':')[1] == 'field':
aValue = mc.floatField('angleField', q=True, value=True)
mc.floatSlider('angleSlider', edit=True, value=aValue)
if command.split(':')[1] == 'slider':
aValue = mc.floatSlider('angleSlider', q=True, value=True)
mc.floatField('angleField', edit=True, value=aValue)
elif 'match' in command:
aValue = mc.floatSlider('matchSlider', q=True, value=True)
mc.floatField('MatchUVDistance', edit=True, value=aValue)
elif command == 'scale_pivot':
#Check if scaling pivot is based on selection
if mc.radioButton('PivSel', q=True, sl=True):
mc.floatField('scalePivotFieldU', edit=True, enable=False)
mc.floatField('scalePivotFieldV', edit=True, enable=False)
mc.text('spu', edit=True, enable=False)
mc.text('spv', edit=True, enable=False)
mc.button('samplePivotButton', edit=True, enable=False)
else:
mc.floatField('scalePivotFieldU', edit=True, enable=True)
mc.floatField('scalePivotFieldV', edit=True, enable=True)
mc.text('spu', edit=True, enable=True)
mc.text('spv', edit=True, enable=True)
mc.button('samplePivotButton', edit=True, enable=True)
if 'ratio_value' in command:
#Updates the floatField containing the value that gets queried by unfold.
mult = setRatioMultiplier()
unfold = 0.0009765625 * (mc.intField(
'densityField', q=True, value=True))
mc.floatField('ratioField', edit=True, v=unfold * mult)
return
def distanceUnit_set(arg):
_str_func = 'distanceUnit_set'
log.debug(cgmGEN.logString_start(_str_func))
d_validArgs = {
'm': ['meter', 'metre'],
'cm': ['centimeter', 'centi'],
'mm': ['milimeter', 'mili'],
'yd': ['yard'],
'in': ['inch', 'inches'],
'ft': ['feet', 'foot']
}
_arg = VALID.kw_fromDict(arg, d_validArgs, calledFrom=_str_func)
log.debug(
cgmGEN.logString_msg(_str_func,
"| arg: {0} | validated: {1}".format(arg, _arg)))
mc.currentUnit(linear=_arg)
def test_fps(self):
fps_map = {
"ntsc": 30,
"game": 15,
"film": 24,
"pal": 25,
"show": 48,
"palf": 50,
"ntscf": 60
}
for name, fps in fps_map.items():
cmds.currentUnit(time=name)
temp_file = os.path.join(self.temp_dir,
'test_{}.usda'.format(name))
cmds.mayaUSDExport(f=temp_file, frameRange=(1, 5))
stage = Usd.Stage.Open(temp_file)
self.assertEqual(stage.GetTimeCodesPerSecond(), fps)
self.assertEqual(stage.GetFramesPerSecond(), fps)
def RetimeHelper(*args):
cur = cmds.currentTime(query=True)
TimeSet = cmds.currentUnit(q=True, time=True)
if TimeSet == "ntscf":
No = 60.0
else:
No = 30.0
Set = cur / No
cmds.retimeHelper(edit=True, frame=Set)
def setupSceneFromCam():
#set attributes from camera
perspCameras = cmds.listCameras(p=True)
if (cmds.attributeQuery('frameRate', node=item, exists=True)):
cameraframeRate = cmds.getAttr(item + '.frameRate')
cmds.currentUnit(time=cameraframeRate)
if (cmds.attributeQuery('width', node=item, exists=True)):
cameraWidth = cmds.getAttr(item + '.width')
cmds.setAttr('defaultResolution.width', cameraWidth)
if (cmds.attributeQuery('height', node=item, exists=True)):
cameraHeight = cmds.getAttr(item + '.height')
cmds.setAttr('defaultResolution.height', cameraHeight)
if (cmds.attributeQuery('startFrame', node=item, exists=True)):
cameraStart = cmds.getAttr(item + '.startFrame')
cmds.setAttr('defaultRenderGlobals.startFrame', cameraStart)
cmds.playbackOptions(min=cameraStart, ast=cameraStart)
if (cmds.attributeQuery('endFrame', node=item, exists=True)):
cameraEnd = cmds.getAttr(item + '.endFrame')
cmds.setAttr('defaultRenderGlobals.endFrame', cameraEnd)
cmds.playbackOptions(max=cameraEnd, aet=cameraEnd)
def torusField():
cmds.file(force=True, new=True)
cmds.currentUnit(linear="centimeter", angle="degree", time="film")
# Create the new field node
cmds.createNode("spTorusField", name="torus")
# create particle object.
#
cmds.particle(jbp=(0.0, 0.0, 0.0), nj=250, jr=5, c=1, name="particles")
# connect torus field node with the particle object.
#
cmds.connectDynamic("particles", f="torus")
cmds.setAttr("torus.attractDistance", 10)
cmds.setAttr("torus.repelDistance", 5)
cmds.playbackOptions(e=True, min=0.00, max=600.0)
cmds.currentTime(0, e=True)
cmds.play(wait=True, forward=True)
def set_project_settings(self, data, **kwargs):
import ast
data = ast.literal_eval(data)
####################
" FPS "
####################
current_fps = cmds.currentUnit( query=True, linear=True )
fps = data["sg_fps"]
if 15 in fps:
fps = "game"
if 23.9 in fps:
fps = "film"
if 24 in fps:
fps = "film"
if 25 in fps:
fps = "pal"
if 29.9 in fps:
fps = "ntsc"
if 30 in fps:
fps = "ntsc"
if 48 in fps:
fps = "show"
if 50 in fps:
fps = "palf"
if 59 in fps:
fps = "ntscf"
if 60 in fps:
fps = "ntscf"
msg = """
The Following settings have been fetched from Shotgun and will be applied:\n
FPS\n
{} --> {}
\n
Framerange\n
First frame: {} --> {}\n
Last frame: {} --> {}\n
Head handles: {} -- Tail handles: {}
\n
Apply?
""".format(current_fps, fps, current_framerange[0], str(in_frame), current_framerange[1], str(out_frame), head_handles, tail_handles)
confirm = confirmDialog("Should I copy shaders?")
if confirm == "Yes":
for tgt in tgts:
shp = cmds.listRelatives(src, s=True)[0]
sg = cmds.listConnections(shp, t="shadingEngine")[0]
tshp = cmds.listRelatives(tgt, s=True)[0]
cmds.sets(tshp, e=True, forceElement=sg)
def setUpMdlShot(): ''' Set up modeling environment. ''' # Start new shot confirmSaveCurScene() # Working unit cmds.currentUnit(linear = 'centimeter') cmds.currentUnit(time = 'ntsc') # set time slider and current frame to 1 cmds.playbackOptions(min = 1) cmds.currentTime(1) # Make group hierarchy pipeHier() cmds.select(cl = True)
def _get_frame_rate(self):
'''获取帧数率
'''
_dict = {
'film':24,
"pal":25,
"ntsc":30
}
_mode = cmds.currentUnit(q=1, t=1)
_frame_rate = _dict[_mode]
return u"帧率: %s"%str(_frame_rate)
def getFPS(self):
data = {
'game': 15,
'film': 24,
'pal': 25,
'ntsc': 30,
'show': 48,
'palf': 50,
'ntscf': 60
}
qFPS = cmds.currentUnit(query=True, t=True)
self.curFPS = data[qFPS] if qFPS in data else 0
def applyConfig(weak=True):
cmds.currentUnit(time=config.getConfig('time'), updateAnimation=False)
cmds.setAttr("%s.width" % cmds.ls(renderResolutions=True)[0],
config.getConfig('camResX'))
cmds.setAttr("%s.height" % cmds.ls(renderResolutions=True)[0],
config.getConfig('camResY'))
if cmds.file(q=1, sn=1, shn=1) and weak: return
ast = int(cmds.playbackOptions(q=1, ast=1))
aet = int(cmds.playbackOptions(q=1, aet=1))
mint = int(cmds.playbackOptions(q=1, min=1))
maxt = int(cmds.playbackOptions(q=1, max=1))
configAST = config.getConfig('startFrame')
offset = configAST - ast
cmdKeyframe(offset)
cmds.currentTime(configAST)
cmds.playbackOptions(min=mint + offset,
max=maxt + offset,
ast=ast + offset,
aet=aet + offset)
def _checkFrameRates(self, elem, elem_info):
"""
Check that the frame rate for the given element matches the sequence (i.e Maya) frame rate.
If it does not, log an error.
"""
fps = cmds.currentUnit(q=1, time=1)
fps = [k for k, v in mayaFrameRates.iteritems() if v == fps][0]
elemFPS = elem_info.get("framerate", None)
if elemFPS is not None and elemFPS != fps:
self.translator.logger.error(
"Frame rate for %s does not not match sequence frame rate" %
self.translator.formatErrorElement(elem))
def setTimeSlider(*args):
mode = cmds.radioButtonGrp(UI.widgets['timeSldrRadBtn'],
q=True,
select=True)
if mode == 1:
nModeStart = cmds.textField(UI.widgets['timeSldrNrmStartTxtFld'],
q=True,
text=True)
nModeEnd = cmds.textField(UI.widgets['timeSldrNrmEndTxtFld'],
q=True,
text=True)
cmds.playbackOptions(minTime=nModeStart)
cmds.playbackOptions(maxTime=nModeEnd)
cmds.currentTime(nModeStart)
elif mode == 2:
tModeDur = float(
cmds.textField(UI.widgets['timeSldrTimeDurTxtFld'],
q=True,
text=True))
tModeStart = float(
cmds.textField(UI.widgets['timeSldrTimeStartTxtFld'],
q=True,
text=True))
curTime = cmds.currentUnit(q=True, time=True)
if curTime == 'film':
fps = 24
elif curTime == 'pal':
fps = 25
elif curTime == 'ntsc':
fps = 30
durFrameLen = tModeDur * fps
tModeEnd = (tModeStart + durFrameLen) - 1
cmds.playbackOptions(minTime=tModeStart)
cmds.playbackOptions(maxTime=tModeEnd)
cmds.currentTime(tModeStart)
elif mode == 3:
mel.eval('source "updateSoundMenu.mel";')
sModeSndPath = cmds.textField(
UI.widgets['timeSldrSoundPathTxtFld'], q=True, text=True)
sModeStart = int(
cmds.textField(UI.widgets['timeSldrSoundStartTxtFld'],
q=True,
text=True))
sndNode = cmds.sound(offset=sModeStart, file=sModeSndPath)
soundLength = round(cmds.sound(sndNode, q=True, length=True)) - 1
sModeEnd = sModeStart + soundLength
cmds.playbackOptions(minTime=sModeStart)
cmds.playbackOptions(maxTime=sModeEnd)
cmds.currentTime(sModeStart)
gPlayBackSlider = mel.eval('$tmpVar=$gPlayBackSlider')
cmds.timeControl(gPlayBackSlider, edit=True, sound=sndNode)
mel.eval('setSoundDisplay %s 1;' % (sndNode))
def __init__(self):
self.bo = [[-1] * h for i in range(w)] #screen borad
self.preBo = [[-2] * h for i in range(w)] #off screen borad
self.playerPos = list(spownPos)
self.playerMino = [[None, None]] * 3
self.playerMinoNum = 0
self.minoRand = self.createMinoRand()
self.timer = 0
self.timerLevel = 20
self.isContact = False
self.gameOverCount = 100
self.rec = {}
self.recLen = 0
cmds.undoInfo(st=False)
cmds.currentUnit(t='ntsc')
cmds.playbackOptions(e=1, playbackSpeed=0, maxPlaybackSpeed=1)
cmds.evaluationManager(mode='off')
#cmds.evaluationManager(inv=True)
cmds.playbackOptions(min=1, max=5000)
self.createObjs()
def CheackWorkUnits(self, *args):
# 检查工作尺寸
try:
Export_type = cmds.radioButtonGrp("Export_type",
q=True,
select=True)
if Export_type == 1:
#设置场景帧率和尺寸 ntsc: 30 fps ; pal: 25 fps ; centimeter ; meter
cmds.currentUnit(time='ntsc', linear='meter')
# fbx导出设置，文件单位转化,FBXExportConvertUnitString [mm|dm|cm|m|km|In|ft|yd|mi];
mel.eval('FBXExportConvertUnitString m;')
# print("Unity 模式")
elif Export_type == 2:
#设置场景帧率和尺寸 ntsc: 30 fps ; pal: 25 fps ; centimeter ; meter
cmds.currentUnit(time='pal', linear='centimeter')
mel.eval('FBXExportConvertUnitString cm;')
# print("UE4 模式")
except Exception as e:
raise e
def __exit__(self, *_):
if self.oldlin is not None:
mc.currentUnit(linear=self.oldlin)
if self.oldang is not None:
mc.currentUnit(angle=self.oldang)
if self.oldtim is not None:
mc.currentUnit(time=self.oldtim)
def setWorkUnits(self):
#load path and config
path_config = cfgl.configLoader()[99:101]
if self.cboxSysUnits.currentIndex() == 0:
cmds.currentUnit(linear='m')
self.lblInfo_01.setText("Units changed to m")
print "Units changed to m"
cfgl.ConfigWriter('Units', 'Custom_System_type_units', 'm',
path_config[0], path_config[1])
if self.cboxSysUnits.currentIndex() == 1:
cmds.currentUnit(linear='cm')
self.lblInfo_01.setText("Units changed to cm")
print "Units changed to cm"
cfgl.ConfigWriter('Units', 'Custom_System_type_units', 'cm',
path_config[0], path_config[1])
if self.cboxSysUnits.currentIndex() == 2:
cmds.currentUnit(linear='mm')
self.lblInfo_01.setText("Units changed to mm")
print "Units changed to mm"
cfgl.ConfigWriter('Units', 'Custom_System_type_units', 'mm',
path_config[0], path_config[1])
def reset_frame_range():
"""Set frame range to current asset"""
shot = api.Session["AVALON_ASSET"]
shot = io.find_one({"name": shot, "type": "asset"})
try:
frame_start = shot["data"].get(
"frameStart",
# backwards compatibility
shot["data"].get("edit_in"))
frame_end = shot["data"].get(
"frameEnd",
# backwards compatibility
shot["data"].get("edit_out"))
except KeyError:
cmds.warning("No edit information found for %s" % shot["name"])
return
fps = {
"12": "12fps",
"15": "game",
"16": "16fps",
"24": "film",
"25": "pal",
"30": "ntsc",
"48": "show",
"50": "palf",
"60": "ntscf"
}.get(api.Session.get("AVALON_FPS"), "pal") # Default to "pal"
cmds.currentUnit(time=fps)
cmds.playbackOptions(minTime=frame_start)
cmds.playbackOptions(maxTime=frame_end)
cmds.playbackOptions(animationStartTime=frame_start)
cmds.playbackOptions(animationEndTime=frame_end)
cmds.playbackOptions(minTime=frame_start)
cmds.playbackOptions(maxTime=frame_end)
cmds.currentTime(frame_start)
def prefFunction(self, pref, obj, *args):
if pref == 'evaluation':
cmds.evaluationManager(mode=obj)
print 'Evaluation Mode: %s' % cmds.evaluationManager(q=True,
mode=True)[0]
elif pref == 'default tangent':
cmds.keyTangent(g=True, itt=obj)
cmds.keyTangent(g=True, ott=obj)
print 'Default Tangents: %s, %s' % (cmds.keyTangent(
q=True, g=True,
itt=True)[0], cmds.keyTangent(q=True, g=True, ott=True)[0])
elif pref == 'frames per second':
# Keep Keys at Current Frames
# cmds.currentUnit(time='', ua=True)
cmds.currentUnit(t=obj)
print 'Frames Per Second: %s' % cmds.currentUnit(
q=True,
t=True,
ua=cmds.menuItem(self.keepFrames, q=True, checkBox=True))
elif pref == 'playback speed':
cmds.playbackOptions(ps=obj)
print 'Playback Speed: %s' % cmds.playbackOptions(q=True, ps=True)
elif pref == 'up axis':
cmds.upAxis(ax=obj)
print 'Up Axis: %s' % cmds.upAxis(q=True, ax=True)
elif pref == 'working units':
cmds.currentUnit(l=obj)
print 'Working Units: %s' % cmds.currentUnit(q=True, l=True)
def _setHWRenderGlobals(width=1280, height=720, animation=False):
cmds.currentUnit(time='pal')
cmds.currentUnit(linear='cm')
mel.eval('setAttr defaultResolution.width %s' % width)
mel.eval('setAttr defaultResolution.height %s' % height)
mel.eval('setAttr defaultResolution.deviceAspectRatio 1.777')
mel.eval('setAttr defaultResolution.pixelAspect 1')
cmds.setAttr('defaultRenderGlobals.currentRenderer',
'mayaHardware',
type='string')
# mel.eval('unifiedRenderGlobalsWindow;')
## Default Render Globals
cmds.setAttr('defaultRenderGlobals.imageFormat', 51)
cmds.setAttr('defaultRenderGlobals.imfkey', 'exr', type='string')
cmds.setAttr('defaultRenderGlobals.animation', 1)
cmds.setAttr('defaultRenderGlobals.extensionPadding', 3)
cmds.getAttr('defaultRenderGlobals.extensionPadding')
cmds.setAttr('defaultRenderGlobals.periodInExt', 1)
cmds.setAttr('defaultRenderGlobals.outFormatControl', 0)
cmds.setAttr('defaultRenderGlobals.putFrameBeforeExt', 1)
cmds.setAttr('defaultRenderGlobals.enableDefaultLight', 0)
cmds.setAttr('defaultResolution.aspectLock', 0)
## Set Hardware render globals
cmds.setAttr("hardwareRenderGlobals.colorTextureResolution", 512)
cmds.setAttr("hardwareRenderGlobals.bumpTextureResolution", 1024)
cmds.setAttr("hardwareRenderGlobals.enableNonPowerOfTwoTexture", 1)
cmds.setAttr("hardwareRenderGlobals.culling", 0)
cmds.setAttr("hardwareRenderGlobals.numberOfSamples", 9)
cmds.setAttr("hardwareRenderGlobals.textureCompression", 0)
cmds.setAttr("hardwareRenderGlobals.motionBlurByFrame", .5)
cmds.setAttr("hardwareRenderGlobals.numberOfExposures", 3)
cmds.setAttr("hardwareRenderGlobals.maximumGeometryCacheSize", 64)
cmds.setAttr("hardwareRenderGlobals.enableGeometryMask", 1)
cmds.setAttr("hardwareRenderGlobals.blendSpecularWithAlpha", 0)
cmds.setAttr("hardwareRenderGlobals.enableHighQualityLighting", 1)
cmds.setAttr("hardwareRenderGlobals.frameBufferFormat", 1)
def export_transformsBake(targets, fileName=None):
import sgBFunction_fileAndPath
import sgBFunction_dag
import cPickle
if not fileName:
scenePath = cmds.file(q=1, sceneName=1)
if scenePath:
sceneFolder = '/'.join(scenePath.split('/')[:-1])
fileName = sceneFolder + '/transformsBake/bakeFile.txt'
else:
fileName = sgBFunction_fileAndPath.getMayaDocPath(
) + '/transformsBake/bakeFile.txt'
defaultExportTransformBakePath = sgBFunction_fileAndPath.getMayaDocPath(
) + '/defaultExportTransformsBake.txt'
exTargets = []
for target in targets:
if cmds.nodeType(target) != 'transform': continue
cloneH = sgBFunction_dag.getParents(target)
cloneH.append(cmds.ls(target, l=1)[0])
exTargets += cloneH
exTargets = list(set(exTargets))
exTargets.sort()
exTargetMtxs = [[] for i in range(len(exTargets))]
minFrame = cmds.playbackOptions(q=1, min=1)
maxFrame = cmds.playbackOptions(q=1, max=1)
unit = cmds.currentUnit(q=1, time=1)
for t in range(int(minFrame), int(maxFrame + 1)):
cmds.currentTime(t)
for i in range(len(exTargets)):
exTargetMtx = cmds.getAttr(exTargets[i] + '.m')
exTargetMtxs[i].append(exTargetMtx)
fileName = sgBFunction_fileAndPath.makeFile(fileName)
f = open(fileName, 'w')
datas = [unit, minFrame, maxFrame]
for i in range(len(exTargets)):
extargetName = exTargets[i].replace(':', '_')
datas.append([extargetName, exTargetMtxs[i]])
cPickle.dump(datas, f)
f.close()
f = open(defaultExportTransformBakePath, 'w')
cPickle.dump(fileName, f)
f.close()
print "Export Path : ", fileName
def GetFPS():
fps = 24
tunit = cmds.currentUnit(time=True, q=True)
fpsMap = {
'2fps': 2,
'3fps': 3,
'4fps': 4,
'5fps': 5,
'6fps': 6,
'8fps': 8,
'10fps': 10,
'12fps': 12,
'game': 15,
'16fps': 2,
'20fps': 2,
'23.976fps': 2,
'film': 24,
'pal': 25,
'29.97fps': 2,
'ntsc': 30,
'40fps': 30,
'47.952fps': 30,
'show': 48,
'palf': 50,
'59.94fps': 50,
'ntscf': 60,
'75fps': 70,
'80fps': 80,
'100fps': 100,
'120fps': 120,
'125fps': 125,
'150fps': 150,
'200fps': 200,
'240fps': 240,
'250fps': 250,
'300fps': 300,
'375fps': 375,
'400fps': 400,
'500fps': 500,
'600fps': 600,
'750fps': 750,
'1200fps': 1200,
'1500fps': 1500,
'2000fps': 2000,
'3000fps': 3000,
'6000fps': 6000,
'44100fps': 44100,
'48000fps': 48000,
}
if fpsMap.has_key(tunit):
fps = fpsMap[tunit]
return fps
def set_defaults(self):
""" Automatically set some defaults from the shot settings for a new
scene.
"""
unit = os.getenv('IC_LINEAR_UNIT', 'cm')
angle = os.getenv('IC_ANGULAR_UNIT', 'deg')
timeFormat = os.getenv('IC_TIME_UNIT', 'pal')
startFrame = int(os.getenv('IC_STARTFRAME', '1001'))
endFrame = int(os.getenv('IC_ENDFRAME', '1100'))
inFrame = int(os.getenv('IC_INFRAME', startFrame))
outFrame = int(os.getenv('IC_OUTFRAME', endFrame))
psExecutable = os.getenv('IC_PS_EXECUTABLE', '')
djvExecutable = os.getenv('IC_DJV_EXECUTABLE', '')
# Set defaults for Maya startup
# mc.currentUnit(l=unit, a=angle, t=timeFormat)
try:
mc.currentUnit(l=unit)
mc.optionVar(sv=('workingUnitLinear', unit))
mc.optionVar(sv=('workingUnitLinearDefault', unit))
except RuntimeError:
mc.warning("Unable to set linear unit.")
try:
mc.currentUnit(a=angle)
mc.optionVar(sv=('workingUnitAngular', angle))
mc.optionVar(sv=('workingUnitAngularDefault', angle))
except RuntimeError:
mc.warning("Unable to set angular unit.")
try:
mc.currentUnit(t=timeFormat)
mc.optionVar(sv=('workingUnitTime', timeFormat))
mc.optionVar(sv=('workingUnitTimeDefault', timeFormat))
except RuntimeError:
mc.warning('Unable to set time unit.')
mc.optionVar(fv=('playbackMinRangeDefault', startFrame))
mc.optionVar(fv=('playbackMinDefault', inFrame))
mc.optionVar(fv=('playbackMaxRangeDefault', endFrame))
mc.optionVar(fv=('playbackMaxDefault', outFrame))
mc.optionVar(sv=('upAxisDirection', 'y'))
mc.optionVar(sv=('EditImageDir', psExecutable))
mc.optionVar(sv=('PhotoshopDir', psExecutable))
mc.optionVar(sv=('PlayblastCmdAvi', djvExecutable))
mc.optionVar(sv=('PlayblastCmdQuicktime', djvExecutable))
mc.optionVar(sv=('ViewImageDir', djvExecutable))
mc.optionVar(sv=('ViewSequenceDir', djvExecutable))
mc.playbackOptions(
animationStartTime=startFrame,
minTime=inFrame,
maxTime=outFrame,
animationEndTime=endFrame,
playbackSpeed=0,
maxPlaybackSpeed=1)
def timeRange(*arg):
# Set to normal mode for all display layers
dpLayers = cmds.ls(type='displayLayer')
for dpLay in dpLayers:
if dpLay == 'defaultLayer':
continue
cmds.setAttr('%s.displayType' % dpLay, 0)
# Set fps to PAL
cmds.currentUnit(time='pal')
setFrameRange()
cmds.editRenderLayerGlobals(currentRenderLayer='defaultRenderLayer')
# Turn off dummy
allCtrls = cmds.ls(type='transform')
for ctrl in allCtrls:
if 'ROOT' in ctrl:
if cmds.objExists('%s.Dummy' % ctrl):
cmds.cutKey(ctrl, at='Dummy', cl=True)
cmds.setAttr('%s.Dummy' % ctrl, 0)
def test_bwav_handler(self):
'''
test the bwav handler and formatting of the data
'''
assert self.audioNode.isBwav()
#print self.audioNode.bwav_timecodeFormatted()
cmds.currentUnit(time='ntscf')
assert r9General.getCurrentFPS() == 60
#print 'ntscf' , self.audioNode.bwav_timecodeFormatted()
assert self.audioNode.bwav_timecodeFormatted() == '01:26:04:11'
cmds.currentUnit(time='pal')
assert r9General.getCurrentFPS() == 25
#print 'pal : ', self.audioNode.bwav_timecodeFormatted()
assert self.audioNode.bwav_timecodeFormatted() == '01:26:04:05'
#print self.audioNode.bwav_timecodeFormatted(smpte=False)
assert self.audioNode.bwav_timecodeFormatted(
smpte=False) == '01:26:04:172'
assert self.audioNode.bwav_timecodeReference() == 227739993
assert self.audioNode.bwav_timecodeMS() == 5164172.1768707484
#need to get the bWav header to bind it to the var
self.audioNode.bwav_getHeader()
assert self.audioNode.bwav_HeaderData == {
'AudioFormat': 0,
'BextVersion': 0,
'BitsPerSample': 0,
'ChunkSize': 732516,
'Description':
'This is a unitTest file for validating the Red9 broadcast wav extraction of metaData',
'Format': 'WAVE',
'InternalFormat': 'fmt ',
'OriginationDate': '2014-03-03',
'OriginationTime': '10:00:00',
'Originator': 'Pro Tools',
'OriginatorReference': 'ffgDDffdhgff',
'Subchunk1Size': 16,
'TimeReference': 227739993,
'TimeReferenceHigh': 0
}
def fSceneTidy(self):
cmds.currentUnit(linear="m")
geoList = cmds.ls(g=True)
grp = cmds.group(geoList, absolute=1)
scenePosition = cmds.xform(grp, q=1, ws=1, rp=1)
scenePosition = [
-1 * scenePosition[0], -1 * scenePosition[1], scenePosition[2]
]
#
bbox = cmds.exactWorldBoundingBox(geoList)
constH = 23
xValue = bbox[3] - bbox[0]
yValue = bbox[4] - bbox[1]
zValue = bbox[5] - bbox[2]
tValue = 0
if xValue > tValue: tValue = xValue
if yValue > tValue: tValue = yValue
if zValue > tValue: tValue = zValue
sceneScale = constH / tValue
cmds.ungroup(grp)
return (scenePosition, sceneScale)
def checkUnits(self):
#load custom units from cfg file cfgl.configLoader()[9]
custom_sys_units = cfgl.configLoader()[9]
cur_work_units = cmds.currentUnit(query=True)
#check units change Job
UnitsCheckerJob = cmds.scriptJob(
runOnce=False, event=['linearUnitChanged', self.UnitChanger])
if custom_sys_units != cur_work_units:
cmds.currentUnit(linear=custom_sys_units)
if custom_sys_units == 'm':
self.cboxSysUnits.setCurrentIndex(0)
if custom_sys_units == 'cm':
self.cboxSysUnits.setCurrentIndex(1)
if custom_sys_units == 'mm':
self.cboxSysUnits.setCurrentIndex(2)
print "PolygonTools: Units changed to ", custom_sys_units
self.lblInfo_01.setText("Units changed to " + custom_sys_units)
else:
if custom_sys_units == 'm':
self.cboxSysUnits.setCurrentIndex(0)
if custom_sys_units == 'cm':
self.cboxSysUnits.setCurrentIndex(1)
if custom_sys_units == 'mm':
self.cboxSysUnits.setCurrentIndex(2)
print "PolygonTools: Units is ", custom_sys_units
self.lblInfo_01.setText("Units is " + custom_sys_units)
def setup():
assert __import__("pyblish_maya").is_setup(), (
"mindbender-core depends on pyblish_maya which has not "
"yet been setup. Run pyblish_maya.setup()")
from mindbender import api, maya
api.install(maya)
FPS = {
"12": "12fps",
"15": "game",
"16": "16fps",
"24": "film",
"25": "pal",
"30": "ntsc",
"48": "show",
"50": "palf",
"60": "ntscf"
}.get(os.getenv("MINDBENDER_FPS"), "pal") # Default to "pal"
# Load dependencies
cmds.loadPlugin("AbcExport.mll", quiet=True)
cmds.loadPlugin("AbcImport.mll", quiet=True)
EDIT_IN = getenv("MINDBENDER_EDIT_IN", int) or 101
EDIT_OUT = getenv("MINDBENDER_EDIT_OUT", int) or 201
RESOLUTION_WIDTH = getenv("MINDBENDER_RESOLUTION_WIDTH", int) or 1920
RESOLUTION_HEIGHT = getenv("MINDBENDER_RESOLUTION_HEIGHT", int) or 1080
cmds.setAttr("defaultResolution.width", RESOLUTION_WIDTH)
cmds.setAttr("defaultResolution.height", RESOLUTION_HEIGHT)
cmds.currentUnit(time=FPS)
cmds.playbackOptions(minTime=EDIT_IN)
cmds.playbackOptions(maxTime=EDIT_OUT)
cmds.playbackOptions(animationStartTime=EDIT_IN)
cmds.playbackOptions(animationEndTime=EDIT_OUT)
cmds.playbackOptions(minTime=EDIT_IN)
cmds.playbackOptions(maxTime=EDIT_OUT)
