def get_frame_per_file_render_arguments(self):
"""
Generates the render arguments for when FramePerFile mode is set to True.
This means that each output frame has an associated scene file with the same frame number.
This is mostly used in Octane 1 before .orbx was a thing.
:return: a list of commandline arguments, and the scene file
"""
render_args = ['-e', '-q']
sceneFile = self.GetPluginInfoEntry("SceneFile")
sceneFile = PathUtils.ToPlatformIndependentPath(
RepositoryUtils.CheckPathMapping(sceneFile))
outputFile = self.CreateOutputFile()
paddingSize = 0
if not self.GetBooleanPluginInfoEntryWithDefault("SingleFile", True):
currPadding = FrameUtils.GetFrameStringFromFilename(sceneFile)
paddingSize = len(currPadding)
if paddingSize > 0:
newPadding = StringUtils.ToZeroPaddedString(
self.GetStartFrame(), paddingSize, False)
sceneFile = FrameUtils.SubstituteFrameNumber(
sceneFile, newPadding)
# Build the new output file name.
if outputFile:
outputFile = PathUtils.ToPlatformIndependentPath(
RepositoryUtils.CheckPathMapping(outputFile))
# Add padding to output file if necessary.
if paddingSize > 0:
outputFile = FrameUtils.SubstituteFrameNumber(
outputFile, newPadding)
outputPath = os.path.dirname(outputFile)
outputFileName, outputExtension = os.path.splitext(outputFile)
outputFile = os.path.join(
outputPath, outputFileName + newPadding + outputExtension)
render_args.extend(['-o', outputFile])
sample = self.GetIntegerPluginInfoEntryWithDefault(
"OverrideSampling", 0)
if sample > 0:
render_args.extend(['-s', str(sample)])
render_target = self.GetPluginInfoEntryWithDefault(
"RenderTargetOCS", "")
if render_target:
render_args.extend(['-t', render_target])
return render_args, sceneFile
def RenderArgument(self):
"""
Builds up the commandline render arguments as a list which then gets transformed into string
:return: a string of commandline arguments
"""
scene_file = self.GetPluginInfoEntry("SceneFile")
scene_file = PathUtils.ToPlatformIndependentPath(
RepositoryUtils.CheckPathMapping(scene_file))
render_args = ['--no-gui']
frame_per_file_mode = self.GetBooleanPluginInfoEntryWithDefault(
"FramePerFileMode", False)
if frame_per_file_mode:
# Octane 1 workflow that's still supported in 2 and onward.
temp_render_args, scene_file = self.get_frame_per_file_render_arguments(
)
render_args.extend(temp_render_args)
else:
render_args.extend(self.get_script_render_arguments())
additional_args = self.GetPluginInfoEntryWithDefault(
"AdditionalArgs", "").strip()
if additional_args:
render_args.append(additional_args)
render_args.extend(self.get_gpu_render_arguments())
render_args.append(scene_file)
return self.quote_cmdline_args(render_args)
def get_script_render_arguments(self):
"""
Generates the render arguments for the octane lua script workflow. Octane 2 and later.
:return: a list of commandline arguments
"""
output_folder = self.GetPluginInfoEntryWithDefault("OutputFolder", "")
output_folder = PathUtils.ToPlatformIndependentPath(
RepositoryUtils.CheckPathMapping(output_folder))
lua_script = os.path.join(self.GetPluginDirectory(),
"DeadlineOctane.lua")
filename_template = self.GetPluginInfoEntryWithDefault(
"FilenameTemplate", "")
file_format = self.GetPluginInfoEntryWithDefault("FileFormat", "png8")
render_target_ocs = self.GetPluginInfoEntryWithDefault(
"RenderTargetOCS", "")
render_target_orbx = self.GetPluginInfoEntryWithDefault(
"RenderTargetORBX", "")
render_target = ""
if render_target_ocs:
render_target = render_target_ocs
elif render_target_orbx:
render_target = render_target_orbx
render_args = [
'-q',
'--script',
lua_script,
'-a',
filename_template,
'-a',
output_folder,
'-a',
file_format,
'-a',
str(self.GetStartFrame()),
'-a',
str(self.GetEndFrame()),
'-a',
render_target,
'--stop-after-script',
]
sample = self.GetIntegerPluginInfoEntryWithDefault(
"OverrideSampling", 0)
if sample > 0:
render_args.extend(['-s', str(sample)])
if render_target:
render_args.extend(['-t', render_target])
return render_args
def renderArgument(self):
renderEngines = {
"V-Ray": "0",
"V-Ray RT": "1",
u"V-Ray RT(OpenCL)": "3",
u"V-Ray RT(CUDA)": "5"
}
sRGBOptions = ["On", "Off"]
displayWindow = self.GetBooleanPluginInfoEntryWithDefault(
"DisplayVFB", False)
autoclose = self.GetBooleanPluginInfoEntryWithDefault(
"AutocloseVFB", True)
displaySRGB = self.GetPluginInfoEntryWithDefault("DisplaySRGB", "On")
# Get the frame information.
startFrame = self.GetStartFrame()
endFrame = self.GetEndFrame()
singleRegionJob = self.IsTileJob()
singleRegionFrame = str(self.GetStartFrame())
singleRegionIndex = self.GetCurrentTaskId()
separateFilesPerFrame = self.GetBooleanPluginInfoEntryWithDefault(
"SeparateFilesPerFrame", False)
regionRendering = self.GetBooleanPluginInfoEntryWithDefault(
"RegionRendering", False)
rtEngine = self.GetPluginInfoEntryWithDefault("VRayEngine", "V-Ray")
rtTimeout = self.GetFloatPluginInfoEntryWithDefault("RTTimeout", 0.00)
rtNoise = self.GetFloatPluginInfoEntryWithDefault("RTNoise", 0.001)
rtSampleLevel = self.GetIntegerPluginInfoEntryWithDefault(
"RTSamples", 0)
# Can't allow it to be interactive or display the image because that would hang the slave
renderarguments = " -scenefile=\"" + self.tempSceneFilename + "\" -interactive=0"
if not displayWindow:
renderarguments += " -display=0" # Default value is 1
else:
if autoclose:
renderarguments += " -autoclose=1" # Default value is 0
renderarguments += " -displaySRGB=%s" % (
sRGBOptions.index(displaySRGB) + 1)
renderarguments += " -rtEngine=%s" % renderEngines[rtEngine.strip()]
if not rtEngine == "V-Ray":
renderarguments += " -rtTimeOut=%s -rtNoise=%s -rtSampleLevel=%s" % (
rtTimeout, rtNoise, rtSampleLevel)
renderarguments += " -frames=" + str(startFrame)
if endFrame > startFrame:
renderarguments += "-" + str(endFrame)
# Set the output path.
outputFile = self.GetPluginInfoEntryWithDefault("OutputFilename",
"").strip()
if outputFile != "":
outputFile = RepositoryUtils.CheckPathMapping(outputFile)
outputFile = PathUtils.ToPlatformIndependentPath(outputFile)
if regionRendering:
outputPath = Path.GetDirectoryName(outputFile)
outputFileName = Path.GetFileNameWithoutExtension(outputFile)
outputExtension = Path.GetExtension(outputFile)
if singleRegionJob:
outputFile = os.path.join(
outputPath, ("_tile%s_" % singleRegionIndex) +
outputFileName + outputExtension)
else:
currTile = self.GetIntegerPluginInfoEntryWithDefault(
"CurrentTile", 1)
outputFile = os.path.join(outputPath,
("_tile%d_" % currTile) +
outputFileName + outputExtension)
renderarguments += " -imgFile=\"" + outputFile + "\""
# Now set the rest of the options.
renderarguments += " -numThreads=" + str(self.GetThreadCount())
width = self.GetIntegerPluginInfoEntryWithDefault("Width", 0)
if width > 0:
renderarguments += " -imgWidth=" + str(width)
height = self.GetIntegerPluginInfoEntryWithDefault("Height", 0)
if height > 0:
renderarguments += " -imgHeight=" + str(height)
if regionRendering:
regionNumString = ""
if singleRegionJob:
regionNumString = str(singleRegionIndex)
#Coordinates In Pixels will always be true when using the common tilerendering code.
if self.GetBooleanPluginInfoEntryWithDefault(
"CoordinatesInPixels", False):
#With the coordinates already being in pixels we do not need to modify the coordinates.
xStart = self.GetIntegerPluginInfoEntryWithDefault(
"RegionXStart" + regionNumString, 0)
xEnd = self.GetIntegerPluginInfoEntryWithDefault(
"RegionXEnd" + regionNumString, 0)
yStart = self.GetIntegerPluginInfoEntryWithDefault(
"RegionYStart" + regionNumString, 0)
yEnd = self.GetIntegerPluginInfoEntryWithDefault(
"RegionYEnd" + regionNumString, 0)
else:
self.LogWarning(
"Using deprecated coordinate system. Please submit new jobs to use the new coordinates system."
)
xStart = round(
self.GetFloatPluginInfoEntryWithDefault(
"RegionXStart" + regionNumString, 0) * width)
xEnd = round(
self.GetFloatPluginInfoEntryWithDefault(
"RegionXEnd" + regionNumString, 0) * width)
yStart = round(
self.GetFloatPluginInfoEntryWithDefault(
"RegionYStart" + regionNumString, 0) * height)
yEnd = round(
self.GetFloatPluginInfoEntryWithDefault(
"RegionYEnd" + regionNumString, 0) * height)
renderarguments += " -region=%d;%d;%d;%d" % (xStart, yStart, xEnd,
yEnd)
disableProgressColor = self.GetBooleanConfigEntryWithDefault(
"DisableProgressColor", False)
if disableProgressColor:
renderarguments += " -DisableProgressColor=0"
renderarguments += " " + self.GetPluginInfoEntryWithDefault(
"CommandLineOptions", "")
yetiSearchPaths = []
searchPathIndex = 0
while True:
searchPath = self.GetPluginInfoEntryWithDefault(
"YetiSearchPath" + str(searchPathIndex),
"").replace("\\", "/")
if not searchPath:
break
yetiSearchPaths.append(
RepositoryUtils.CheckPathMapping(searchPath))
searchPathIndex += 1
if len(yetiSearchPaths) > 0:
oldSearchPath = os.environ.get("PG_IMAGE_PATH")
if oldSearchPath:
yetiSearchPaths.append(oldSearchPath)
yetiSepChar = ":"
if SystemUtils.IsRunningOnWindows():
yetiSepChar = ";"
self.SetProcessEnvironmentVariable(
"PG_IMAGE_PATH", yetiSepChar.join(yetiSearchPaths))
return renderarguments
def PreRenderTasks(self):
self.LogInfo("Starting V-Ray Task")
# Get the scene file to render.
sceneFilename = self.GetPluginInfoEntry("InputFilename")
sceneFilename = RepositoryUtils.CheckPathMapping(sceneFilename)
sceneFilename = PathUtils.ToPlatformIndependentPath(sceneFilename)
# If we're rendering separate files per frame, need to get the vrscene file for the current frame.
separateFilesPerFrame = self.GetBooleanPluginInfoEntryWithDefault(
"SeparateFilesPerFrame", False)
if separateFilesPerFrame:
currPadding = FrameUtils.GetFrameStringFromFilename(sceneFilename)
paddingSize = len(currPadding)
newPadding = StringUtils.ToZeroPaddedString(
self.GetStartFrame(), paddingSize, False)
sceneFilename = sceneFilename.replace(currPadding, newPadding)
# Check if we should be doing path mapping.
slaveInfo = RepositoryUtils.GetSlaveInfo(self.GetSlaveName(), True)
if self.GetBooleanConfigEntryWithDefault(
"EnableVrscenePathMapping",
True) or slaveInfo.IsAWSPortalInstance:
self.LogInfo("Performing path mapping on vrscene file")
tempSceneDirectory = self.CreateTempDirectory(
"thread" + str(self.GetThreadNumber()))
tempSceneFileName = Path.GetFileName(sceneFilename)
self.tempSceneFilename = os.path.join(tempSceneDirectory,
tempSceneFileName)
mappedFiles = set()
filesToMap = [(sceneFilename, os.path.dirname(sceneFilename))]
while filesToMap:
curFile, originalSceneDirectory = filesToMap.pop()
#Include directives normally contain relative paths but just to be safe we must run pathmapping again.
curFile = RepositoryUtils.CheckPathMapping(curFile)
if not os.path.isabs(curFile):
curFile = os.path.join(originalSceneDirectory, curFile)
if not os.path.exists(curFile):
self.LogInfo("The include file %s does not exist." %
curFile)
continue
if os.path.basename(curFile) in mappedFiles:
self.LogInfo(
"The include file %s has already been mapped." %
curFile)
continue
self.LogInfo("Starting to map %s" % curFile)
mappedFiles.add(os.path.basename(curFile))
tempFileName = os.path.join(tempSceneDirectory,
os.path.basename(curFile))
foundFiles = self.map_vrscene_includes_cancelable(
curFile, tempFileName)
newOriginDirectory = os.path.dirname(curFile)
for foundFile in foundFiles:
filesToMap.append((foundFile, newOriginDirectory))
map_files_and_replace_slashes(tempFileName, tempFileName)
if self.IsCanceled():
self.FailRender(
"Received cancel task command from Deadline.")
else:
self.tempSceneFilename = sceneFilename
self.tempSceneFilename = PathUtils.ToPlatformIndependentPath(
self.tempSceneFilename)
def PostRenderTasks(self):
failures = 0
if self.FailWithoutFinishedMessage:
if not self.RenderSuccess: # fail here if Succeed didn't get tripped.
self.FailAERender(
"The composition was not rendered completely. Found NO \"Finished Composition\" notice. To disable this failure if applicable, ensure 'Fail Without Finished Message' is set to False in AE plugin configuration."
)
myRePath = self.getAERenderOnlyFileName()
self.CleanupRenderEngineFile(myRePath)
# Clean up the temp file if we did path mapping on the aepx project file.
if (os.path.splitext(self.TempSceneFilename)[1]
).lower() == ".aepx" and self.GetBooleanConfigEntryWithDefault(
"EnableAepxPathMapping", True):
os.remove(self.TempSceneFilename)
if self.DelayedFailure:
self.FailRender(
"There was an error but the message could not properly be extracted\n"
+ self.FailureMessage)
else:
# Since the output option is only valid when rendering a specific comp, we will only check
# the output size in this case.
comp = self.GetPluginInfoEntryWithDefault("Comp", "")
if comp and not self.MultiMachine:
if self.LocalRendering:
self.LogInfo("Moving output files and folders from " +
self.LocalFilePath + " to " +
self.NetworkFilePath)
self.VerifyAndMoveDirectory(self.LocalFilePath,
self.NetworkFilePath, True, 0)
outputDirectories = self.GetJob().JobOutputDirectories
outputFilenames = self.GetJob().JobOutputFileNames
minSizeInKB = self.GetIntegerPluginInfoEntryWithDefault(
"MinFileSize", 0)
deleteFilesUnderMinSize = self.GetBooleanPluginInfoEntryWithDefault(
"DeleteFilesUnderMinSize", False)
for outputDirectory, outputFilename in zip(
outputDirectories, outputFilenames):
outputFile = os.path.join(outputDirectory, outputFilename)
outputFile = RepositoryUtils.CheckPathMapping(outputFile)
outputFile = PathUtils.ToPlatformIndependentPath(
outputFile)
if outputFile and minSizeInKB > 0:
if outputFile.find("#") >= 0:
frames = range(self.GetStartFrame(),
self.GetEndFrame() + 1)
for frame in frames:
currFile = FrameUtils.ReplacePaddingWithFrameNumber(
outputFile, frame)
failures += self.CheckFileSize(
currFile, minSizeInKB,
deleteFilesUnderMinSize)
else:
failures += self.CheckFileSize(
outputFile, minSizeInKB,
deleteFilesUnderMinSize)
if failures != 0:
self.FailRender(
"There were 1 or more errors with the output")
else:
self.SetProgress(100)
self.SetStatusMessage("Finished Rendering " +
str(self.GetEndFrame() -
self.GetStartFrame() + 1) +
" frames")
else:
self.LogInfo(
"Skipping output file size check because a specific comp isn't being rendered or Multi-Machine rendering is enabled"
)
def PreRenderTasks(self):
self.FailureMessage = ""
self.Framecount = 0
self.PreviousFrameTime = ""
# Reset Slave Status Message between Tasks.
self.SetStatusMessage("")
# Check if we should be doing path mapping.
sceneFilename = RepositoryUtils.CheckPathMapping(
self.GetPluginInfoEntryWithDefault("SceneFile",
self.GetDataFilename()))
if SystemUtils.IsRunningOnMac():
sceneFilename = sceneFilename.replace("\\", "/")
else:
sceneFilename = sceneFilename.replace("/", "\\")
# We can only do path mapping on .aepx files (they're xml files).
if (os.path.splitext(sceneFilename)[1]
).lower() == ".aepx" and self.GetBooleanConfigEntryWithDefault(
"EnableAepxPathMapping", True):
self.LogInfo("Performing path mapping on aepx project file")
tempSceneDirectory = self.CreateTempDirectory(
"thread" + str(self.GetThreadNumber()))
tempSceneFileName = os.path.basename(sceneFilename)
self.TempSceneFilename = os.path.join(tempSceneDirectory,
tempSceneFileName)
if SystemUtils.IsRunningOnMac():
RepositoryUtils.CheckPathMappingInFileAndReplace(
sceneFilename, self.TempSceneFilename,
("\\", "platform=\"Win\""), ("/", "platform=\"MacPOSIX\""))
os.chmod(self.TempSceneFilename,
os.stat(sceneFilename).st_mode)
else:
RepositoryUtils.CheckPathMappingInFileAndReplace(
sceneFilename, self.TempSceneFilename,
("/", "platform=\"MacPOSIX\"", "\\>"),
("\\", "platform=\"Win\"", "/>"))
if SystemUtils.IsRunningOnLinux():
os.chmod(self.TempSceneFilename,
os.stat(sceneFilename).st_mode)
else:
self.TempSceneFilename = sceneFilename
self.TempSceneFilename = PathUtils.ToPlatformIndependentPath(
self.TempSceneFilename)
# Get the path to the text file that forces After Effects to run the English version.
if SystemUtils.IsRunningOnMac():
myDocumentsPath = os.path.join(
Environment.GetFolderPath(Environment.SpecialFolder.Personal),
"Documents/ae_force_english.txt")
else:
myDocumentsPath = os.path.join(
Environment.GetFolderPath(Environment.SpecialFolder.Personal),
"ae_force_english.txt")
# Check if we want to change After Effects to the English version. If we do, create the file.
if self.GetBooleanConfigEntryWithDefault("ForceRenderingEnglish",
False):
try:
self.LogInfo(
"Attempting to create \"%s\" to force After Effects to run in English"
% myDocumentsPath)
open(myDocumentsPath, 'w').close()
except:
self.LogWarning("Failed to create \"%s\" because %s" %
(myDocumentsPath, traceback.format_exc()))
else:
# If we don't want to force the English version, delete the file.
if os.path.isfile(myDocumentsPath):
try:
self.LogInfo(
"Attempting to delete \"%s\" to allow After Effects to run in the user's original language"
% myDocumentsPath)
os.remove(myDocumentsPath)
except:
self.LogWarning("Failed to delete \"%s\" because %s" %
(myDocumentsPath, traceback.format_exc()))
myRePath = self.getAERenderOnlyFileName()
# Check if we want to start After Effects in render engine mode. If we do, create the file. And important delete it later.
if self.GetBooleanConfigEntryWithDefault("ForceRenderEngine", False):
try:
self.LogInfo(
"Attempting to create \"%s\" to force After Effects to run in Render Engine mode"
% myRePath)
open(myRePath, 'w').close()
except:
self.LogWarning("Failed to create \"%s\" because %s" %
(myRePath, traceback.format_exc()))
else:
if self.GetBooleanConfigEntryWithDefault("DeleteRenderEngineFile",
False):
# If we don't want to force in Render Engine mode, delete the file.
if os.path.isfile(myRePath):
try:
self.LogInfo(
"Attempting to delete \"%s\" to allow After Effects to run in the workstation environment"
% myDocumentsPath)
os.remove(myRePath)
except:
self.LogWarning("Failed to delete \"%s\" because %s" %
(myRePath, traceback.format_exc()))
def RenderArgument(self):
version = int(self.GetFloatPluginInfoEntry("Version"))
self.MultiMachine = self.GetBooleanPluginInfoEntryWithDefault(
"MultiMachineMode", False)
if self.MultiMachine:
self.MultiMachineStartFrame = self.GetIntegerPluginInfoEntryWithDefault(
"MultiMachineStartFrame", -1)
self.MultiMachineEndFrame = self.GetIntegerPluginInfoEntryWithDefault(
"MultiMachineEndFrame", -1)
renderarguments = "-project \"" + self.TempSceneFilename + "\""
# See if we're rendering a specific comp. The -s, -e, and -output options are only valid in this case.
comp = self.GetPluginInfoEntryWithDefault("Comp", "")
if comp != "":
self.HandleProgress = True
renderarguments += " -comp \"" + comp + "\""
if self.MultiMachine:
self.LogInfo("Multi Machine Mode enabled")
else:
renderarguments += " -s " + str(self.GetStartFrame())
renderarguments += " -e " + str(self.GetEndFrame())
self.LocalRendering = False
outputFile = self.GetPluginInfoEntryWithDefault("Output",
"").strip()
outputFile = RepositoryUtils.CheckPathMapping(outputFile)
outputFile = PathUtils.ToPlatformIndependentPath(outputFile)
if outputFile != "":
outputDir = os.path.dirname(outputFile)
self.NetworkFilePath = outputDir
if not self.MultiMachine:
self.LocalRendering = self.GetBooleanPluginInfoEntryWithDefault(
"LocalRendering", False)
if self.LocalRendering:
outputDir = self.CreateTempDirectory(
"AfterEffectsOutput")
self.LocalFilePath = outputDir
outputFile = os.path.join(outputDir,
os.path.basename(outputFile))
self.LogInfo(
"Rendering to local drive, will copy files and folders to final location after render is complete"
)
else:
self.LogInfo("Rendering to network drive")
if SystemUtils.IsRunningOnMac():
outputFile = outputFile.replace("\\", "/")
else:
outputFile = outputFile.replace("/", "\\")
self.ValidateFilepath(self.NetworkFilePath)
renderarguments += " -output \"" + outputFile + "\""
else:
self.HandleProgress = False
# Check if we should use the memory management flag.
memoryManagementString = self.GetBooleanPluginInfoEntryWithDefault(
"MemoryManagement", False)
if memoryManagementString:
imageCache = self.GetIntegerPluginInfoEntryWithDefault(
"ImageCachePercentage", 0)
maxMemory = self.GetIntegerPluginInfoEntryWithDefault(
"MaxMemoryPercentage", 0)
if imageCache > 0 and maxMemory > 0:
renderarguments = renderarguments + " -mem_usage " + str(
imageCache) + " " + str(maxMemory)
# Check if we should use the multi-process flag (AE 8 and later).
multiProcessString = self.GetBooleanPluginInfoEntryWithDefault(
"MultiProcess", False)
if multiProcessString:
renderarguments = renderarguments + " -mp"
continueOnMissingFootage = self.GetBooleanPluginInfoEntryWithDefault(
"ContinueOnMissingFootage", False)
if version >= 9 and continueOnMissingFootage:
self.LogInfo("Continuing on missing footage")
renderarguments = renderarguments + " -continueOnMissingFootage"
if self.GetBooleanPluginInfoEntryWithDefault(
"IgnoreMissingEffectReferencesErrors", False):
self.LogInfo("Ignoring missing effect reference errors")
if self.GetBooleanPluginInfoEntryWithDefault(
"IgnoreMissingLayerDependenciesErrors", False):
self.LogInfo("Ignoring missing layer dependency errors")
if self.GetBooleanPluginInfoEntryWithDefault("FailOnWarnings", False):
self.LogInfo("Failing on warning messages")
# Ensure we always enforce StdOut/Err/render progress to be generated.
if version >= 9:
renderarguments += " -v ERRORS_AND_PROGRESS"
renderarguments += " -close DO_NOT_SAVE_CHANGES"
renderarguments += " -sound OFF"
return renderarguments