python/api2/py2ViewObjectSetOverride.py

import sys
import maya.api.OpenMaya as om
import maya.api.OpenMayaRender as omr
import maya.api.OpenMayaUI as omui

def maya_useNewAPI():
    """
    The presence of this function tells Maya that the plugin produces, and
    expects to be passed, objects created using the Maya Python API 2.0.
    """

    pass


class ObjectSetSceneRender(omr.MSceneRender):
    def __init__(self, name, setName, clearMask):
        omr.MSceneRender.__init__(self, name)
        self.mSetName = setName
        self.mClearMask = clearMask
        self.mFilterSet = ""
        self.mExcludeFilters = [ ]

    def objectSetOverride(self):
        """
        Return filtered list of items to draw
        """

        list = om.MSelectionList()
        list.add( self.mSetName )
        
        obj = list.getDependNode( 0 )

        set = om.MFnSet( obj )
        self.mFilterSet = set.getMembers( True )

        return self.mFilterSet


    def pluginDisplayFilterExclusions(self):
        """
        The list of displayFilters to exclude
        """
        return self.mExcludeFilters

    def clearOperation(self):
        self.mClearOperation.setMask( self.mClearMask )

        self.mClearOperation.setClearColor( [ 0.0, 0.2, 0.8, 1.0 ] )
        self.mClearOperation.setClearColor2( [ 0.5, 0.4, 0.1, 1.0 ] )
        self.mClearOperation.setClearGradient( True )

        return self.mClearOperation

class viewObjectSetOverride(omr.MRenderOverride):
    """Render override which draws three sets of objects in multiple "passes"
    (MSceneRenders) by using a filtered draw for each pass.

    Additionaly, as a demonstration of how to filter out specific types of
    plugin geometry from each MSceneRender "pass":
    
    "Render Set 1" excludes nodes of type "apiMesh" by using the displayFilter
    named "apiMeshFilter", which is registered by the devkit "apiMeshShape"
    C++ plug-in.
    
    "Render Set 2" excludes nodes of type "footPrint_py" by using the
    displayFilter named "footPrintFilter_py", which is registered by the devkit
    "py2FootPrintNode.py" Python plug-in.
    
    "Render Set 3" excludes nodes of both the "apiMesh" and "footPrint_py"
    types.

    """

    def __init__(self, name ):
        omr.MRenderOverride.__init__(self, name)
        self.mUIName = "(PY) Multi-pass filtered object-set renderer"
        self.mOperation = 0
        
        render1Name = "Render Set 1"
        render2Name = "Render Set 2"
        render3Name = "Render Set 3"

        set1Name = "set1"
        set2Name = "set2"
        set3Name = "set3"

        presentName = "Present Target"

        # Clear and render set 1 (excluding any apiMesh shapes)
        self.mRenderSet1 = ObjectSetSceneRender( render1Name, set1Name, omr.MClearOperation.kClearAll )
        exclusions1 = self.mRenderSet1.pluginDisplayFilterExclusions()
        exclusions1.append( "apiMeshFilter" )

        # Don't clear and render set 2 (excluding any footPrint_py shapes)
        self.mRenderSet2 = ObjectSetSceneRender( render2Name, set2Name, omr.MClearOperation.kClearNone )
        exclusions2 = self.mRenderSet2.pluginDisplayFilterExclusions()
        exclusions2.append( "footPrintFilter_py" )

        # Don't clear and render set 3 (excluding both apiMesh and footPrint_py shapes)
        self.mRenderSet3 = ObjectSetSceneRender( render3Name, set3Name, omr.MClearOperation.kClearNone )
        exclusions3 = self.mRenderSet3.pluginDisplayFilterExclusions()
        exclusions3.append( "apiMeshFilter" )
        exclusions3.append( "footPrintFilter_py" )
        
        # Present results
        self.mPresentTarget = omr.MPresentTarget( presentName ) 

    def __del__(self):
        self.mRenderSet1 = None
        self.mRenderSet2 = None
        self.mRenderSet3 = None
        self.mPresentTarget = None
        
    def supportedDrawAPIs(self):
        # this plugin supports both GL and DX
        return ( omr.MRenderer.kOpenGL | omr.MRenderer.kOpenGLCoreProfile | omr.MRenderer.kDirectX11 )

    def startOperationIterator(self):
        self.mOperation = 0
        return True

    def renderOperation(self):
        match self.mOperation:
            case 0 : 
                return self.mRenderSet1
            case 1 : 
                return self.mRenderSet2
            case 2 : 
                return self.mRenderSet3
            case 3 : 
                return self.mPresentTarget
            case _:
                return None

    def nextRenderOperation(self):
        self.mOperation += 1 
        return self.mOperation < 4

    def uiName(self):
        # UI name to appear as renderer 
        return self.mUIName

viewObjectSetOverrideInstance = None

def initializePlugin(obj):
    """ 
    Register an override
    """
    plugin = om.MFnPlugin(obj, "Autodesk", "1.0", "Any")

    try:
        global viewObjectSetOverrideInstance
        viewObjectSetOverrideInstance = viewObjectSetOverride("py_viewObjectSetOverride")
        omr.MRenderer.registerOverride( viewObjectSetOverrideInstance )
    except:
        sys.stderr.write("registerOverride")
        raise


def uninitializePlugin(obj):
    """ 
    Deregister an override
    """
    plugin = om.MFnPlugin(obj)

    try:
        global viewObjectSetOverrideInstance
        if not viewObjectSetOverrideInstance is None:
            omr.MRenderer.deregisterOverride( viewObjectSetOverrideInstance )
            viewOjectSetOverrideInstance = None

    except:
        sys.stderr.write("deregisterOverride")
        pass