Template engine (Python)

def onFieldChanged(self,  fieldName, fieldValue, fieldsToChange):
	if fieldName == "MAYAFILENAME":
		basePath = os.path.dirname(fieldValue)
		if basePath.endswith("scenes") and len(basePath) > 6:
			separator = "/";
			if fieldValue.find("\\") != -1: 
				separator = "\\"
			projectPath = basePath[0:len(basePath)-7]
			fieldsToChange.addEvent("MAYAPROJECTPATH",projectPath,MTemplateAPI.MTemplateItemEvent.kTemplateItemFieldsActivationNone)
			fieldsToChange.addEvent("MAYADESTINATION",projectPath + separator + "images",MTemplateAPI.MTemplateItemEvent.kTemplateItemFieldsActivationNone)

The previous code sample is used inside the Maya template to automatically fill the projects and image output path when a user selects the Maya scene.

def onBuildCommandLine(self, platform, job, chunk, clientTemplatePreferences,instanceNum):
	renderCmd = "-r sw"
	renderCmd += " -n " + clientTemplatePreferences['PROCUSAGE']
	renderCmd += " -proj \"" + job.attributeGetString(manager.resolveMappingToJob(self.getID(),"MAYAPROJECTPATH")) + "\""
	if job.attributeIsEnabled(manager.resolveMappingToJob(self.getID(),"MAYADESTINATION")):
		renderCmd += " -rd \"" + job.attributeGetString(manager.resolveMappingToJob(self.getID(),"MAYADESTINATION")) + "\""
	renderCmd += " -s " + '%.3f' % chunk.getStartFrame()
	renderCmd += " -e " + '%.3f' % chunk.getEndFrame()
	renderCmd += " -b " + '%.3f' % chunk.getByFrame()
	renderCmd += " -rfs " + str(chunk.getFrameStart())
	renderCmd += " -rfb " + str(chunk.getFrameStep())
	renderCmd += " -pad " + job.attributeGetString("MAYADIGITS")
	renderCmd += " " + job.attributeGetString("ADD_FLAGS")
	renderCmd += " \"" + job.attributeGetString(manager.resolveMappingToJob(self.getID(),"MAYAFILENAME")) + "\""
	return renderCmd

The previous code sample is used inside the Maya template to create the Mayabatch command line.

def onBuildAdditionalParameters(self, attributes):
	renderCmd = ""
	if (attributes.isEnabled("MM")):
		renderCmd += "-mm " + attributes.getString("MM") + " "
	return renderCmd

The previous code sample is used inside the Maya template to create additional parameters from the attributes previously declared.

def onGetApplicationPath(self,job,clientTemplatePreferences,pathOut ):
	pathOut.setString(clientTemplatePreferences['MAYAEXECUTABLE'])
	return MTemplateAPI.MTemplateError()

The previous code sets the Maya batch process grabbing the value from the MAYAEXECUTABLE field of the client preferences.

def onGetApplicationStartingFolder(self,job,clientTemplatePreferences,pathOut):
	pathOut.setString(clientTemplatePreferences['MAYASTARTINGFOLDER'])
	return MTemplateAPI.MTemplateError()

The previous code sets the Maya starting folder grabbing the value from the MAYASTARTINGFOLDER field of the client preferences.

def onBuildEnvironment(self, job, chunk, clientTemplatePreferences, existingEnvironment):
	environment = existingEnvironment
	platform = MClientAPI.GetPlatform()
	if platform == MClientAPI.kPlatformOSX:
		environment.setValue("DYLD_LIBRARY_PATH","")
	elif platform == MClientAPI.kPlatformLinux:
		environment.setValue("LD_LIBRARY_PATH","")
	return environment

The previous code sample is used inside the Maya template. It grabs the running platform, and resets the library search paths to avoid clashing with the Muster QT distribution by setting new environmental variables.

def onCheckForSubframeAdvancingString(self,line):
	result = re.search(".*(Finished Rendering).*", line)
	if result != None:
		return 1
	return 0

The previous code sample is used inside the Maya template to check for the “Finished rendering” log line to tell Muster that a frame has been completed.

def onCheckForFramesPrefixString(self,line, prefixOut):
	result = re.search(".*Finished Rendering\\s(.*\\.)(\\d+)\\.", line)
	if result != None:
		prefixOut.setString(result.group(1))
		return 1
	return 0

The previous code uses a regular expression to grab the frames prefix from the Maya log and report it back to Muster. Notice the usage of the MStringRef class to set back the value into the prefixOut variable.

The previous code sample is used inside the Maya template to create additional parameters from the attributes previously declared.

def onCheckLogLine(self,job,chunk,clientTemplatePreferences,line):
	abortRendering = job.attributeGetBool("ABORTRENDER")
	if abortRendering and line.find("Error") != -1 :
		error = MTemplateAPI.MTemplateError(1,"Premature render termination. Error keyword found in the log",MTemplateAPI.MTemplateError.kTemplateErrorTypeError)
		error.addErrorAction(MTemplateAPI.MTemplateError.kTemplateErrorAbortRender);
		return error
 
	return MTemplateAPI.MTemplateError()

The previous code checks the Maya output line by line while rendering. If the ABORTRENDER field is enabled, it checks for an “Error” string in the output, and aborts the render before its termination by setting an MTemplateError object according.

def onCheckLog(self,job,chunk,clientTemplatePreferences,log):
	if log.find("Warning") != -1:
		return MTemplateAPI.MTemplateError(2,"Warning keyword found",MTemplateAPI.MTemplateError.kTemplateErrorTypeWarning)
	if log.find("Error") != -1:
		return MTemplateAPI.MTemplateError(1,"Error keyword found",MTemplateAPI.MTemplateError.kTemplateErrorTypeError)
	if log.find("Total Time For Render") == -1:
		return MTemplateAPI.MTemplateError(3,"Missing \"Total Time For Render\" keyword. Batch render may have crashed",MTemplateAPI.MTemplateError.kTemplateErrorTypeWarning)
	if log.find("Total Elapsed Time For Maya") == -1:
		return MTemplateAPI.MTemplateError(3,"Missing \"Total Elapsed Time For Maya\" keyword. Batch render may have crashed",MTemplateAPI.MTemplateError.kTemplateErrorTypeWarning)
	if log.find("completed.") == -1:
		return MTemplateAPI.MTemplateError(3,"Missing \"completed.\" keyword. Batch render may have crashed",MTemplateAPI.MTemplateError.kTemplateErrorTypeWarning)
 
	return MTemplateAPI.MTemplateError()

The previous code sample is used inside the Maya template to parse the output log and check for specific strings. It sets the MTemplateError object according.

def onCheckExitCode(self,job,chunk,clientTemplatePreferences,exitCode):
	if exitCode == 211:
		return MTemplateAPI.MTemplateError(exitCode,"Abnormal render termination",MTemplateAPI.MTemplateError.kTemplateErrorTypeError)
	if exitCode != 0:
		return MTemplateAPI.MTemplateError(exitCode, "%d Exit code different from expected 0 value" % exitCode,MTemplateAPI.MTemplateError.kTemplateErrorTypeWarning)
 
	return MTemplateAPI.MTemplateError()

The previous code sample is used inside the Maya template to check the batch process exit code.

def onApplicationFinder(self,moduleRegExp,moduleTag):
	platform = MClientAPI.GetPlatform()
	''' Search maya.exe '''
	if platform == MClientAPI.kPlatformWindows:
		moduleRegExp.setString("mayabatch.exe")
	elif platform == MClientAPI.kPlatformOSX:
		moduleRegExp.setString("MayaBatch")
	elif platform == MClientAPI.kPlatformLinux:
		moduleRegExp.setString("maya")
	moduleTag.setString("Maya")
	return MTemplateAPI.kTemplateScanModule

The previous code sample is used inside the Maya template to instruct the Services Control panel applet on how to search for Maya inside the filesystem. It returns the MTemplateAPI.kTemplateScanModule to tell Muster that it must search for a specific module inside the file system. Alternatively, it can report kTemplateScanNone to avoid application scanning, or kTemplateScanClass to use the template onFindApplication() function.

def onFindApplication(self, basePath, clientTemplatePreferences):
	basePath.setString("/usr/local/bin/myrender")
	return 1

The previous code sample directly sets the path to the render engine without performing a file system scan.

def onModuleFound(self,moduleExec,modulePath,clientTemplatePreferences):
	platform = MClientAPI.GetPlatform()
	basePath = modulePath.getString()
	if platform == MClientAPI.kPlatformWindows:
		clientTemplatePreferences["MAYAEXECUTABLE"] = basePath + "\\Render.exe"
	elif platform == MClientAPI.kPlatformOSX:
		clientTemplatePreferences["MAYAEXECUTABLE"] = basePath + "/Render"
	elif platform == MClientAPI.kPlatformLinux:
		clientTemplatePreferences["MAYAEXECUTABLE"] = basePath + "/Render"
 
	clientTemplatePreferences["MAYASTARTINGFOLDER"] = basePath
	return 1

The previous code sample is used inside the Maya template to setup the client preferences with the values reported back by the application filesystem scan.

def onGetSlicesInputFilename(self, job, chunk):
	imgFile = job.attributeGetString("output_folder")
	imgFile += os.sep + "Muster_sf_" + '%d' % job.getJobId() + "_" + '%d' % chunk.getChunkId() + "." + job.attributeGetString("source_file_format") + '.%d' % int(job.attributeGetString("start_frame")) 
	return imgFile

The previous code sample is used inside the Maya template to tell Muster the slices filenames and path.

def onGetSlicesOutputFilename(self, job):
	imgFile = job.attributeGetString("output_folder")
	imgFile += os.sep + "final" + "_" + '%d' % job.getJobId() + "." + job.attributeGetString("destination_file_format")
	return imgFile

The previous code sample is used inside the Maya template to tell Muster the output assembled image filename and path.

def onGetSliceBoundaries(self, job, chunk, refBoundaries):
	final_x_res = int(job.attributeGetString("x_res"))
	final_y_res = int(job.attributeGetString("y_res"))
	as_overlap = int(job.attributeGetString("as_overlap"))
	num_slices = job.getPacketSize()
	sliceWidth = int(final_x_res / num_slices);
	sliceNumber = chunk.getChunkId()
	sliceEffectiveWidth = sliceWidth + as_overlap
	if (sliceNumber == num_slices):
		sliceEffectiveWidth = final_x_res - (sliceWidth * (sliceNumber - 1))
 
	refBoundaries.setSliceFrameResolutionX(sliceEffectiveWidth);
	refBoundaries.setSliceFrameResolutionY(final_y_res);
	refBoundaries.setSliceSamplesOriginX(0);
	refBoundaries.setSliceSamplesOriginY(0);
	refBoundaries.setSliceWidth(sliceWidth);
	refBoundaries.setSliceHeight(final_y_res);
	refBoundaries.setFinalPositionX(sliceWidth * (sliceNumber-1));
	refBoundaries.setFinalPositionY(0);

The previous code sample is used inside the Maya template to tell Muster how to expect the slices.

def onStartProcess(self, job, instanceNum, runningProcessPid):

…

def onTerminateProcess(self, job, process, instanceNum):

…

def onChangeProcessPriority(self, job, process, priority instanceNum):

…

def onCheckProcessTermination(self, job, priority instanceNum):

…

def onValidateJobSubmission(self, job, err):
	return 1

The function is invoked when a job requires validation before the submission. This is fired from the Console and/or mrtool before a job submission.

def onDeleteJob(self,job):
	pass

The function is invoked when a job is deleted. This is fired from the Dispatcher, be as fast as possible to avoid stalling the networking thread.

def onSubmitJob(self, job):
	pass

The function is invoked when a job is submitted in the queue. This is fired from the Dispatcher, be as fast as possible to avoid stalling the networking thread.

def onReinitJob(self,job):
	pass

The function is invoked when a job is reset. This is fired from the Dispatcher, be as fast as possible to avoid stalling the networking thread.

def onEditJob(self,job):
	pass

The function is invoked when a job is edited. This is fired from the Dispatcher, be as fast as possible to avoid stalling the networking thread.

def onJobPropertiesChanged(self,job):
	pass

The function is invoked when any of the job parameter is changed live. This is fired from the Dispatcher, be as fast as possible to avoid stalling the networking thread.

def onJobStart(self,job):
	return MTemplateAPI.MTemplateError()

The function is invoked when the job is started. This is fired from the Dispatcher in a new thread, you can take your time inside the function.

def onJobEnd(self,job):
	return MTemplateAPI.MTemplateError()

The function is invoked when the job ends. This is fired form the Dispatcher in a new thread, you can take your time inside the function.

def onChunkStart(self, job, chunk,clientTemplatePreferences,instanceNum):
	return MTemplateAPI.MTemplateError()

The function is invoked when a chunk is started. This is fired from the Render client, you should be as fast as possible to avoid a rendering start timeout.

def onChunkEnd(self, job, chunk,clientTemplatePreferences,instanceNum):
	return MTemplateAPI.MTemplateError()

The function is invoked when a chunk is started. This is fired from the Render client, you should be as fast as possible to avoid stalling the client.

def onCustomMessage(self, instanceId, message):
	print(message);

The function is invoked when an instance sends a custom message.

def onValidateJobDependancies(self, job):
    return MTemplateAPI.kTemplateFunctionFailed # Job is not valid
    return MTemplateAPI.kTemplateFunctionSuccess # Job is valid
    return MTemplateAPI.kTemplateFunctionDoDefault # Perform the default check

The function is invoked by the Dispatcher to check if a job is valid for submission.

def onValidateJobDependancies(self, chunk):
    return MTemplateAPI.kTemplateFunctionFailed # Chunk is not valid
    return MTemplateAPI.kTemplateFunctionSuccess # Chunk is valid
    return MTemplateAPI.kTemplateFunctionDoDefault # Perform the default check

The function is invoked by the Dispatcher to check if a chunk is valid for submission.