def __func__(self):
"""
"""
self.ml_joints = cgmMeta.validateObjListArg(self.d_kws['l_joints'],cgmMeta.cgmObject,mayaType='joint',noneValid=False)
self.mi_orientation = cgmValid.simpleOrientation(self.d_kws['orientation'],self._str_funcCombined)
ml_chain = self.ml_joints
for mJoint in ml_chain:
mJoint.__setattr__("r%s"%self.mi_orientation.p_string[2],180)
metaFreezeJointOrientation(ml_chain)
def __func__(self):
"""
"""
self.ml_joints = cgmMeta.validateObjListArg(self.d_kws['l_joints'],
cgmMeta.cgmObject,
mayaType='joint',
noneValid=False)
self.mi_orientation = cgmValid.simpleOrientation(
self.d_kws['orientation'], self._str_funcCombined)
ml_chain = self.ml_joints
for mJoint in ml_chain:
mJoint.__setattr__("r%s" % self.mi_orientation.p_string[2],
180)
metaFreezeJointOrientation(ml_chain)
def _validate(self):
#>> validate ============================================================================
self.mi_obj = cgmMeta.validateObjArg(self.d_kws['objToAttach'],
cgmMeta.cgmObject,
noneValid=False)
self.mi_targetSurface = cgmMeta.validateObjArg(
self.d_kws['targetSurface'], noneValid=False)
self.mi_orientation = VALID.simpleOrientation(
self.d_kws['orientation'])
self._str_funcCombined = self._str_funcCombined + "(%s,%s)" % (
self.mi_obj.p_nameShort, self.mi_targetSurface.p_nameShort)
self.l_shapes = mc.listRelatives(self.mi_targetSurface.mNode,
shapes=True)
if len(self.l_shapes) > 1:
log.debug(
"More than one shape found. Using 0. targetSurface : %s | shapes: %s"
% (self.mi_targetSurface.p_nameShort, self.l_shapes))
self.mi_shape = cgmMeta.validateObjArg(self.l_shapes[0],
cgmMeta.cgmNode,
noneValid=False)
self.b_createControlLoc = VALID.boolArg(
self.d_kws['createControlLoc'],
calledFrom=self._str_funcCombined)
self.b_createUpLoc = VALID.boolArg(
self.d_kws['createUpLoc'], calledFrom=self._str_funcCombined)
self.b_parentToFollowGroup = VALID.boolArg(
self.d_kws['parentToFollowGroup'],
calledFrom=self._str_funcCombined)
self.b_attachControlLoc = VALID.boolArg(
self.d_kws['attachControlLoc'],
calledFrom=self._str_funcCombined)
self.b_connectOffset = VALID.boolArg(
self.d_kws['connectOffset'], calledFrom=self._str_funcCombined)
self.b_pointAttach = VALID.boolArg(
self.d_kws['pointAttach'], calledFrom=self._str_funcCombined)
self.f_offset = VALID.valueArg(self.d_kws['f_offset'],
calledFrom=self._str_funcCombined)
#Get info ============================================================================
self.d_closestInfo = distance.returnClosestPointOnSurfaceInfo(
self.mi_obj.mNode, self.mi_targetSurface.mNode)
self.d_closestInfo = DIST.get_closest_point_data_from_mesh(
self.mi_obj.mNode, self.mi_targetSurface.mNode)
#Running Lists ============================================================================
self.md_return = {}
def _validate(self):
#>> validate ============================================================================
self.mi_obj = cgmMeta.validateObjArg(self.d_kws['objToAttach'],cgmMeta.cgmObject,noneValid=False)
self.mi_targetSurface = cgmMeta.validateObjArg(self.d_kws['targetSurface'],mayaType='nurbsSurface',noneValid=False)
self.mi_orientation = cgmValid.simpleOrientation( self.d_kws['orientation'] )
self._str_funcCombined = self._str_funcCombined + "(%s,%s)"%(self.mi_obj.p_nameShort,self.mi_targetSurface.p_nameShort)
self.l_shapes = mc.listRelatives(self.mi_targetSurface.mNode,shapes=True)
if len(self.l_shapes)>1:
log.debug( "More than one shape found. Using 0. targetSurface : %s | shapes: %s"%(self.mi_targetSurface.p_nameShort,self.l_shapes) )
self.mi_shape = cgmMeta.validateObjArg(self.l_shapes[0],cgmMeta.cgmNode,noneValid=False)
self.b_createControlLoc = cgmValid.boolArg(self.d_kws['createControlLoc'],calledFrom=self._str_funcCombined)
self.b_createUpLoc = cgmValid.boolArg(self.d_kws['createUpLoc'],calledFrom=self._str_funcCombined)
self.b_parentToFollowGroup = cgmValid.boolArg(self.d_kws['parentToFollowGroup'],calledFrom=self._str_funcCombined)
self.b_attachControlLoc = cgmValid.boolArg(self.d_kws['attachControlLoc'],calledFrom=self._str_funcCombined)
self.b_connectOffset = cgmValid.boolArg(self.d_kws['connectOffset'],calledFrom=self._str_funcCombined)
self.b_pointAttach = cgmValid.boolArg(self.d_kws['pointAttach'],calledFrom=self._str_funcCombined)
self.f_offset = cgmValid.valueArg(self.d_kws['f_offset'], calledFrom=self._str_funcCombined)
#Get info ============================================================================
self.d_closestInfo = distance.returnClosestPointOnSurfaceInfo(self.mi_obj.mNode,self.mi_targetSurface.mNode)
#Running Lists ============================================================================
self.md_return = {}
def register(
controlObject=None, #(mObject - None) -- The object to use as a control
typeModifier=None, #(string - None) -- Tag for cgmTypeModifier for naming
copyTransform=None, #(mObject - None) -- Object to copy the transform of for our control object
copyPivot=None, #(mObject - None) -- Object to copy the pivot of for our control object
shapeParentTo=None, #'(mObject - None) -- Object to shape parent our control curve to to use that transform
useShape=None, #'(mObject - None) -- Object to use the curve shape of for our control
setRotateOrder=None, #'(rotateOrder - None) -- Argument for a rotate order to set
autoLockNHide=None, #'(bool - None) -- Try to set lock and hide
mirrorAxis=None, #'(string - None) -- Mirror axis to set - using red9's setup terms
mirrorSide=None, #'(string/int - None) -- Mirror side - using red9's setup terms
makeMirrorable=True, #'(bool - True) -- Setup for mirrorability (using red9) -- implied by other mirror args
addDynParentGroup=False, #'(False) -- Add a dynParent group setup
addExtraGroups=False, #'(int - False) -- Number of nested extra groups desired
addConstraintGroup=False, #'(bool - False) -- If a group just above the control is desired for consraining
freezeAll=False, #'(bool - False) -- Freeze all transforms on the control object
noFreeze=False,
addSpacePivots=False, #'(int - False) -- Number of space pivots to generate and connect
controlType=None, #'(string - None) -- Tag for cgmType
aim=None, #'(string/int - None) -- aim axis to use
up=None, #'(string/int - None) -- up axis to use
out=None, #'(string/int - None) -- out axis to use
makeAimable=None, #'(mObject - False) -- Make object aimable -- implied by aim/up/out):
**kws):
_str_func = 'register'
"""
[{'step':'validate','call':self._validate},
{'step':'Copy Transform','call':self._copyTransform},
{'step':'Shape Parent','call':self._shapeParent},
{'step':'Copy Pivot','call':self._copyPivot},
{'step':'Naming','call':self._naming},
{'step':'Aim Setup','call':self._aimSetup},
{'step':'Rotate Order','call':self._rotateOrder},
{'step':'Initial Freeze','call':self._initialFreeze},
{'step':'Groups Setup','call':self._groupsSetup},
{'step':'Space Pivot','call':self._spacePivots},
{'step':'Mirror Setup','call':self._mirrorSetup},
{'step':'Freeze','call':self._freeze},
{'step':'Mirror Attribute Bridges','call':self._mirrorAttributeBridges_},
{'step':'lock N Hide','call':self._lockNHide},
{'step':'Return build','call':self._returnBuild}]
"""
try:
#Validate ================================================================================================
mi_control = cgmMeta.validateObjArg(controlObject,
'cgmControl',
setClass=True)
str_mirrorAxis = VALID.stringArg(mirrorAxis, calledFrom=_str_func)
str_mirrorSide = cgmGeneral.verify_mirrorSideArg(
mirrorSide) #VALID.stringArg(mirrorSide,calledFrom = _str_func)
b_makeMirrorable = VALID.boolArg(makeMirrorable, calledFrom=_str_func)
_addMirrorAttributeBridges = kws.get('addMirrorAttributeBridges',
False)
addForwardBack = kws.get('addForwardBack', False)
if _addMirrorAttributeBridges:
if type(_addMirrorAttributeBridges) not in [list, tuple]:
raise ValueError, "[Bad addMirrorAttributeBridge arg]{arg: %s}" % _addMirrorAttributeBridge
for i, l in enumerate(_addMirrorAttributeBridges):
if type(l) not in [list, tuple]:
raise ValueError, "[Bad addMirrorAttributeBridge arg: %s]{arg: %s}" % (
i, l)
# Running lists ------------------------------------------------------------------------------------------
ml_groups = [] #Holder for groups
ml_constraintGroups = []
ml_spacePivots = []
#Copy Transform ================================================================================================
if copyTransform is not None:
mTarget = cgmMeta.validateObjArg(copyTransform,
'cgmObject',
noneValid=True)
if not mTarget:
raise StandardError, "Failed to find suitable copyTransform object: '%s" % copyTransform
#Need to move this to default cgmNode stuff
mBuffer = mi_control
i_newTransform = cgmMeta.cgmObject(
rigging.groupMeObject(mTarget.mNode, False))
for a in mc.listAttr(mi_control.mNode, userDefined=True):
ATTR.copy_to(mi_control.mNode, a, i_newTransform.mNode)
curves.parentShapeInPlace(i_newTransform.mNode,
mi_control.mNode) #Parent shape
i_newTransform.parent = mi_control.parent #Copy parent
mi_control = cgmMeta.asMeta(i_newTransform,
'cgmControl',
setClass=True)
mc.delete(mBuffer.mNode)
#ShapeParent ================================================================================================
if shapeParentTo:
i_target = cgmMeta.validateObjArg(shapeParentTo, 'cgmObject')
CORERIG.shapeParent_in_place(i_target.mNode, mi_control.mNode)
i_target = cgmMeta.asMeta(i_target, 'cgmControl', setClass=True)
#mi_control.delete()
mi_control = i_target #replace the control with the joint
if useShape is not None:
i_shape = cgmMeta.validateObjArg(useShape,
cgmMeta.cgmObject,
mayaType='nurbsCurve')
curves.parentShapeInPlace(mi_control.mNode, i_shape.mNode)
#Copy Pivot ============================================================================================
if copyPivot is not None:
if issubclass(type(copyPivot), cgmMeta.cgmNode):
i_target = copyPivot
elif mc.objExists(copyPivot):
i_target = cgmMeta.cgmObject(copyPivot)
else:
raise StandardError, "Failed to find suitable copyTransform object: '%s" % copyPivot
#Need to move this to default cgmNode stuff
mi_control.doCopyPivot(i_target.mNode)
#Naming ============================================================================================
mi_control.addAttr('cgmType', 'controlAnim', lock=True)
if typeModifier is not None:
mi_control.addAttr('cgmTypeModifier', str(typeModifier), lock=True)
mi_control.doName() #mi_control.doName(nameShapes=True)
#Rotate Order ============================================================================================
_rotateOrder = False
if setRotateOrder is not None:
_rotateOrder = setRotateOrder
elif controlType in __d_rotateOrderDefaults__.keys():
_rotateOrder = __d_rotateOrderDefaults__[controlType]
elif mi_control.getAttr('cgmName') in __d_rotateOrderDefaults__.keys():
_rotateOrder = __d_rotateOrderDefaults__[mi_control.getAttr(
'cgmName')]
else:
log.debug("|{0}| >> Rotate order not set on: {1}".format(
_str_func, mi_control.p_nameShort))
#Set it ---------------------------------------------------------------
if _rotateOrder:
mRotateOrder = VALID.simpleOrientation(_rotateOrder)
#dictionary.validateRotateOrderString(_rotateOrder)
mc.xform(mi_control.mNode, rotateOrder=mRotateOrder.p_string)
#Initial Freeze ============================================================================================
if freezeAll:
mc.makeIdentity(mi_control.mNode, apply=True, t=1, r=1, s=1, n=0)
#Groups ============================================================================================
if addDynParentGroup or addSpacePivots or mi_control.getAttr(
'cgmName') == 'cog' or _addMirrorAttributeBridges:
mi_control.addAttr('________________',
attrType='int',
keyable=False,
hidden=False,
lock=True)
ATTR.reorder(mi_control.mNode, '________________', top=True)
#Aim Setup ============================================================================================
if aim is not None or up is not None or makeAimable:
mi_control._verifyAimable()
#First our master group:
i_masterGroup = (cgmMeta.asMeta(mi_control.doGroup(True),
'cgmObject',
setClass=True))
i_masterGroup.doStore('cgmName', mi_control)
i_masterGroup.addAttr('cgmTypeModifier', 'master', lock=True)
i_masterGroup.doName()
mi_control.connectChildNode(i_masterGroup, 'masterGroup', 'groupChild')
if addDynParentGroup:
i_dynGroup = (cgmMeta.cgmObject(mi_control.doGroup(True)))
i_dynGroup = cgmRigMeta.cgmDynParentGroup(dynChild=mi_control,
dynGroup=i_dynGroup)
i_dynGroup.doName()
"""
i_zeroGroup = (cgmMeta.cgmObject(mi_control.doGroup(True)))
i_zeroGroup.addAttr('cgmTypeModifier','zero',lock=True)
i_zeroGroup.doName()
mi_control.connectChildNode(i_zeroGroup,'zeroGroup','groupChild')"""
if addExtraGroups:
for i in range(addExtraGroups):
i_group = (cgmMeta.asMeta(mi_control.doGroup(True),
'cgmObject',
setClass=True))
if type(
addExtraGroups
) == int and addExtraGroups > 1: #Add iterator if necessary
i_group.addAttr('cgmIterator', str(i + 1), lock=True)
i_group.doName()
ml_groups.append(i_group)
mi_control.msgList_connect("extraGroups", ml_groups, 'groupChild')
if addConstraintGroup: #ConstraintGroups
i_constraintGroup = (cgmMeta.asMeta(mi_control.doGroup(True),
'cgmObject',
setClass=True))
i_constraintGroup.addAttr('cgmTypeModifier',
'constraint',
lock=True)
i_constraintGroup.doName()
ml_constraintGroups.append(i_constraintGroup)
mi_control.connectChildNode(i_constraintGroup, 'constraintGroup',
'groupChild')
#Space Pivot ============================================================================================
if addSpacePivots:
parent = mi_control.getMessage('masterGroup')[0]
for i in range(int(addSpacePivots)):
#i_pivot = rUtils.create_spaceLocatorForObject(mi_control.mNode,parent)
i_pivot = SPACEPIVOTS.create(mi_control.mNode, parent)
ml_spacePivots.append(i_pivot)
#log.info("spacePivot created: {0}".format(i_pivot.p_nameShort))
#Mirror Setup ============================================================================================
if str_mirrorSide is not None or b_makeMirrorable:
for mObj in [mi_control] + ml_spacePivots:
mi_control._verifyMirrorable()
l_enum = cgmMeta.cgmAttr(mi_control, 'mirrorSide').p_enum
if str_mirrorSide in l_enum:
#log.debug("|{0}| >> Rotate order not set on: {1}".format(_str_func,mi_control.p_nameShort))
#log.debug("%s >> %s >> found in : %s"%(_str_funcCombined, "mirrorSetup", l_enum))
mi_control.mirrorSide = l_enum.index(str_mirrorSide)
if str_mirrorAxis:
mi_control.mirrorAxis = str_mirrorAxis
for mObj in mi_control.msgList_get('spacePivots'):
mObj._verifyMirrorable()
mi_control.doConnectOut('mirrorAxis',
mObj.mNode + '.mirrorAxis')
mi_control.doConnectOut('mirrorSide',
mObj.mNode + '.mirrorSide')
#cgmMeta.cgmAttr(mObj,'mirrorSide').doConnectIn(mi_control,'mirrorSide')
#cgmMeta.cgmAttr(mi_control,'mirrorAxis').doCopyTo(mObj,connectTargetToSource = 1)
#ATTR.connect(mObj.mNode + '.mirrorAxis',"{0}.mirrorAxis".format(mi_control.mNode))
#ATTR.connect(mObj.mNode + 'mirrorSide',"{0}.mirrorSide".format(mi_control.mNode))
#Freeze ============================================================================================
if not shapeParentTo and noFreeze is not True:
if not freezeAll:
if mi_control.getAttr(
'cgmName'
) == 'cog' or controlType in __l_fullFreezeTypes__:
mc.makeIdentity(mi_control.mNode,
apply=True,
t=1,
r=1,
s=1,
n=0)
else:
mc.makeIdentity(mi_control.mNode,
apply=True,
t=1,
r=0,
s=1,
n=0)
else:
mc.makeIdentity(mi_control.mNode,
apply=True,
t=1,
r=1,
s=1,
n=0)
#Mirror attriubte Bridges ==========================================================================
if addForwardBack:
mPlug_forwardBackDriver = cgmMeta.cgmAttr(mi_control,
"forwardBack",
attrType='float',
keyable=True)
try:
mPlug_forwardBackDriven = cgmMeta.validateAttrArg(
[mi_control, addForwardBack])['mi_plug']
except Exception, error:
raise StandardError, "push pull driver | %s" % (error)
if str_mirrorSide.lower() == 'right':
arg_forwardBack = "%s = -%s" % (
mPlug_forwardBackDriven.p_combinedShortName,
mPlug_forwardBackDriver.p_combinedShortName)
else:
arg_forwardBack = "%s = %s" % (
mPlug_forwardBackDriven.p_combinedShortName,
mPlug_forwardBackDriver.p_combinedShortName)
mPlug_forwardBackDriven.p_locked = True
mPlug_forwardBackDriven.p_hidden = True
mPlug_forwardBackDriven.p_keyable = False
NodeF.argsToNodes(arg_forwardBack).doBuild()
if _addMirrorAttributeBridges:
for l_bridge in _addMirrorAttributeBridges:
_attrName = VALID.stringArg(l_bridge[0])
_attrToBridge = VALID.stringArg(l_bridge[1])
if not mi_control.hasAttr(_attrToBridge):
raise StandardError, "['%s' lacks the bridge attr '%s']" % (
mi_control.p_nameShort, _attrToBridge)
mPlug_attrBridgeDriver = cgmMeta.cgmAttr(mi_control,
_attrName,
attrType='float',
keyable=True)
try:
mPlug_attrBridgeDriven = cgmMeta.validateAttrArg(
[mi_control, _attrToBridge])['mi_plug']
except Exception, error:
raise StandardError, "[validate control attribute bridge attr]{%s}" % (
error)
if str_mirrorSide.lower() == 'right':
arg_attributeBridge = "%s = -%s" % (
mPlug_attrBridgeDriven.p_combinedShortName,
mPlug_attrBridgeDriver.p_combinedShortName)
else:
arg_attributeBridge = "%s = %s" % (
mPlug_attrBridgeDriven.p_combinedShortName,
mPlug_attrBridgeDriver.p_combinedShortName)
mPlug_attrBridgeDriven.p_locked = True
mPlug_attrBridgeDriven.p_hidden = True
mPlug_attrBridgeDriven.p_keyable = False
NodeF.argsToNodes(arg_attributeBridge).doBuild()
def ribbon_seal(
driven1=None,
driven2=None,
influences1=None,
influences2=None,
msgDriver=None, #...msgLink on joint to a driver group for constaint purposes
extendEnds=False,
loftAxis='z',
orientation='zyx',
secondaryAxis='y+',
baseName=None,
baseName1=None,
baseName2=None,
connectBy='constraint',
sectionSpans=1,
settingsControl=None,
specialMode=None,
sealSplit=False,
sealDriver1=None,
sealDriver2=None,
sealDriverMid=None,
sealName1='left',
sealName2='right',
sealNameMid='center',
maxValue=10.0,
moduleInstance=None,
parentGutsTo=None):
try:
_str_func = 'ribbon_seal'
ml_rigObjectsToConnect = []
md_drivers = {}
md_base = {}
md_seal = {}
md_blend = {}
md_follicles = {}
md_follicleShapes = {}
d_dat = {1: {}, 2: {}}
if msgDriver:
ml_missingDrivers = []
def check_msgDriver(mObj):
mDriver = mObj.getMessageAsMeta(msgDriver)
if mDriver:
md_drivers[mObj] = mDriver
else:
log.error("|{0}| >> Missing driver: {1}".format(
_str_func, mObj))
ml_missingDrivers.append(mObj)
return False
#>>> Verify ===================================================================================
log.debug("|{0}| >> driven1 [Check]...".format(_str_func))
d_dat[1]['driven'] = cgmMeta.validateObjListArg(driven1,
mType='cgmObject',
mayaType=['joint'],
noneValid=False)
log.debug("|{0}| >> driven2 [Check]...".format(_str_func))
d_dat[2]['driven'] = cgmMeta.validateObjListArg(driven2,
mType='cgmObject',
mayaType=['joint'],
noneValid=False)
#Check our msgDrivers -----------------------------------------------------------
if msgDriver:
log.debug("|{0}| >> msgDriver [Check]...".format(_str_func))
for mObj in d_dat[1]['driven'] + d_dat[2]['driven']:
if mObj not in ml_missingDrivers:
check_msgDriver(mObj)
if ml_missingDrivers:
raise ValueError, "Missing drivers. See errors."
log.debug("|{0}| >> msgDriver [Pass]...".format(_str_func))
d_dat[1]['int_driven'] = len(d_dat[1]['driven'])
d_dat[2]['int_driven'] = len(d_dat[2]['driven'])
log.debug("|{0}| >> Driven lengths {1} | {2}".format(
_str_func, d_dat[1]['int_driven'], d_dat[2]['int_driven']))
log.debug("|{0}| >> influences1 [Check]...".format(_str_func))
d_dat[1]['mInfluences'] = cgmMeta.validateObjListArg(
influences1,
mType='cgmObject',
mayaType=['joint'],
noneValid=False)
log.debug("|{0}| >> influences2 [Check]...".format(_str_func))
d_dat[2]['mInfluences'] = cgmMeta.validateObjListArg(
influences2,
mType='cgmObject',
mayaType=['joint'],
noneValid=False)
d_dat[1]['int_influences'] = len(d_dat[1]['mInfluences'])
d_dat[2]['int_influences'] = len(d_dat[2]['mInfluences'])
log.debug("|{0}| >> Influence lengths {1} | {2}".format(
_str_func, d_dat[1]['int_influences'], d_dat[2]['mInfluences']))
mi_mayaOrientation = VALID.simpleOrientation(orientation)
str_orientation = mi_mayaOrientation.p_string
str_secondaryAxis = VALID.stringArg(secondaryAxis, noneValid=True)
if specialMode and specialMode not in [
'noStartEnd', 'endsToInfluences'
]:
raise ValueError, "Unknown special mode: {0}".format(specialMode)
#module -----------------------------------------------------------------------------------------------
mModule = cgmMeta.validateObjArg(moduleInstance, noneValid=True)
#try:mModule.isModule()
#except:mModule = False
mi_rigNull = False
if mModule:
log.debug("|{0}| >> mModule [Check]...".format(_str_func))
mi_rigNull = mModule.rigNull
if str_baseName is None:
str_baseName = mModule.getPartNameBase() #Get part base name
if not baseName: baseName = 'testRibbonSeal'
if not baseName1: baseName1 = 'ribbon1'
if not baseName2: baseName2 = 'ribbon2'
d_check = {
'driven1': d_dat[1]['int_driven'],
'driven2': d_dat[2]['int_driven']
}
for k, i in d_check.iteritems():
if i < 3:
raise ValueError, "needs at least three driven. Found : {0} | {1}".format(
k, i)
log.debug("|{0}| >> Group [Check]...".format(_str_func))
if parentGutsTo is None:
mGroup = cgmMeta.cgmObject(name='newgroup')
mGroup.addAttr('cgmName', str(baseName), lock=True)
mGroup.addAttr('cgmTypeModifier', 'segmentStuff', lock=True)
mGroup.doName()
else:
mGroup = cgmMeta.validateObjArg(parentGutsTo, 'cgmObject', False)
if mModule:
mGroup.parent = mModule.rigNull
#Good way to verify an instance list? #validate orientation
#> axis -------------------------------------------------------------
"""
axis_aim = VALID.simpleAxis("{0}+".format(str_orientation[0]))
axis_aimNeg = axis_aim.inverse
axis_up = VALID.simpleAxis("{0}+".format(str_orientation [1]))
axis_out = VALID.simpleAxis("{0}+".format(str_orientation [2]))
v_aim = axis_aim.p_vector#aimVector
v_aimNeg = axis_aimNeg.p_vector#aimVectorNegative
v_up = axis_up.p_vector #upVector
v_out = axis_out.p_vector
str_up = axis_up.p_string
loftAxis2 = False
#Figure out our loft axis stuff
if loftAxis not in orientation:
_lower_loftAxis = loftAxis.lower()
if _lower_loftAxis in ['out','up']:
if _lower_loftAxis == 'out':
loftAxis = str_orientation[2]
else:
loftAxis = str_orientation[1]
else:
raise ValueError,"Not sure what to do with loftAxis: {0}".format(loftAxis)
"""
outChannel = str_orientation[2] #outChannel
upChannel = str_orientation[1]
#upChannel = '{0}up'.format(str_orientation[1])#upChannel
#>>> Ribbon Surface ============================================================================
log.debug("|{0}| >> Ribbons generating...".format(_str_func))
l_surfaceReturn1 = IK.ribbon_createSurface(d_dat[1]['driven'],
loftAxis, sectionSpans,
extendEnds)
d_dat[1]['mSurf'] = cgmMeta.validateObjArg(l_surfaceReturn1[0],
'cgmObject',
setClass=True)
d_dat[1]['mSurf'].addAttr('cgmName',
str(baseName1),
attrType='string',
lock=True)
d_dat[1]['mSurf'].addAttr('cgmType',
'controlSurface',
attrType='string',
lock=True)
d_dat[1]['mSurf'].doName()
l_surfaceReturn2 = IK.ribbon_createSurface(d_dat[2]['driven'],
loftAxis, sectionSpans,
extendEnds)
d_dat[2]['mSurf'] = cgmMeta.validateObjArg(l_surfaceReturn1[0],
'cgmObject',
setClass=True)
d_dat[2]['mSurf'].addAttr('cgmName',
str(baseName2),
attrType='string',
lock=True)
d_dat[2]['mSurf'].addAttr('cgmType',
'controlSurface',
attrType='string',
lock=True)
d_dat[2]['mSurf'].doName()
log.debug("d_dat[1]['mSurf']: {0}".format(d_dat[1]['mSurf']))
log.debug("d_dat[2]['mSurf']: {0}".format(d_dat[2]['mSurf']))
ml_toConnect = []
ml_toConnect.extend([d_dat[1]['mSurf'], d_dat[2]['mSurf']])
#Special Mode =================================================================================
if specialMode in ['noStartEnd', 'endsToInfluences']:
log.debug(
"|{0}| >> Special Mode: {1}".format(_str_func, specialMode) +
cgmGEN._str_subLine)
if specialMode == 'endsToInfluences':
d_special = {
'1start': {
'mObj': d_dat[1]['driven'][0],
'mDriver': d_dat[1]['mInfluences'][0]
},
'1end': {
'mObj': d_dat[1]['driven'][-1],
'mDriver': d_dat[1]['mInfluences'][-1]
},
'2start': {
'mObj': d_dat[2]['driven'][0],
'mDriver': d_dat[2]['mInfluences'][0]
},
'2end': {
'mObj': d_dat[2]['driven'][-1],
'mDriver': d_dat[2]['mInfluences'][-1]
}
}
for n, dat in d_special.iteritems():
mObj = dat['mObj']
mDriven = md_drivers[mObj]
mDriver = dat['mDriver']
log.debug("|{0}| >> {1} | Driver: {2}".format(
_str_func, i, mDriven))
_const = mc.parentConstraint([mDriver.mNode],
mDriven.mNode,
maintainOffset=True)[0]
ATTR.set(_const, 'interpType', 2)
d_dat[1]['driven'] = d_dat[1]['driven'][1:-1]
d_dat[2]['driven'] = d_dat[2]['driven'][1:-1]
driven1 = driven1[1:-1]
driven2 = driven2[1:-1]
#>>> Setup our Attributes ================================================================
log.debug("|{0}| >> Settings...".format(_str_func))
if settingsControl:
mSettings = cgmMeta.validateObjArg(settingsControl, 'cgmObject')
else:
mSettings = d_dat[1]['mSurf']
mPlug_sealHeight = cgmMeta.cgmAttr(mSettings.mNode,
'sealHeight',
attrType='float',
lock=False,
keyable=True)
mPlug_sealHeight.doDefault(.5)
mPlug_sealHeight.value = .5
#>>> Setup blend results --------------------------------------------------------------------
if sealSplit:
d_split = split_blends(
driven1, #d_dat[1]['driven'],
driven2, #d_dat[2]['driven'],
sealDriver1,
sealDriver2,
sealDriverMid,
nameSeal1=sealName1,
nameSeal2=sealName2,
nameSealMid=sealNameMid,
settingsControl=mSettings,
maxValue=maxValue)
for k, d in d_split.iteritems():
d_dat[k]['mPlugs'] = d['mPlugs']
else:
mPlug_seal = cgmMeta.cgmAttr(mSettings.mNode,
'seal',
attrType='float',
lock=False,
keyable=True)
mPlug_sealOn = cgmMeta.cgmAttr(mSettings,
'result_sealOn',
attrType='float',
defaultValue=0,
keyable=False,
lock=True,
hidden=False)
mPlug_sealOff = cgmMeta.cgmAttr(mSettings,
'result_sealOff',
attrType='float',
defaultValue=0,
keyable=False,
lock=True,
hidden=False)
NODEFACTORY.createSingleBlendNetwork(mPlug_seal.p_combinedName,
mPlug_sealOn.p_combinedName,
mPlug_sealOff.p_combinedName)
d_dat[1]['mPlug_sealOn'] = mPlug_sealOn
d_dat[1]['mPlug_sealOff'] = mPlug_sealOff
d_dat[2]['mPlug_sealOn'] = mPlug_sealOn
d_dat[2]['mPlug_sealOff'] = mPlug_sealOff
mPlug_FavorOneMe = cgmMeta.cgmAttr(mSettings,
'result_sealOneMe',
attrType='float',
defaultValue=0,
keyable=False,
lock=True,
hidden=False)
mPlug_FavorOneThee = cgmMeta.cgmAttr(mSettings,
'result_sealOneThee',
attrType='float',
defaultValue=0,
keyable=False,
lock=True,
hidden=False)
mPlug_FavorTwoMe = cgmMeta.cgmAttr(mSettings,
'result_sealTwoMe',
attrType='float',
defaultValue=0,
keyable=False,
lock=True,
hidden=False)
mPlug_FavorTwoThee = cgmMeta.cgmAttr(mSettings,
'result_sealTwoThee',
attrType='float',
defaultValue=0,
keyable=False,
lock=True,
hidden=False)
NODEFACTORY.createSingleBlendNetwork(mPlug_sealHeight.p_combinedName,
mPlug_FavorOneThee.p_combinedName,
mPlug_FavorOneMe.p_combinedName)
NODEFACTORY.createSingleBlendNetwork(mPlug_sealHeight.p_combinedName,
mPlug_FavorTwoThee.p_combinedName,
mPlug_FavorTwoMe.p_combinedName)
d_dat[1]['mPlug_me'] = mPlug_FavorOneMe
d_dat[1]['mPlug_thee'] = mPlug_FavorOneThee
d_dat[2]['mPlug_me'] = mPlug_FavorTwoMe
d_dat[2]['mPlug_thee'] = mPlug_FavorTwoThee
"""
b_attachToInfluences = False
if attachEndsToInfluences:
log.debug("|{0}| >> attachEndsToInfluences flag. Checking...".format(_str_func))
if influences and len(influences) > 1:
b_attachToInfluences = True
log.debug("|{0}| >> b_attachToInfluences: {1}".format(_str_func,b_attachToInfluences))
"""
#>>> Skinning ============================================================================
log.debug("|{0}| >> Skinning Ribbons...".format(_str_func))
for idx, dat in d_dat.iteritems():
max_influences = 2
mode_tighten = 'twoBlend'
blendLength = int(dat['int_driven'] / 2)
blendMin = 2
_hardLength = 2
if extendEnds:
blendMin = 4
_hardLength = 4
mode_tighten = None
if dat['int_influences'] > 2:
mode_tighten = None
#blendLength = int(int_lenInfluences/2)
max_influences = MATH.Clamp(blendLength, 2, 4)
blendLength = MATH.Clamp(int(dat['int_influences'] / 2), 2, 6)
if dat['int_influences'] == dat['int_driven']:
_hardLength = 3
#Tighten the weights...
mSkinCluster = cgmMeta.validateObjArg(mc.skinCluster(
[mObj.mNode for mObj in dat['mInfluences']],
dat['mSurf'].mNode,
tsb=True,
maximumInfluences=max_influences,
normalizeWeights=1,
dropoffRate=5.0),
'cgmNode',
setClass=True)
mSkinCluster.doStore('cgmName', dat['mSurf'])
mSkinCluster.doName()
#Tighten the weights...
RIGSKIN.surface_tightenEnds(dat['mSurf'].mNode,
hardLength=_hardLength,
blendLength=blendLength,
mode=mode_tighten)
#>>> Meat ============================================================================
ml_processed = []
for idx, dat in d_dat.iteritems():
idx_seal = 1
if idx == 1:
idx_seal = 2
dat_seal = d_dat[idx_seal]
log.debug("|{0}| >> Building [{1}] | seal idx: {2} |".format(
_str_func, idx, idx_seal) + cgmGEN._str_subLine)
mSurfBase = dat['mSurf']
mSurfSeal = dat_seal['mSurf']
for i, mObj in enumerate(dat['driven']):
if mObj in ml_processed:
log.debug("|{0}| >> Already completed: {1}".format(
_str_func, mObj))
continue
ml_processed.append(mObj)
log.debug("|{0}| >> {1} | Driven: {2}".format(
_str_func, i, mObj))
mDriven = md_drivers[mObj]
log.debug("|{0}| >> {1} | Driver: {2}".format(
_str_func, i, mDriven))
log.debug("|{0}| >> Create track drivers...".format(_str_func))
mTrackBase = mDriven.doCreateAt(setClass=True)
mTrackBase.doStore('cgmName', mObj)
mTrackSeal = mTrackBase.doDuplicate()
mTrackBlend = mTrackBase.doDuplicate()
mTrackSeal.doStore('cgmType', 'trackSeal')
mTrackBase.doStore('cgmType', 'trackBase')
mTrackBlend.doStore('cgmType', 'trackBlend')
for mTrack in mTrackBase, mTrackSeal, mTrackBlend:
mTrack.doName()
log.debug("|{0}| >> Attach drivers...".format(_str_func))
d_tmp = {
'base': {
'mSurf': mSurfBase,
'mTrack': mTrackBase
},
'seal': {
'mSurf': mSurfSeal,
'mTrack': mTrackSeal
},
}
for n, d in d_tmp.iteritems():
mTrack = d['mTrack']
mSurf = d['mSurf']
_res = RIGCONSTRAINTS.attach_toShape(
mTrack.mNode, mSurf.mNode, 'parent')
mFollicle = _res[-1][
'mFollicle'] #cgmMeta.asMeta(follicle)
mFollShape = _res[-1][
'mFollicleShape'] #cgmMeta.asMeta(shape)
md_follicleShapes[mObj] = mFollShape
md_follicles[mObj] = mFollicle
mFollicle.parent = mGroup.mNode
if mModule: #if we have a module, connect vis
mFollicle.overrideEnabled = 1
cgmMeta.cgmAttr(
mModule.rigNull.mNode, 'gutsVis',
lock=False).doConnectOut(
"%s.%s" %
(mFollicle.mNode, 'overrideVisibility'))
cgmMeta.cgmAttr(
mModule.rigNull.mNode, 'gutsLock',
lock=False).doConnectOut(
"%s.%s" %
(mFollicle.mNode, 'overrideDisplayType'))
#Blend point --------------------------------------------------------------------
_const = mc.parentConstraint(
[mTrackBase.mNode, mTrackSeal.mNode], mTrackBlend.mNode)[0]
ATTR.set(_const, 'interpType', 2)
targetWeights = mc.parentConstraint(_const,
q=True,
weightAliasList=True)
#Connect
if idx == 1:
dat['mPlug_thee'].doConnectOut('%s.%s' %
(_const, targetWeights[0]))
dat['mPlug_me'].doConnectOut('%s.%s' %
(_const, targetWeights[1]))
else:
dat['mPlug_me'].doConnectOut('%s.%s' %
(_const, targetWeights[0]))
dat['mPlug_thee'].doConnectOut('%s.%s' %
(_const, targetWeights[1]))
#seal --------------------------------------------------------------------
_const = mc.parentConstraint(
[mTrackBase.mNode, mTrackBlend.mNode], mDriven.mNode)[0]
ATTR.set(_const, 'interpType', 2)
targetWeights = mc.parentConstraint(_const,
q=True,
weightAliasList=True)
if sealSplit:
dat['mPlugs']['off'][i].doConnectOut(
'%s.%s' % (_const, targetWeights[0]))
dat['mPlugs']['on'][i].doConnectOut(
'%s.%s' % (_const, targetWeights[1]))
else:
dat['mPlug_sealOff'].doConnectOut(
'%s.%s' % (_const, targetWeights[0]))
dat['mPlug_sealOn'].doConnectOut(
'%s.%s' % (_const, targetWeights[1]))
log.debug("|{0}| >> Blend drivers...".format(_str_func))
"""
#Simple contrain
if b_attachToInfluences and mJnt in [ml_joints[0],ml_joints[-1]]:
if mJnt == ml_joints[0]:
mUse = ml_influences[0]
else:
mUse = ml_influences[-1]
mc.parentConstraint([mUse.mNode], mDriven.mNode, maintainOffset=True)
else:
mc.parentConstraint([mDriver.mNode], mDriven.mNode, maintainOffset=True)
"""
#pprint.pprint(d_dat)
return
except Exception, err:
cgmGEN.cgmExceptCB(Exception, err, msg=vars())
