function.py

#functions for constraint manager tool
#constraint manager uses matrix math instead of normal cosntraints for a more lightweight setup.
#connected to a user friendly UI
#by thomas dameris

import maya.cmds as cmds
from maya.api.OpenMaya import MMatrix
import maya.api.OpenMaya as om
from functools import partial

#variables
customConstraintName = "test" #any string
constraintType = 2 # point = 0, orient = 1, parent = 2
display = "show"
keepOffset = True

def run_ConstraintManager():
    
    selection = cmds.ls(sl=True)
    if len(selection) < 2:
        return        

    parentObjs = selection[:-1]
    childObj = selection[-1]
    
    # Create or reuse master group
    masterGroup = "custom_constraints_master"
    if not cmds.objExists(masterGroup):
        masterGroup = cmds.group(em=True, n=masterGroup)

    customName = f"{customConstraintName}"
    
    # Call your setup functions per parent
    invParentMatrixHolder, masterWeightAttr, prevSpaceAttr, childShortName = prepareMatrixConstrain(customName, 
        parentObjs, 
        childObj, 
        masterGroup
        )
    
 
    spaceAttrName = matrixConstrain(
        parentObjs, childObj, childShortName,
        constraintType,
        customName, masterGroup, keepOffset,
        invParentMatrixHolder,
        masterWeightAttr
    )
    

    
############################# HELPER FUNCTIONS ###############################


def getOffsetMatrix(parentObj, childObj):
    
    childMatrix = cmds.getAttr(f"{childObj}.worldMatrix[0]")
    parentMatrix = cmds.getAttr(f"{parentObj}.worldInverseMatrix[0]")
    
    #get offset matrix
    offset = MMatrix(childMatrix) * MMatrix(parentMatrix)

    return offset

def matchToWorld(childObj, mm):
    #get current world transforms
    t = cmds.xform(childObj, q=True, ws=True, t=True)
    r = cmds.xform(childObj, q=True, ws=True, ro=True)

    #break connection
    cmds.disconnectAttr(f"{mm}.matrixSum", f"{childObj}.offsetParentMatrix")

    #reset offsetParentMatrix
    identity = [1, 0, 0, 0,
                0, 1, 0, 0,
                0, 0, 1, 0,
                0, 0, 0, 1]
                
    cmds.setAttr(f"{childObj}.offsetParentMatrix", *identity, type="matrix")

    #reapply original transforms
    cmds.xform(childObj, ws=True, t=t)
    cmds.xform(childObj, ws=True, ro=r)

################# IN PROGRESS ########################    

def makeShortName(obj):
    if ":" in obj:
        _, shortName = obj.split(":", 1)

        return shortName
    else:
        shortName = obj
        return shortName
        
def getWorldOffset(masterGroup, childObj, customName):
    worldOffsetHolder = f"{customName}_worldSpace_Holder"
    if not cmds.attributeQuery(worldOffsetHolder, node=masterGroup, exists=True):
        cmds.addAttr(masterGroup, ln = worldOffsetHolder, at = "matrix")
    worldOffset = getOffsetMatrix(masterGroup, childObj)
    cmds.setAttr(f"{masterGroup}.{worldOffsetHolder}", *worldOffset, type = "matrix")
    
    return worldOffset, worldOffsetHolder

def makeHolder(obj, masterGroup):
    matrixHolder = f"{obj}_matrixHolder"
    if not cmds.attributeQuery(matrixHolder, node=masterGroup, exists=True):
        cmds.addAttr(masterGroup, ln = matrixHolder, at = "matrix")
    return matrixHolder            

def matcher(childObj, masterGroup, spaceAttrName):
   
    #get the current transforms of the child object before moving
    t = cmds.xform(childObj, q=True, ws=True, t=True)
    r = cmds.xform(childObj, q=True, ws=True, ro=True)
    print(t, r)

    #read the space index from the master control
    currentSpace = cmds.getAttr(f"{masterGroup}.{spaceAttrName}")
    prevSpace = cmds.getAttr(f"{masterGroup}.prevSpace") 

    #now change the space
    cmds.setAttr(f"{masterGroup}.prevSpace", currentSpace)
    
    #match transforms of where the child was in its previous space
    cmds.xform(childObj, ws=True, t=t)
    cmds.xform(childObj, ws=True, ro=r)


def matcherScriptJob(childObj, masterGroup, spaceAttrName):

    callback = partial(matcher, childObj, masterGroup, spaceAttrName, None)
    jobID = cmds.scriptJob(
        attributeChange=[f"{masterGroup}.{spaceAttrName}", callback],
        parent = masterGroup
    )
    return jobID
    
#################### PREPARE NAMING OF TO BE CONSTRAINED OBJECTS  #####################

def prepareMatrixConstrain(customName, parentObjs, childObj, masterGroup):
    
    
    childShortName = makeShortName(childObj)
    invParentMatrixHolder = makeHolder(childShortName, masterGroup)
    print(childShortName)
    #create master group weight attr
    masterWeightAttr = f"{customName}_Master_Weight"
    prevSpaceAttr = f"{customName}_prevSpace"
    if not cmds.attributeQuery(masterWeightAttr, node=masterGroup, exists = True):
        cmds.addAttr(masterGroup, ln=masterWeightAttr, at="double", min=0, max=1, dv=1, keyable=True)
    if not cmds.attributeQuery(masterWeightAttr, node=masterGroup, exists = True):
        cmds.addAttr(masterGroup, ln=prevSpaceAttr, at="long", dv = 0, keyable = False)
   
    #create group to keep track of what of the previous space for matching
    if not cmds.attributeQuery("prevSpace", node=masterGroup, exists=True):   
        cmds.addAttr(masterGroup, ln=prevSpaceAttr, at="long", dv = 0, keyable = False)
    
    
    return invParentMatrixHolder, masterWeightAttr, prevSpaceAttr, childShortName
    
#################### MATRIX CONSTRAINT MAIN FUNCTIONS #####################

def matrixConstrain(parentObjs, childObj, childShortName, constraintType, customName, masterGroup, keepOffset, invParentMatrixHolder, masterWeightAttr):
    
    #create multmatrix, choice, and blend nodes
    mm = cmds.createNode("multMatrix", n=f"{customName}_{childShortName}_mm")
    offsetMatrixChoice = cmds.createNode("choice", n = f"{customName}_{childShortName}_offsetChoice")
    blendMatrix = cmds.createNode("blendMatrix", n = f"{customName}_{childShortName}_blendMatrix")
    pickMatrix = cmds.createNode("pickMatrix", n = f"{customName}_{childShortName}_pickMatrix")
    
    cmds.setAttr(f"{pickMatrix}.useScale", 0)

    #get !!!child parent inv!!! matrix
    childParentInvMatrix = cmds.getAttr(f"{childObj}.parentInverseMatrix[0]")
    cmds.setAttr(f"{masterGroup}.{invParentMatrixHolder}", *childParentInvMatrix, type = "matrix")
    
    #space list
    enumNames = []
    
    #get individual offsets
    for i, parentObj in enumerate(parentObjs):
        
        #clean name for each parent
        cleanParentName = makeShortName(parentObj)
        
        #connect each parent world matrix into the blendMatrix node 
        cmds.connectAttr(f"{parentObj}.worldMatrix[0]", f"{blendMatrix}.target[{i}].targetMatrix")
    
        #set transform value based on constraint type selection
        cmds.setAttr(f"{blendMatrix}.target[{i}].scaleWeight", 0)
        if constraintType == 0:
            cmds.setAttr(f"{blendMatrix}.target[{i}].rotateWeight", 0)
        elif constraintType == 1:
            cmds.setAttr(f"{blendMatrix}.target[{i}].translateWeight", 0)

        #each parent needs its own offset matrix attr to be fed into the choice
        
        offsetHolder = makeHolder(cleanParentName, masterGroup)
        
        #get offset and plug in
        offset = getOffsetMatrix(parentObj, childObj)
        cmds.setAttr(f"{masterGroup}.{offsetHolder}", *offset, type = "matrix")

        #connect offset holder to offset choice
        cmds.connectAttr(f"{masterGroup}.{offsetHolder}", f"{offsetMatrixChoice}.input[{i}]", force = True)
        
        #add to space list
        enumNames.append(cleanParentName)


    #make world space
    worldOffset, worldOffsetHolder = getWorldOffset(masterGroup, childObj, customName)
    enumNames.append("world_space")
    
    end = len(enumNames) - 1
    cmds.connectAttr(f"{masterGroup}.{worldOffsetHolder}", f"{offsetMatrixChoice}.input[{end}]", force = True)
    cmds.connectAttr(f"{masterGroup}.worldMatrix[0]", f"{blendMatrix}.target[{end}].targetMatrix", force = True)

    #create space list attr from enumNames
    spaceAttr = f"{childShortName}_Space"
    if not cmds.attributeQuery(spaceAttr, node=masterGroup, exists=True):
        enumString = ":".join(enumNames)
        cmds.addAttr(masterGroup, ln = spaceAttr, at = "enum", enumName = enumString, keyable = True)

    #connect matricies to nodes
    cmds.connectAttr(f"{masterGroup}.{masterWeightAttr}",f"{blendMatrix}.envelope")
    cmds.connectAttr(f"{masterGroup}.{spaceAttr}",f"{offsetMatrixChoice}.selector")

    for i, enum in enumerate(enumNames):

        spaceCond = cmds.createNode("condition", name=f"{customName}_{enumNames[i]}_spaceCond")
        cmds.connectAttr(f"{masterGroup}.{spaceAttr}", f"{spaceCond}.firstTerm")
        cmds.setAttr(f"{spaceCond}.secondTerm", i)
        cmds.setAttr(f"{spaceCond}.operation", 0)  
        cmds.setAttr(f"{spaceCond}.colorIfTrueR", 1)
        cmds.setAttr(f"{spaceCond}.colorIfFalseR", 0)
        
        cmds.connectAttr(f"{spaceCond}.outColorR", f"{blendMatrix}.target[{i}].translateWeight", force=True)
        cmds.connectAttr(f"{spaceCond}.outColorR", f"{blendMatrix}.target[{i}].rotateWeight", force=True)
        
    if keepOffset == True:

        cmds.connectAttr(f"{offsetMatrixChoice}.output", f"{pickMatrix}.inputMatrix", force = True)
        cmds.connectAttr(f"{pickMatrix}.outputMatrix", f"{mm}.matrixIn[0]", force = True)


    cmds.connectAttr(f"{blendMatrix}.outputMatrix", f"{mm}.matrixIn[1]", force = True)
    cmds.connectAttr(f"{masterGroup}.{invParentMatrixHolder}",  f"{mm}.matrixIn[2]", force = True)

    
    cmds.connectAttr(f"{mm}.matrixSum", f"{childObj}.offsetParentMatrix")
    
    #reset child transforms to stay in place
    cmds.setAttr(f"{childObj}.translate", 0, 0, 0)
    cmds.setAttr(f"{childObj}.rotate", 0, 0, 0)
    
    print(parentObjs, childObj, masterGroup, offsetMatrixChoice, blendMatrix, invParentMatrixHolder, spaceAttr)
    
    return spaceAttr
  

    jobID = matcherScriptJob(childObj, masterGroup, spaceAttrName)

run_ConstraintManager()