def bakeSequenceScale(s):
print "baking shot camera: ", s
#create shot render cam
renderCam = mc.shot(s, cc=True, q=True)
copiedRenderCam = mc.duplicate(renderCam,
name=renderCam + "_baked_" + s,
un=True)[0]
print "copied render cam for ", s, " : ", copiedRenderCam
#shot sequence vars
seq_startTime = mc.shot(s, sst=True, q=True)
seq_endTime = mc.shot(s, set=True, q=True)
seq_duration = mc.shot(s, sequenceDuration=True, q=True)
#get shot info
#this assumes start time is never subframe
startTime = mc.shot(s, st=True, q=True)
#get actual end time, api endtime doesnt return subframe.
mc.sequenceManager(currentTime=seq_endTime)
endTime = mc.currentTime(q=True)
print renderCam, ":"
print "camera time:", startTime, "=>", endTime
#set current time to start time
mc.setKeyframe(copiedRenderCam, hi="both", t=startTime)
print "Created initial keys"
mc.setKeyframe(copiedRenderCam, hi="both", t=endTime)
print "Created ending keys"
#remove any keyframes that's not in this frame range
print "cleanup keyframes."
mc.cutKey(copiedRenderCam,
clear=True,
time=(":" + str(startTime - 0.01), ),
option="keys")
mc.cutKey(copiedRenderCam,
clear=True,
time=(str(endTime + 0.01) + ":", ),
option="keys")
#set end time to scale
scaleEndTime = startTime + seq_duration - 1
print "scaling to: ", startTime, " => ", scaleEndTime
mc.scaleKey(copiedRenderCam,
time=(startTime, endTime),
newStartTime=startTime,
newEndTime=scaleEndTime,
timePivot=0)
return copiedRenderCam
def connectLoc(self, arg):
locName = mc.ls(sl=True)
self.listSel = []
for loc in locName:
print loc
gpu_name = loc.split('_loc')
self.listSel.append(gpu_name[0])
#self.listSel = mc.ls(selection = True)
mc.select(clear=True)
for self.sel in self.listSel:
self.locName = self.sel + "_loc"
#mc.cutKey(self.sel, option='keys')
self.parentCon = mc.parentConstraint(self.locName,
self.sel,
maintainOffset=False) #True
self.scaleCon = mc.scaleConstraint(self.locName,
self.sel,
maintainOffset=False)
mc.parent(self.locName, 'ARLoc_Grp')
for shotSq in mc.sequenceManager(listShots=True):
self.currentShotStart = mc.shot(shotSq, q=True, st=True)
self.currentShotEnd = mc.shot(shotSq, q=True, et=True)
mc.cutKey(self.locName,
time=((self.currentShotStart + 1),
(self.currentShotEnd - 1)),
option='keys')
def connectLoc (self,arg):
locName = mc.ls(sl=True)
self.listSel = []
for loc in locName:
print loc
#gpu_name = loc.split('_loc')
gpuNameSpace = loc.rsplit('_',5)[0] #060117 edit because namespace AD_AR are change
nameSplit = loc.split(gpuNameSpace)[1].split('_',1)[1].split('_loc')[0]
gpu_name = '%s:%s'%(gpuNameSpace,nameSplit)
self.listSel.append(gpu_name)
#self.listSel = mc.ls(selection = True)
mc.select(clear=True)
for self.sel in self.listSel:
#self.locName = self.sel+"_loc"
self.locName = self.sel.replace(':','_')+"_loc" #060117 edit because namespace AD_AR are change
#mc.cutKey(self.sel, option='keys')
self.parentCon = mc.parentConstraint(self.locName,self.sel,maintainOffset = False) #True
self.scaleCon = mc.scaleConstraint(self.locName,self.sel,maintainOffset = False)
mc.parent(self.locName,'ARLoc_Grp')
for shotSq in mc.sequenceManager(listShots = True):
self.currentShotStart = mc.shot( shotSq,q=True,st=True)
self.currentShotEnd = mc.shot (shotSq,q=True,et=True )
mc.cutKey(self.locName,time=((self.currentShotStart+1), (self.currentShotEnd-1)), option='keys')
def autoTranfer (self,arg):
self.listSel = mc.ls(selection = True)
if not mc.objExists('ARLoc_Grp'):
mc.group( em=True, name='ARLoc_Grp')
self.bakeLoc = []
self.delPar = []
self.delScale = []
self.selList = []
for self.sel in self.listSel:
#self.locName = self.sel+"_loc"
self.locName = self.sel.replace(':','_')+"_loc" #060117 edit because namespace AD_AR are change
self.loc = mc.spaceLocator(p=(0,0,0),name = self.locName )
self.parentLoc = mc.parentConstraint(self.sel,self.loc,maintainOffset = False)
self.scaleLoc = mc.scaleConstraint(self.sel,self.loc,maintainOffset = False) #
self.bakeLoc.append(self.loc[0]) #because loc is list
self.delPar.append(self.parentLoc[0]) #because delPar is list
self.selList.append(self.sel)
#mc.bakeResults(self.loc,simulation=True,time = (self.timeSliderMin,self.timeSliderMax))
#mc.delete(self.parentLoc)
#mc.cutKey(self.sel, option='keys')
#self.parentCon = mc.parentConstraint(self.loc,self.sel,maintainOffset = True)
#self.scaleCon = mc.scaleConstraint(self.loc,self.sel,maintainOffset = True)
#mc.parent(self.loc,'ARLoc_Grp')
#mc.cutKey(self.loc,time=((self.timeSliderMin+1), (self.timeSliderMax-1)), option='keys')
print self.delPar
self.animNodes = mc.ls (type='animCurve')
self.firstKey = mc.findKeyframe(self.animNodes,which='first')
self.lastKey = mc.findKeyframe(self.animNodes,which='last')
if self.firstKey < 101:
self.firstKey = 101
# isolate viewport for faster baking
mayaTools.isolateObj(True)
# bake locator
mc.bakeResults(self.bakeLoc,simulation=True,time = (self.firstKey,self.lastKey))
# restore viewport back
mayaTools.isolateObj(False)
mc.delete(self.delPar)
mc.delete(self.delScale)
mc.cutKey(self.selList, option='keys')
#return
for self.sel in self.listSel:
#self.locName = self.sel+"_loc"
self.locName = self.sel.replace(':','_')+"_loc" #060117 edit because namespace AD_AR are change
#mc.cutKey(self.sel, option='keys')
self.parentCon = mc.parentConstraint(self.locName,self.sel,maintainOffset = False) #True
self.scaleCon = mc.scaleConstraint(self.locName,self.sel,maintainOffset = False)
mc.parent(self.locName,'ARLoc_Grp')
for shotSq in mc.sequenceManager(listShots = True):
self.currentShotStart = mc.shot( shotSq,q=True,st=True)
self.currentShotEnd = mc.shot (shotSq,q=True,et=True )
mc.cutKey(self.locName,time=((self.currentShotStart+1), (self.currentShotEnd-1)), option='keys')
def camDict():
list = []
seqShots = cmds.sequenceManager(listShots=True)
for each in seqShots:
startFrame = cmds.getAttr(each+".startFrame")
endFrame = cmds.getAttr(each+".endFrame")
dict = {'shot': each, 'camera' : cmds.shot(each, q=True, cc = True), 'startFrame': int(startFrame), 'endFrame': int(endFrame)};
list.append(dict)
return list
def get_camera():
sel = mc.ls(selection=True)
cam_shot = mc.sequenceManager(currentShot=True, query=True)
cam_list = []
cam_panel = []
if sel:
for c in sel:
if mc.listRelatives(c, type='camera'):
cam_list.append(c)
elif mc.listRelatives(c, type='nurbsCurve') and mc.listRelatives(
c, allDescendents=True, type='camera'):
cam_shape = mc.listRelatives(c,
allDescendents=True,
type='camera')[0]
parent_node = mc.listRelatives(cam_shape, parent=True)[0]
cam_list.append(parent_node)
if cam_list:
cam = cam_list[0]
elif not cam_list and cam_shot:
if not mc.listRelatives(mc.shot(
cam_shot, currentCamera=True, query=True),
shapes=True):
cam = mc.listRelatives(mc.shot(cam_shot,
currentCamera=True,
query=True),
parent=True)[0]
else:
cam = mc.shot(cam_shot, currentCamera=True, query=True)
else:
all_cam = mc.ls(type='camera')
cam = mc.listRelatives(all_cam[1], parent=True)[0]
for p in mc.getPanel(type="modelPanel"):
if mc.modelPanel(p, query=True, camera=True) == cam:
cam_panel = p
elif mc.modelPanel(p, query=True,
camera=True) == mc.listRelatives(cam,
shapes=True)[0]:
cam_panel = p
else:
continue
if not cam_panel:
mc.warning('No Panel with this camera. Put one and refresh')
camera = Camera(cam, mc.getAttr(cam + '.focalLength'),
mc.getAttr(cam + '.nearClipPlane'), cam_panel)
return camera
def run(pre_roll=0, ao=True):
movpaths = []
shot_selected = cmds.ls(sl=True, type='shot')
shot_list = shot_selected if shot_selected else cmds.sequenceManager(listShots=True)
for shot_node in shot_list:
start = cmds.getAttr(shot_node + '.sequenceStartFrame') - pre_roll
end = cmds.getAttr(shot_node + '.sequenceEndFrame') + (1 if pre_roll else 0)
camera = cmds.shot(shot_node, q=True, currentCamera=True)
print shot_node, start, end, camera, ao
cmds.currentTime(start, e=True)
movie_path,version_file = playblastControl.setPlayblast(shot_node, start, end, camera, AOswitch=ao)
if os.path.exists(movie_path):
movpaths.append([movie_path,version_file])
return movpaths
def getSequencerData(self): #List to be populated and then returned sequencerData = [] #Store shot names as a list sequencerVar = ma.sequenceManager(lsh = True) #In case of there being no data to pull, return empty list try: #For each shot on the list, retrieve its information for sVT in sequencerVar: #tempList for storing data sVTListTemp = [] #append cameraName, frameStart and frameEnd sVTListTemp.append(str(ma.shot(sVT, q = True, cc = True))) sVTListTemp.append(int(ma.shot(sVT, q = True, st = True))) sVTListTemp.append(int(ma.shot(sVT, q = True, et = True))) #append information to shotPulledList sequencerData.append(sVTListTemp) #once all shot info has been stored within shotPulledList return return sequencerData except TypeError: return sequencerData
def camSeqRender(sh):
allshots = mc.sequenceManager(lsh=True)
print allshots
for rs in allshots:
if rs == sh:
s=rs
print s
renderCam = mc.shot(s, cc=True, q=True)
startTime = mc.shot(s, st=True, q=True)
endTime = mc.shot(s, et=True, q=True)
#get it for nuke
seq_startTime = mc.shot(s, sst=True, q=True)
seq_endTime = mc.shot(s, set=True, q=True)
offsetTime = int(seq_startTime-startTime)
print s, startTime, endTime,"(",seq_startTime, seq_endTime, ")", renderCam
print "start rendering: ", renderCam
camTransform = mc.listRelatives(renderCam, p=True)[0]
#mel.eval("lookThroughModelPanel %s modelPanel4;"%(renderCam))
mel.eval('currentTime %s ;'%(startTime))
while(startTime <= endTime):
mel.eval('renderWindowRender redoPreviousRender renderView;')
startTime += 1
mel.eval('currentTime %s ;'%(startTime))
callString = "mv /X/projects/luna/SHOTS/"+os.getenv("SHOT")+"/chichang/images/elements/tmp/ /X/projects/luna/SHOTS/"+os.getenv("SHOT")+"/chichang/images/elements/"+camTransform+"_"+str(offsetTime)+"/"
mycmd=subprocess.Popen(callString, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
output, error=mycmd.communicate()
def sequenceManager(*args, **kwargs):
res = cmds.sequenceManager(*args, **kwargs)
if not kwargs.get('query', kwargs.get('q', False)):
res = _factories.maybeConvert(res, _general.PyNode)
return res
def _readClip(self, clip, isVideo, start, end, in_adjustment):
# TODO: ensure that we don't already have a shot with
# the same shot name in the scene
# TODO: ensure that the rate associated with the clip
# is the same as the rate of the whole sequence. Can
# Maya support playback of different shots at different
# rates? (I'm guessing no)
# TODO: figure out how the naming should work. Should the
# shot/audio node's name also match the "name" specified in
# the EDL?
if start == -1:
self.logger.warning(
"Importer._readClip, start parameter == -1, clip not loaded")
return
if end == -1:
self.logger.warning(
"Importer._readClip, end parameter == -1, clip not loaded")
return
clip_info = self.translator.getClip(clip)
# Ensure that clip frame rate matches sequence frame rate
self._checkFrameRates(clip, clip_info)
clipIn = float(clip_info.get("in", 0))
clipIn += in_adjustment
clipNode = None
clip_name = clip_info.get("name", "")
# Note: The XML file could be utf-8, but Maya's nodes and attrs cannot be unicode.
# So only use the name if it's valid
try:
clip_name = clip_name.encode("ascii")
except:
self.translator.logger.warning(
"Clip name contains multi-byte characters, using default name")
clip_name = ""
clipObjectName = _getValidClipObjectName(clip_name, isVideo)
if isVideo:
clipNode = cmds.shot(clipObjectName)
adjustedEnd = float(end)
adjustedEnd -= 1 #Final frame in editorial is always exclusive bug 342715
cmds.shot(
clipNode,
e=1,
shotName=clip_name,
sequenceStartTime=start,
sequenceEndTime=adjustedEnd,
clipZeroOffset=clipIn,
startTime=start, # Make Maya start/end the same as
endTime=
adjustedEnd, # sequence start/end. Maya sequenceStart/end is not transoorted through EDL
mute=(clip_info.get("enabled", True) == False))
# create a custom camera
# TODO: write out camera info as meta-data, perhaps??
cameraNodes = cmds.camera(name=(clipNode + "Camera"))
cmds.shot(clipNode, e=1, currentCamera=cameraNodes[0])
else:
clipNode = cmds.createNode("audio", name=clipObjectName)
cmds.sequenceManager(attachSequencerAudio=clipNode)
cmds.sound(clipNode,
e=1,
offset=start,
sourceStart=clipIn,
sourceEnd=float(clip_info.get("out", 1)),
endTime=end,
mute=(clip_info.get("enabled", True) == False))
# Store the minimum frame of the sequence
if self.minFrameInFile is None or start < self.minFrameInFile:
self.minFrameInFile = start
file_elem = clip_info.get("file", None)
if file_elem is not None:
file_info = self.translator.getFile(file_elem)
# Ensure that file frame rate matches sequence frame rate
self._checkFrameRates(file_elem, file_info)
# TODO: convert from pathurl to an abs path that maya knows how to read
# Or, just use the file-name and assume it's in the Maya project?
if "pathurl" in file_info:
if isVideo:
# query the frameCount. If this raises an error, it could be because
# the movie format is not supported on this platform
try:
frameCount = cmds.movieInfo(file_info["pathurl"],
frameCount=1)[0]
except:
self.translator.logger.warning(
"Could not open video file %s. File could be corrupt, or movie format is not supported on this platform"
% file_info["pathurl"])
frameCount = 0
video_height = file_info.get("height", None)
if video_height is not None:
cmds.setAttr((clipNode + ".hResolution"),
int(video_height))
video_width = file_info.get("width", None)
if video_width is not None:
cmds.setAttr((clipNode + ".wResolution"),
int(video_width))
cmds.shot(clipNode, e=1, clip=file_info["pathurl"])
cmds.setAttr((clipNode + ".clipDuration"), frameCount)
cmds.setAttr((clipNode + ".clipValid"), 1)
cmds.setAttr((clipNode + ".clipScale"),
1) #FCP Speed Effect not supported yet
else:
try:
cmds.sound(clipNode, e=1, file=file_info["pathurl"])
except:
self.translator.logger.warning(
"Could not open audio file %s. File not found, or audio format not supported"
% file_info["pathurl"])
self.clip_dict[clip] = clipNode
return clipNode
def camSeqRenderAll(deleteBakedCam=True):
'''
render all shots in sequence manager.
'''
#path variables
userShotDir = os.getenv("USER_SHOT_DIR")
fileRuleImages = mc.workspace("images", fre=True, q=True)[3:]
renderGlobalPath = os.path.join(userShotDir, fileRuleImages)
renderTempPath = os.path.join(renderGlobalPath, "tmp")
#setup output path
currentFile = mc.file(q=True, sn=True).split("/")[-1]
fileName = os.path.splitext(currentFile)[0]
outputDir = os.path.join(renderGlobalPath, fileName)
#if shot render already exists. stop the render
if os.path.exists(outputDir):
mc.warning("output directory already exist. render canceled.")
return
else:
pass
#query render settings
#todo
#check if active panel is
allMdPanel = mc.getPanel(type="modelPanel")
activePanel = mc.getPanel(wf=True)
if activePanel not in allMdPanel:
mc.warning("please select the view you want to render.")
return
#create shot output dir
try:
#create dir
callString = "mkdir " + outputDir
mycmd = subprocess.Popen(callString,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
shell=True)
output, error = mycmd.communicate()
except:
print error
#delete current tmp if found
#for my local hacking rendering only ...
if os.path.exists(renderTempPath):
try:
print "deleting current tmp dir: ", renderTempPath
callString = "rm -rf " + renderTempPath
mycmd = subprocess.Popen(callString,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
shell=True)
output, error = mycmd.communicate()
except:
print error
else:
print "no temp dir found."
#get all shots in sequence
allshots = mc.sequenceManager(lsh=True)
renderedShots = []
#playblast each shot
for s in allshots:
deleteCam = False
#shot render cam vars
renderCam = mc.shot(s, cc=True, q=True)
startTime = math.floor(mc.shot(s, st=True, q=True))
endTime = math.floor(mc.shot(s, et=True, q=True))
#shot sequence vars
seq_startTime = math.floor(mc.shot(s, sst=True, q=True))
seq_endTime = math.floor(mc.shot(s, set=True, q=True))
seq_duration = mc.shot(s, sequenceDuration=True, q=True)
seq_scale = mc.shot(s, scale=True, q=True)
offsetTime = int(seq_startTime - startTime)
#setup render time
renderStartFrame = startTime
renderEndFrame = startTime + seq_duration - 1
print s, startTime, endTime, "(", seq_startTime, seq_endTime, ")", renderCam, seq_duration
if seq_scale != 1.0:
print "sequnce scale is not uniform. baking camera animation for endering."
renderCam = bakeSequenceScale(s)
deleteCam = True
print "start rendering: ", renderCam
#set current panel to the current shot cam
mel.eval("lookThroughModelPanel %s %s;" % (renderCam, activePanel))
#initialize render! note this will render out an image!
mel.eval('currentTime %s ;' % (renderStartFrame))
mel.eval('RenderIntoNewWindow;')
#close render view
mel.eval('removeRenderWindowPanel renderView;')
#do the render
mel.eval('currentTime %s ;' % (renderStartFrame))
while (renderStartFrame <= renderEndFrame):
mel.eval('renderWindowRender redoPreviousRender renderView;')
renderStartFrame += 1
mel.eval('currentTime %s ;' % (renderStartFrame))
#remove render camera
if deleteBakedCam and deleteCam:
print "deleting camera: ", renderCam
mc.delete(renderCam)
#File Operations
#rename and move shot renders
shotDirName = s + "_" + str(offsetTime)
shotDir = os.path.join(renderGlobalPath, shotDirName)
#TODO: handle this better
#if there is a same found. this will move the tmp into it instead of rename tmp.
#for now just remove the old one assume it's from a preveus failed render
if os.path.exists(shotDir):
print "found " + shotDir + "removing it..."
callString = "rm -rf " + shotDir
mycmd = subprocess.Popen(callString,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
shell=True)
output, error = mycmd.communicate()
else:
pass
#rename the tmp dir to the shot name
callString = "mv " + renderTempPath + " " + shotDir
mycmd = subprocess.Popen(callString,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
shell=True)
output, error = mycmd.communicate()
#move into output dir
callString = "mv " + shotDir + " " + outputDir
mycmd = subprocess.Popen(callString,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
shell=True)
output, error = mycmd.communicate()
#write nuke comp
makeSeqComp(elementsDir=outputDir)
#display result
mc.confirmDialog(title='render finished: ',
message=outputDir,
button=['OK'],
defaultButton='OK')
#done.
mc.warning(
"all shots submited for render, Check script editer for more detail.")
import maya.cmds as cmds
#get list of shots from camera sequencer
shotList = cmds.sequenceManager(lsh=True)
print(shotList)
previousCameras = []
aimConstraintNum = 1
leftConstrainList = []
rightConstrainList = []
for x in shotList:
#get camera for the current shot
currentShot = str(x)
currentCamera = cmds.shot(currentShot, q=True, currentCamera=True)
if currentCamera.endswith('Shape'):
currentCamera = currentCamera[:-5]
#if not already used, set up locator and parent constraint system for the camera
if currentCamera not in previousCameras:
#Now is a previous camera so this doesn't get done twice
previousCameras.append(currentCamera)
#Put a locator in the same position as the camera and directly parent it in
cameraPosition = cmds.camera(currentCamera, q=True, position=True)
locator = cmds.spaceLocator(name=currentCamera + "_locator",
position=cameraPosition)
cmds.parent(locator, currentCamera)
#Create aim constraints between the new locator and the eye controls
cmds.aimConstraint(locator, "seq005_LUExport:LU:LEye_ctrlgrp")
cmds.aimConstraint(locator, "seq005_LUExport:LU:REye_ctrlgrp")
def set_first_frame(shotName):
st = mc.getAttr('%s.startFrame' %(shotName))
mc.currentTime(st)
mc.sequenceManager(currentTime=st)
def get_current_shot():
return mc.sequenceManager(q=True,currentShot=True)
