def build(self):
_nuke_proxy_template = "{d}/usr/custom/nuke/proxy_script_templates/nuke_proxy_v002.nk".format(d=self.dabrender)
_nuke_version = "Nuke{}".format(config.CurrentConfiguration().nukeversion)
_nuke_envkey = "nuke{}".format(config.CurrentConfiguration().nukeversion)
_nuke_executable="/Applications/{n}/{n}.app/Contents/MacOS/{n}".format(n=_nuke_version)
_nuke_range="{start}-{end}".format(start=self.startframe, end=self.endframe)
_nukescriptbaseonly = os.path.basename(self.nukescriptfullpath)
self.job = author.Job(title="Nuke Render Job: {} {}".format(self.renderusername, _nukescriptbaseonly),
priority=100,
envkey=[_nuke_envkey],
metadata="user={} realname={}".format(self.user,self.renderusername),
comment="LocalUser is {} {} {}".format(self.user, self.renderusername,
self.renderusernumber),
service="NukeRender")
# ############## 1 NUKE RENDER ###############
parent = author.Task(title="Nuke Rendering",service="NukeRender")
parent.serialsubtasks = 0
if (self.endframe - self.startframe) < self.framechunks:
self.framechunks = 1
_chunkend = self.endframe
else:
_chunkend = self.startframe + self.framechunks
_chunkstart = self.startframe
while self.endframe >= _chunkstart:
if _chunkend >= self.endframe:
_chunkend = self.endframe
t1 = "{} {}-{}".format("Nuke Batch Render", _chunkstart, _chunkend)
thischunk = author.Task(title=t1, service="NukeRender")
commonargs = [_nuke_executable, "-x" ]
userspecificargs = [
utils.expandargumentstring(self.options),
]
filespecificargs = [self.nukescriptfullpath, "{}-{}".format( _chunkstart, _chunkend)]
finalargs = commonargs + userspecificargs + filespecificargs
render = author.Command(argv=finalargs,
service="NukeRender",
envkey=[_nuke_envkey]
)
thischunk.addCommand(render)
_chunkstart = _chunkend + 1
_chunkend += self.framechunks
parent.addChild(thischunk)
self.job.addChild(parent)
def build(self):
_nuke_proxy_template = "{d}/usr/custom/nuke/proxy_script_templates/nuke_proxy_v002.nk".format(d=self.dabrender)
_nuke_version = "Nuke{}".format(config.CurrentConfiguration().nukeversion)
_nuke_envkey = "nuke{}".format(config.CurrentConfiguration().nukeversion)
_nuke_executable="{n}".format(n=_nuke_version)
_nukescriptbaseonly = os.path.basename(self.nukescriptfullpath)
if self.testing:
_service_Testing="Testing"
_tier="admin"
else:
_service_Testing=""
_tier="batch"
self.job = author.Job(title="Nuke Render Job: {} {}".format(self.renderusername, _nukescriptbaseonly),
priority=100,
envkey=[_nuke_envkey,"ProjectX",
"TYPE={}".format(self.envtype),
"SHOW={}".format(self.envshow),
"PROJECT={}".format(self.envproject),
"SCENE={}".format(self.envscene),
"SCENENAME={}".format(self.scenebasename)],
metadata="user={} realname={}".format(self.renderusernumber,self.renderusername),
comment="LocalUser is {} {} {}".format(
self.renderusernumber, self.renderusername,self.renderusernumber),
tier=_tier,
projects=[str(self.projectgroup)],
tags=["theWholeFarm"],
service=_service_Testing)
# ############## 1 NUKE RENDER ###############
parent = author.Task(title="Nuke Rendering",service="NukeRender")
parent.serialsubtasks = 0
_totalframes=int(self.endframe-self.startframe+1)
_chunks = int(self.framechunks)
_framesperchunk=_totalframes
if _chunks < _totalframes:
_framesperchunk=int(_totalframes/_chunks)
else:
_chunks=1
for i, chunk in enumerate(range(1,_chunks+1)):
_offset=i*_framesperchunk
_chunkstart=(self.startframe+_offset)
_chunkend=(_offset+_framesperchunk)
_chunkby=self.byframe
logger.info("Chunk {} is frames {}-{}".format(chunk,_chunkstart,_chunkend))
if chunk ==_chunks:
_chunkend = self.endframe
t1 = "{} {}-{}".format("Nuke Batch Render", _chunkstart, _chunkend)
thischunk = author.Task(title=t1, service="NukeRender")
commonargs = [_nuke_executable]
filespecificargs = ["-x", self.nukescriptfullpath, "{}-{}".format( _chunkstart, _chunkend)]
if self.options:
userspecificargs = [utils.expandargumentstring(self.options),]
finalargs = commonargs + userspecificargs + filespecificargs
else:
finalargs = commonargs + filespecificargs
render = author.Command(
argv=finalargs,
service="NukeRender",
tags=["nuke",],
envkey=[_nuke_envkey])
thischunk.addCommand(render)
parent.addChild(thischunk)
self.job.addChild(parent)
def build(self):
"""
Main method to build the job
"""
########### TESTING ##############
# _threadsM=4
_threadsPixarRender=4
_threads_RfMRibGen=1
_servicePixarRender=_service_RfMRibGen=_serviceMaya=None
if self.testing:
_service_Testing="Testing"
_tier="admin"
else:
_service_Testing=""
_tier="batch"
_servicePixarRender="PixarRender"
_serviceMaya="PixarRender"
_service_RfMRibGen="RfMRibGen"
_service_NukeRender="NukeRender"
#############################
# ################ 0 JOB ################
self.job = author.Job(title="Renderman: {} {} {}-{}".format(
self.renderusername,self.scenename,self.startframe,self.endframe),
priority=10,
envkey=[self.envkey_rms,"ProjectX",
"TYPE={}".format(self.envtype),
"SHOW={}".format(self.envshow),
"PROJECT={}".format(self.envproject),
"SCENE={}".format(self.envscene),
"SCENENAME={}".format(self.scenebasename)],
metadata="user={} username={} usernumber={}".format(
self.user, self.renderusername,self.renderusernumber),
comment="LocalUser is {} {} {}".format(self.user,self.renderusername,self.renderusernumber),
projects=[str(self.projectgroup)],
tier=_tier,
tags=["theWholeFarm",],
service=_service_Testing)
self.job.newDirMap("/dabrender", "/Volumes/dabrender", "linux")
self.job.newDirMap("/dabrender", "/Volumes/dabrender", "osx")
self.job.newDirMap("/dabrender", "Z:", "windows")
self.job.newDirMap("/Volumes/dabrender", "Z:", "windows")
'''
self.job.newDirMap("Z:","//Volumes/dabrender", "UNC")
self.job.newDirMap("Z:","/Volumes/dabrender", "NFS")
{{mayabatch} {maya} NFS}
{{X:/} {//fileserver/projects/} UNC}
{{X:/} {/fileserver/projects/} NFS}
{ { source } { destination } zone }
'''
# ############## 0 ThisJob #################
task_thisjob = author.Task(title="Renderman Job")
task_thisjob.serialsubtasks = 1
# ############## 1 PREFLIGHT ##############
task_preflight = author.Task(title="Preflight")
task_preflight.serialsubtasks = 1
task_thisjob.addChild(task_preflight)
task_generate_rib_preflight = author.Task(title="Generate RIB Preflight")
command_ribgen = author.Command(argv=["maya","-batch","-proj", utils.usedirmap(self.mayaprojectpath),
"-command",
"renderManBatchGenRibForLayer {layerid} {start} {end} {phase}".format(
layerid=0, start=self.startframe, end=self.endframe, phase=1),
"-file", utils.usedirmap(self.mayascenefilefullpath)],
tags=["maya", "rms", "theWholeFarm"],
atleast=_threads_RfMRibGen,atmost=_threads_RfMRibGen,
service=_service_RfMRibGen)
task_generate_rib_preflight.addCommand(command_ribgen)
task_preflight.addChild(task_generate_rib_preflight)
task_render_preflight = author.Task(title="Render Preflight")
command_render_preflight = author.Command(argv=[
"prman","-t:{}".format(_threadsPixarRender), "-Progress", "-recover", "%r", "-checkpoint", "5m",
"-cwd", utils.usedirmap(self.mayaprojectpath),
"renderman/{}/rib/job/job.rib".format(self.scenebasename)],
tags=["prman", "theWholeFarm"],
atleast=_threadsPixarRender,atmost=_threadsPixarRender,
service=_servicePixarRender)
task_render_preflight.addCommand(command_render_preflight)
task_preflight.addChild(task_render_preflight)
# ############## 3 RIBGEN ##############
task_render_allframes = author.Task(title="ALL FRAMES {}-{}".format(self.startframe, self.endframe))
task_render_allframes.serialsubtasks = 1
task_ribgen_allframes = author.Task(title="RIB GEN {}-{}".format(self.startframe, self.endframe))
# divide the frame range up into chunks
_totalframes=int(self.endframe-self.startframe+1)
_chunks = int(self.ribgenchunks)
_framesperchunk=_totalframes
if _chunks < _totalframes:
_framesperchunk=int(_totalframes/_chunks)
else:
_chunks=1
# loop thru chunks
for i,chunk in enumerate(range(1,_chunks+1)):
_offset=i*_framesperchunk
_chunkstart=(self.startframe+_offset)
_chunkend=(_offset+_framesperchunk)
logger.info("Chunk {} is frames {}-{}".format(chunk,_chunkstart,_chunkend))
if chunk ==_chunks:
_chunkend = self.endframe
task_generate_rib = author.Task(title="RIB GEN chunk {} frames {}-{}".format(
chunk,_chunkstart, _chunkend ))
command_generate_rib = author.Command(argv=[
"maya","-batch","-proj", utils.usedirmap(self.mayaprojectpath),"-command",
"renderManBatchGenRibForLayer {layerid} {start} {end} {phase}".format(
layerid=0, start=_chunkstart, end=_chunkend, phase=2),
"-file", utils.usedirmap(self.mayascenefilefullpath)],
tags=["maya", "rms", "theWholeFarm"],
atleast=int(_threads_RfMRibGen),atmost=int(_threads_RfMRibGen),
service=_service_RfMRibGen)
task_generate_rib.addCommand(command_generate_rib)
task_ribgen_allframes.addChild(task_generate_rib)
task_render_allframes.addChild(task_ribgen_allframes)
# ############### 4 RENDER ##############
task_render_frames = author.Task(title="RENDER Frames {}-{}".format(self.startframe, self.endframe))
task_render_frames.serialsubtasks = 0
for frame in range(self.startframe, (self.endframe + 1), self.byframe):
_shofile = "{proj}/{scenebase}.{frame:04d}.{ext}".format(
proj=self.renderimages, scenebase=self.scenebasename, frame=frame, ext=self.outformat)
_imgfile = "{proj}/{scenebase}.{frame:04d}.{ext}".format(
proj=self.finaloutputimagebase, scenebase=self.scenebasename, frame=frame, ext=self.outformat)
_statsfile = "{proj}/rib/{frame:04d}/{frame:04d}.xml".format(
proj=self.rendermanpath, frame=frame)
_ribfile = "{proj}/rib/{frame:04d}/{frame:04d}.rib".format(
proj=self.rendermanpath, frame=frame)
task_render_rib = author.Task(title="RENDER Frame %s" % frame, preview="sho {}".format(_shofile),
metadata="statsfile={} imgfile={}".format(_statsfile, _imgfile))
commonargs = ["prman", "-cwd", utils.usedirmap(self.mayaprojectpath)]
rendererspecificargs = []
# ################ handle image resolution formats ###########
if self.resolution == "720p":
self.xres, self.yres = 1280, 720
rendererspecificargs.extend(["-res", "%s" % self.xres, "%s" % self.yres])
elif self.resolution == "1080p":
self.xres, self.yres = 1920, 1080
rendererspecificargs.extend(["-res", "%s" % self.xres, "%s" % self.yres])
elif self.resolution == "540p":
self.xres, self.yres = 960, 540
rendererspecificargs.extend(["-res", "%s" % self.xres, "%s" % self.yres])
elif self.resolution == "108p":
self.xres, self.yres = 192, 108
rendererspecificargs.extend(["-res", "%s" % self.xres, "%s" % self.yres])
if self.rendermaxsamples != "FROMFILE":
rendererspecificargs.extend([ "-maxsamples", "{}".format(self.rendermaxsamples) ])
if self.threadmemory != "FROMFILE":
rendererspecificargs.extend([ "-memorylimit", "{}".format(self.threadmemory) ])
# if self.rendermaxsamples != "FROMFILE":
# rendererspecificargs.extend([ "-maxsamples", "{}".format(self.rendermaxsamples) ])
# if self.threads != "FROMFILE":
# rendererspecificargs.extend([ "-maxsamples", "{}".format(self.rendermaxsamples) ])
rendererspecificargs.extend([
# "-pad", "4",
# "-memorylimit", self.threadmemory, # mb
"-t:{}".format(self.threads),
"-Progress",
"-recover", "%r",
"-checkpoint", "5m",
"-statslevel", "2",
# "-maxsamples", "{}".format(self.rendermaxsamples) # override RIB ray trace hider maxsamples
# "-pixelvariance","3" # override RIB PixelVariance
# "-d", "" # dispType
# -version : print the version
# "-progress ", : print percent complete while rendering
# -recover [0|1] : resuming rendering partial frames
# -t:X : render using 'X' threads
# -woff msgid,... : suppress error messages from provided list
# -catrib file : write RIB to 'file' without rendering
# -ascii : write RIB to ASCII format file
# -binary : write RIB to Binary format file
# -gzip : compress output file
# -capture file : write RIB to 'file' while rendering
# -nobake : disallow re-render baking
# -res x y[:par] : override RIB Format
# -crop xmin xmax ymin ymax
# : override RIB CropWindow
# -maxsamples i : override RIB ray trace hider maxsamples
# -pixelvariance f : override RIB PixelVariance
# -d dispType : override RIB Display type
# -statsfile f : override RIB stats file & level (1)
# -statslevel i : override RIB stats level
# -memorylimit f : override RIB to set memory limit ratio
# -checkpoint t[,t] : checkpoint interval and optional exit time
])
userspecificargs = [
utils.expandargumentstring(self.options),
"{}".format(_ribfile)
]
finalargs = commonargs + rendererspecificargs + userspecificargs
command_render = author.Command(argv=finalargs,
#envkey=[self.envkey_prman],
tags=["prman", "theWholeFarm"],
atleast=int(self.threads),
atmost=int(self.threads),
service=_servicePixarRender)
task_render_rib.addCommand(command_render)
task_render_frames.addChild(task_render_rib)
task_render_allframes.addChild(task_render_frames)
task_thisjob.addChild(task_render_allframes)
# ############## 5 PROXY ###############
# using nuke as exr colour is handled correctly
if self.makeproxy:
#### using the proxy_run.py script
try:
_directory = "{p}/renderman/{s}/images".format( p=self.mayaprojectpath, s=self.scenebasename)
_nuke_envkey = "proxynuke{}".format(config.CurrentConfiguration().nukeversion)
_proxy_runner_cmd = ["proxy_run.py","-s",_directory]
task_proxy = author.Task(title="Proxy Generation", service=_service_NukeRender)
nukecommand = author.Command(argv=_proxy_runner_cmd,
service="NukeRender",
tags=["nuke", "theWholeFarm"],
envkey=[_nuke_envkey])
task_proxy.addCommand(nukecommand)
task_thisjob.addChild(task_proxy)
except Exception, proxyerror:
logger.warn("Cant make a proxy {}".format(proxyerror))
def build(self):
"""
Main method to build the job
"""
########### TESTING ##############
# _threadsM=4
_threadsPixarRender=4
_threads_RfMRibGen=4
_threadsMaya=4
_servicePixarRender=_service_RfMRibGen=_serviceMaya=None
if self.testing:
_service_Testing="Testing"
_tier="admin"
else:
_service_Testing=""
_tier="batch"
_servicePixarRender="PixarRender"
_serviceMaya="PixarRender"
_service_RfMRibGen="RfMRibGen"
_service_NukeRender="NukeRender"
#############################
# ################ 0 JOB ################
self.job = author.Job(title="MentalRay: {} {} {}-{}".format(self.renderusername,
self.scenename,self.startframe,self.endframe),
priority=10,
envkey=[self.envkey_maya,"ProjectX",
"TYPE={}".format(self.envtype),
"SHOW={}".format(self.envshow),
"PROJECT={}".format(self.envproject),
"SCENE={}".format(self.envscene),
"SCENENAME={}".format(self.scenebasename)],
metadata="user={} username={} usernumber={}".format(self.user, self.renderusername,
self.renderusernumber),
comment="LocalUser is {} {} {}".format(self.user,
self.renderusername,
self.renderusernumber),
projects=[str(self.projectgroup)],
tier=_tier,
tags=[
"theWholeFarm",
],
service=_service_Testing)
self.job.newDirMap("/dabrender", "/Volumes/dabrender", "linux")
self.job.newDirMap("/dabrender", "/Volumes/dabrender", "osx")
self.job.newDirMap("/dabrender", "Z:", "windows")
self.job.newDirMap("/Volumes/dabrender", "Z:", "windows")
# self.job.newDirMap("Z:","//Volumes/dabrender", "UNC")
# self.job.newDirMap("Z:","/Volumes/dabrender", "NFS")
# ############## PARENT #################
task_thisjob = author.Task(title="Maya Render Job", service="MayaMentalRay")
task_thisjob.serialsubtasks = 1
# ############## 1 PREFLIGHT ##############
# ############## 3 RENDER ##############
task_render = author.Task(title="Rendering",service="MayaMentalRay")
task_render.serialsubtasks = 0
if (self.endframe - self.startframe) < self.framechunks:
self.framechunks = 1
_chunkend = self.endframe
else:
_chunkend = self.startframe + self.framechunks
_chunkstart = self.startframe
while self.endframe >= _chunkstart:
if _chunkend >= self.endframe:
_chunkend = self.endframe
t1 = "{} {}-{}".format(self.renderername,_chunkstart, _chunkend)
thischunk = author.Task(title=t1,
service="MayaMentalRay")
commonargs = [
"Render",
"-r", self.renderer,
"-proj", self.mayaprojectpath,
"-s", "{}".format(_chunkstart),
"-e", "{}".format(_chunkend),
"-b", self.byframe,
"-rd", self.finaloutputpath,
"-rt", self.threads,
"-mem", self.threadmemory,
"-im", self.mayascenenamebase, # this is the name bit of below
"-fnc", "3" # this means name.#.ext
]
rendererspecificargs = []
if self.resolution == "720p":
self.xres, self.yres = 1280, 720
rendererspecificargs.extend(["-x", "%s" % self.xres])
rendererspecificargs.extend(["-y", "%s" % self.yres])
rendererspecificargs.extend(["-ard", "1.778"])
elif self.resolution == "1080p":
self.xres, self.yres = 1920, 1080
rendererspecificargs.extend(["-x", "%s" % self.xres])
rendererspecificargs.extend(["-y", "%s" % self.yres])
rendererspecificargs.extend(["-ard", "1.778"])
elif self.resolution == "540p":
self.xres, self.yres = 960, 540
rendererspecificargs.extend(["-x", "%s" % self.xres])
rendererspecificargs.extend(["-y", "%s" % self.yres])
rendererspecificargs.extend(["-ard", "1.778"])
elif self.resolution == "108p":
self.xres, self.yres = 192, 108
rendererspecificargs.extend(["-x", "%s" % self.xres])
rendererspecificargs.extend(["-y", "%s" % self.yres])
rendererspecificargs.extend(["-ard", "1.778"])
else:
# dont define the resolutions or aspect - so use what is the file
pass
rendererspecificargs.extend([
"-mem", "4000",
"-v", "4",
"-pad", "4",
#"-of", "%s" % self.outformat,
# the -of flag is fawlty for setting exr
"-skipExistingFrames", "%s" % self.skipframes])
userspecificargs = [
utils.expandargumentstring(self.options),
self.mayascenefilefullpath
]
finalargs = commonargs + rendererspecificargs + userspecificargs
render = author.Command(argv=finalargs,
service="MayaMentalRay",
tags=["maya", "theWholeFarm"],
atmost=int(self.threads),
atleast=int(self.threads),
envkey=["maya{}".format(self.mayaversion)]
)
# thischunk.addCommand(env)
thischunk.addCommand(render)
_chunkstart = _chunkend + 1
_chunkend += self.framechunks
task_render.addChild(thischunk)
task_thisjob.addChild(task_render)
# ############## 4 PROXY ###############
# using nuke as exr colour is handled correctly
if self.makeproxy:
#### using the proxy_run.py script
try:
_directory = "{p}/images/{s}".format( p=self.mayaprojectpath, s=self.mayascenenamebase)
_nuke_envkey = "proxynuke{}".format(config.CurrentConfiguration().nukeversion)
_proxy_runner_cmd = ["proxy_run.py","-s",_directory]
task_proxy = author.Task(title="Proxy Generation", service="NukeRender")
nukecommand = author.Command(argv=_proxy_runner_cmd,
service="NukeRender",
tags=["nuke", "theWholeFarm"],
envkey=[_nuke_envkey])
task_proxy.addCommand(nukecommand)
task_thisjob.addChild(task_proxy)
except Exception, proxyerror:
logger.warn("Cant make a proxy {}".format(proxyerror))
