9 from builtins
import object
10 from builtins
import range
12 from OpenGL.GL
import *
13 import maya.api.OpenMayaRender
as omr
14 import maya.api.OpenMayaUI
as omui
15 import maya.api.OpenMaya
as om
19 The presence of this function tells Maya that the plugin produces, and
20 expects to be passed, objects created using the Maya Python API 2.0.
26 kMaya3dSceneRender = 1
27 kMaya3dSceneRenderOpaque = 2
28 kMaya3dSceneRenderTransparent = 3
35 kMaya3dSceneRenderUI = 10
50 def printDrawContextLightInfo(drawContext):
52 considerAllSceneLights = omr.MDrawContext.kFilteredIgnoreLightLimit
53 omr.MRenderer.needEvaluateAllLights()
54 lightCount = drawContext.numberOfActiveLights(considerAllSceneLights)
58 positions = om.MFloatPointArray()
59 position = om.MFloatPoint(0, 0, 0)
60 direction = om.MFloatVector()
64 for i
in range(lightCount):
65 lightParam = drawContext.getLightParameterInformation( i, considerAllSceneLights )
66 if not lightParam
is None:
67 print(
"\tLight " + str(i) +
"\n\t{")
69 for pname
in lightParam.parameterList():
70 ptype = lightParam.parameterType(pname)
71 if ptype == omr.MLightParameterInformation.kBoolean:
72 print(
"\t\tLight parameter " + pname +
". Bool " + str(lightParam.getParameter(pname)))
73 elif ptype == omr.MLightParameterInformation.kInteger:
74 print(
"\t\tLight parameter " + pname +
". Integer " + str(lightParam.getParameter(pname)))
75 elif ptype == omr.MLightParameterInformation.kFloat:
76 print(
"\t\tLight parameter " + pname +
". Float " + str(lightParam.getParameter(pname)))
77 elif ptype == omr.MLightParameterInformation.kFloat2:
78 print(
"\t\tLight parameter " + pname +
". Float " + str(lightParam.getParameter(pname)))
79 elif ptype == omr.MLightParameterInformation.kFloat3:
80 print(
"\t\tLight parameter " + pname +
". Float3 " + str(lightParam.getParameter(pname)))
81 elif ptype == omr.MLightParameterInformation.kFloat4:
82 print(
"\t\tLight parameter " + pname +
". Float4 " + str(lightParam.getParameter(pname)))
83 elif ptype == omr.MLightParameterInformation.kFloat4x4Row:
84 print(
"\t\tLight parameter " + pname +
". Float4x4Row " + str(lightParam.getParameter(pname)))
85 elif ptype == omr.MLightParameterInformation.kFloat4x4Col:
86 print(
"\t\tLight parameter " + pname +
". kFloat4x4Col " + str(lightParam.getParameter(pname)))
87 elif ptype == omr.MLightParameterInformation.kTexture2:
89 print(
"\t\tLight texture parameter " + pname +
". OpenGL texture id = " + str(lightParam.getParameterTextureHandle(pname)))
92 elif ptype == omr.MLightParameterInformation.kSampler:
93 print(
"\t\tLight sampler parameter " + pname +
". filter = " + str(lightParam.getParameter(pname).filter))
94 elif ptype == omr.MLightParameterInformation.kTextureCube:
96 print(
"\t\tLight texture parameter " + pname +
". OpenGL texture id = " + str(lightParam.getParameterTextureHandle(pname)))
103 semantic = lightParam.parameterSemantic(pname)
104 if semantic == omr.MLightParameterInformation.kLightEnabled:
105 print(
"\t\t- Parameter semantic : light enabled")
106 elif semantic == omr.MLightParameterInformation.kWorldPosition:
107 print(
"\t\t- Parameter semantic : world position")
108 floatVals = lightParam.getParameter(pname)
109 position += om.MFloatPoint( floatVals[0], floatVals[1], floatVals[2] )
110 positionCount = positionCount + 1
111 elif semantic == omr.MLightParameterInformation.kWorldDirection:
112 print(
"\t\t- Parameter semantic : world direction")
113 direction = lightParam.getParameter(pname)
114 elif semantic == omr.MLightParameterInformation.kIntensity:
115 print(
"\t\t- Parameter semantic : intensity")
116 elif semantic == omr.MLightParameterInformation.kColor:
117 print(
"\t\t- Parameter semantic : color")
118 color = om.MColor( lightParam.getParameter(pname) )
119 elif semantic == omr.MLightParameterInformation.kEmitsDiffuse:
120 print(
"\t\t- Parameter semantic : emits-diffuse")
121 elif semantic == omr.MLightParameterInformation.kEmitsSpecular:
122 print(
"\t\t- Parameter semantic : emits-specular")
123 elif semantic == omr.MLightParameterInformation.kDecayRate:
124 print(
"\t\t- Parameter semantic : decay rate")
125 elif semantic == omr.MLightParameterInformation.kDropoff:
126 print(
"\t\t- Parameter semantic : drop-off")
127 elif semantic == omr.MLightParameterInformation.kCosConeAngle:
128 print(
"\t\t- Parameter semantic : cosine cone angle")
129 elif semantic == omr.MLightParameterInformation.kShadowMap:
130 print(
"\t\t- Parameter semantic : shadow map")
131 elif semantic == omr.MLightParameterInformation.kShadowSamp:
132 print(
"\t\t- Parameter semantic : shadow map sampler")
133 elif semantic == omr.MLightParameterInformation.kShadowBias:
134 print(
"\t\t- Parameter semantic : shadow map bias")
135 elif semantic == omr.MLightParameterInformation.kShadowMapSize:
136 print(
"\t\t- Parameter semantic : shadow map size")
137 elif semantic == omr.MLightParameterInformation.kShadowViewProj:
138 print(
"\t\t- Parameter semantic : shadow map view projection matrix")
139 elif semantic == omr.MLightParameterInformation.kShadowColor:
140 print(
"\t\t- Parameter semantic : shadow color")
141 elif semantic == omr.MLightParameterInformation.kGlobalShadowOn:
142 print(
"\t\t- Parameter semantic : global shadows on")
143 elif semantic == omr.MLightParameterInformation.kShadowOn:
144 print(
"\t\t- Parameter semantic : local shadows on")
145 elif semantic == omr.MLightParameterInformation.kDepthRange:
146 print(
"\t\t- Parameter semantic : depth range")
149 if positionCount > 1:
150 position /= positionCount
151 print(
"\t\tCompute average position " + str(position))
154 print(
"\t\tSemantic -> Parameter Name Lookups")
155 paramNames = lightParam.parameterNames(omr.MLightParameterInformation.kLightEnabled)
158 floatVals = lightParam.getParameter(omr.MLightParameterInformation.kLightEnabled)
161 print(
"\t\t\tkLightEnabled -> " + str(paramNames) +
" -- " + str(floatVals))
162 paramNames = lightParam.parameterNames(omr.MLightParameterInformation.kWorldPosition)
163 print(
"\t\t\tkWorldPosition -> " + str(paramNames))
164 paramNames = lightParam.parameterNames(omr.MLightParameterInformation.kWorldDirection)
165 print(
"\t\t\tkWorldDirection -> " + str(paramNames))
166 paramNames = lightParam.parameterNames(omr.MLightParameterInformation.kIntensity)
167 print(
"\t\t\tkIntensity -> " + str(paramNames))
168 paramNames = lightParam.parameterNames(omr.MLightParameterInformation.kColor)
169 print(
"\t\t\tkColor -> " + str(paramNames))
170 paramNames = lightParam.parameterNames(omr.MLightParameterInformation.kEmitsDiffuse)
171 print(
"\t\t\tkEmitsDiffuse -> " + str(paramNames))
172 paramNames = lightParam.parameterNames(omr.MLightParameterInformation.kEmitsSpecular)
173 print(
"\t\t\tkEmitsSpecular -> " + str(paramNames))
174 paramNames = lightParam.parameterNames(omr.MLightParameterInformation.kDecayRate)
175 print(
"\t\t\tkDecayRate -> " + str(paramNames))
176 paramNames = lightParam.parameterNames(omr.MLightParameterInformation.kDropoff)
177 print(
"\t\t\tkDropoff -> " + str(paramNames))
178 paramNames = lightParam.parameterNames(omr.MLightParameterInformation.kCosConeAngle)
179 print(
"\t\t\tkCosConeAngle -> " + str(paramNames))
180 paramNames = lightParam.parameterNames(omr.MLightParameterInformation.kIrradianceIn)
181 print(
"\t\t\tkIrradianceIn -> " + str(paramNames))
182 paramNames = lightParam.parameterNames(omr.MLightParameterInformation.kShadowMap)
183 print(
"\t\t\tkShadowMap -> " + str(paramNames))
184 paramNames = lightParam.parameterNames(omr.MLightParameterInformation.kShadowSamp)
185 print(
"\t\t\tkShadowSamp -> " + str(paramNames))
186 paramNames = lightParam.parameterNames(omr.MLightParameterInformation.kShadowBias)
187 print(
"\t\t\tkShadowBias -> " + str(paramNames))
188 paramNames = lightParam.parameterNames(omr.MLightParameterInformation.kShadowMapSize)
189 print(
"\t\t\tkShadowMapSize -> " + str(paramNames))
190 paramNames = lightParam.parameterNames(omr.MLightParameterInformation.kShadowColor)
191 print(
"\t\t\tkShadowColor -> " + str(paramNames))
192 paramNames = lightParam.parameterNames(omr.MLightParameterInformation.kGlobalShadowOn)
193 print(
"\t\t\tkGlobalShadowOn -> " + str(paramNames))
194 paramNames = lightParam.parameterNames(omr.MLightParameterInformation.kShadowOn)
195 print(
"\t\t\tkShadowOn -> " + str(paramNames))
196 paramNames = lightParam.parameterNames(omr.MLightParameterInformation.kDepthRange)
197 print(
"\t\t\tkDepthRange -> " + str(paramNames))
213 def callbackDataPrint(context, renderItemList, shaderInstance):
214 if not shaderInstance
is None:
215 paramNames = shaderInstance.parameterList()
216 paramCount = len(paramNames)
217 print(
"\tSHADER: # of parameters = " + str(paramCount))
218 for i
in range(paramCount):
219 print(
"\t\tPARAM[" + paramNames[i] +
"]")
221 numItems = len(renderItemList)
222 for i
in range(numItems):
223 item = renderItemList[i]
225 path = item.sourceDagPath()
226 print(
"\tRENDER ITEM: '" + item.name() +
"' -- SOURCE: '" + path.fullPathName() +
"'")
228 passCtx = context.getPassContext()
229 passId = passCtx.passIdentifier()
230 passSem = passCtx.passSemantics()
231 print(
"PASS ID[" + passId +
"], PASS SEMANTICS[" + str(passSem) +
"]")
239 def shaderOverrideCallbackBindLightingInfo(drawContext, renderItemList, shaderInstance):
240 if shaderInstance
is None:
245 globalShadowsOn =
False
246 localShadowsOn =
False
247 direction = om.MFloatVector(0.0, 0.0, 1.0)
249 lightColor = [ 0.0, 0.0, 0.0 ]
254 considerAllSceneLights = omr.MDrawContext.kFilteredIgnoreLightLimit
255 omr.MRenderer.needEvaluateAllLights()
256 lightCount = drawContext.numberOfActiveLights(considerAllSceneLights)
258 shadowViewProj = om.MMatrix()
259 shadowResourceTexture =
None
260 samplerDesc = omr.MSamplerStateDesc()
261 shadowColor = [ 0.0, 0.0, 0.0 ]
263 foundDirectional =
False
264 for i
in range(lightCount):
267 globalShadowsOn =
False
268 localShadowsOn =
False
269 direction = om.MFloatVector(0.0, 0.0, 1.0)
271 lightColor = [ 0.0, 0.0, 0.0 ]
273 lightParam = drawContext.getLightParameterInformation( i, considerAllSceneLights )
274 if not lightParam
is None:
275 for pname
in lightParam.parameterList():
276 semantic = lightParam.parameterSemantic( pname )
278 if semantic == omr.MLightParameterInformation.kWorldDirection:
279 floatVals = lightParam.getParameter( pname )
280 direction = om.MFloatVector( floatVals[0], floatVals[1], floatVals[2] )
281 foundDirectional =
True
282 elif semantic == omr.MLightParameterInformation.kIntensity:
283 floatVals = lightParam.getParameter( pname )
284 lightIntensity = floatVals[0]
285 elif semantic == omr.MLightParameterInformation.kColor:
286 lightColor = lightParam.getParameter( pname )
289 elif semantic == omr.MLightParameterInformation.kGlobalShadowOn:
290 intVals = lightParam.getParameter( pname )
292 globalShadowsOn = (intVals[0] != 0)
293 elif semantic == omr.MLightParameterInformation.kShadowOn:
294 intVals = lightParam.getParameter( pname )
296 localShadowsOn = (intVals[0] != 0)
297 elif semantic == omr.MLightParameterInformation.kShadowViewProj:
298 shadowViewProj = lightParam.getParameter( pname )
299 elif semantic == omr.MLightParameterInformation.kShadowMap:
300 shadowResourceTexture = lightParam.getParameter( pname )
301 elif semantic == omr.MLightParameterInformation.kShadowSamp:
302 samplerDesc = lightParam.getParameter( pname )
303 elif semantic == omr.MLightParameterInformation.kShadowColor:
304 shadowColor = lightParam.getParameter( pname )
308 if foundDirectional
and globalShadowsOn
and localShadowsOn
and not shadowResourceTexture
is None:
309 resourceHandle = shadowResourceTexture.resourceHandle()
310 if resourceHandle > 0:
311 debugShadowBindings =
False
313 shaderInstance.setParameter(
"mayaShadowPCF1_shadowMap", shadowResource )
314 if debugShadowBindings:
315 print(
"Bound shadow map to shader param mayaShadowPCF1_shadowMap")
319 shaderInstance.setParameter(
"mayaShadowPCF1_shadowViewProj", shadowViewProj )
320 if debugShadowBindings:
321 print(
"Bound shadow map transform to shader param mayaShadowPCF1_shadowViewProj")
325 shaderInstance.setParameter(
"mayaShadowPCF1_shadowColor", shadowColor )
326 if debugShadowBindings:
327 print(
"Bound shadow map color to shader param mayaShadowPCF1_shadowColor")
331 textureManager = omr.MRenderer.getTextureManager()
332 if not textureManager
is None:
333 textureManager.releaseTexture(shadowResourceTexture)
334 shadowResourceTexture =
None
337 shaderInstance.setParameter(
"mayaDirectionalLight_direction", direction)
338 shaderInstance.setParameter(
"mayaDirectionalLight_intensity", lightIntensity)
339 shaderInstance.setParameter(
"mayaDirectionalLight_color", lightColor)
340 shaderInstance.setParameter(
"mayaShadowPCF1_mayaGlobalShadowOn", globalShadowsOn)
341 shaderInstance.setParameter(
"mayaShadowPCF1_mayaShadowOn", localShadowsOn)
346 def shaderOverridePreDrawCallback(context, renderItemList, shaderInstance):
347 print(
"PRE-draw callback triggered for render item list with data:")
348 callbackDataPrint(context, renderItemList, shaderInstance)
352 printDrawContextLightInfo( context )
358 def shaderOverridePostDrawCallback(context, renderItemList, shaderInstance):
359 print(
"POST-draw callback triggered for render item list with data:")
360 callbackDataPrint(context, renderItemList, shaderInstance)
367 class viewRenderHUDOperation(omr.MHUDRender):
369 omr.MHUDRender.__init__(self)
374 def targetOverrideList(self):
375 if not self.mTargets
is None:
376 return [ self.mTargets[kMyColorTarget], self.mTargets[kMyDepthTarget] ]
379 def hasUIDrawables(self):
382 def addUIDrawables(self, drawManager2D, frameContext):
384 drawManager2D.beginDrawable()
386 drawManager2D.setColor( om.MColor( (0.455, 0.212, 0.596) ) )
388 drawManager2D.setFontSize( omr.MUIDrawManager.kSmallFontSize )
391 dim = frameContext.getViewportDimensions()
396 drawManager2D.text( om.MPoint(w*0.5, h*0.91),
"Sample VP2 Renderer Override", omr.MUIDrawManager.kCenter )
399 viewportInfoText =
"Viewport information: x= "
400 viewportInfoText += str(x)
401 viewportInfoText +=
", y= "
402 viewportInfoText += str(y)
403 viewportInfoText +=
", w= "
404 viewportInfoText += str(w)
405 viewportInfoText +=
", h= "
406 viewportInfoText += str(h)
407 drawManager2D.text( om.MPoint(w*0.5, h*0.885), viewportInfoText, omr.MUIDrawManager.kCenter )
410 drawManager2D.endDrawable()
412 def setRenderTargets(self, targets):
413 self.mTargets = targets
422 class viewRenderPresentTarget(omr.MPresentTarget):
423 def __init__(self, name):
424 omr.MPresentTarget.__init__(self, name)
429 def targetOverrideList(self):
430 if not self.mTargets
is None:
431 return [ self.mTargets[kMyColorTarget], self.mTargets[kMyDepthTarget] ]
434 def setRenderTargets(self, targets):
435 self.mTargets = targets
445 class viewRenderQuadRender(omr.MQuadRender):
448 kPost_EffectMonochrome = 1
449 kPost_EffectEdgeDetect = 2
450 kPost_EffectInvert = 3
457 def __init__(self, name):
458 omr.MQuadRender.__init__(self, name)
461 self.mShaderInstance =
None
465 self.mViewRectangle = om.MFloatPoint()
467 self.mShader = self.kEffectNone
470 if not self.mShaderInstance
is None:
471 shaderMgr = omr.MRenderer.getShaderManager()
472 if not shaderMgr
is None:
473 shaderMgr.releaseShader(self.mShaderInstance)
474 self.mShaderInstance =
None
481 if self.mShaderInstance
is None:
482 shaderMgr = omr.MRenderer.getShaderManager()
483 if not shaderMgr
is None:
496 if self.mShader == self.kPre_MandelBrot:
497 self.mShaderInstance = shaderMgr.getEffectsFileShader(
"MandelBrot",
"" )
498 elif self.mShader == self.kPost_EffectMonochrome:
499 self.mShaderInstance = shaderMgr.getEffectsFileShader(
"FilterMonochrome",
"" )
500 elif self.mShader == self.kPost_EffectEdgeDetect:
501 self.mShaderInstance = shaderMgr.getEffectsFileShader(
"FilterEdgeDetect",
"" )
502 elif self.mShader == self.kPost_EffectInvert:
503 self.mShaderInstance = shaderMgr.getEffectsFileShader(
"Invert",
"" )
504 elif self.mShader == self.kScene_Threshold:
505 self.mShaderInstance = shaderMgr.getEffectsFileShader(
"Threshold",
"" )
506 elif self.mShader == self.kScene_BlurHoriz:
507 self.mShaderInstance = shaderMgr.getEffectsFileShader(
"Blur",
"BlurHoriz" )
508 elif self.mShader == self.kScene_BlurVert:
509 self.mShaderInstance = shaderMgr.getEffectsFileShader(
"Blur",
"BlurVert" )
510 elif self.mShader == self.kSceneBlur_Blend:
511 self.mShaderInstance = shaderMgr.getEffectsFileShader(
"Blend",
"Add" )
518 if not self.mShaderInstance
is None:
519 if self.mShader == self.kPre_MandelBrot:
522 self.mShaderInstance.setParameter(
"gIterate", 50)
524 print(
"Could not change mandelbrot parameter")
527 elif self.mShader == self.kPost_EffectInvert:
531 self.mShaderInstance.setParameter(
"gInputTex", self.mTargets[kMyColorTarget])
533 print(
"Could not set input render target / texture parameter on invert shader")
536 elif self.mShader == self.kScene_Threshold:
540 self.mShaderInstance.setParameter(
"gSourceTex", self.mTargets[kMyColorTarget])
542 print(
"Could not set input render target / texture parameter on threshold shader")
544 self.mShaderInstance.setParameter(
"gBrightThreshold", 0.7 )
546 elif self.mShader == self.kScene_BlurHoriz:
550 self.mShaderInstance.setParameter(
"gSourceTex", self.mTargets[kMyBlurTarget])
552 print(
"Could not set input render target / texture parameter on hblur shader")
555 elif self.mShader == self.kScene_BlurVert:
559 self.mShaderInstance.setParameter(
"gSourceTex", self.mTargets[kMyBlurTarget])
561 print(
"Could not set input render target / texture parameter on vblur shader")
564 elif self.mShader == self.kSceneBlur_Blend:
568 self.mShaderInstance.setParameter(
"gSourceTex", self.mTargets[kMyColorTarget])
574 self.mShaderInstance.setParameter(
"gSourceTex2", self.mTargets[kMyBlurTarget])
577 self.mShaderInstance.setParameter(
"gBlendSrc", 0.3 )
579 elif self.mShader == self.kPost_EffectMonochrome:
583 self.mShaderInstance.setParameter(
"gInputTex", self.mTargets[kMyColorTarget])
585 print(
"Could not set input render target / texture parameter on monochrome shader")
588 elif self.mShader == self.kPost_EffectEdgeDetect:
592 self.mShaderInstance.setParameter(
"gInputTex", self.mTargets[kMyColorTarget])
594 print(
"Could not set input render target / texture parameter on edge detect shader")
596 self.mShaderInstance.setParameter(
"gThickness", 1.0 )
597 self.mShaderInstance.setParameter(
"gThreshold", 0.1 )
599 return self.mShaderInstance
606 def targetOverrideList(self):
607 if not self.mTargets
is None:
609 if self.mShader == self.kScene_Threshold
or self.mShader == self.kScene_BlurHoriz
or self.mShader == self.kScene_BlurVert:
610 return [ self.mTargets[kMyBlurTarget] ]
612 return [ self.mTargets[kMyColorTarget], self.mTargets[kMyDepthTarget] ]
616 def clearOperation(self):
617 clearOp = self.mClearOperation
619 if self.mShader == self.kPre_MandelBrot:
620 clearOp.setClearGradient(
False )
621 clearOp.setMask( omr.MClearOperation.kClearAll )
624 clearOp.setClearGradient(
False )
625 clearOp.setMask( omr.MClearOperation.kClearNone )
628 def setRenderTargets(self, targets):
629 self.mTargets = targets
631 def setShader(self, shader):
632 self.mShader = shader
634 def viewRectangle(self):
635 return self.mViewRectangle
637 def setViewRectangle(self, rect):
638 self.mViewRectangle = rect
646 class simpleViewRenderSceneRender(omr.MSceneRender):
647 def __init__(self, name):
648 omr.MSceneRender.__init__(self, name)
650 self.mViewRectangle = om.MFloatPoint(0.0, 0.0, 1.0, 1.0)
652 def viewportRectangleOverride(self):
654 testRectangleSize =
False
655 if testRectangleSize:
657 self.mViewRectangle = om.MFloatPoint(0.33, 0.10, 0.50, 0.50)
658 return self.mViewRectangle
660 def clearOperation(self):
662 val1 = [ 0.0, 0.2, 0.8, 1.0 ]
663 val2 = [ 0.5, 0.4, 0.1, 1.0 ]
664 clearOp = self.mClearOperation
665 clearOp.setClearColor( val1 )
666 clearOp.setClearColor2( val2 )
667 clearOp.setClearGradient(
True )
677 class viewRenderSceneRender(omr.MSceneRender):
678 def __init__(self, name, sceneFilter, clearMask):
679 omr.MSceneRender.__init__(self, name)
681 self.mSelectionList = om.MSelectionList()
686 self.mCameraOverride = omr.MCameraOverride()
688 self.mViewRectangle = om.MFloatPoint(0.0, 0.0, 1.0, 1.0)
692 self.mShaderOverride =
None
694 self.mSceneFilter = sceneFilter
696 self.mClearMask = clearMask
699 self.mUseShaderOverride =
False
700 self.mUseStockShaderOverride =
False
701 self.mAttachPrePostShaderCallback =
False
702 self.mUseShadowShader =
False
703 self.mOverrideDisplayMode =
True
704 self.mOverrideLightingMode =
False
705 self.mOverrideCullingMode =
False
706 self.mDebugTargetResourceHandle =
False
707 self.mOverrrideM3dViewDisplayMode =
False
708 self.mPrevDisplayStyle = omui.M3dView.kGouraudShaded
709 self.mFilterDrawNothing =
False
710 self.mFilterDrawSelected =
False
711 self.mEnableSRGBWrite =
False
715 if not self.mShaderOverride
is None:
716 shaderMgr = omr.MRenderer.getShaderManager()
717 if not shaderMgr
is None:
718 shaderMgr.releaseShader(self.mShaderOverride)
719 self.mShaderOverride =
None
721 def setRenderTargets(self, targets):
722 self.mTargets = targets
724 def targetOverrideList(self):
725 if not self.mTargets
is None:
726 return [ self.mTargets[kMyColorTarget], self.mTargets[kMyDepthTarget] ]
730 def enableSRGBWrite(self):
731 return self.mEnableSRGBWrite
735 def cameraOverride(self):
736 if len(self.mPanelName) > 0:
737 view = omui.M3dView.getM3dViewFromModelPanel(self.mPanelName)
738 self.mCameraOverride.mCameraPath = view.getCamera()
739 return self.mCameraOverride
741 print(
"\t" + self.mName +
": Query custom scene camera override -- no override set")
746 def renderFilterOverride(self):
747 return self.mSceneFilter
753 def displayModeOverride(self):
754 if self.mOverrideDisplayMode:
755 return ( omr.MSceneRender.kBoundingBox | omr.MSceneRender.kShaded )
756 return omr.MSceneRender.kNoDisplayModeOverride
760 def lightModeOverride(self):
761 if self.mOverrideLightingMode:
762 return omr.MSceneRender.kSelectedLights
763 return omr.MSceneRender.kNoLightingModeOverride
766 def shadowEnableOverride(self):
767 if (self.mSceneFilter & omr.MSceneRender.kRenderShadedItems) == 0:
775 def cullingOverride(self):
776 if self.mOverrideCullingMode:
777 return omr.MSceneRender.kCullBackFaces
778 return omr.MSceneRender.kNoCullingOverride
785 if self.mOverrrideM3dViewDisplayMode:
786 if len(self.mPanelName) > 0:
787 view = omui.M3dView.getM3dViewFromModelPanel(self.mPanelName)
788 self.mPrevDisplayStyle = view.displayStyle();
789 view.setDisplayStyle( omui.M3dView.kGouraudShaded )
795 def postRender(self):
796 if self.mDebugTargetResourceHandle:
800 if not self.mTargets[kMyColorTarget]
is None:
801 colorResourceHandle = self.mTargets[kMyColorTarget].resourceHandle()
802 print(
"\t - Color target resource handle = " + str(colorResourceHandle))
804 if not self.mTargets[kMyDepthTarget]
is None:
805 depthStencilResourceHandle = self.mTargets[kMyDepthTarget].resourceHandle()
806 print(
"\t - Depth target resource handle = " + str(depthStencilResourceHandle))
808 if self.mOverrrideM3dViewDisplayMode:
809 if len(self.mPanelName) > 0:
810 view = omui.M3dView.getM3dViewFromModelPanel(self.mPanelName)
811 view.setDisplayStyle( self.mPrevDisplayStyle )
815 def getObjectTypeExclusions(self):
817 return omr.MFrameContext.kExcludeCameras
828 def objectSetOverride(self):
829 self.mSelectionList.clear()
835 if self.mFilterDrawNothing:
836 return self.mSelectionList
841 if self.mFilterDrawSelected:
842 selList = om.MGlobal.getActiveSelectionList()
843 if selList.length() > 0:
844 iter = om.MItSelectionList(selList)
845 while not iter.isDone():
846 comp = iter.getComponent()
847 self.mSelectionList.add( comp[0], comp[1] )
850 if self.mSelectionList.length() > 0:
851 print(
"\t" + self.name() +
" : Filtering render with active object list")
852 return self.mSelectionList
861 def clearOperation(self):
862 clearOp = self.mClearOperation
863 if (self.mSceneFilter & (omr.MSceneRender.kRenderOpaqueShadedItems | omr.MSceneRender.kRenderTransparentShadedItems | omr.MSceneRender.kRenderUIItems)) != 0:
864 clearOp.setClearGradient(
False)
868 val1 = [ 0.0, 0.2, 0.8, 1.0 ]
869 val2 = [ 0.5, 0.4, 0.1, 1.0 ]
870 clearOp.setClearColor(val1)
871 clearOp.setClearColor2(val2)
872 clearOp.setClearGradient(
True)
874 clearOp.setMask(self.mClearMask)
882 def shaderOverride(self):
883 if self.mUseShaderOverride:
884 if self.mShaderOverride
is None:
885 shaderManager = omr.MRenderer.getShaderManager()
886 if not shaderManager
is None:
889 if not self.mUseStockShaderOverride:
890 if self.mUseShadowShader:
893 preCallBack = shaderOverrideCallbackBindLightingInfo
894 self.mShaderOverride = shaderManager.getEffectsFileShader(
"MayaBlinnDirectionalLightShadow",
"",
None,
True, preCallBack, postCallBack)
897 if self.mAttachPrePostShaderCallback:
898 preCallBack = shaderOverridePreDrawCallback
899 if self.mAttachPrePostShaderCallback:
900 postCallBack = shaderOverridePostDrawCallback
901 self.mShaderOverride = shaderManager.getEffectsFileShader(
"Gooch",
"",
None,
True, preCallBack, postCallBack)
905 if self.mAttachPrePostShaderCallback:
906 preCallBack = shaderOverridePreDrawCallback
907 if self.mAttachPrePostShaderCallback:
908 postCallBack = shaderOverridePostDrawCallback
909 self.mShaderOverride = shaderManager.getStockShader( omr.MShaderManager.k3dBlinnShader, preCallBack, postCallBack)
911 if not self.mShaderOverride
is None:
912 print(
"\t" + self.name() +
" : Set stock shader override " + str(omr.MShaderManager.k3dBlinnShader))
913 diffColor = [0.0, 0.4, 1.0, 1.0]
915 self.mShaderOverride.setParameter(
"diffuseColor", diffColor)
917 print(
"Could not set diffuseColor on shader")
919 return self.mShaderOverride
924 def hasUIDrawables(self):
928 def addPreUIDrawables(self, drawManager, frameContext):
929 drawManager.beginDrawable()
930 drawManager.setColor( om.MColor( (0.1, 0.5, 0.95) ) )
931 drawManager.setFontSize( omr.MUIDrawManager.kSmallFontSize )
932 drawManager.text( om.MPoint( -2, 2, -2 ),
"Pre UI draw test in Scene operation", omr.MUIDrawManager.kRight )
933 drawManager.line( om.MPoint( -2, 0, -2 ), om.MPoint( -2, 2, -2 ) )
934 drawManager.setColor( om.MColor( (1.0, 1.0, 1.0) ) )
935 drawManager.sphere( om.MPoint( -2, 2, -2 ), 0.8,
False )
936 drawManager.setColor( om.MColor( (0.1, 0.5, 0.95, 0.4) ) )
937 drawManager.sphere( om.MPoint( -2, 2, -2 ), 0.8,
True )
938 drawManager.endDrawable()
941 def addPostUIDrawables(self, drawManager, frameContext):
942 drawManager.beginDrawable()
943 drawManager.setColor( om.MColor( (0.05, 0.95, 0.34) ) )
944 drawManager.setFontSize( omr.MUIDrawManager.kSmallFontSize )
945 drawManager.text( om.MPoint( 2, 2, 2 ),
"Post UI draw test in Scene operation", omr.MUIDrawManager.kLeft )
946 drawManager.line( om.MPoint( 2, 0, 2), om.MPoint( 2, 2, 2 ) )
947 drawManager.setColor( om.MColor( (1.0, 1.0, 1.0) ) )
948 drawManager.sphere( om.MPoint( 2, 2, 2 ), 0.8,
False )
949 drawManager.setColor( om.MColor( (0.05, 0.95, 0.34, 0.4) ) )
950 drawManager.sphere( om.MPoint( 2, 2, 2 ), 0.8,
True )
951 drawManager.endDrawable()
954 return self.mPanelName
956 def setPanelName(self, name):
957 self.mPanelName = name
959 def viewRectangle(self):
960 return self.mViewRectangle
962 def setViewRectangle(self, rect):
963 self.mViewRectangle = rect
965 def colorTarget(self):
966 if not self.mTargets
is None:
967 return self.mTargets[kMyColorTarget]
970 def depthTarget(self):
971 if not self.mTargets
is None:
972 return self.mTargets[kMyDepthTarget]
975 def setEnableSRGBWriteFlag(self, val):
976 self.mEnableSRGBWrite = val
978 def enableSRGBWriteFlag(self):
979 return self.mEnableSRGBWrite
989 class MCustomSceneDraw(object):
991 def matrixAsArray(self, matrix):
994 array.append(matrix[i])
998 def drawBounds(self, dagPath, box):
999 matrix = dagPath.inclusiveMatrix()
1003 bottomLeftFront = [ minPt.x, minPt.y, minPt.z ]
1004 topLeftFront = [ minPt.x, maxPt.y, minPt.z ]
1005 bottomRightFront = [ maxPt.x, minPt.y, minPt.z ]
1006 topRightFront = [ maxPt.x, maxPt.y, minPt.z ]
1007 bottomLeftBack = [ minPt.x, minPt.y, maxPt.z ]
1008 topLeftBack = [ minPt.x, maxPt.y, maxPt.z ]
1009 bottomRightBack = [ maxPt.x, minPt.y, maxPt.z ]
1010 topRightBack = [ maxPt.x, maxPt.y, maxPt.z ]
1012 glMatrixMode( GL_MODELVIEW )
1014 glMultMatrixd( self.matrixAsArray(matrix) )
1016 glBegin( GL_LINE_STRIP )
1017 glVertex3dv( bottomLeftFront )
1018 glVertex3dv( bottomLeftBack )
1019 glVertex3dv( topLeftBack )
1020 glVertex3dv( topLeftFront )
1021 glVertex3dv( bottomLeftFront )
1022 glVertex3dv( bottomRightFront )
1023 glVertex3dv( bottomRightBack)
1024 glVertex3dv( topRightBack )
1025 glVertex3dv( topRightFront )
1026 glVertex3dv( bottomRightFront )
1030 glVertex3dv(bottomLeftBack)
1031 glVertex3dv(bottomRightBack)
1033 glVertex3dv(topLeftBack)
1034 glVertex3dv(topRightBack)
1036 glVertex3dv(topLeftFront)
1037 glVertex3dv(topRightFront)
1043 def draw(self, cameraPath, size):
1044 if not cameraPath.isValid:
1048 MDrawTraversal *trav = NULL;
1049 trav = new MSurfaceDrawTraversal;
1054 trav->enableFiltering( true );
1055 trav->setFrustum( cameraPath, width, height );
1056 if (!trav->frustumValid())
1058 delete trav; trav = NULL;
1063 unsigned int numItems = trav->numberOfItems();
1065 for (i=0; i<numItems; i++)
1068 trav->itemPath(i, path);
1072 bool drawIt = false;
1075 // Draw surfaces (polys, nurbs, subdivs)
1077 if ( path.hasFn( MFn::kMesh) ||
1078 path.hasFn( MFn::kNurbsSurface) ||
1079 path.hasFn( MFn::kSubdiv) )
1082 if (trav->itemHasStatus( i, MDrawTraversal::kActiveItem ))
1084 gGLFT->glColor3f( 1.0f, 1.0f, 1.0f );
1086 else if (trav->itemHasStatus( i, MDrawTraversal::kTemplateItem ))
1088 gGLFT->glColor3f( 0.2f, 0.2f, 0.2f );
1092 if (path.hasFn( MFn::kMesh ))
1093 gGLFT->glColor3f( 0.286f, 0.706f, 1.0f );
1094 else if (path.hasFn( MFn::kNurbsSurface))
1095 gGLFT->glColor3f( 0.486f, 0.306f, 1.0f );
1097 gGLFT->glColor3f( 0.886f, 0.206f, 1.0f );
1103 MFnDagNode dagNode(path);
1104 MBoundingBox box = dagNode.boundingBox();
1105 drawBounds( path, box );
1131 class viewRenderUserOperation(omr.MUserRenderOperation):
1132 def __init__(self, name):
1133 omr.MUserRenderOperation.__init__(self, name)
1136 self.mPanelName =
""
1138 self.mCameraOverride = omr.MCameraOverride()
1140 self.mViewRectangle = om.MFloatPoint(0.0, 0.0, 1.0, 1.0)
1142 self.mTargets =
None
1144 self.fEnableSRGBWriteFlag =
False
1146 self.fDrawLabel =
False
1148 self.fUserCameraOverride =
False
1150 self.fDrawBoundingBoxes =
False
1152 self.fDebugDrawContext =
False
1153 self.fDebugLightingInfo =
False
1155 def execute(self, drawContext):
1157 debugPassInformation =
False
1158 if debugPassInformation:
1159 passCtx = drawContext.getPassContext()
1160 passId = passCtx.passIdentifier()
1161 passSem = passCtx.passSemantics()
1162 print(
"viewRenderUserOperation: drawing in pass[" + str(passId) +
"], semantic[" + str(passSem) +
"]")
1169 overrideName = omr.MRenderer.activeRenderOverride()
1170 overrideFunc = omr.MRenderer.findRenderOverride( overrideName )
1174 if self.fDebugLightingInfo:
1175 printDrawContextLightInfo( drawContext )
1179 if self.fDebugDrawContext:
1180 matrix = drawContext.getMatrix(omr.MFrameContext.kWorldMtx)
1181 print(
"World matrix is: " + str(matrix))
1183 viewDirection = drawContext.getTuple(omr.MFrameContext.kViewDirection)
1184 print(
"Viewdirection is: " + str(viewDirection))
1186 box = drawContext.getSceneBox()
1187 print(
"Screen box is: " + str(box))
1188 print(
"\tcenter=" + str(box.center))
1190 vpdim = drawContext.getViewportDimensions()
1191 print(
"Viewport dimension: " + str(vpdim))
1195 if len(self.mPanelName) > 0:
1196 view = omui.M3dView.getM3dViewFromModelPanel(self.mPanelName)
1199 targetSize = drawContext.getRenderTargetSize()
1202 testString =
"Drawing with override: "
1203 testString += overrideFunc.name()
1204 pos = om.MPoint(0.0, 0.0, 0.0)
1205 glColor3f( 1.0, 1.0, 1.0 )
1206 view.drawText( testString, pos )
1210 if self.fDrawBoundingBoxes:
1211 cameraPath = view.getCamera()
1212 userDraw = MCustomSceneDraw()
1213 userDraw.draw( cameraPath, targetSize )
1215 def cameraOverride(self):
1216 if self.fUserCameraOverride:
1217 if len(self.mPanelName) > 0:
1218 view = omui.M3dView.getM3dViewFromModelPanel(self.mPanelName)
1219 self.mCameraOverride.mCameraPath = view.getCamera()
1220 return self.mCameraOverride
1224 def targetOverrideList(self):
1225 if not self.mTargets
is None:
1226 return [ self.mTargets[kMyColorTarget], self.mTargets[kMyDepthTarget] ]
1229 def enableSRGBWrite(self):
1230 return self.fEnableSRGBWriteFlag
1232 def hasUIDrawables(self):
1235 def addUIDrawables(self, drawManager, frameContext):
1236 drawManager.beginDrawable()
1237 drawManager.setColor( om.MColor( (0.95, 0.5, 0.1) ) )
1238 drawManager.text( om.MPoint( 0, 2, 0 ),
"UI draw test in user operation" )
1239 drawManager.line( om.MPoint( 0, 0, 0), om.MPoint( 0, 2, 0 ) )
1240 drawManager.setColor( om.MColor( (1.0, 1.0, 1.0) ) )
1241 drawManager.sphere( om.MPoint( 0, 2, 0 ), 0.8,
False )
1242 drawManager.setColor( om.MColor( (0.95, 0.5, 0.1, 0.4) ) )
1243 drawManager.sphere( om.MPoint( 0, 2, 0 ), 0.8,
True )
1244 drawManager.endDrawable()
1246 def setRenderTargets(self, targets):
1247 self.mTargets = targets
1249 def setEnableSRGBWriteFlag(self, val):
1250 self.fEnableSRGBWriteFlag = val
1252 def panelName(self):
1253 return self.mPanelName
1255 def setPanelName(self, name):
1256 self.mPanelName = name
1258 def viewRectangle(self):
1259 return self.mViewRectangle
1261 def setViewRectangle(self, rect):
1262 self.mViewRectangle = rect
1289 class viewRenderOverride(omr.MRenderOverride):
1290 def __init__(self, name):
1291 omr.MRenderOverride.__init__(self, name)
1295 self.mUIName =
"Sample VP2 Renderer Override"
1298 self.mRenderOperations = []
1299 self.mRenderOperationNames = []
1301 for i
in range(kNumberOfOps):
1302 self.mRenderOperations.append(
None)
1303 self.mRenderOperationNames.append(
"")
1304 self.mCurrentOperation = -1
1307 self.mTargetOverrideNames = []
1308 self.mTargetDescriptions = []
1310 self.mTargetSupportsSRGBWrite = []
1312 for i
in range(kTargetCount):
1313 self.mTargetOverrideNames.append(
"")
1314 self.mTargetDescriptions.append(
None)
1315 self.mTargets.append(
None)
1316 self.mTargetSupportsSRGBWrite.append(
False)
1320 colorFormat = omr.MRenderer.kR8G8B8A8_UNORM
1321 depthFormat = omr.MRenderer.kD24S8
1328 self.mTargetOverrideNames [kMyColorTarget] =
"__viewRenderOverrideCustomColorTarget__"
1329 self.mTargetDescriptions [kMyColorTarget] = omr.MRenderTargetDescription(self.mTargetOverrideNames[kMyColorTarget], 256, 256, sampleCount, colorFormat, 0,
False)
1330 self.mTargets [kMyColorTarget] =
None
1331 self.mTargetSupportsSRGBWrite[kMyColorTarget] =
False
1333 self.mTargetOverrideNames [kMyDepthTarget] =
"__viewRenderOverrideCustomDepthTarget__"
1334 self.mTargetDescriptions [kMyDepthTarget] = omr.MRenderTargetDescription(self.mTargetOverrideNames[kMyDepthTarget], 256, 256, sampleCount, depthFormat, 0,
False)
1335 self.mTargets [kMyDepthTarget] =
None
1336 self.mTargetSupportsSRGBWrite[kMyDepthTarget] =
False
1338 self.mTargetOverrideNames [kMyBlurTarget] =
"__viewRenderOverrideBlurTarget__"
1339 self.mTargetDescriptions [kMyBlurTarget]= omr.MRenderTargetDescription(self.mTargetOverrideNames[kMyBlurTarget], 256, 256, sampleCount, colorFormat, 0,
False)
1340 self.mTargets [kMyBlurTarget] =
None
1341 self.mTargetSupportsSRGBWrite[kMyBlurTarget] =
False
1344 self.mSplitUIDraw =
False
1347 self.mDebugOverride =
False
1350 self.mSimpleRendering =
False
1353 self.mPanelName =
""
1356 targetMgr = omr.MRenderer.getRenderTargetManager()
1359 for i
in range(kTargetCount):
1360 self.mTargetDescriptions[i] =
None
1362 if not self.mTargets[i]
is None:
1363 if not targetMgr
is None:
1364 targetMgr.releaseRenderTarget(self.mTargets[i])
1365 self.mTargets[i] =
None
1372 for i
in range(kNumberOfOps):
1373 self.mRenderOperations[i] =
None
1383 def supportedDrawAPIs(self):
1384 return ( omr.MRenderer.kOpenGL | omr.MRenderer.kDirectX11 | omr.MRenderer.kOpenGLCoreProfile )
1388 def startOperationIterator(self):
1389 self.mCurrentOperation = 0
1393 def renderOperation(self):
1394 if self.mCurrentOperation >= 0
and self.mCurrentOperation < kNumberOfOps:
1395 while self.mRenderOperations[self.mCurrentOperation]
is None:
1396 self.mCurrentOperation = self.mCurrentOperation+1
1397 if self.mCurrentOperation >= kNumberOfOps:
1400 if not self.mRenderOperations[self.mCurrentOperation]
is None:
1401 if self.mDebugOverride:
1402 print(
"\t" + self.name() +
"Queue render operation[" + str(self.mCurrentOperation) +
"] = (" + self.mRenderOperations[self.mCurrentOperation].name() +
")")
1403 return self.mRenderOperations[self.mCurrentOperation]
1407 def nextRenderOperation(self):
1408 self.mCurrentOperation = self.mCurrentOperation + 1
1409 if self.mCurrentOperation < kNumberOfOps:
1416 def updateRenderTargets(self):
1417 if self.mDebugOverride:
1418 print(
"\t" + self.name() +
": Set output render target overrides: color=" + self.mTargetDescriptions[kMyColorTarget].name() +
", depth=" + self.mTargetDescriptions[kMyDepthTarget].name())
1423 targetSize = omr.MRenderer.outputTargetSize()
1424 targetWidth = targetSize[0]
1425 targetHeight = targetSize[1]
1435 for targetId
in range(kTargetCount):
1436 self.mTargetDescriptions[targetId].setWidth( targetWidth )
1437 self.mTargetDescriptions[targetId].setHeight( targetHeight )
1440 colorTargetSupportsSGRBWrite =
False
1442 sDebugSRGBWrite =
False
1444 testUnorderedWriteAccess =
False
1448 targetManager = omr.MRenderer.getRenderTargetManager()
1449 if not targetManager
is None:
1451 if omr.MRenderer.drawAPI() != omr.MRenderer.kOpenGL:
1453 for i
in range(omr.MRenderer.kNumberOfRasterFormats):
1454 if targetManager.formatSupportsSRGBWrite(i):
1455 print(
"Format " + str(i) +
" supports SRGBwrite")
1457 for targetId
in range(kTargetCount):
1460 supportsSRGBWrite =
False
1461 if omr.MRenderer.drawAPI() != omr.MRenderer.kOpenGL:
1462 supportsSRGBWrite = targetManager.formatSupportsSRGBWrite( self.mTargetDescriptions[targetId].rasterFormat() )
1463 self.mTargetSupportsSRGBWrite[targetId] = supportsSRGBWrite
1464 self.mTargetDescriptions[targetId].setAllowsUnorderedAccess( testUnorderedWriteAccess )
1467 if targetId == kMyColorTarget:
1468 colorTargetSupportsSGRBWrite = supportsSRGBWrite
1471 if targetId == kMyColorTarget
or targetId == kMyBlurTarget:
1472 print(
"Color target " + str(targetId) +
" supports sRGB write = " + str(supportsSRGBWrite))
1474 if targetId == kMyDepthTarget:
1475 print(
"Depth target supports sRGB write = " + str(supportsSRGBWrite))
1478 if self.mTargets[targetId]
is None:
1479 self.mTargets[targetId] = targetManager.acquireRenderTarget( self.mTargetDescriptions[targetId] )
1483 self.mTargets[targetId].updateDescription( self.mTargetDescriptions[targetId] )
1485 if testUnorderedWriteAccess
and not self.mTargets[targetId]
is None:
1486 returnDesc = self.mTargets[targetId].targetDescription()
1487 self.mTargetDescriptions[targetId].setAllowsUnorderedAccess( returnDesc.allowsUnorderedAccess() )
1488 print(
"Acquire target[" + returnDesc.name() +
"] with unordered access = " + str(returnDesc.allowsUnorderedAccess()) +
". Should fail if attempting with depth target = " + str(targetId == kMyDepthTarget))
1496 quadOp = self.mRenderOperations[kBackgroundBlit]
1497 if not quadOp
is None:
1498 quadOp.setRenderTargets(self.mTargets)
1500 sceneOp = self.mRenderOperations[kMaya3dSceneRender]
1501 if not sceneOp
is None:
1502 sceneOp.setRenderTargets(self.mTargets)
1503 sceneOp.setEnableSRGBWriteFlag( colorTargetSupportsSGRBWrite )
1505 opaqueSceneOp = self.mRenderOperations[kMaya3dSceneRenderOpaque]
1506 if not opaqueSceneOp
is None:
1507 opaqueSceneOp.setRenderTargets(self.mTargets)
1508 opaqueSceneOp.setEnableSRGBWriteFlag( colorTargetSupportsSGRBWrite )
1510 transparentSceneOp = self.mRenderOperations[kMaya3dSceneRenderTransparent]
1511 if not transparentSceneOp
is None:
1512 transparentSceneOp.setRenderTargets(self.mTargets)
1513 transparentSceneOp.setEnableSRGBWriteFlag( colorTargetSupportsSGRBWrite )
1515 uiSceneOp = self.mRenderOperations[kMaya3dSceneRenderUI]
1516 if not uiSceneOp
is None:
1517 uiSceneOp.setRenderTargets(self.mTargets)
1518 uiSceneOp.setEnableSRGBWriteFlag(
False )
1520 quadOp2 = self.mRenderOperations[kPostOperation1]
1521 if not quadOp2
is None:
1522 quadOp2.setRenderTargets(self.mTargets)
1524 quadOp3 = self.mRenderOperations[kPostOperation2]
1525 if not quadOp3
is None:
1526 quadOp3.setRenderTargets(self.mTargets)
1528 userOp = self.mRenderOperations[kUserOpNumber]
1529 if not userOp
is None:
1530 userOp.setRenderTargets(self.mTargets)
1531 userOp.setEnableSRGBWriteFlag( colorTargetSupportsSGRBWrite )
1533 presentOp = self.mRenderOperations[kPresentOp]
1534 if not presentOp
is None:
1535 presentOp.setRenderTargets(self.mTargets)
1537 thresholdOp = self.mRenderOperations[kThresholdOp]
1538 if not thresholdOp
is None:
1539 thresholdOp.setRenderTargets(self.mTargets)
1541 horizBlur = self.mRenderOperations[kHorizBlurOp]
1542 if not horizBlur
is None:
1543 horizBlur.setRenderTargets(self.mTargets)
1545 vertBlur = self.mRenderOperations[kVertBlurOp]
1546 if not vertBlur
is None:
1547 vertBlur.setRenderTargets(self.mTargets)
1549 blendOp = self.mRenderOperations[kBlendOp]
1550 if not blendOp
is None:
1551 blendOp.setRenderTargets(self.mTargets)
1553 hudOp = self.mRenderOperations[kHUDBlit]
1554 if not hudOp
is None:
1555 hudOp.setRenderTargets(self.mTargets)
1557 return (
not self.mTargets[kMyColorTarget]
is None and not self.mTargets[kMyDepthTarget]
is None and not self.mTargets[kMyBlurTarget]
is None)
1563 def setup(self, destination ):
1564 if self.mDebugOverride:
1565 print(self.name() +
" : Perform setup with panel [" + destination +
"]")
1570 self.mPanelName = destination
1579 if self.mRenderOperations[kPresentOp]
is None:
1582 if self.mSimpleRendering:
1583 self.mSplitUIDraw =
False
1585 self.mRenderOperations[kBackgroundBlit] =
None
1587 self.mRenderOperationNames[kMaya3dSceneRender] =
"__MySimpleSceneRender"
1588 sceneOp = simpleViewRenderSceneRender( self.mRenderOperationNames[kMaya3dSceneRender] )
1589 self.mRenderOperations[kMaya3dSceneRender] = sceneOp
1592 self.mRenderOperations[kMaya3dSceneRenderOpaque] =
None
1593 self.mRenderOperations[kMaya3dSceneRenderTransparent] =
None
1594 self.mRenderOperations[kThresholdOp] =
None
1595 self.mRenderOperations[kHorizBlurOp] =
None
1596 self.mRenderOperations[kVertBlurOp] =
None
1597 self.mRenderOperations[kPostOperation1] =
None
1598 self.mRenderOperations[kPostOperation2] =
None
1599 self.mRenderOperations[kMaya3dSceneRenderUI] =
None
1600 self.mRenderOperations[kUserOpNumber] =
None
1602 self.mRenderOperations[kHUDBlit] = viewRenderHUDOperation()
1603 self.mRenderOperationNames[kHUDBlit] = self.mRenderOperations[kHUDBlit].name()
1605 self.mRenderOperationNames[kPresentOp] =
"__MyPresentTarget"
1606 self.mRenderOperations[kPresentOp] = viewRenderPresentTarget( self.mRenderOperationNames[kPresentOp] )
1607 self.mRenderOperationNames[kPresentOp] = self.mRenderOperations[kPresentOp].name()
1612 rect = om.MFloatPoint(0.0, 0.0, 1.0, 1.0)
1616 self.mRenderOperationNames[kBackgroundBlit] =
"__MyPreQuadRender"
1617 quadOp = viewRenderQuadRender( self.mRenderOperationNames[kBackgroundBlit] )
1618 quadOp.setShader( viewRenderQuadRender.kPre_MandelBrot )
1619 quadOp.setViewRectangle(rect)
1620 self.mRenderOperations[kBackgroundBlit] = quadOp
1632 self.mSplitUIDraw =
True
1633 self.mRenderOperations[kMaya3dSceneRender] =
None
1634 self.mRenderOperations[kMaya3dSceneRenderOpaque] =
None
1635 self.mRenderOperations[kMaya3dSceneRenderTransparent] =
None
1636 self.mRenderOperations[kMaya3dSceneRenderUI] =
None
1637 if self.mSplitUIDraw:
1642 self.mRenderOperationNames[kMaya3dSceneRenderOpaque] =
"__MyStdSceneRenderOpaque"
1643 clearMask = omr.MClearOperation.kClearDepth | omr.MClearOperation.kClearStencil
1644 sceneOp = viewRenderSceneRender( self.mRenderOperationNames[kMaya3dSceneRenderOpaque], omr.MSceneRender.kRenderOpaqueShadedItems, clearMask )
1645 sceneOp.setViewRectangle(rect)
1646 self.mRenderOperations[kMaya3dSceneRenderOpaque] = sceneOp
1649 sDrawTransparent =
True
1650 if sDrawTransparent:
1651 self.mRenderOperationNames[kMaya3dSceneRenderTransparent] =
"__MyStdSceneRenderTransparent"
1652 clearMask = omr.MClearOperation.kClearDepth | omr.MClearOperation.kClearStencil
1654 clearMask = omr.MClearOperation.kClearNone
1655 sceneOp = viewRenderSceneRender( self.mRenderOperationNames[kMaya3dSceneRenderTransparent], omr.MSceneRender.kRenderTransparentShadedItems, clearMask )
1656 sceneOp.setViewRectangle(rect)
1657 self.mRenderOperations[kMaya3dSceneRenderTransparent] = sceneOp
1660 self.mRenderOperationNames[kMaya3dSceneRenderUI] =
"__MyStdSceneRenderUI"
1661 clearMask = omr.MClearOperation.kClearDepth | omr.MClearOperation.kClearStencil
1662 if sDrawOpaque
or sDrawTransparent:
1663 clearMask = omr.MClearOperation.kClearStencil
1664 sceneOp = viewRenderSceneRender( self.mRenderOperationNames[kMaya3dSceneRenderUI], omr.MSceneRender.kRenderUIItems, clearMask )
1665 sceneOp.setViewRectangle(rect)
1666 self.mRenderOperations[kMaya3dSceneRenderUI] = sceneOp
1669 self.mRenderOperationNames[kMaya3dSceneRender] =
"__MyStdSceneRender"
1670 clearMask = omr.MClearOperation.kClearDepth | omr.MClearOperation.kClearStencil
1671 sceneOp = viewRenderSceneRender( self.mRenderOperationNames[kMaya3dSceneRender], omr.MSceneRender.kNoSceneFilterOverride, clearMask )
1672 sceneOp.setViewRectangle(rect)
1673 self.mRenderOperations[kMaya3dSceneRender] = sceneOp
1679 self.mRenderOperationNames[kThresholdOp] =
"__ThresholdColor"
1680 quadThreshold = viewRenderQuadRender( self.mRenderOperationNames[kThresholdOp] )
1681 quadThreshold.setShader( viewRenderQuadRender.kScene_Threshold )
1682 quadThreshold.setViewRectangle(rect)
1683 self.mRenderOperations[kThresholdOp] = quadThreshold
1685 self.mRenderOperationNames[kHorizBlurOp] =
"__HorizontalBlur"
1686 quadHBlur = viewRenderQuadRender( self.mRenderOperationNames[kHorizBlurOp] )
1687 quadHBlur.setShader( viewRenderQuadRender.kScene_BlurHoriz )
1688 quadHBlur.setViewRectangle(rect)
1689 self.mRenderOperations[kHorizBlurOp] = quadHBlur
1691 self.mRenderOperationNames[kVertBlurOp] =
"__VerticalBlur"
1692 quadVBlur = viewRenderQuadRender( self.mRenderOperationNames[kVertBlurOp] )
1693 quadVBlur.setShader( viewRenderQuadRender.kScene_BlurVert )
1694 quadVBlur.setViewRectangle(rect)
1695 self.mRenderOperations[kVertBlurOp] = quadVBlur
1697 self.mRenderOperationNames[kBlendOp] =
"__SceneBlurBlend"
1698 quadBlend = viewRenderQuadRender( self.mRenderOperationNames[kBlendOp] )
1699 quadBlend.setShader( viewRenderQuadRender.kSceneBlur_Blend )
1700 quadBlend.setViewRectangle(rect)
1701 self.mRenderOperations[kBlendOp] = quadBlend
1705 self.mRenderOperationNames[kUserOpNumber] =
"__MyCustomSceneRender"
1706 userOp = viewRenderUserOperation( self.mRenderOperationNames[kUserOpNumber] )
1707 userOp.setViewRectangle(rect)
1708 self.mRenderOperations[kUserOpNumber] = userOp
1710 wantPostQuadOps =
False
1714 self.mRenderOperationNames[kPostOperation1] =
"__PostOperation1"
1715 quadOp2 = viewRenderQuadRender( self.mRenderOperationNames[kPostOperation1] )
1716 quadOp2.setShader( viewRenderQuadRender.kPost_EffectMonochrome )
1717 quadOp2.setViewRectangle(rect)
1719 self.mRenderOperations[kPostOperation1] = quadOp2
1721 self.mRenderOperations[kPostOperation1] =
None
1724 self.mRenderOperationNames[kPostOperation2] =
"__PostOperation2"
1725 quadOp3 = viewRenderQuadRender( self.mRenderOperationNames[kPostOperation2] )
1726 quadOp3.setShader( viewRenderQuadRender.kPost_EffectInvert )
1727 quadOp3.setViewRectangle(rect)
1729 self.mRenderOperations[kPostOperation2] = quadOp3
1731 self.mRenderOperations[kPostOperation2] =
None
1736 self.mRenderOperationNames[kPresentOp] =
"__MyPresentTarget"
1737 self.mRenderOperations[kPresentOp] = viewRenderPresentTarget( self.mRenderOperationNames[kPresentOp] )
1738 self.mRenderOperationNames[kPresentOp] = self.mRenderOperations[kPresentOp].name()
1741 self.mRenderOperations[kHUDBlit] = viewRenderHUDOperation()
1742 self.mRenderOperationNames[kHUDBlit] = self.mRenderOperations[kHUDBlit].name()
1745 if not self.mSimpleRendering:
1747 gotTargets = self.updateRenderTargets()
1751 if not self.mRenderOperations[kMaya3dSceneRender]
is None:
1752 self.mRenderOperations[kMaya3dSceneRender].setPanelName( self.mPanelName )
1753 if not self.mRenderOperations[kMaya3dSceneRenderOpaque]
is None:
1754 self.mRenderOperations[kMaya3dSceneRenderOpaque].setPanelName( self.mPanelName )
1755 if not self.mRenderOperations[kMaya3dSceneRenderTransparent]
is None:
1756 self.mRenderOperations[kMaya3dSceneRenderTransparent].setPanelName( self.mPanelName )
1757 if not self.mRenderOperations[kMaya3dSceneRenderUI]
is None:
1758 self.mRenderOperations[kMaya3dSceneRenderUI].setPanelName( self.mPanelName )
1759 if not self.mRenderOperations[kUserOpNumber]
is None:
1760 self.mRenderOperations[kUserOpNumber].setPanelName( self.mPanelName )
1762 self.mCurrentOperation = -1
1770 if self.mDebugOverride:
1771 print(self.name() +
" : Perform cleanup. panelname=" + self.mPanelName)
1773 quadOp = self.mRenderOperations[kPostOperation1]
1774 if not quadOp
is None:
1775 quadOp.setRenderTargets(
None)
1777 quadOp = self.mRenderOperations[kPostOperation2]
1778 if not quadOp
is None:
1779 quadOp.setRenderTargets(
None)
1782 self.mPanelName =
""
1784 self.mCurrentOperation = -1
1786 def panelName(self):
1787 return self.mPanelName
1789 def setSimpleRendering(self, flag):
1790 self.mSimpleRendering = flag
1796 viewRenderOverrideInstance =
None
1801 def initializePlugin(obj):
1802 plugin = om.MFnPlugin(obj)
1804 global viewRenderOverrideInstance
1805 viewRenderOverrideInstance = viewRenderOverride(
"my_viewRenderOverride" )
1806 omr.MRenderer.registerOverride(viewRenderOverrideInstance)
1808 sys.stderr.write(
"registerOverride\n")
1817 def uninitializePlugin(obj):
1818 plugin = om.MFnPlugin(obj)
1820 global viewRenderOverrideInstance
1821 if not viewRenderOverrideInstance
is None:
1822 omr.MRenderer.deregisterOverride(viewRenderOverrideInstance)
1823 viewRenderOverrideInstance =
None
1825 sys.stderr.write(
"deregisterOverride\n")