def render(rl, width, height, *args):
dar = width / float(height)
cmds.setAttr('defaultResolution.deviceAspectRatio', dar)
mel.eval('RenderViewWindow')
cmds.Mayatomr( preview=True, layer=rl, xResolution=width, yResolution=height, camera='perspShape' )
editor = 'renderView'
cmds.renderWindowEditor(editor, e=True, si=True)
def screenShot(i):
mel.eval('renderWindowRender redoPreviousRender renderView')
editor = 'renderView'
cmds.renderWindowEditor(editor,
e=True,
refresh=True,
writeImage=('D:\\test\\lol\\Telescope\\Telescope' +
str(i)))
def screenShot(objName, l):
#imageSnapshot = wsp + "/" + str(objName) + str(l) +".jpg"
mel.eval('renderWindowRender redoPreviousRender renderView')
editor = 'renderView'
cmds.renderWindowEditor(editor,
e=True,
refresh=True,
writeImage=('D:\\test\\tr' + objName + str(l)))
def saveCurrentImageInRenderView(self, filename):
path = cmds.file(query=True,sceneName=True)
sceneName = os.path.split(path)[1].rsplit('.')[0]
projectSpace = cmds.workspace(q=True, rd=True)
imagesFolder = projectSpace + 'images/tmp/'
editor = 'renderView'
print 'Saving file', imagesFolder+sceneName+'_'+filename
cmds.renderWindowEditor(editor, e=True, writeImage=imagesFolder+sceneName+'_'+filename)
def screenShot(
i
): # a function used to take save rendered images with takes in a string input
mel.eval('renderWindowRender redoPreviousRender renderView')
editor = 'renderView'
cmds.renderWindowEditor(editor,
e=True,
refresh=True,
writeImage=(pathname + '\\ObjName\\ObjName' +
str(i)))
def renderMaya(self, ts, te, outFile=""):
print "\n\n\n"
print " REND : ", ts, te, outFile, "_____!"
print "\n\n\n"
if len(outFile) == 0:
print " renderMaya no OUT FILE ", outFile
else:
basename = os.path.basename(outFile)
outDir = outFile[:-1 * len(basename)]
outFileHeader = basename.split(".")[0]
outFileExt = basename.split(".")[1]
print " SimC Rend ! ", outDir, outFileHeader, outFileExt
frStart = self.intOrVal(ts, 0)
frEnd = self.intOrVal(te, 0)
# ma = hou.node('out/mantra_ipr')
# for fr in range (frStart, frEnd+1):
# frZeros = self.strWithZeros( fr , 4 )
# outputFile = "{}{}.{}.{}".format( outDir , outFileHeader, frZeros, outFileExt)
# ma.render( frame_range = (fr,fr) , output_file= outputFile )
# import time
# time.sleep(2)
import maya.cmds as cmx
for fr in range(1, 70):
cmx.currentTime(fr)
cmx.refresh()
fi = outFile[:-6] + "__" + self.strWithZeros(
fr, 3) + ".jpg" #### hack rend
print fi
fi = fi.replace('\\', '/')
print fi
##### maya 16
# editores = cmx.renderWindowEditor(q=True) #, editorName=True )
# if( len(editores) == 0 ):
# editores = cmx.renderWindowEditor( "renderView" )
##### maya 16
editores = cmx.renderWindowEditor("renderView",
q=True) #, editorName=True )
if (editores == None):
editores = cmx.renderWindowEditor("renderView", e=True)
cmx.render('persp', x=800, y=450)
cmx.setAttr('defaultRenderGlobals.imageFormat', 8)
cmx.renderWindowEditor(
editores, e=True, writeImage=fi) # currentCamera='persp',
def saveCurrentImageInRenderView(self, filename):
path = cmds.file(query=True, sceneName=True)
sceneName = os.path.split(path)[1].rsplit('.')[0]
projectSpace = cmds.workspace(q=True, rd=True)
imagesFolder = projectSpace + 'images/tmp/'
editor = 'renderView'
print 'Saving file', imagesFolder + sceneName + '_' + filename
cmds.renderWindowEditor(editor,
e=True,
writeImage=imagesFolder + sceneName + '_' +
filename)
def hyperRender():
gamma = mc.floatSliderGrp("gamma", q=True, v=True)
width = mc.intFieldGrp("Resolution", q=True, value1=True)
height = mc.intFieldGrp("Resolution", q=True, value2=True)
fr = mc.textFieldButtonGrp("setFile", q=True, text=True) + "/"
mc.eval
mc.select(lights)
mc.select(meshes, add=True)
mc.showHidden(a=True)
for m in meshes:
hideChildren(m)
for l in lights:
mc.hide(l)
for mesh in meshes:
# hideChildren(mesh)
for light in lights:
mc.select(cl=True)
mc.select(mesh)
mc.select(light, add=True)
showChildren(mesh)
mc.showHidden(light)
name = mesh + light + "output"
mc.setAttr("defaultArnoldDriver.ai_translator",
"png",
type="string")
mc.setAttr("defaultArnoldDriver.pre", name, type="string")
arnoldRender(width, height, True, True, 'RenderCam_',
' -layer defaultRenderLayer')
#render stuff here
editor = 'renderView'
#render_output = mc.renderer(editor, e=True)
# mc.eval('renderWindowRender redoPreviousRender renderView')
# editor = 'renderView'
formatManager = createImageFormats.ImageFormats()
formatManager.pushRenderGlobalsForDesc("PNG")
mc.renderWindowEditor(editor,
e=True,
ga=gamma,
com=True,
cme=True,
writeImage=fr + name + '.png')
exec("print 'file saved to' + fr+name+'.png'")
formatManager.popRenderGlobals()
mc.hide(light)
hideChildren(mesh)
def unpackImg():
'''Write string to image and open in renderview'''
imgPath = os.environ['tmpdir'] + '/mRSnapShot_Grab.jpg'
global mTeleport_buffer
fh = open(imgPath, 'w')
fh.write(mTeleport_buffer)
fh.close()
mel.eval('RenderViewWindow')
rview = cmds.getPanel(sty= 'renderWindowPanel')
cmds.renderWindowEditor(rview, e= True, li= imgPath)
print 'Snapshot send.'
return 0
def Render(k, *args):
formatManager = createImageFormats.ImageFormats()
formatManager.pushRenderGlobalsForDesc("JPEG")
mc.render()
global renderpath
mc.renderWindowEditor(makeCamera.editor,
crc=str(makeCamera.cam[0]),
e=True,
writeImage=str(renderpath[0] + '/testImage' +
str(k) + '.jpg'))
formatManager.popRenderGlobals()
def rpr_render(scene):
cmds.optionVar(rm="RPR_DevicesSelected")
cmds.optionVar(iva=("RPR_DevicesSelected", 1))
cmds.fireRender(waitForItTwo=True)
TIMER = datetime.datetime.now()
mel.eval("renderIntoNewWindow render")
output = os.path.join("{work_dir}", "Color", scene)
cmds.renderWindowEditor("renderView", edit=True, dst="color")
cmds.renderWindowEditor("renderView", edit=True, com=True, writeImage=output)
Render_time = datetime.datetime.now() - TIMER
return Render_time
def mkThumbNail():
# get file name and path for thumbnail
files = maya.cmds.file(query=1, list=1, withoutCopyNumber=1)
changeformat = 'setAttr "defaultRenderGlobals.imageFormat" 8;'
thumbFileName = files[0].replace( '.mb', '.jpg' )
mel.eval(changeformat)
currentCam = mkRenderCam()
if currentCam == " ":
cmds.warning ("no renderable camera")
# render and save image
cmds.render(currentCam[0], x= 720, y =405)
editor = 'renderView'
cmds.renderWindowEditor(editor, e = True, writeImage = thumbFileName)
return thumbFileName
def mkThumbNail():
# get file name and path for thumbnail
files = maya.cmds.file(query=1, list=1, withoutCopyNumber=1)
changeformat = 'setAttr "defaultRenderGlobals.imageFormat" 8;'
thumbFileName = files[0].replace('.mb', '.jpg')
mel.eval(changeformat)
currentCam = mkRenderCam()
if currentCam == " ":
cmds.warning("no renderable camera")
# render and save image
cmds.render(currentCam[0], x=720, y=405)
editor = 'renderView'
cmds.renderWindowEditor(editor, e=True, writeImage=thumbFileName)
return thumbFileName
def render(rl, width, height, *args):
"""
renders the scene with the given attributes
keyword args:
width -- width of render image in pixels
height -- height of render image in pixels
*args -- additional args
"""
dar = width / float(height)
cmds.setAttr('defaultResolution.deviceAspectRatio', dar)
mel.eval('RenderViewWindow')
cmds.Mayatomr(preview=True, layer=rl, xResolution=width, yResolution=height, camera='perspShape')
editor = 'renderView'
cmds.renderWindowEditor(editor, e=True, si=True)
def rpr_render(case):
logging('Render image')
mel.eval('fireRender -waitForItTwo')
start_time = time.time()
mel.eval('renderIntoNewWindow render')
cmds.sysFile(path.join(WORK_DIR, 'Color'), makeDir=True)
test_case_path = path.join(WORK_DIR, 'Color', case['case'])
cmds.renderWindowEditor('renderView', edit=1, dst='color')
cmds.renderWindowEditor('renderView',
edit=1,
com=1,
writeImage=test_case_path)
test_time = time.time() - start_time
reportToJSON(case, test_time)
def savePicInRenderView(frameIndex, x):
# save the image to a exist folder
editor = 'renderView'
formatManager = createImageFormats.ImageFormats()
formatManager.pushRenderGlobalsForDesc("PNG")
# The name of the Image is CharacterImage'+str(x)+.jpg ,example CharacterImage1.jpg\
cmds.renderWindowEditor(
editor,
e=True,
writeImage='E:/mayaStore/images/imageSequence/CharacterImage_' +
str(frameIndex).zfill(2) + '_' + str(x).zfill(2) + '.png')
formatManager.popRenderGlobals()
#Test Function
#renderSequence(0,24,renderfn_args = getCameraCharacter())
def mkThumbNail(fileName,zipfile):
# get file name and path for thumbnail
changeformat ='setAttr "defaultRenderGlobals.imageFormat" 8;'
files = fileName
thumbFileName = files[0].replace( '.mb', '.jpg' )
mel.eval(changeformat)
currentCam =mkRenderCam()
if currentCam == " ":
cmds.warning ("no renderable camera")
# render and save image
cmds.render(currentCam[0], x= 720, y =405)
editor = 'renderView'
cmds.renderWindowEditor(editor, e = True, writeImage = thumbFileName)
newFolder = mkIngestionDir(thumbFileName,'.jpg')
mkIngestionDir(zipfile,'.zip')
DepotIngestion()
removeFolder(newFolder)
def resetImageDataWindow(self, imageName, oiiotoolPath):
editor = cmds.renderWindowEditor(q=True, editorName=True)
if editor:
renderRegion = cmds.renderWindowEditor(editor, q=True, mq=True)
if renderRegion:
left = cmds.getAttr("defaultRenderGlobals.left")
right = cmds.getAttr("defaultRenderGlobals.rght")
top = cmds.getAttr("defaultRenderGlobals.top")
bottom = cmds.getAttr("defaultRenderGlobals.bot")
imageWidth = cmds.getAttr("defaultResolution.width")
imageHeight = cmds.getAttr("defaultResolution.height")
pathTokens = os.path.splitext(imageName)
imageNameCropped = "%s_crop%s" % (pathTokens[0], pathTokens[1])
oiiotoolResult = None
try:
#print( "Generating cropped image : %s" % imageNameCropped )
#oiiotool picks up on the PBRT EXR's pixel data origin, so
#we don't have to do anything fancy here
cropArgs = '%dx%d-%d-%d' % (imageWidth, imageHeight, 0, 0)
args = [
'-v', imageName, '--crop', cropArgs, '--noautocrop',
'-o', imageNameCropped
]
oiiotool = Process(description='reset image data window',
cmd=oiiotoolPath,
args=args)
oiiotool.execute()
oiiotoolResult = oiiotool.status
#print( "oiiotool result : %s" % oiiotoolResult )
except:
print("Unable to run oiiotool")
oiiotoolResult = None
# Move the image with the new data window over the original rendered image
if oiiotoolResult in [0, None]:
# Useful for debugging
#imageNameOriginal = "%s_uncropped%s" % (pathTokens[0], pathTokens[1])
#os.rename(imageName, imageNameOriginal)
os.rename(imageNameCropped, imageName)
def renderOnlyThisLight(self, lights):
if type(lights) != list:
lights = [lights]
lightNames = ''
for light in lights:
lightNames += '_' + cmds.listRelatives(light, p=1)[0]
wasHidden = False
if self.isLightHidden(light):
cmds.showHidden(light)
wasHidden = True
#-Revise!--if it is an ibl light then turn off emit Final Gather
if cmds.objectType(light, isType='mentalrayIblShape') == True:
if cmds.getAttr('%s.visibleInFinalGather' % light) == False:
cmds.setAttr('%s.visibleInFinalGather' % light, 1)
wasHidden = True
mel.eval("renderIntoNewWindow render")
#See if we are rendering with vray frame buffer and save it to the maya render buffer
if cmds.getAttr('defaultRenderGlobals.currentRenderer') == 'vray':
if self.isRenderEngineInstalled('vray'):
if cmds.getAttr("vraySettings.vfbOn"):
mel.eval("vrend -cloneVFB")
rv = cmds.getPanel(scriptType='renderWindowPanel')
caption = cmds.renderWindowEditor(rv, query=True, pca=True)
newCaption = caption + ' contriburion of ' + lightNames.replace(
'_', ' ')
cmds.renderWindowEditor(rv, edit=True, pca=newCaption)
# save the frame in mel
mel.eval("renderWindowMenuCommand keepImageInRenderView renderView;")
if self.saveImages:
self.saveCurrentImageInRenderView('contributionOf' + lightNames)
for light in lights:
if wasHidden:
cmds.hide(light)
#-Revise!-- if it was the ibl node disable final gather again
if cmds.objectType(light, isType='mentalrayIblShape') == True:
cmds.setAttr('%s.visibleInFinalGather' % light, 0)
def renderOnlyThisLight(self, lights):
if type(lights)!=list:
lights = [lights]
lightNames =''
for light in lights:
lightNames += '_'+cmds.listRelatives(light, p=1)[0]
wasHidden = False
if self.isLightHidden(light) :
cmds.showHidden(light)
wasHidden = True
#-Revise!--if it is an ibl light then turn off emit Final Gather
if cmds.objectType( light, isType='mentalrayIblShape' ) == True:
if cmds.getAttr('%s.visibleInFinalGather' % light) == False:
cmds.setAttr('%s.visibleInFinalGather' % light, 1)
wasHidden = True
mel.eval("renderIntoNewWindow render")
#See if we are rendering with vray frame buffer and save it to the maya render buffer
if cmds.getAttr('defaultRenderGlobals.currentRenderer') == 'vray':
if self.isRenderEngineInstalled('vray'):
if cmds.getAttr ("vraySettings.vfbOn"):
mel.eval("vrend -cloneVFB")
rv = cmds.getPanel(scriptType='renderWindowPanel')
caption = cmds.renderWindowEditor(rv, query=True, pca=True)
newCaption = caption+' contriburion of '+lightNames.replace('_',' ')
cmds.renderWindowEditor(rv, edit=True, pca= newCaption)
# save the frame in mel
mel.eval("renderWindowMenuCommand keepImageInRenderView renderView;")
if self.saveImages:
self.saveCurrentImageInRenderView('contributionOf'+lightNames)
for light in lights:
if wasHidden:
cmds.hide(light)
#-Revise!-- if it was the ibl node disable final gather again
if cmds.objectType( light, isType='mentalrayIblShape' ) == True:
cmds.setAttr('%s.visibleInFinalGather' % light, 0)
def rpr_render(scene):
cmds.optionVar(rm="RPR_DevicesSelected")
cmds.optionVar(iva=("RPR_DevicesSelected", 1))
cameras = cmds.ls(cameras=True)
if ("cameraShape1" in cameras):
mel.eval("lookThru camera1")
else:
print("[ERROR]: no camera1\n")
cmds.fireRender(waitForItTwo=True)
mel.eval("renderIntoNewWindow render")
output = os.path.join("{work_dir}", "Color", "converted_" + scene)
cmds.renderWindowEditor("renderView", edit=True, dst="color")
cmds.renderWindowEditor("renderView",
edit=True,
com=True,
writeImage=output)
def mkThumbNail(fileName,zipfile):
# get file name and path for thumbnail
# vrayOn = 'source "Q:/Tools/maya/2012/scripts/mel/Misc/awLoadVray.mel"; awLoadVray;'
# mel.eval(vrayOn)
vrayEnable = 'source "Q:/Tools/maya/2012/scripts/mel/Misc/awLoadVray.mel"; awVrayOn;'
mel.eval(vrayEnable)
files = fileName
thumbFileName = files[0].replace( '.mb', '.jpg' )
print thumbFileName
currentCam = mkRenderCam()
if currentCam == " ":
cmds.warning ("no renderable camera")
# render and save image
VRAYRENDER ='RenderIntoNewWindow;'
mel.eval(VRAYRENDER)
editor = 'renderView'
cmds.renderWindowEditor(editor, e = True, writeImage = thumbFileName)
cmd = DJV_LS + ' -columns 500 "' + thumbFileName + '"'
proc = subprocess.Popen( cmd, shell=True, stdout=subprocess.PIPE, )
def render(rl, width, height, *args):
"""
renders the scene with the given attributes
keyword args:
width -- width of render image in pixels
height -- height of render image in pixels
*args -- additional args
"""
dar = width / float(height)
cmds.setAttr('defaultResolution.deviceAspectRatio', dar)
mel.eval('RenderViewWindow')
cmds.Mayatomr(preview=True,
layer=rl,
xResolution=width,
yResolution=height,
camera='perspShape')
editor = 'renderView'
cmds.renderWindowEditor(editor, e=True, si=True)
def load_aov(self):
""" Load the selected AOV into the Render View framebuffer.
"""
# Get the name of the selected AOV by querying the combo box
aov = mc.optionMenu("aov_comboBox", query=True, value=True)
frame_str = str(int(self.frame)).zfill(
mc.getAttr("defaultRenderGlobals.extensionPadding"))
img_path = mc.renderSettings(fullPathTemp=True,
leaveUnmatchedTokens=True,
genericFrameImageName=frame_str)
if self.renderer == "arnold":
img = img_path[0].replace("<RenderPass>", aov)
elif self.renderer == "redshift": # TODO: update this to respect Redshift's AOV name prefix attribute
if aov == self.default_beauty_aov_name:
#img = img_path[0].replace( "<RenderPass>", "Beauty" )
img = img_path[0]
else:
#img = img_path[0].replace( "<RenderPass>", "Beauty.%s" %aov )
layer = mc.editRenderLayerGlobals(query=True,
currentRenderLayer=True)
if layer == "defaultRenderLayer":
layer = "masterLayer"
img = img_path[0].replace("%s." % layer,
"%s.%s." % (layer, aov))
elif self.renderer == "mentalRay":
if aov == self.default_beauty_aov_name:
img = img_path[0].replace("<RenderPass>", "MasterBeauty")
else:
img = img_path[0].replace("<RenderPass>", aov)
#img = os.path.normpath(os.path.expandvars(img)).replace("\\", "/")
#img = os_wrapper.absolutePath(img)
print(img)
# Load the image
rview = mc.getPanel(scriptType="renderWindowPanel")
mc.renderWindowEditor(rview, edit=True, loadImage=img)
def resetImageDataWindow(self, imageName, oiiotoolPath):
editor = cmds.renderWindowEditor(q=True, editorName=True)
#print( "resetImageDataWindow - editor : %s" % editor )
if editor:
renderRegion = cmds.renderWindowEditor(editor, q=True, mq=True)
#print( "resetImageDataWindow - render region : %s" % renderRegion )
if renderRegion:
left = cmds.getAttr("defaultRenderGlobals.left")
right = cmds.getAttr("defaultRenderGlobals.rght")
top = cmds.getAttr("defaultRenderGlobals.top")
bottom = cmds.getAttr("defaultRenderGlobals.bot")
imageWidth = cmds.getAttr("defaultResolution.width")
imageHeight = cmds.getAttr("defaultResolution.height")
pathTokens = os.path.splitext(imageName)
imageNameCropped = "%s_crop%s" % (pathTokens[0], pathTokens[1])
#print( "Generating cropped image : %s" % imageNameCropped )
oiiotoolResult = None
try:
#cmd = '/usr/local/bin/oiiotool'
cropArgs = '%dx%d-%d-%d' % (imageWidth, imageHeight, left,
imageHeight - top)
args = [
'-v', imageName, '--crop', cropArgs, '--noautocrop',
'-o', imageNameCropped
]
oiiotool = Process(description='reset image data window',
cmd=oiiotoolPath,
args=args)
oiiotool.execute()
oiiotoolResult = oiiotool.status
#print( "oiiotool result : %s" % oiiotoolResult )
except:
print("Unable to run oiiotool")
oiiotoolResult = None
# Move the image with the new data window over the original rendered image
if oiiotoolResult in [0, None]:
os.rename(imageNameCropped, imageName)
def saveVrayRender(dstDir, dstFile, img='jpg'):
dst = '%s/%s' % (dstDir, dstFile)
if not os.path.exists(dstDir):
os.makedirs(dstDir)
# send back to maya viewport
mm.eval('vrend -cloneVFB;')
# set to jpeg
mc.setAttr('defaultRenderGlobals.imageFormat', 8)
# save from render view to disk
try:
mc.renderWindowEditor('renderWindowPanel', edit=True, writeImage=dst)
except:
mc.renderWindowEditor('renderView', edit=True, writeImage=dst)
return dst
def printNewMenuItem(item):
aov = item
rview = cmds.getPanel(sty='renderWindowPanel')
fileExtention = fileFormat(aov) #get file type
latest_file = (basePathFolder + "/" + AOVPath(aov) + fileNumber + "." +
fileExtention)
splitPath = latest_file.replace('/', '\\')
splitPath = splitPath.split(os.sep)
for n, i in enumerate(splitPath):
if i in aovs or i == 'beauty':
splitPath[n] = selectedAOV
splitPath[0] = splitPath[0] + '\\'
pathToImg = reduce(os.path.join, splitPath)
print pathToImg
cmds.renderWindowEditor(rview, e=True, li=pathToImg)
def mkThumbNail(fileName, zipfile):
# get file name and path for thumbnail
# vrayOn = 'source "Q:/Tools/maya/2012/scripts/mel/Misc/awLoadVray.mel"; awLoadVray;'
# mel.eval(vrayOn)
vrayEnable = 'source "Q:/Tools/maya/2012/scripts/mel/Misc/awLoadVray.mel"; awVrayOn;'
mel.eval(vrayEnable)
files = fileName
thumbFileName = files[0].replace('.mb', '.jpg')
print thumbFileName
currentCam = mkRenderCam()
if currentCam == " ":
cmds.warning("no renderable camera")
# render and save image
VRAYRENDER = 'RenderIntoNewWindow;'
mel.eval(VRAYRENDER)
editor = 'renderView'
cmds.renderWindowEditor(editor, e=True, writeImage=thumbFileName)
cmd = DJV_LS + ' -columns 500 "' + thumbFileName + '"'
proc = subprocess.Popen(
cmd,
shell=True,
stdout=subprocess.PIPE,
)
def renderWindowEditor(*args, **kwargs):
if len(args):
doPassSelf = kwargs.pop('passSelf', False)
else:
doPassSelf = False
for key in ['cc', 'changeCommand']:
try:
cb = kwargs[key]
if callable(cb):
kwargs[key] = _factories.makeUICallback(cb, args, doPassSelf)
except KeyError:
pass
res = cmds.renderWindowEditor(*args, **kwargs)
return res
def saveRV():
temp = getReviewFileName()
path = temp[0]
filename = (temp[1] + ".jpg")
network_base_path = "//Art-1405260002/d/assets/simpleslot/"
src_filename = path + filename
if os.path.isdir(network_base_path + temp[2][0] + "/review/") is False:
os.mkdir(network_base_path + temp[2][0] + "/review/")
dst_filename = network_base_path + temp[2][0] + "/review/" + filename
if cmds.intScrollBar("scrollBar", q=1, v=1) == -1:
cmds.renderWindowEditor("renderView", e=1, si=1)
cmds.intScrollBar("scrollBar", e=1, v=0)
orig_format = mel.eval('getAttr "defaultRenderGlobals.imageFormat";')
mel.eval('setAttr "defaultRenderGlobals.imageFormat" 8;')
cmds.renderWindowEditor("renderView", e=1, wi=src_filename)
mel.eval('setAttr "defaultRenderGlobals.imageFormat" ' + str(orig_format) +
';')
shutil.copy2(src_filename, dst_filename)
expr = "@SOBJECT(simpleslot/game['name','" + temp[2][
0] + "'].simpleslot/assets['name','" + temp[2][
1] + "'].sthpw/task['process','" + temp[2][2] + "'])"
task = server.eval(expr)
sk = task[0].get("__search_key__")
final_filename = "/mnt/hgfs/assets/simpleslot/" + temp[2][
0] + "/review/" + filename
server.simple_checkin(sk,
temp[2][2],
final_filename,
description="image",
mode="inplace")
def resetImageDataWindow(self, imageName, oiiotoolPath):
editor = cmds.renderWindowEditor(q=True, editorName=True )
#print( "resetImageDataWindow - editor : %s" % editor )
if editor:
renderRegion = cmds.renderWindowEditor(editor, q=True, mq=True)
#print( "resetImageDataWindow - render region : %s" % renderRegion )
if renderRegion:
left = cmds.getAttr( "defaultRenderGlobals.left" )
right = cmds.getAttr( "defaultRenderGlobals.rght" )
top = cmds.getAttr( "defaultRenderGlobals.top" )
bottom = cmds.getAttr( "defaultRenderGlobals.bot" )
imageWidth = cmds.getAttr("defaultResolution.width")
imageHeight = cmds.getAttr("defaultResolution.height")
pathTokens = os.path.splitext(imageName)
imageNameCropped = "%s_crop%s" % (pathTokens[0], pathTokens[1])
#print( "Generating cropped image : %s" % imageNameCropped )
oiiotoolResult = None
try:
#cmd = '/usr/local/bin/oiiotool'
cropArgs = '%dx%d-%d-%d' % (imageWidth, imageHeight, left, imageHeight-top)
args = ['-v', imageName, '--crop', cropArgs, '--noautocrop', '-o', imageNameCropped]
oiiotool = Process(description='reset image data window',
cmd=oiiotoolPath,
args=args)
oiiotool.execute()
oiiotoolResult = oiiotool.status
#print( "oiiotool result : %s" % oiiotoolResult )
except:
print( "Unable to run oiiotool" )
oiiotoolResult = None
# Move the image with the new data window over the original rendered image
if oiiotoolResult in [0, None]:
os.rename(imageNameCropped, imageName)
def getRegion(rrStart_x, rrStart_y, rrLast_x, rrLast_y):
values = [rrStart_x, rrStart_y, rrLast_x, rrLast_y]
camOverscan = cmds.camera(camera0, q=1, ovr=1)
if LockedAttr() == 'locked':
cmds.warning('Unlock you camera\'s main attributtes')
return False
if cmds.window("vpRenderWindow", exists=1) == False:
getRvStatus()
getPaneLayoutStatus()
if values[3] < 0:
values[3] = 0
if values[2] > formX:
values[2] = formX
if values[2] - values[0] < 20 or values[1] - values[3] < 20:
cmds.warning('Region is too small')
else:
leftW = marLeft + values[0]
topW = marTop + (formY - values[1])
resoX = values[2] - values[0]
resoY = values[1] - values[3]
main(values)
if "Viewport_RenderShape" not in cmds.ls(ca=1):
setToolBegin()
else:
cmds.setAttr('defaultResolution.width', resoX)
cmds.setAttr('defaultResolution.height', resoY)
aspRatio = float(cmds.getAttr('defaultResolution.width')) / float(
cmds.getAttr('defaultResolution.height'))
cmds.setAttr('defaultResolution.deviceAspectRatio', aspRatio)
ScaleToCrop = float(formX) / resoX
ScaleToCrop2 = float(formY) / resoY
cmds.setAttr(camera0 + '.preScale', float(ScaleToCrop) / camOverscan)
if 'OverScanExpression' not in cmds.ls(et='expression'):
cmds.expression(name='OverScanExpression',
s=camera0 +
'.overscan = Viewport_RenderShape.overscan',
o=camera0,
ae=1)
# Pixel Offset
pixoffX = (float(formX) / 2) - (values[0] + float(resoX) / 2)
pixoffY = (float(formY) / 2) - (formY - values[1]) - (float(resoY) / 2)
# Film Translate
FxOff = float(pixoffX) / (formX / 2)
FxOff = FxOff * ScaleToCrop
if FxOff > 0:
FxOff = FxOff * -1
else:
FxOff = -FxOff
cmds.setAttr(camera0 + '.filmTranslateH', FxOff)
unitY = float(formY) / 2 * float(formX) / formY
FyOff = float(pixoffY) / unitY
FyOff = FyOff * ScaleToCrop
cmds.setAttr(camera0 + '.filmTranslateV', FyOff)
cmds.setAttr('defaultResolution.width', resoX)
cmds.setAttr('defaultResolution.height', resoY)
aspRatio = float(cmds.getAttr('defaultResolution.width')) / float(
cmds.getAttr('defaultResolution.height'))
cmds.setAttr('defaultResolution.deviceAspectRatio', aspRatio)
cmds.layout('scrollBarForm', e=1, vis=0)
cmds.renderWindowEditor(renderViews,
e=True,
snp=(currentPanel, resoX, resoY))
cmds.renderWindowEditor(renderViews, e=True, rs=True, cap=0, pca=0)
cmds.renderWindowEditor(renderViews, e=1, cl=(resoX, resoY, 0, 0, 0))
if currentRender == 'arnold':
cmds.arnoldRender(cam=camera1)
elif currentRender == 'vray':
if cmds.getAttr("vraySettings.vfbOn") == 1:
cmds.setAttr("vraySettings.vfbOn", 0)
cmds.setAttr('vraySettings.width', resoX)
cmds.setAttr('vraySettings.height', resoY)
mel.eval('vraySetPixelDeviceAspect();')
vrendCommand = 'vrend -camera %s' % (camera0)
mel.eval(vrendCommand)
elif currentRender == 'mentalRay':
cmds.Mayatomr(pv=True, cam=camera0)
else:
cmds.warning(
'Render engine not supported. Rendering using Maya Software renderer.'
)
cmds.render(camera1, x=resoX, y=resoY)
reRenderVals.append(resoX)
reRenderVals.append(resoY)
cName=camName[0]
cx=0
cy=0
cz=0
v=45
im=0
while (cx <=360):
for a in s:
x = a +"."+"rotate" +"X"
cmds.setAttr(x,cx)
cy=0
while(cy<=360):
for a in s:
x = a +"."+"rotate" +"Y"
cmds.setAttr(x,cy)
cz=0
while(cz<=360):
for a in s:
x = a +"."+"rotate" +"Z"
cmds.setAttr(x,cz)
mel.eval('renderWindowRender redoPreviousRender renderView')
editor = 'renderView'
cmds.renderWindowEditor( editor, e=True,refresh = True, writeImage=('/Users/tinyteddybear/Documents/NoShadow/Black/Weapons/Gun/ACR Bushmaster/Weapon_Gun_ACR Bushmaster'+'_X'+str(cx)+'_Y'+str(cy)+'_Z'+str(cz)+'_No'))
im=im+1
cz=cz+v
cy=cy+v
cx=cx+v
def createCrossBounce():
import maya.cmds as cmds
import maya.mel as mel
import domeCamera
reload(domeCamera)
import domeMaterial
reload(domeMaterial)
# ---------------------------------------------------------------------
# Variables
# ---------------------------------------------------------------------
# The fulldome mesh should be 25 units in size
fulldomeMeshScale = 25
# Outliner name for the all quads fulldome mesh shape
fulldomeMeshName = 'fulldomeMesh'
# ---------------------------------------------------------------------
# Scene Setup
# ---------------------------------------------------------------------
#Create a new Maya scene
cmds.file( force=True, newFile=True)
# Tell the mental ray plugin to load automatically
domeCamera.forceMentalRayLoad()
# Add a default mentalrayGlobals node
mel.eval('createNode "mentalrayGlobals" -n "mentalrayGlobals";')
# Add the initial rendering settings for the scene
setupDomeRenderOptions()
# ---------------------------------------------------------------------
# FulldomeIBL Lighting Setup
# ---------------------------------------------------------------------
# Add a mental ray IBL shape to the scene
domeCamera.createFulldomeIBL()
# Adjust the IBL shape position
cmds.setAttr('mentalrayIbl1.rotate', -90, 0, 0, type='float3')
cmds.setAttr('mentalrayIbl1.scale', -200, 200, 200, type='float3')
dome_tex_remap = 'dome_mib_texture_remap1'
#Set the matrix to use a mirrored effect on the X and Y axis matrix cells
melSetAttrMatrixString = 'setAttr "' + dome_tex_remap + '.transform" -type "matrix" -1 0 0 0 0 -1 0 0 0 0 1 0 0 0 0 1;'
mel.eval(melSetAttrMatrixString)
# Load the following LDR to HDR presets file:
ldrToHdrPresetsFile = domeMaterial.getDomePresetsPath("remapColor/ldr_to_hdr_boost_10x.mel")
# Apply the ldr_to_hdr_boost_10x preset to the FulldomeIBL shading network
mel.eval('applyPresetToNode "dome_remapColor1" "" "" "' + ldrToHdrPresetsFile + '" 1')
# Set the HDR light boosting ratio to 7.5X brighter on the highlights
cmds.setAttr('dome_remapColor1.outputMax', 7.5)
# 180 Degree Fulldome Camera
domeCamera.createDomeAFL_FOV_Camera()
# Turn off the domeAFL_FOV shader's preview shape
cmds.setAttr('domeAFL_FOV.fovDisplayMode', 0)
# ---------------------------------------------------------------------
# Load the all quads based fulldome mesh
# ---------------------------------------------------------------------
# Add the fulldome_quads_mesh.ma mesh to the scene
fulldomeBaseMesh = domeMaterial.getSourceImagesPath("fulldome_quads_mesh.ma")
# Note: Maya 2014+ has the mergeNamespacesOnClash flag
#mel.eval('file -import -type "mayaAscii" -ra true -mergeNamespacesOnClash false -rpr "fulldome_quads_mesh" -options "v=0;" "' + fulldomeBaseMesh + '"')
# Note: Maya 2010 doesn't have the mergeNamespacesOnClash flag
# Cross platform file path
mel.eval('file -import -type "mayaAscii" -ra true -rpr "fulldome_quads_mesh" -options "v=0;" "' + fulldomeBaseMesh + '"')
# Rename the fulldome mesh
cmds.rename('fulldome_quads_mesh_domeViewer', fulldomeMeshName)
# Resize the fulldome mesh
cmds.setAttr(fulldomeMeshName+'.scale', fulldomeMeshScale, fulldomeMeshScale, fulldomeMeshScale, type='float3')
# ---------------------------------------------------------------------
# Render Settings Setup
# ---------------------------------------------------------------------
#Add a surface material to the fulldome shape
setupDomeMatteMaterial(fulldomeMeshName)
# Frame the perspective view on the fulldome mesh shape
cmds.setAttr('persp.rotate', 30, 45, 0, type='float3')
cmds.select(fulldomeMeshName, replace=True)
mel.eval('viewFit')
# ---------------------------------------------------------------------
# Load an image in the view
# ---------------------------------------------------------------------
referenceFulldomeImage = domeMaterial.getSourceImagesPath("fulldome_2K.jpg")
# Load the ocean fulldome test image
cmds.setAttr('dome_map_mentalrayTexture1.File_Name_Prefix', referenceFulldomeImage, type='string')
# Set the mentalrayTexture's Frame Animation Ext value to name(Single Frame)
cmds.setAttr('dome_map_mentalrayTexture1.Frame_Animation_Ext', 0)
# Set the mentalrayTexture's Frame Animation Ext value to name.ext (Single Frame)
#cmds.setAttr('dome_map_mentalrayTexture1.Frame_Animation_Ext', 1)
#Enable the JPG image format
cmds.setAttr('dome_map_mentalrayTexture1.Image_Format', 2)
cmds.currentTime(2)
cmds.currentTime(1)
# Force the Frame_Animation_Ext mode to Native Image Name (Passthrough) once the referenceFulldomeImage name has been loaded once
# Set the mentalrayTexture's Frame Animation Ext value to Native Image Name (Passthrough)
cmds.setAttr('dome_map_mentalrayTexture1.Frame_Animation_Ext', 7)
cmds.currentTime(2)
cmds.currentTime(1)
# ---------------------------------------------------------------------
# Snapshot the fulldome camera in the render view
# ---------------------------------------------------------------------
# Grab the name of the current render view
currentRenderView = cmds.getPanel( scriptType='renderWindowPanel' )
theView = currentRenderView[0]
#Result: theView = 'renderView'
# Show the render view
mel.eval('RenderViewWindow;')
# Take a snapshot through the domeAFL_FOV camera
mel.eval('renderWindowRenderCamera snapshot ' + theView + ' domeAFL_FOV_CameraShape2;')
# Load the reference image in the view
#referenceFulldomeImage = domeMaterial.getSourceImagesPath("fulldome_2K.jpg")
print('Loading image ' + referenceFulldomeImage + ' in the render view\n')
cmds.renderWindowEditor(theView, edit=True, autoResize=True, loadImage=referenceFulldomeImage)
cmds.renderWindowEditor(theView, edit=True, realSize=True)
# Snapshot the image in the view
mel.eval('renderWindowMenuCommand keepImageInRenderView '+ theView)
# ---------------------------------------------------------------------
# Finish the last few steps
# ---------------------------------------------------------------------
#Show the mental ray texture in the Attribute Editor window
mel.eval('evalDeferred( "showEditor dome_map_mentalrayTexture1");')
#Turn on smooth shading with textures
mel.eval('evalDeferred("DisplayShadedAndTextured")')
import maya.cmds as cmds
import os
imageFormats = { "tga":19, "tif":4, "png":32, "jpg":8 }
editor = 'renderView'
if not cmds.renderWindowEditor(editor, q=True, exists=True ):
cmds.warning("No render window found!")
try:
path, frmt = str( cmds.fileDialog2( dialogStyle=2)[0] ).split(".")
except TypeError:
pass
if not path:
maya.warning("Please provide a valid path.")
if frmt == "*" or frmt not in imageFormats.keys():
cmds.warning("Please provide one of the formats in tga, tif, png, jpg.")
else:
cmds.setAttr ('defaultRenderGlobals.imageFormat', imageFormats[frmt])
editor = 'renderView'
totalImages = cmds.renderWindowEditor(editor, q=True, nbImages=True ) + 1
for i in range(0, int(totalImages)):
cmds.renderWindowEditor(editor, e=True, displayImage=i-1)
imgNumber = ( "00000" + str(i) )[-4:]
imgPath = path + "_" + imgNumber
cmds.renderWindowEditor(editor, e=True, writeImage= imgPath)
positions = character_sight.positions(n)
rotations = character_sight.rotations(character_mocap, n)
for i in range(n):
name = "control_interp_%d" % i
rr.set_rotation(name, rotations[i])
rr.set_position(name, positions[i])
# Update robot
character_robot.set_tpose()
character_robot.set_from_other_spline(character_sight, prop_s2r)
character_robot.interpolate_rotations_for_joints(character_sight)
character_robot.interpolate_positions_for_joints()
rpx,rpy,rpz = rr.get_position("root")
rr.set_position("Character_Controller", [rpx*1.0+10.0, rpy*1.0+0.0, rpz*1.0+0.0])
rr.set_position("Controller_Interps", [rpx*1.0+10.0, rpy*1.0+0.0, rpz*1.0+0.0])
rr.set_position("all_ctrl", [rpx*1.0+24.0, rpy*1.0+-10.25, rpz*1.0+0.0])
import maya.mel as mel
import maya.cmds as cmds
for i in range(1, 575):
cmds.currentTime(i+1)
update_now()
mel.eval("renderWindowRender redoPreviousRender renderView")
cmds.renderWindowEditor("renderView", e=True, writeImage="C:/Users/roberts/Desktop/tmp2/test_pb_%d" % (i+1))
def showRender(fileName):
renderWindowName = getRenderWindowPanel()
cmds.renderWindowEditor(renderWindowName, edit=True, loadImage=fileName)
def rpr_render(scene):
cmds.optionVar(rm="RPR_DevicesSelected")
cmds.optionVar(iva=("RPR_DevicesSelected", 1))
scenes_cam_fix_1 = [
"LightEnv.ma", "LightEnv1.ma", "LightEnv2.ma", "LightEnv3.ma",
"LightDome1.ma", "LightDome2.ma", "LightDome3.ma", "LightDome4.ma",
"LightDome5.ma", "LightDome6.ma", "LightDome7.ma", "IES1.ma",
"IES2.ma", "IES3.ma", "IES4.ma", "IES5.ma", "IES6.ma",
"PhysicalSky1.ma", "PhysicalSky2.ma", "PhysicalSky3.ma",
"PhysicalSky4.ma", "PhysicalSky5.ma", "PhysicalSky6.ma",
"PhysicalSky7.ma", "Triplanar.ma", "Triplanar1.ma", "Triplanar2.ma",
"Triplanar3.ma", "Triplanar4.ma", "Triplanar5.ma", "Triplanar6.ma",
"Triplanar7.ma", "Triplanar8.ma", "Triplanar9.ma", "Architectural1.ma",
"Architectural10.ma", "Architectural11.ma", "Architectural12.ma",
"Architectural2.ma", "Architectural3.ma", "Architectural4.ma",
"Architectural5.ma", "Architectural6.ma", "Architectural7.ma",
"Architectural8.ma", "Architectural9.ma", "rsMaterial.ma",
"rsMaterial1.ma", "rsMaterial10.ma", "rsMaterial11.ma",
"rsMaterial12.ma", "rsMaterial13.ma", "rsMaterial14.ma",
"rsMaterial15.ma", "rsMaterial16.ma", "rsMaterial17.ma",
"rsMaterial18.ma", "rsMaterial19.ma", "rsMaterial2.ma",
"rsMaterial20.ma", "rsMaterial21.ma", "rsMaterial22.ma",
"rsMaterial23.ma", "rsMaterial24.ma", "rsMaterial25.ma",
"rsMaterial26.ma", "rsMaterial27.ma", "rsMaterial28.ma",
"rsMaterial29.ma", "rsMaterial3.ma", "rsMaterial30.ma",
"rsMaterial31.ma", "rsMaterial32.ma", "rsMaterial33.ma",
"rsMaterial34.ma", "rsMaterial35.ma", "rsMaterial36.ma",
"rsMaterial37.ma", "rsMaterial38.ma", "rsMaterial39.ma",
"rsMaterial4.ma", "rsMaterial40.ma", "rsMaterial41.ma",
"rsMaterial42.ma", "rsMaterial43.ma", "rsMaterial44.ma",
"rsMaterial5.ma", "rsMaterial6.ma", "rsMaterial7.ma", "rsMaterial8.ma",
"rsMaterial9.ma", "LightArea.ma", "LightArea1.ma", "LightArea10.ma",
"LightArea11.ma", "LightArea12.ma", "LightArea2.ma", "LightArea3.ma",
"LightArea4.ma", "LightArea5.ma", "LightArea6.ma", "LightArea7.ma",
"LightArea8.ma", "LightArea9.ma", "LightAreaCylinder.ma",
"LightAreaDisk.ma", "LightAreaMesh.ma", "LightAreaRectangle.ma",
"LightAreaSize100.ma", "LightAreaSize50.ma", "LightAreaSize50x25.ma",
"LightAreaSphere.ma", "LightPhysDirect.ma", "LightPhysDirect1.ma",
"LightPhysDirect2.ma", "LightPhysDirect3.ma", "LightPhysDirect4.ma",
"LightPhysDirect5.ma", "LightPoint.ma", "LightPoint1.ma",
"LightPoint10.ma", "LightPoint2.ma", "LightPoint3.ma",
"LightPoint4.ma", "LightPoint5.ma", "LightPoint6.ma", "LightPoint7.ma",
"LightPoint8.ma", "LightPoint9.ma", "SpotLight.ma", "SpotLight1.ma",
"SpotLight10.ma", "SpotLight11.ma", "SpotLight2.ma", "SpotLight3.ma",
"SpotLight4.ma", "SpotLight5.ma", "SpotLight6.ma", "SpotLight7.ma",
"SpotLight8.ma", "SpotLight9.ma"
]
scenes_cam_fix_2 = [
"VolumeScattering.ma", "VolumeScattering1.ma", "VolumeScattering2.ma",
"VolumeScattering3.ma", "VolumeScattering4.ma", "VolumeScattering5.ma",
"VolumeScattering6.ma", "VolumeScattering7.ma", "VolumeScattering8.ma",
"VolumeScattering9.ma", "LightPortal.ma", "LightPortal1.ma",
"LightPortal2.ma", "LightPortal3.ma", "LightPortal4.ma",
"LightPortal5.ma"
]
cameras = cmds.ls(cameras=True)
if ("cameraShape1" in cameras):
mel.eval("lookThru camera1")
'''
for each in scenes_cam_fix_1:
if each == scene:
try:
cmds.setAttr("cameraShape1.focalLength", 52.3)
except:
print "[ERROR]: Can't set focalLength\n";
for each in scenes_cam_fix_2:
if each == scene:
try:
cmds.setAttr("cameraShape1.focalLength", 36)
except:
print "[ERROR]: Can't set focalLength\n";
'''
else:
print "[ERROR]: no camera1\n"
cmds.fireRender(waitForItTwo=True)
start_time = datetime.datetime.now()
mel.eval("renderIntoNewWindow render")
output = os.path.join("{work_dir}", "Color", "converted_" + scene)
cmds.renderWindowEditor("renderView", edit=True, dst="color")
cmds.renderWindowEditor("renderView",
edit=True,
com=True,
writeImage=output)
end_time = datetime.datetime.now()
return (end_time - start_time).total_seconds()
def snapshots(*args, **kwargs):
""" in GUI mode, renders snapshots of the model views
returns reportsDir
render_snapshots() -> string
"""
t0 = float(time.time())
try:
verbose = kwargs["verbose"]
except KeyError:
verbose = False
if cmds.optionVar(exists="checkmateVerbosity"):
verbose = cmds.optionVar(query="checkmateVerbosity")
else:
pass
# check that we;re running in GUI mode
if cmds.about(batch=True):
print "You can't create a render view in batch mode"
return 1
# turn off the heads-up diplay
cmds.headsUpDisplay(layoutVisibility=False)
# clear selection
cmds.select(clear=True)
_userWorkspaceDir = cmds.internalVar(userWorkspaceDir=True)
scene = cmds.file(query=True, sn=True, shn=True) or "unknown.mb"
(root, ext) = os.path.splitext(scene)
fullscenepath = cmds.file(query=True, sn=True, shn=False) or "unknown.mb"
fullscenedirname = os.path.dirname(fullscenepath)
if fullscenedirname == "":
fullscenedirname = os.path.join(_userWorkspaceDir, "reports")
reportname = "".join([root, ext.replace(".", "_")])
img_dir = os.path.join(fullscenedirname, reportname)
# before we render, save render globals presets
cmds.nodePreset(save=("defaultRenderQuality", "ttRestorePreviousDefaultRenderViewPreset"))
cmds.nodePreset(save=("defaultRenderGlobals", "ttRestorePreviousDefaultRenderViewPreset"))
cmds.nodePreset(save=("defaultResolution", "ttRestorePreviousDefaultRenderViewPreset"))
# override the user settings
cmds.setAttr("defaultRenderGlobals.imageFormat", 32)
ext = ".png"
# set resolution ot 320x240
cmds.setAttr("defaultResolution.width", 320)
cmds.setAttr("defaultResolution.height", 240)
cmds.setAttr("defaultResolution.deviceAspectRatio", (float(320) / float(240)))
# set file format to png
cmds.setAttr("defaultRenderGlobals.imageFormat", 32)
ext = ".png"
# bring up the render view
if not cmds.window("renderViewWindow", exists=True):
cmds.RenderViewWindow()
# cameras to render
cameras = ["top", "front", "side", "persp"]
for camera in cameras:
mel.eval("".join(["renderWindowRenderCamera snapshot renderView ", camera]))
image = "".join([camera, ext])
# we can get the path from the report class instance
imagepath = os.path.join(img_dir, image)
if verbose:
print "imagepath : %s " % imagepath
# delete the images before saving
cmds.sysFile(imagepath, delete=True)
cmds.renderWindowEditor("renderView", edit=True, writeImage=imagepath)
# restore the node presets
# globalsNodes = cmds.renderer( 'mayaSoftware', query=True, globalsNodes=True)
try:
cmds.nodePreset(load=("defaultRenderQuality", "ttRestorePreviousDefaultRenderViewPreset"))
except LockedAttrError:
print "Cannot restore defaultRenderQuality to defaults"
try:
cmds.nodePreset(load=("defaultRenderGlobals", "ttRestorePreviousDefaultRenderViewPreset"))
except LockedAttrError:
print "Cannot restore defaultRenderGlobals to defaults"
try:
cmds.nodePreset(load=("defaultResolution", "ttRestorePreviousDefaultRenderViewPreset"))
except LockedAttrError:
print "Cannot restore defaultRenderGlobals to defaults"
# turn the heads-up diplay back on
cmds.headsUpDisplay(layoutVisibility=True)
print "%-24s : %.6f seconds" % ("render.snapshots()", (float(time.time()) - t0))
return img_dir
def rView():
panels=mc.getPanel(scriptType='renderWindowPanel')
form=mc.renderWindowEditor(panels[0],q=True,parent=True)
scroll= 'pass' #form - editorform +'scrollBarForm|scrollBar'
curIndex= mc.intScrollBar(scroll,q=True)
maxIndex= mc.renderWindowEditor('renderView',q=True,nbImages=True)
def mk_view(name, values):
mw = QMainWindow(getMayaWindow())
mw.setObjectName(name)
# clean renderview controls
cmds.optionVar(iv=('renderViewDisplayToolbar', 0))
cmds.scriptedPanel(renderViews, e=True, mbv=0)
cmds.renderWindowEditor(renderViews, e=1, cap=0)
cmds.renderWindowEditor(renderViews, e=1, rs=1)
form = cmds.formLayout('ViewportRenderForm')
pane = cmds.paneLayout(configuration='single', bgc=(0.1, 0.1, 0.1))
cmds.formLayout(form,
e=1,
af=[(pane, 'top', 1), (pane, 'left', 1),
(pane, 'right', 1), (pane, 'bottom', 1)])
cmds.scriptedPanel(renderViews[0], e=1, p=pane)
closeBtn = cmds.button('myClosebtn',
label="x",
w=20,
h=20,
p=form,
c=dropTool,
ebg=0,
bgc=(0, 0, 0))
bReRender = cmds.button('bReRender',
label="r",
w=20,
h=20,
p=form,
c=reRender)
iprR = cmds.button('iprR', label="ir", w=20, h=20, p=form, c=iprRender)
cmds.formLayout(form,
e=True,
af=[(closeBtn, 'top', 5), (closeBtn, 'left', 5)])
cmds.formLayout(form,
e=True,
af=[(bReRender, 'top', 5), (bReRender, 'left', 30)])
cmds.formLayout(form, e=True, af=[(iprR, 'top', 5), (iprR, 'left', 55)])
cmds.formLayout(form,
e=True,
af=[(closeBtn, 'top', 5), (closeBtn, 'left', 5)])
panel = getPanelAttach(form)
mw.setCentralWidget(panel)
mw.setWindowTitle(name)
#mw.setWindowFlags(QtCore.Qt.Tool|QtCore.Qt.FramelessWindowHint)
leftW = marLeft + values[0]
topW = marTop + (formY - values[1])
resoX = values[2] - values[0]
resoY = values[1] - values[3]
mw.setGeometry(leftW, topW, resoX, resoY)
mw.update()
return mw
def saveIcon(self, filename):
renderPanels = cmds.getPanel(scriptType="renderWindowPanel")
formatManager = createImageFormats.ImageFormats()
formatManager.pushRenderGlobalsForDesc("PNG")
cmds.renderWindowEditor(renderPanels[0], e=True, writeImage=str(filename))
formatManager.popRenderGlobals()
def createCrossBounce():
import maya.cmds as cmds
import maya.mel as mel
import domeCamera
reload(domeCamera)
import domeMaterial
reload(domeMaterial)
# ---------------------------------------------------------------------
# Variables
# ---------------------------------------------------------------------
# The fulldome mesh should be 25 units in size
fulldomeMeshScale = 25
# Outliner name for the all quads fulldome mesh shape
fulldomeMeshName = 'fulldomeMesh'
# ---------------------------------------------------------------------
# Scene Setup
# ---------------------------------------------------------------------
#Create a new Maya scene
cmds.file(force=True, newFile=True)
# Tell the mental ray plugin to load automatically
domeCamera.forceMentalRayLoad()
# Add a default mentalrayGlobals node
mel.eval('createNode "mentalrayGlobals" -n "mentalrayGlobals";')
# Add the initial rendering settings for the scene
setupDomeRenderOptions()
# ---------------------------------------------------------------------
# FulldomeIBL Lighting Setup
# ---------------------------------------------------------------------
# Add a mental ray IBL shape to the scene
domeCamera.createFulldomeIBL()
# Adjust the IBL shape position
cmds.setAttr('mentalrayIbl1.rotate', -90, 0, 0, type='float3')
cmds.setAttr('mentalrayIbl1.scale', -200, 200, 200, type='float3')
dome_tex_remap = 'dome_mib_texture_remap1'
#Set the matrix to use a mirrored effect on the X and Y axis matrix cells
melSetAttrMatrixString = 'setAttr "' + dome_tex_remap + '.transform" -type "matrix" -1 0 0 0 0 -1 0 0 0 0 1 0 0 0 0 1;'
mel.eval(melSetAttrMatrixString)
# Load the following LDR to HDR presets file:
ldrToHdrPresetsFile = domeMaterial.getDomePresetsPath(
"remapColor/ldr_to_hdr_boost_10x.mel")
# Apply the ldr_to_hdr_boost_10x preset to the FulldomeIBL shading network
mel.eval('applyPresetToNode "dome_remapColor1" "" "" "' +
ldrToHdrPresetsFile + '" 1')
# Set the HDR light boosting ratio to 7.5X brighter on the highlights
cmds.setAttr('dome_remapColor1.outputMax', 7.5)
# 180 Degree Fulldome Camera
domeCamera.createDomeAFL_FOV_Camera()
# Turn off the domeAFL_FOV shader's preview shape
cmds.setAttr('domeAFL_FOV.fovDisplayMode', 0)
# ---------------------------------------------------------------------
# Load the all quads based fulldome mesh
# ---------------------------------------------------------------------
# Add the fulldome_quads_mesh.ma mesh to the scene
fulldomeBaseMesh = domeMaterial.getSourceImagesPath(
"fulldome_quads_mesh.ma")
# Note: Maya 2014+ has the mergeNamespacesOnClash flag
#mel.eval('file -import -type "mayaAscii" -ra true -mergeNamespacesOnClash false -rpr "fulldome_quads_mesh" -options "v=0;" "' + fulldomeBaseMesh + '"')
# Note: Maya 2010 doesn't have the mergeNamespacesOnClash flag
# Cross platform file path
mel.eval(
'file -import -type "mayaAscii" -ra true -rpr "fulldome_quads_mesh" -options "v=0;" "'
+ fulldomeBaseMesh + '"')
# Rename the fulldome mesh
cmds.rename('fulldome_quads_mesh_domeViewer', fulldomeMeshName)
# Resize the fulldome mesh
cmds.setAttr(fulldomeMeshName + '.scale',
fulldomeMeshScale,
fulldomeMeshScale,
fulldomeMeshScale,
type='float3')
# ---------------------------------------------------------------------
# Render Settings Setup
# ---------------------------------------------------------------------
#Add a surface material to the fulldome shape
setupDomeMatteMaterial(fulldomeMeshName)
# Frame the perspective view on the fulldome mesh shape
cmds.setAttr('persp.rotate', 30, 45, 0, type='float3')
cmds.select(fulldomeMeshName, replace=True)
mel.eval('viewFit')
# ---------------------------------------------------------------------
# Load an image in the view
# ---------------------------------------------------------------------
referenceFulldomeImage = domeMaterial.getSourceImagesPath(
"fulldome_2K.jpg")
# Load the ocean fulldome test image
cmds.setAttr('dome_map_mentalrayTexture1.File_Name_Prefix',
referenceFulldomeImage,
type='string')
# Set the mentalrayTexture's Frame Animation Ext value to name(Single Frame)
cmds.setAttr('dome_map_mentalrayTexture1.Frame_Animation_Ext', 0)
# Set the mentalrayTexture's Frame Animation Ext value to name.ext (Single Frame)
#cmds.setAttr('dome_map_mentalrayTexture1.Frame_Animation_Ext', 1)
#Enable the JPG image format
cmds.setAttr('dome_map_mentalrayTexture1.Image_Format', 2)
cmds.currentTime(2)
cmds.currentTime(1)
# Force the Frame_Animation_Ext mode to Native Image Name (Passthrough) once the referenceFulldomeImage name has been loaded once
# Set the mentalrayTexture's Frame Animation Ext value to Native Image Name (Passthrough)
cmds.setAttr('dome_map_mentalrayTexture1.Frame_Animation_Ext', 7)
cmds.currentTime(2)
cmds.currentTime(1)
# ---------------------------------------------------------------------
# Snapshot the fulldome camera in the render view
# ---------------------------------------------------------------------
# Grab the name of the current render view
currentRenderView = cmds.getPanel(scriptType='renderWindowPanel')
theView = currentRenderView[0]
#Result: theView = 'renderView'
# Show the render view
mel.eval('RenderViewWindow;')
# Take a snapshot through the domeAFL_FOV camera
mel.eval('renderWindowRenderCamera snapshot ' + theView +
' domeAFL_FOV_CameraShape2;')
# Load the reference image in the view
#referenceFulldomeImage = domeMaterial.getSourceImagesPath("fulldome_2K.jpg")
print('Loading image ' + referenceFulldomeImage + ' in the render view\n')
cmds.renderWindowEditor(theView,
edit=True,
autoResize=True,
loadImage=referenceFulldomeImage)
cmds.renderWindowEditor(theView, edit=True, realSize=True)
# Snapshot the image in the view
mel.eval('renderWindowMenuCommand keepImageInRenderView ' + theView)
# ---------------------------------------------------------------------
# Finish the last few steps
# ---------------------------------------------------------------------
#Show the mental ray texture in the Attribute Editor window
mel.eval('evalDeferred( "showEditor dome_map_mentalrayTexture1");')
#Turn on smooth shading with textures
mel.eval('evalDeferred("DisplayShadedAndTextured")')
import maya.cmds as cmds
import maya.mel
s = cmds.ls(selection=True)
axes = ['X', 'Y', 'Z']
for axis in axes:
c = 0
while (c <= 360):
for a in s:
x = a + "." + "rotate" + axis
cmds.setAttr(x, c)
mel.eval('renderWindowRender redoPreviousRender renderView')
editor = 'renderView'
#c= c+5
cmds.renderWindowEditor(
editor,
e=True,
refresh=True,
writeImage=('/Users/tinyteddybear/Documents/Sword/Sword' + axis +
str(c)))
c = c + 10
