def __init__(self,
obj=None,
aimFwd='z+',
aimUp='y+',
damp=7.0,
objectScale=100,
debug=False,
showBake=False):
PostBake.PostBake.__init__(self, obj=obj, showBake=showBake)
self.aimFwd = VALID.simpleAxis(aimFwd)
self.aimUp = VALID.simpleAxis(aimUp)
self.debug = debug
self._debugLoc = None
self.damp = damp
self.objectScale = objectScale
self.dir = self.obj.getTransformDirection(
self.aimFwd.p_vector) * self.objectScale
self.aimTargetPos = self.obj.p_position + self.dir
self.keyableAttrs = ['rx', 'ry', 'rz']
self.lastFwd = MATH.Vector3.forward()
self.lastUp = MATH.Vector3.up()
def __init__(self, obj=None, velocityDamp=30.0, showBake=False):
self.obj = None
self.velocityDamp = velocityDamp
self.showBake = showBake
self.velocity = MATH.Vector3.zero()
self.previousPosition = MATH.Vector3.zero()
self.startPosition = MATH.Vector3.zero()
if obj is None:
self.obj = cgmMeta.asMeta(mc.ls(sl=True)[0])
else:
self.obj = cgmMeta.asMeta(obj)
self.aimFwd = VALID.simpleAxis('z+')
self.aimUp = VALID.simpleAxis('y+')
self.velocity = MATH.Vector3.zero()
self.startPosition = VALID.euclidVector3Arg(self.obj.p_position)
self.previousPosition = self.startPosition
self.keyableAttrs = ['translate', 'rotate', 'scale']
self._bakedLoc = None
self.startTime = int(mc.playbackOptions(q=True, min=True))
self.endTime = int(mc.playbackOptions(q=True, max=True))
def __init__(self,
plane='screen',
mode='position',
planeObject=None,
recordMode='combine',
aimFwd='z+',
aimUp='y+',
onStart=None,
onUpdate=None,
onComplete=None,
onReposition=None,
onExit=None,
postBlendFrames=6,
loopTime=False,
debug=False):
_str_func = 'AnimDraw._init_'
try:
self.recordableObjs = [RecordableObj(x) for x in mc.ls(sl=True)]
except:
log.error("|{0}| >> No objects selected".format(_str_func))
return
LiveRecord.__init__(self,
onStart=onStart,
onUpdate=onUpdate,
onComplete=onComplete,
onExit=onExit,
loopTime=loopTime,
debug=debug)
self.onReposition = onReposition
self.plane = plane
self.postBlendFrames = postBlendFrames
self.mode = mode
self.planeObject = cgmMeta.asMeta(planeObject) if planeObject else None
self.aimFwd = VALID.simpleAxis(aimFwd)
self.aimUp = VALID.simpleAxis(aimUp)
self.recordMode = recordMode
self._currentPlaneObject = self.planeObject
self._debugPlane = None
self._debugLoc = None
self._prevDataDict = {}
self._useCache = False
self._recordButtons = [1]
def __init__(self,
obj=None,
aimFwd='z+',
aimUp='y+',
damp=.1,
angularDamp=.1,
spring=1.0,
maxDistance=100.0,
objectScale=100,
pushForce=8.0,
springForce=5.0,
angularSpringForce=5.0,
collider=None,
debug=False,
showBake=False):
PostBake.PostBake.__init__(self, obj=obj, showBake=showBake)
self.aimFwd = VALID.simpleAxis(aimFwd)
self.aimUp = VALID.simpleAxis(aimUp)
self.pushForce = pushForce
self.springForce = springForce
self.angularSpringForce = angularSpringForce
self.maxDistance = maxDistance
self.positionForce = MATH.Vector3.zero()
self.angularForce = MATH.Vector3.zero()
self.spring = spring
self.debug = debug
self._debugLoc = None
self._wantedPosLoc = None
self._wantedUpLoc = None
self.collider = cgmMeta.asMeta(collider) if collider else None
self.damp = damp
self.angularDamp = angularDamp
self.objectScale = objectScale
self.dir = self.obj.getTransformDirection(
self.aimFwd.p_vector) * self.objectScale
self.aimTargetPos = self.obj.p_position + self.dir
self.upTargetPos = self.obj.getTransformDirection(
self.aimUp.p_vector) * self.objectScale
self.keyableAttrs = ['rx', 'ry', 'rz']
def __init__(self,
obj=None,
aimFwd='z+',
aimUp='y+',
damp=10,
showBake=False):
PostBake.PostBake.__init__(self, obj=obj, showBake=showBake)
self.aimFwd = VALID.simpleAxis(aimFwd)
self.aimUp = VALID.simpleAxis(aimUp)
self.damp = damp
self.keyableAttrs = ['rx', 'ry', 'rz']
self.lastFwd = MATH.Vector3.forward()
self.lastUp = MATH.Vector3.up()
def uiFunc_set_chain_up(self, idx, upMenu):
#print "Changing up on %s to %s" % ( chain.p_nameBase, upMenu.getValue() )
axis = upMenu.getValue()
if axis == 'None':
axis = None
else:
axis = VALID.simpleAxis(axis)
self._mDynFK.chain_setOrientUpByIdx(idx, axis)
def closestAxisTowardObj_get(sourceObj, targetObj):
v = sourceObj.getTransformInversePoint(targetObj.p_position).normalized()
m = max( abs(v.x), abs(v.y), abs(v.z) )
va = ( int(v.x / abs(v.x)) if MATH.isclose(abs(v.x), m) else 0,
int(v.y / abs(v.y)) if MATH.isclose(abs(v.y), m) else 0,
int(v.z / abs(v.z)) if MATH.isclose(abs(v.z), m) else 0 )
return VALID.simpleAxis(va)
def closestAxisToObjAxis_get(sourceObj, targetObj, targetAxis):
targetWorldAxisVector = targetObj.getTransformDirection(targetAxis.p_vector)
v = sourceObj.getTransformInverseDirection(targetWorldAxisVector).normalized()
m = max( abs(v.x), abs(v.y), abs(v.z) )
va = ( int(v.x / abs(v.x)) if MATH.isclose(abs(v.x), m) else 0,
int(v.y / abs(v.y)) if MATH.isclose(abs(v.y), m) else 0,
int(v.z / abs(v.z)) if MATH.isclose(abs(v.z), m) else 0 )
return VALID.simpleAxis(va)
mJnt.parent = _d_parents[mJnt]
for mChild in _d_children[mJnt]:
#if mChild not in ml_joints:
#log.debug("|{0}| >> reparenting child: {1}".format(_str_func,mChild.mNode))
mChild.parent = mJnt
if mJnt in ml_ends and mJnt not in ml_world:
log.debug("|{0}| >> End joint. No world: {1}".format(_str_func,mJnt))
mJnt.jointOrient = 0,0,0
ml_joints = cgmMeta.validateObjListArg(joints,mayaType=['joint'],noneValid=False)
ml_joints = LISTS.get_noDuplicates(ml_joints)
mAxis_aim = VALID.simpleAxis(axisAim)
mAxis_up = VALID.simpleAxis(axisUp)
_axisWorldUp = worldUpAxis
str_aim = mAxis_aim.p_string
str_up = mAxis_up.p_string
if str_aim == str_up:
raise ValueError,"axisAim and axisUp cannot be the same"
_len = len(ml_joints)
_d_parents = {}
_d_children = {}
ml_roots = []
ml_ends = []
ml_world =[]
ml_done = []
def aim_atPoint(obj = None, position = [0,0,0], aimAxis = "z+", upAxis = "y+", mode = 'local',vectorUp = None,ignoreAimAttrs = False):
"""
Aim functionality.
:parameters:
obj(str): Object to modify
position(array): object to copy from
aimAxis(str): axis that is pointing forward
upAxis(str): axis that is pointing up
mode(str):
'local'-- use standard maya aiming with local axis
'world' -- use standard maya aiming with world axis
'matrix' -- use Bokser's fancy method
'vector' -- maya standard with vector up axis
'object' -- maya standard with object
:returns
success(bool)
"""
try:
_str_func = 'aimAtPoint'
_loc = False
_obj = VALID.objString(obj, noneValid=False, calledFrom = __name__ + _str_func + ">> validate obj")
try:position = position.x,position.y,position.z
except:pass
try:vectorUp = vectorUp.x,vectorUp.y,vectorUp.z
except:pass
log.debug("|{0}| >> obj: {1} | position:{2} | mode: {3}".format(_str_func,_obj,position,mode))
if not ignoreAimAttrs:
_d_aim = ATTR.validate_arg(_obj,'axisAim')
_d_up =ATTR.validate_arg(_obj,'axisUp')
if ATTR.has_attr(_d_aim) and ATTR.has_attr(_d_up):
aimAxis = ATTR.get_enumValueString(_d_aim)
upAxis = ATTR.get_enumValueString(_d_up)
log.debug("|{0}| >> obj: {1} aimable from attrs. aim: {2} | up: {3}".format(_str_func,_obj,aimAxis,upAxis))
if mode == 'matrix':
'''Rotate transform based on look vector'''
# get source and target vectors
objPos = POS.get(_obj, asEuclid=True)
targetPos = MATH.Vector3.Create(position)
aim = (targetPos - objPos).normalized()
if not vectorUp:
upVector = MATH.Vector3.up()
if upAxis == "y-":
upVector = MATH.Vector3.down()
elif upAxis == "z+":
upVector = MATH.Vector3.forward()
elif upAxis == "z-":
upVector = MATH.Vector3.back()
elif upAxis == "x+":
upVector = MATH.Vector3.right()
elif upAxis == "x-":
upVector = MATH.Vector3.left()
else:
upVector = MATH.Vector3.up()
vectorUp = MATH.transform_direction( _obj, upVector )
wantedAim, wantedUp = MATH.convert_aim_vectors_to_different_axis(aim, vectorUp, aimAxis, upAxis)
xformPos = mc.xform(_obj, q=True, matrix = True, ws=True)
pos = MATH.Vector3(xformPos[12], xformPos[13], xformPos[14])
rot_matrix = EUCLID.Matrix4.new_look_at(MATH.Vector3.zero(), -wantedAim, wantedUp)
s = MATH.Vector3.Create( mc.xform(_obj, q=True, ws=True, s=True) )
scale_matrix = EUCLID.Matrix4()
scale_matrix.a = s.x
scale_matrix.f = s.y
scale_matrix.k = s.z
scale_matrix.p = 1
result_matrix = rot_matrix * scale_matrix
transform_matrix = result_matrix[0:12] + [pos.x, pos.y, pos.z, 1.0]
mc.xform(_obj, matrix = transform_matrix , roo="xyz", ws=True)
"""elif mode == 'world':
_loc = mc.spaceLocator()[0]
mc.move (position[0],position[1],position[2], _loc, ws=True)
mAxis_aim = VALID.simpleAxis(aimAxis)
mAxis_up = VALID.simpleAxis(upAxis)
_constraint = mc.aimConstraint(_loc,_obj,
maintainOffset = False,
aimVector = mAxis_aim.p_vector,
upVector = mAxis_up.p_vector,
worldUpType = 'scene',)
mc.delete(_constraint + [_loc])"""
elif mode in ['local','world','vector','object']:
_loc = mc.spaceLocator(name='test')[0]
_loc_snap = POS.create_loc(_obj)
mc.move (position[0],position[1],position[2], _loc, ws=True)
mAxis_aim = VALID.simpleAxis(aimAxis)
mAxis_up = VALID.simpleAxis(upAxis)
if mode == 'world':
_constraint = mc.aimConstraint(_loc,_loc_snap,
maintainOffset = False,
aimVector = mAxis_aim.p_vector,
upVector = mAxis_up.p_vector,
worldUpType = 'scene',)
elif mode == 'object':
vectorUp = VALID.mNodeString(vectorUp)
_constraint = mc.aimConstraint(_loc,_loc_snap,
maintainOffset = False,
aimVector = mAxis_aim.p_vector,
upVector = mAxis_up.p_vector,
worldUpType = 'object',
worldUpObject = vectorUp)
#worldUpVector = _vUp)
else:
if mode == 'vector':
_vUp = vectorUp
else:
_vUp = MATH.get_obj_vector(_obj,upAxis)
_constraint = mc.aimConstraint(_loc,_loc_snap,
maintainOffset = False,
aimVector = mAxis_aim.p_vector,
upVector = mAxis_up.p_vector,
worldUpType = 'vector',
worldUpVector = _vUp)
go(obj,_loc_snap)
mc.delete(_constraint,_loc_snap)
else:
raise NotImplementedError,"mode: {0}".format(mode)
if _loc:mc.delete(_loc)
return True
except Exception,err:
try:mc.delete(_loc)
except:pass
log.error( "aim_atPoint | obj: {0} | err: {1}".format(obj,err) )
def build_aimSequence(l_driven = None,
l_targets = None,
l_parents = None,
l_upTargets = None,
msgLink_masterGroup = 'masterGroup',
aim = [0,0,1],
up = [0,1,0],
mode = 'sequence',#sequence,singleBlend
upMode = 'objRotation',#objRotation,decomposeMatrix
upParent = [0,1,0],
rootTargetEnd = None,
rootTargetStart=None,#specify root targets by index and mObj
mRoot = None,#need for sequence
interpType = None,
maintainOffset = False):
"""
This kind of setup is for setting up a blended constraint so that obj2 in an obj1/obj2/obj3 sequence can aim forward or back as can obj3.
:parameters:
l_jointChain1 - First set of objects
:returns:
:raises:
Exception | if reached
"""
_str_func = 'build_aimSequence'
ml_driven = cgmMeta.validateObjListArg(l_driven,'cgmObject')
ml_targets = cgmMeta.validateObjListArg(l_targets,'cgmObject',noneValid=True)
ml_parents = cgmMeta.validateObjListArg(l_parents,'cgmObject',noneValid=True)
ml_upTargets = cgmMeta.validateObjListArg(l_upTargets,'cgmObject',noneValid=True)
if not ml_upTargets:
ml_upTargets = ml_parents
axis_aim = VALID.simpleAxis(aim)
axis_aimNeg = axis_aim.inverse
axis_up = VALID.simpleAxis(up)
v_aim = axis_aim.p_vector#aimVector
v_aimNeg = axis_aimNeg.p_vector#aimVectorNegative
v_up = axis_up.p_vector #upVector
#cgmGEN.func_snapShot(vars())
if mode == 'singleBlend':
if len(ml_targets) != 2:
cgmGEN.func_snapShot(vars())
return log.error("|{0}| >> Single blend mode must have 2 targets.".format(_str_func))
if len(ml_driven) != 1:
cgmGEN.func_snapShot(vars())
return log.error("|{0}| >> Single blend mode must have 1 driven obj.".format(_str_func))
if not ml_parents:
cgmGEN.func_snapShot(vars())
return log.error("|{0}| >> Single blend mode must have handleParents.".format(_str_func))
if len(ml_parents) != 1:
cgmGEN.func_snapShot(vars())
return log.error("|{0}| >> Single blend mode must have 1 handleParent.".format(_str_func))
mDriven = ml_driven[0]
if not mDriven.getMessage(msgLink_masterGroup):
log.debug("|{0}| >> No master group, creating...".format(_str_func))
raise ValueError, log.error("|{0}| >> Add the create masterGroup setup, Josh".format(_str_func))
mMasterGroup = mDriven.getMessage(msgLink_masterGroup,asMeta=True)[0]
s_rootTarget = False
s_targetForward = ml_targets[-1].mNode
s_targetBack = ml_targets[0].mNode
i = 0
mMasterGroup.p_parent = ml_parents[i]
mUpDecomp = None
if upMode == 'decomposeMatrix':
#Decompose matrix for parent...
mUpDecomp = cgmMeta.cgmNode(nodeType = 'decomposeMatrix')
mUpDecomp.rename("{0}_aimMatrix".format(ml_parents[i].p_nameBase))
#mUpDecomp.doStore('cgmName',ml_parents[i])
#mUpDecomp.addAttr('cgmType','aimMatrix',attrType='string',lock=True)
#mUpDecomp.doName()
ATTR.connect("{0}.worldMatrix".format(ml_parents[i].mNode),"{0}.{1}".format(mUpDecomp.mNode,'inputMatrix'))
d_worldUp = {'worldUpObject' : ml_parents[i].mNode,
'worldUpType' : 'vector', 'worldUpVector': [0,0,0]}
elif upMode == 'objectRotation':
d_worldUp = {'worldUpObject' : ml_parents[i].mNode,
'worldUpType' : 'objectRotation', 'worldUpVector': upParent}
else:
raise ValueError, log.error("|{0}| >> Unknown upMode: {1}".format(_str_func,upMode))
if s_targetForward:
mAimForward = mDriven.doCreateAt()
mAimForward.parent = mMasterGroup
mAimForward.doStore('cgmTypeModifier','forward')
mAimForward.doStore('cgmType','aimer')
mAimForward.doName()
_const=mc.aimConstraint(s_targetForward, mAimForward.mNode, maintainOffset = True, #skip = 'z',
aimVector = v_aim, upVector = v_up, **d_worldUp)
s_targetForward = mAimForward.mNode
if mUpDecomp:
ATTR.connect("%s.%s"%(mUpDecomp.mNode,"outputRotate"),"%s.%s"%(_const[0],"upVector"))
else:
s_targetForward = ml_parents[i].mNode
if s_targetBack:
mAimBack = mDriven.doCreateAt()
mAimBack.parent = mMasterGroup
mAimBack.doStore('cgmTypeModifier','back')
mAimBack.doStore('cgmType','aimer')
mAimBack.doName()
_const = mc.aimConstraint(s_targetBack, mAimBack.mNode, maintainOffset = True, #skip = 'z',
aimVector = v_aimNeg, upVector = v_up, **d_worldUp)
s_targetBack = mAimBack.mNode
if mUpDecomp:
ATTR.connect("%s.%s"%(mUpDecomp.mNode,"outputRotate"),"%s.%s"%(_const[0],"upVector"))
else:
s_targetBack = s_rootTarget
#ml_parents[i].mNode
pprint.pprint([s_targetForward,s_targetBack])
mAimGroup = mDriven.doGroup(True,asMeta=True,typeModifier = 'aim')
mDriven.parent = False
const = mc.orientConstraint([s_targetForward, s_targetBack], mAimGroup.mNode, maintainOffset = True)[0]
d_blendReturn = NODEFACTORY.createSingleBlendNetwork([mDriven.mNode,'followRoot'],
[mDriven.mNode,'resultRootFollow'],
[mDriven.mNode,'resultAimFollow'],
keyable=True)
targetWeights = mc.orientConstraint(const,q=True, weightAliasList=True,maintainOffset=True)
#Connect
d_blendReturn['d_result1']['mi_plug'].doConnectOut('%s.%s' % (const,targetWeights[0]))
d_blendReturn['d_result2']['mi_plug'].doConnectOut('%s.%s' % (const,targetWeights[1]))
d_blendReturn['d_result1']['mi_plug'].p_hidden = True
d_blendReturn['d_result2']['mi_plug'].p_hidden = True
mDriven.parent = mAimGroup#...parent back
mDriven.followRoot = .5
return True
elif mode == 'sequence':
"""
if len(ml_targets) != 2:
cgmGEN.func_snapShot(vars())
return log.error("|{0}| >> Single blend mode must have 2 targets.".format(_str_func))
if len(ml_driven) != 1:
cgmGEN.func_snapShot(vars())
return log.error("|{0}| >> Single blend mode must have 1 driven obj.".format(_str_func))
if not ml_parents:
cgmGEN.func_snapShot(vars())
return log.error("|{0}| >> Single blend mode must have handleParents.".format(_str_func))
if len(ml_parents) != 1:
cgmGEN.func_snapShot(vars())
return log.error("|{0}| >> Single blend mode must have 1 handleParent.".format(_str_func))
"""
for i,mDriven in enumerate(ml_driven):
log.debug("|{0}| >> on: {1} | {2}".format(_str_func,i,mDriven))
mUpDecomp = False
if not mDriven.getMessage(msgLink_masterGroup):
log.debug("|{0}| >> No master group, creating...".format(_str_func))
raise ValueError, log.error("|{0}| >> Add the create masterGroup setup, Josh".format(_str_func))
mDriven.masterGroup.parent = ml_parents[i]
if upMode == 'decomposeMatrix':
#Decompose matrix for parent...
mUpDecomp = cgmMeta.cgmNode(nodeType = 'decomposeMatrix')
mUpDecomp.rename("{0}_aimMatrix".format(ml_parents[i].p_nameBase))
#mUpDecomp.doStore('cgmName',ml_parents[i])
#mUpDecomp.addAttr('cgmType','aimMatrix',attrType='string',lock=True)
#mUpDecomp.doName()
ATTR.connect("{0}.worldMatrix".format(ml_upTargets[i].mNode),"{0}.{1}".format(mUpDecomp.mNode,'inputMatrix'))
d_worldUp = {'worldUpObject' : ml_upTargets[i].mNode,
'worldUpType' : 'vector', 'worldUpVector': [0,0,0]}
elif upMode == 'objectRotation':
d_worldUp = {'worldUpObject' : ml_upTargets[i].mNode,
'worldUpType' : 'objectRotation', 'worldUpVector': upParent}
else:
raise ValueError, log.error("|{0}| >> Unknown upMode: {1}".format(_str_func,upMode))
s_rootTarget = False
s_targetForward = False
s_targetBack = False
mMasterGroup = mDriven.masterGroup
b_first = False
if mDriven == ml_driven[0]:
log.debug("|{0}| >> First handle: {1}".format(_str_func,mDriven))
if len(ml_driven) <=2:
s_targetForward = ml_parents[-1].mNode
else:
s_targetForward = ml_driven[i+1].getMessage('masterGroup')[0]
if rootTargetStart:
s_rootTarget = rootTargetStart.mNode
else:
s_rootTarget = mRoot.mNode
b_first = True
elif mDriven == ml_driven[-1]:
log.debug("|{0}| >> Last handle: {1}".format(_str_func,mDriven))
if rootTargetEnd:
s_rootTarget = rootTargetEnd.mNode
else:
s_rootTarget = ml_parents[i].mNode
s_targetBack = ml_driven[i-1].getMessage('masterGroup')[0]
else:
log.debug("|{0}| >> Reg handle: {1}".format(_str_func,mDriven))
s_targetForward = ml_driven[i+1].getMessage('masterGroup')[0]
s_targetBack = ml_driven[i-1].getMessage('masterGroup')[0]
#Decompose matrix for parent...
"""
mUpDecomp = cgmMeta.cgmNode(nodeType = 'decomposeMatrix')
mUpDecomp.doStore('cgmName',ml_parents[i])
mUpDecomp.addAttr('cgmType','aimMatrix',attrType='string',lock=True)
mUpDecomp.doName()
ATTR.connect("%s.worldMatrix"%(ml_parents[i].mNode),"%s.%s"%(mUpDecomp.mNode,'inputMatrix'))
"""
if s_targetForward:
mAimForward = mDriven.doCreateAt()
mAimForward.parent = mMasterGroup
mAimForward.doStore('cgmTypeModifier','forward')
mAimForward.doStore('cgmType','aimer')
mAimForward.doName()
_const=mc.aimConstraint(s_targetForward, mAimForward.mNode, maintainOffset = True, #skip = 'z',
aimVector = v_aim, upVector = v_up,**d_worldUp)
s_targetForward = mAimForward.mNode
if mUpDecomp:
ATTR.connect("%s.%s"%(mUpDecomp.mNode,"outputRotate"),"%s.%s"%(_const[0],"upVector"))
elif s_rootTarget:
s_targetForward = s_rootTarget
else:
s_targetForward = ml_parents[i].mNode
if s_targetBack:
mAimBack = mDriven.doCreateAt()
mAimBack.parent = mMasterGroup
mAimBack.doStore('cgmTypeModifier','back')
mAimBack.doStore('cgmType','aimer')
mAimBack.doName()
_const = mc.aimConstraint(s_targetBack, mAimBack.mNode, maintainOffset = True, #skip = 'z',
aimVector = v_aimNeg, upVector = v_up, **d_worldUp)
s_targetBack = mAimBack.mNode
if mUpDecomp:
ATTR.connect("%s.%s"%(mUpDecomp.mNode,"outputRotate"),"%s.%s"%(_const[0],"upVector"))
else:
s_targetBack = s_rootTarget
#ml_parents[i].mNode
#pprint.pprint([s_targetForward,s_targetBack])
mAimGroup = mDriven.doGroup(True,asMeta=True,typeModifier = 'aim')
mDriven.parent = False
log.debug("|{0}| >> obj: {1} | {2}".format(_str_func,i,mDriven))
log.debug("|{0}| >> forward: {1}".format(_str_func,s_targetForward))
log.debug("|{0}| >> back: {1}".format(_str_func,s_targetBack))
log.debug(cgmGEN._str_subLine)
if b_first:
const = mc.orientConstraint([s_targetBack, s_targetForward], mAimGroup.mNode, maintainOffset = True)[0]
else:
const = mc.orientConstraint([s_targetForward, s_targetBack], mAimGroup.mNode, maintainOffset = True)[0]
d_blendReturn = NODEFACTORY.createSingleBlendNetwork([mDriven.mNode,'followRoot'],
[mDriven.mNode,'resultRootFollow'],
[mDriven.mNode,'resultAimFollow'],
keyable=True)
targetWeights = mc.orientConstraint(const,q=True, weightAliasList=True,maintainOffset=True)
#Connect
d_blendReturn['d_result1']['mi_plug'].doConnectOut('%s.%s' % (const,targetWeights[0]))
d_blendReturn['d_result2']['mi_plug'].doConnectOut('%s.%s' % (const,targetWeights[1]))
d_blendReturn['d_result1']['mi_plug'].p_hidden = True
d_blendReturn['d_result2']['mi_plug'].p_hidden = True
mDriven.parent = mAimGroup#...parent back
if interpType:
ATTR.set(const,'interpType',interpType)
#if mDriven in [ml_driven[0],ml_driven[-1]]:
# mDriven.followRoot = 1
#else:
mDriven.followRoot = .5
return True
raise ValueError,"Not done..."
return
for i,mObj in enumerate(ml_driven):
return
mObj.masterGroup.parent = ml_parents[i]
s_rootTarget = False
s_targetForward = False
s_targetBack = False
mMasterGroup = mObj.masterGroup
b_first = False
if mObj == ml_driven[0]:
log.debug("|{0}| >> First handle: {1}".format(_str_func,mObj))
if len(ml_driven) <=2:
s_targetForward = ml_parents[-1].mNode
else:
s_targetForward = ml_driven[i+1].getMessage('masterGroup')[0]
s_rootTarget = mRoot.mNode
b_first = True
elif mObj == ml_driven[-1]:
log.debug("|{0}| >> Last handle: {1}".format(_str_func,mObj))
s_rootTarget = ml_parents[i].mNode
s_targetBack = ml_driven[i-1].getMessage('masterGroup')[0]
else:
log.debug("|{0}| >> Reg handle: {1}".format(_str_func,mObj))
s_targetForward = ml_driven[i+1].getMessage('masterGroup')[0]
s_targetBack = ml_driven[i-1].getMessage('masterGroup')[0]
#Decompose matrix for parent...
mUpDecomp = cgmMeta.cgmNode(nodeType = 'decomposeMatrix')
mUpDecomp.doStore('cgmName',ml_parents[i])
mUpDecomp.addAttr('cgmType','aimMatrix',attrType='string',lock=True)
mUpDecomp.doName()
ATTR.connect("%s.worldMatrix"%(ml_parents[i].mNode),"%s.%s"%(mUpDecomp.mNode,'inputMatrix'))
if s_targetForward:
mAimForward = mObj.doCreateAt()
mAimForward.parent = mMasterGroup
mAimForward.doStore('cgmTypeModifier','forward')
mAimForward.doStore('cgmType','aimer')
mAimForward.doName()
_const=mc.aimConstraint(s_targetForward, mAimForward.mNode, maintainOffset = True, #skip = 'z',
aimVector = [0,0,1], upVector = [1,0,0], worldUpObject = ml_parents[i].mNode,
worldUpType = 'vector', worldUpVector = [0,0,0])
s_targetForward = mAimForward.mNode
ATTR.connect("%s.%s"%(mUpDecomp.mNode,"outputRotate"),"%s.%s"%(_const[0],"upVector"))
else:
s_targetForward = ml_parents[i].mNode
if s_targetBack:
mAimBack = mObj.doCreateAt()
mAimBack.parent = mMasterGroup
mAimBack.doStore('cgmTypeModifier','back')
mAimBack.doStore('cgmType','aimer')
mAimBack.doName()
_const = mc.aimConstraint(s_targetBack, mAimBack.mNode, maintainOffset = True, #skip = 'z',
aimVector = [0,0,-1], upVector = [1,0,0], worldUpObject = ml_parents[i].mNode,
worldUpType = 'vector', worldUpVector = [0,0,0])
s_targetBack = mAimBack.mNode
ATTR.connect("%s.%s"%(mUpDecomp.mNode,"outputRotate"),"%s.%s"%(_const[0],"upVector"))
else:
s_targetBack = s_rootTarget
#ml_parents[i].mNode
pprint.pprint([s_targetForward,s_targetBack])
mAimGroup = mObj.doGroup(True,asMeta=True,typeModifier = 'aim')
mObj.parent = False
if b_first:
const = mc.orientConstraint([s_targetBack, s_targetForward], mAimGroup.mNode, maintainOffset = True)[0]
else:
const = mc.orientConstraint([s_targetForward, s_targetBack], mAimGroup.mNode, maintainOffset = True)[0]
d_blendReturn = NODEFACTORY.createSingleBlendNetwork([mObj.mNode,'followRoot'],
[mObj.mNode,'resultRootFollow'],
[mObj.mNode,'resultAimFollow'],
keyable=True)
targetWeights = mc.orientConstraint(const,q=True, weightAliasList=True,maintainOffset=True)
#Connect
d_blendReturn['d_result1']['mi_plug'].doConnectOut('%s.%s' % (const,targetWeights[0]))
d_blendReturn['d_result2']['mi_plug'].doConnectOut('%s.%s' % (const,targetWeights[1]))
d_blendReturn['d_result1']['mi_plug'].p_hidden = True
d_blendReturn['d_result2']['mi_plug'].p_hidden = True
mObj.parent = mAimGroup#...parent back
if mObj in [ml_driven[0],ml_driven[-1]]:
mObj.followRoot = 1
else:
mObj.followRoot = .5
def crossAxis_get(axis):
returnAxis = VALID.simpleAxis('y+')
if axis.p_string[0] == 'y':
returnAxis = VALID.simpleAxis('z+')
return returnAxis
def test_vectorToAxis(self):
for k, v in SHARED._d_axis_vector_to_string.iteritems():
self.assertEqual(validateArgs.simpleAxis(k).p_string, v)
def createWrapControlShape(
targetObjects,
targetGeo=None,
latheAxis='z',
aimAxis='y+',
objectUp='y+',
points=8,
curveDegree=1,
insetMult=None, #Inset multiplier
minRotate=None,
maxRotate=None,
posOffset=[],
rootOffset=[], #offset root before cast
rootRotate=None,
joinMode=False,
extendMode=None,
closedCurve=True,
l_specifiedRotates=None,
maxDistance=1000,
closestInRange=True,
vectorOffset=None,
midMeshCast=False,
subSize=None, #For ball on loli for example
rotateBank=None,
joinHits=None, #keys to processed hits to see what to join
axisToCheck=['x', 'y'],
**kws): #'segment,radial,disc'
"""
This function lathes an axis of an object, shoot rays out the aim axis at the provided mesh and returning hits.
it then uses this information to build a curve shape.
:parameters:
mesh(string) | Surface to cast at
mi_obj(string/mObj) | our casting object
latheAxis(str) | axis of the objec to lathe TODO: add validation
aimAxis(str) | axis to shoot out of
points(int) | how many points you want in the curve
curveDegree(int) | specified degree
minRotate(float) | let's you specify a valid range to shoot
maxRotate(float) | let's you specify a valid range to shoot
posOffset(vector) | transformational offset for the hit from a normalized locator at the hit. Oriented to the surface
markHits(bool) | whether to keep the hit markers
returnDict(bool) | whether you want all the infomation from the process.
rotateBank (float) | let's you add a bank to the rotation object
l_specifiedRotates(list of values) | specify where to shoot relative to an object. Ignores some other settings
maxDistance(float) | max distance to cast rays
closestInRange(bool) | True by default. If True, takes first hit. Else take the furthest away hit in range.
:returns:
Dict ------------------------------------------------------------------
'source'(double3) | point from which we cast
'hit'(double3) | world space points | active during single return
'hits'(list) | world space points | active during multi return
'uv'(double2) | uv on surface of hit | only works for mesh surfaces
:raises:
Exception | if reached
"""
_str_func = "createWrapControlShape"
log.debug(">> %s >> " % (_str_func) + "=" * 75)
_joinModes = []
_extendMode = []
if type(targetObjects) not in [list, tuple]:
targetObjects = [targetObjects]
targetGeo = VALID.objStringList(targetGeo, calledFrom=_str_func)
assert type(points) is int, "Points must be int: %s" % points
assert type(curveDegree) is int, "Points must be int: %s" % points
assert curveDegree > 0, "Curve degree must be greater than 1: %s" % curveDegree
if posOffset is not None and len(posOffset) and len(posOffset) != 3:
raise StandardError, "posOffset must be len(3): %s | len: %s" % (
posOffset, len(posOffset))
if rootOffset is not None and len(rootOffset) and len(rootOffset) != 3:
raise StandardError, "rootOffset must be len(3): %s | len: %s" % (
rootOffset, len(rootOffset))
if rootRotate is not None and len(rootRotate) and len(rootRotate) != 3:
raise StandardError, "rootRotate must be len(3): %s | len: %s" % (
rootRotate, len(rootRotate))
if extendMode in ['loliwrap', 'cylinder', 'disc'] and insetMult is None:
insetMult = 1
for axis in ['x', 'y', 'z']:
if axis in latheAxis.lower(): latheAxis = axis
log.debug("targetObjects: %s" % targetObjects)
if len(aimAxis) == 2: single_aimAxis = aimAxis[0]
else: single_aimAxis = aimAxis
mAxis_aim = VALID.simpleAxis(aimAxis)
log.debug("Single aim: %s" % single_aimAxis)
log.debug("createWrapControlShape>> midMeshCast: %s" % midMeshCast)
log.debug("|{0}| >> extendMode: {1}".format(_str_func, extendMode))
#>> Info
l_groupsBuffer = []
il_curvesToCombine = []
l_sliceReturns = []
#Need to do more to get a better size
#>> Build curves
#=================================================================
#> Root curve #
log.debug("RootRotate: %s" % rootRotate)
mi_rootLoc = cgmMeta.cgmNode(targetObjects[0]).doLoc()
if rootOffset:
log.debug("rootOffset: %s" % rootOffset)
mc.move(rootOffset[0],
rootOffset[1],
rootOffset[2], [mi_rootLoc.mNode],
r=True,
rpr=True,
os=True,
wd=True)
if rootRotate is not None and len(rootRotate):
log.debug("rootRotate: %s" % rootRotate)
mc.rotate(rootRotate[0],
rootRotate[1],
rootRotate[2], [mi_rootLoc.mNode],
os=True,
r=True)
#>> Root
mi_rootLoc.doGroup() #Group to zero
if extendMode == 'segment':
log.debug("segment mode. Target len: %s" % len(targetObjects[1:]))
if len(targetObjects) < 2:
log.warning(
"Segment build mode only works with two objects or more")
else:
if insetMult is not None:
rootDistanceToMove = distance.returnDistanceBetweenObjects(
targetObjects[0], targetObjects[1])
log.debug("rootDistanceToMove: %s" % rootDistanceToMove)
mi_rootLoc.__setattr__('t%s' % latheAxis,
rootDistanceToMove * insetMult)
#mi_rootLoc.tz = (rootDistanceToMove*insetMult)#Offset it
#Notes -- may need to play with up object for aim snapping
#mi_upLoc = cgmMeta.cgmNode(targetObjects[0]).doLoc()
#mi_upLoc.doGroup()#To zero
objectUpVector = dictionary.returnStringToVectors(objectUp)
log.debug("objectUpVector: %s" % objectUpVector)
#mi_uploc
for i, obj in enumerate(targetObjects[1:]):
log.debug("i: %s" % i)
#> End Curve
mi_endLoc = cgmMeta.cgmNode(obj).doLoc()
aimVector = dictionary.returnStringToVectors(latheAxis + '-')
log.debug("segment aimback: %s" % aimVector)
#Snap.go(mi_endLoc.mNode,mi_rootLoc.mNode,move=False,aim=True,aimVector=aimVector,upVector=objectUpVector)
#Snap.go(mi_endLoc.mNode,mi_rootLoc.mNode,move=False,orient=True)
SNAP.go(mi_endLoc.mNode,
mi_rootLoc.mNode,
position=False,
rotation=True)
mi_endLoc.doGroup()
if i == len(targetObjects[1:]) - 1:
if insetMult is not None:
log.debug("segment insetMult: %s" % insetMult)
distanceToMove = distance.returnDistanceBetweenObjects(
targetObjects[-1], targetObjects[0])
log.debug("distanceToMove: %s" % distanceToMove)
#mi_endLoc.tz = -(distanceToMove*insetMult)#Offset it
mi_endLoc.__setattr__('t%s' % latheAxis,
-(distanceToMove * insetMult))
log.debug("segment lathe: %s" % latheAxis)
log.debug("segment aim: %s" % aimAxis)
log.debug("segment rotateBank: %s" % rotateBank)
d_endCastInfo = createMeshSliceCurve(
targetGeo,
mi_endLoc,
midMeshCast=midMeshCast,
curveDegree=curveDegree,
latheAxis=latheAxis,
aimAxis=aimAxis,
posOffset=posOffset,
points=points,
returnDict=True,
closedCurve=closedCurve,
maxDistance=maxDistance,
closestInRange=closestInRange,
rotateBank=rotateBank,
l_specifiedRotates=l_specifiedRotates,
axisToCheck=axisToCheck)
l_sliceReturns.append(d_endCastInfo)
mi_end = cgmMeta.cgmObject(d_endCastInfo['curve'])
il_curvesToCombine.append(mi_end)
mc.delete(mi_endLoc.parent) #delete the loc
elif extendMode == 'radial':
log.debug("|{0}| >> radial...".format(_str_func))
d_handleInner = createMeshSliceCurve(
targetGeo,
mi_rootLoc,
midMeshCast=midMeshCast,
curveDegree=curveDegree,
latheAxis=latheAxis,
aimAxis=aimAxis,
posOffset=0,
points=points,
returnDict=True,
closedCurve=closedCurve,
maxDistance=maxDistance,
closestInRange=closestInRange,
rotateBank=rotateBank,
l_specifiedRotates=l_specifiedRotates,
axisToCheck=axisToCheck)
mi_buffer = cgmMeta.cgmObject(d_handleInner['curve']) #instance curve
l_sliceReturns.append(d_handleInner)
il_curvesToCombine.append(mi_buffer)
elif extendMode == 'disc':
log.debug("|{0}| >> disc...".format(_str_func))
d_size = returnBaseControlSize(mi_rootLoc, targetGeo,
axis=[aimAxis]) #Get size
#discOffset = d_size[ d_size.keys()[0]]*insetMult
size = False
l_absSize = [abs(i) for i in posOffset]
if l_absSize: size = max(l_absSize)
if not size:
d_size = returnBaseControlSize(mi_rootLoc,
targetGeo,
axis=[aimAxis]) #Get size
log.debug("d_size: %s" % d_size)
size = d_size[d_size.keys()[0]] * insetMult
discOffset = size
log.debug("d_size: %s" % d_size)
log.debug("discOffset is: %s" % discOffset)
mi_rootLoc.__setattr__('t%s' % latheAxis, discOffset)
if posOffset:
tmp_posOffset = [
posOffset[0] * .5, posOffset[1] * .5, posOffset[2] * .5
]
d_handleInnerUp = createMeshSliceCurve(
targetGeo,
mi_rootLoc,
curveDegree=curveDegree,
midMeshCast=midMeshCast,
latheAxis=latheAxis,
aimAxis=aimAxis,
posOffset=tmp_posOffset,
points=points,
returnDict=True,
closedCurve=closedCurve,
maxDistance=maxDistance,
closestInRange=closestInRange,
rotateBank=rotateBank,
l_specifiedRotates=l_specifiedRotates,
axisToCheck=axisToCheck)
mi_buffer = cgmMeta.cgmObject(
d_handleInnerUp['curve']) #instance curve
l_sliceReturns.append(d_handleInnerUp)
il_curvesToCombine.append(mi_buffer)
mi_rootLoc.__setattr__('t%s' % latheAxis, -discOffset)
d_handleInnerDown = createMeshSliceCurve(
targetGeo,
mi_rootLoc,
curveDegree=curveDegree,
midMeshCast=midMeshCast,
latheAxis=latheAxis,
aimAxis=aimAxis,
posOffset=tmp_posOffset,
points=points,
returnDict=True,
closedCurve=closedCurve,
maxDistance=maxDistance,
closestInRange=closestInRange,
rotateBank=rotateBank,
l_specifiedRotates=l_specifiedRotates,
axisToCheck=axisToCheck)
mi_buffer = cgmMeta.cgmObject(
d_handleInnerDown['curve']) #instance curve
l_sliceReturns.append(d_handleInnerDown)
il_curvesToCombine.append(mi_buffer)
mi_rootLoc.tz = 0
elif extendMode == 'cylinder':
log.debug("|{0}| >> cylinder...".format(_str_func))
d_size = returnBaseControlSize(mi_rootLoc, targetGeo,
axis=[aimAxis]) #Get size
discOffset = d_size[d_size.keys()[0]] * insetMult
log.debug("d_size: %s" % d_size)
log.debug("discOffset is: %s" % discOffset)
mi_rootLoc.__setattr__('t%s' % latheAxis, discOffset)
d_handleInnerUp = createMeshSliceCurve(
targetGeo,
mi_rootLoc,
curveDegree=curveDegree,
midMeshCast=midMeshCast,
latheAxis=latheAxis,
aimAxis=aimAxis,
posOffset=posOffset,
points=points,
returnDict=True,
closedCurve=closedCurve,
maxDistance=maxDistance,
closestInRange=closestInRange,
rotateBank=rotateBank,
l_specifiedRotates=l_specifiedRotates,
axisToCheck=axisToCheck)
mi_buffer = cgmMeta.cgmObject(
d_handleInnerUp['curve']) #instance curve
l_sliceReturns.append(d_handleInnerUp)
il_curvesToCombine.append(mi_buffer)
mi_rootLoc.__setattr__('t%s' % latheAxis, 0)
elif extendMode == 'loliwrap':
log.debug("|{0}| >> lolipop...".format(_str_func))
#l_absSize = [abs(i) for i in posOffset]
size = False
#if l_absSize:
#log.debug("l_absSize: %s"%l_absSize)
#size = max(l_absSize)*1.25
if subSize is not None:
size = subSize
if not size:
d_size = returnBaseControlSize(mi_rootLoc,
targetGeo,
axis=[aimAxis]) #Get size
log.info("d_size: %s" % d_size)
l_size = d_size[single_aimAxis]
size = l_size / 3
log.info("loli size: %s" % size)
i_ball = cgmMeta.cgmObject(
curves.createControlCurve('sphere', size=size))
elif extendMode == 'endCap':
log.debug("|{0}| >> endCap...".format(_str_func))
returnBuffer1 = createMeshSliceCurve(
targetGeo,
mi_rootLoc.mNode,
aimAxis='{0}+'.format(latheAxis),
latheAxis=objectUp[0],
curveDegree=curveDegree,
maxDistance=maxDistance,
closestInRange=closestInRange,
closedCurve=False,
l_specifiedRotates=[-90, -60, -30, 0, 30, 60, 90],
posOffset=posOffset)
mi_rootLoc.rotate = [0, 0, 0]
mi_rootLoc.__setattr__('r%s' % latheAxis, 90)
returnBuffer2 = createMeshSliceCurve(
targetGeo,
mi_rootLoc.mNode,
aimAxis='{0}+'.format(latheAxis),
latheAxis=objectUp[0],
curveDegree=curveDegree,
maxDistance=maxDistance,
closedCurve=False,
closestInRange=closestInRange,
l_specifiedRotates=[-90, -60, -30, 0, 30, 60, 90],
posOffset=posOffset)
l_sliceReturns.extend([returnBuffer1, returnBuffer2])
il_curvesToCombine.append(cgmMeta.cgmObject(returnBuffer1))
il_curvesToCombine.append(cgmMeta.cgmObject(returnBuffer2))
mi_rootLoc.rotate = [0, 0, 0]
#Now cast our root since we needed to move it with segment mode before casting
if extendMode == 'cylinder':
log.debug("|{0}| >> cylinder move...".format(_str_func))
mi_rootLoc.__setattr__('t%s' % latheAxis, -discOffset)
log.debug("|{0}| >> Rootcast...".format(_str_func))
d_rootCastInfo = createMeshSliceCurve(
targetGeo,
mi_rootLoc,
curveDegree=curveDegree,
minRotate=minRotate,
maxRotate=maxRotate,
latheAxis=latheAxis,
midMeshCast=midMeshCast,
aimAxis=aimAxis,
posOffset=posOffset,
points=points,
vectorOffset=vectorOffset,
returnDict=True,
closedCurve=closedCurve,
maxDistance=maxDistance,
closestInRange=closestInRange,
rotateBank=rotateBank,
l_specifiedRotates=l_specifiedRotates,
axisToCheck=axisToCheck)
#d_rootCastInfo = createMeshSliceCurve(targetGeo,mi_rootLoc,**kws)
log.debug("|{0}| >> Rootcast done".format(_str_func) + cgmGEN._str_subLine)
if extendMode == 'disc':
l_sliceReturns.insert(1, d_rootCastInfo)
else:
l_sliceReturns.insert(0, d_rootCastInfo)
#Special loli stuff
if extendMode == 'loliwrap':
SNAP.go(i_ball.mNode, mi_rootLoc.mNode, True,
True) #Snap to main object
#log.debug("hitReturns: %s"%d_rootCastInfo['hitReturns'])
#cgmGEN.walk_dat(d_rootCastInfo['hitReturns'],'hitReturns')
mi_crv = cgmMeta.cgmObject(d_rootCastInfo['curve'])
"""
d_return = RayCast.findMeshIntersectionFromObjectAxis(targetGeo,mi_rootLoc.mNode,mAxis_aim.p_string) or {}
if not d_return.get('hit'):
log.info(d_return)
raise ValueError,"No hit on loli check"
pos = d_return.get('hit')
dist = distance.returnDistanceBetweenPoints(i_ball.getPosition(),pos) * 2"""
if vectorOffset is not None:
dist = vectorOffset + subSize * 4
else:
dist = max(posOffset) + subSize * 4
if '-' in aimAxis:
distM = -dist
else:
distM = dist
log.debug("distM: %s" % distM)
#Move the ball
pBuffer = i_ball.doGroup()
i_ball.__setattr__('t%s' % single_aimAxis, distM)
i_ball.parent = False
mc.delete(pBuffer)
uPos = distance.returnClosestUPosition(i_ball.mNode, mi_crv.mNode)
SNAP.aim(i_ball.mNode, mi_rootLoc.mNode, aimAxis='z-')
#if posOffset:
#mc.move(posOffset[0]*3,posOffset[1]*3,posOffset[2]*3, [i_ball.mNode], r = True, rpr = True, os = True, wd = True)
#Make the curve between the two
mi_traceCrv = cgmMeta.cgmObject(
mc.curve(degree=1, ep=[uPos, i_ball.getPosition()]))
#Combine
il_curvesToCombine.extend([i_ball, mi_traceCrv])
mi_root = cgmMeta.cgmObject(d_rootCastInfo['curve']) #instance curve
il_curvesToCombine.append(mi_root)
mc.delete(mi_rootLoc.parent) #delete the loc
l_curvesToCombine = [mi_obj.mNode for mi_obj in il_curvesToCombine
] #Build our combine list before adding connectors
log.debug("|{0}| >> processed: {1}".format(
_str_func, d_rootCastInfo['processedHits']))
if joinMode and extendMode not in ['loliwrap', 'endCap'
] and len(l_sliceReturns) > 1:
if joinHits:
keys = d_rootCastInfo['processedHits'].keys()
keys.sort()
#goodDegrees = []
#for i,key in enumerate(keys):
#if i in joinHits:
#goodDegrees.append(key)
goodDegrees = [key for i, key in enumerate(keys) if i in joinHits]
log.debug("joinHits: %s" % joinHits)
log.debug("goodDegrees: %s" % goodDegrees)
else:
goodDegrees = [
key for key in d_rootCastInfo['processedHits'].keys()
]
#> Side Curves
for degree in goodDegrees:
l_pos = []
for d in l_sliceReturns:
l_pos.append(d['processedHits'].get(degree) or False)
while False in l_pos:
l_pos.remove(False)
log.debug("l_pos: %s" % l_pos)
if len(l_pos) >= 2:
try:
l_curvesToCombine.append(
mc.curve(d=curveDegree, ep=l_pos,
os=True)) #Make the curve
except:
log.debug(
"createWrapControlShape>>> skipping curve fail: %s" %
(degree))
#>>Combine the curves
newCurve = curves.combineCurves(l_curvesToCombine)
mi_crv = cgmMeta.cgmObject(rigging.groupMeObject(targetObjects[0], False))
curves.parentShapeInPlace(mi_crv.mNode, newCurve) #Parent shape
mc.delete(newCurve)
#>>Copy tags and name
mi_crv.doCopyNameTagsFromObject(targetObjects[0],
ignore=['cgmType', 'cgmTypeModifier'])
mi_crv.addAttr('cgmType',
attrType='string',
value='controlCurve',
lock=True)
mi_crv.doName()
#Store for return
return {'curve': mi_crv.mNode, 'instance': mi_crv}
def validateData(self):
# Validate data in case it was manually changed
#self.obj = cgmMeta.asMeta(self.obj)
self.aimFwd = VALID.simpleAxis(self.aimFwd)
self.aimUp = VALID.simpleAxis(self.aimUp)
def setAim(self, aimFwd=None, aimUp=None):
if aimFwd:
self.aimFwd = VALID.simpleAxis(aimFwd)
if aimUp:
self.aimUp = VALID.simpleAxis(aimUp)
def CreateChain(self, objs = None, fwd = 'z+', up='y+',name = None):
_str_func = 'CreateChain'
objs = cgmMeta.asMeta( mc.ls(sl=True) )
if not objs:
return log.warning("No objects passed. Unable to createChain")
if name is None:
name = objs[-1].p_nameBase
self.targets = self.targets + objs
fwdAxis = simpleAxis(fwd)
upAxis = simpleAxis(up)
crvPositions = []
for obj in objs:
crvPositions.append(obj.p_position)
crvPositions.append( DIST.get_pos_by_axis_dist(objs[-1], fwdAxis.p_string,
DIST.get_distance_between_points(crvPositions[-1],crvPositions[-2])) )
crvPositions.insert(0, DIST.get_pos_by_axis_dist(objs[0], fwdAxis.inverse.p_string,
DIST.get_distance_between_points(crvPositions[0],crvPositions[1])*.5) )
crv = CORERIG.create_at(create='curve',l_pos= crvPositions, baseName = name)
# make the dynamic setup
b_existing = False
if self.hairSystem != None:
log.info(cgmGEN.logString_msg(_str_func,'Using existing system: {0}'.format(self.hairSystem)))
mc.select(self.hairSystem, add=True)
b_existing = True
mel.eval('makeCurvesDynamic 2 { "0", "0", "1", "1", "0" }')
# get relevant nodes
follicle = mc.listRelatives(crv,parent=True)[0]
mFollicle = cgmMeta.asMeta(follicle)
mFollicle.rename("{0}_foll".format(name))
follicle = mFollicle.mNode
self.ml_follicles.append(mFollicle)
follicleShape = mc.listRelatives(mFollicle.mNode, shapes=True)[0]
self.hairSystem = mc.listRelatives( mc.listConnections('%s.currentPosition' % follicleShape)[0], shapes=True)[0]
if not b_existing:
mHairSys = cgmMeta.asMeta(self.hairSystem)
mHairSysDag = mHairSys.getTransform(asMeta=1)
mHairSysDag.rename("{0}_hairSys".format(self.baseName))
self.hairSystem = mHairSys.mNode
outCurve = mc.listConnections('%s.outCurve' % follicle)[0]
outCurveShape = mc.listRelatives(outCurve, shapes=True)[0]
self.nucleus = mc.listConnections( '%s.currentState' % self.hairSystem )[0]
if not b_existing:
pass
mc.select( objs[0].getParent() )
self.follicles.append(follicle)
self.outCurves.append(outCurve)
# set default properties
mc.setAttr( '%s.pointLock' % follicleShape, 1 )
mc.parentConstraint(objs[0].getParent(), follicle, mo=True)
# create locators on objects
locators = []
prs = []
for i, obj in enumerate(objs):
loc = LOC.create(obj.getNameLong())
locators.append(loc)
aimNull = mc.group(em=True)
aimNull = mc.rename('%s_aim' % obj.getShortName())
poc = mc.createNode('pointOnCurveInfo', name='%s_pos' % loc)
pocAim = mc.createNode('pointOnCurveInfo', name='%s_aim' % loc)
pr = CURVES.getUParamOnCurve(loc, outCurve)
mc.connectAttr( '%s.worldSpace[0]' % outCurveShape, '%s.inputCurve' % poc, f=True )
mc.connectAttr( '%s.worldSpace[0]' % outCurveShape, '%s.inputCurve' % pocAim, f=True )
mc.setAttr( '%s.parameter' % poc, pr )
if i < len(objs)-1:
nextpr = CURVES.getUParamOnCurve(objs[i+1], outCurve)
mc.setAttr('%s.parameter' % pocAim, (nextpr + pr) * .5)
else:
mc.setAttr( '%s.parameter' % pocAim, len(objs)+1 )
locParent = mc.group(em=True)
locParent = mc.rename( '%s_pos' % obj.getShortName() )
mc.connectAttr( '%s.position' % poc, '%s.translate' % locParent)
mc.connectAttr( '%s.position' % pocAim, '%s.translate' % aimNull)
aimConstraint = mc.aimConstraint( aimNull, locParent, aimVector=fwdAxis.p_vector, upVector = upAxis.p_vector, worldUpType = "objectrotation", worldUpVector = upAxis.p_vector, worldUpObject = objs[0].getParent() )
mc.parent(loc, locParent)
def create_proxyGeo(proxyShape='cube',
size=[1, 1, 1],
direction='z+',
ch=True):
try:
#cube:sphere:cylinder:cone:torus
_str_func = 'create_proxyGeo'
_proxyShape = _d_proxyCreate.get(proxyShape, proxyShape)
_call = getattr(mc, _proxyShape, None)
if not _call:
raise ValueError, "Failed to find maya.cmds call {0}".format(
_proxyShape)
#if proxyShape not in _d_create.keys():
#raise ValueError,"Unknown shape: {0}".format(proxyShape)
_kws = {'ch': ch}
if proxyShape in ['cube']:
_kws['width'] = size[0]
_kws['ch'] = False
if proxyShape in ['cylinder', 'sphere', 'cone', 'cylinder', 'torus']:
_kws['radius'] = max(size) / 2.0
_kws['axis'] = VALID.simpleAxis(direction).p_vector
_res = _call(**_kws)
if size is not None:
if VALID.isListArg(size):
TRANS.scale_to_boundingBox(_res[0], size)
else:
if absoluteSize:
_f_current = DIST.get_bb_size(_res[0], True, True)
multiplier = size / _f_current
mc.scale(multiplier,
multiplier,
multiplier,
_res[0],
relative=True)
else:
mc.scale(size, size, size, _res[0], os=True)
#mc.makeIdentity(_res[0], apply=True,s=1)
"""
if proxyShape == 'cube':
_d_directionXRotates = {'x+':[0,0,0],'x-':[0,180,0],'y+':[0,0,90],'y-':[0,0,-90],'z+':[0,-90,0],'z-':[0,90,0]}
_r_factor = _d_directionXRotates.get(direction)
mc.rotate (_r_factor[0], _r_factor[1], _r_factor[2], _res[0], ws=True)"""
#mc.makeIdentity(_res[0], apply=True,r =1, n= 1)
if proxyShape == 'cube':
_children = TRANS.children_get(_res[0])
for i, c in enumerate(_children):
_children[i] = TRANS.parent_set(c, False)
combineShapes(_children + [_res[0]],
keepSource=False,
replaceShapes=False)
return _res
except Exception, err:
cgmGEN.cgmExceptCB(Exception, err, msg=vars())
def orientByPlane(joints = None, axisAim = 'z+', axisUp = 'y+',
worldUpAxis = [0,1,0], planarMode = 'up', relativeOrient = True,
progressBar=None,
baseName = None, cleanUp = True, asMeta = True):
"""
Given a chain of joints, setup
:parameters:
planarMode - up/out - What plane to use
:returns
created(list)
"""
_str_func = 'orientPlane'
ml_joints = cgmMeta.validateObjListArg(joints,mayaType=['joint'],noneValid=False)
ml_joints = LISTS.get_noDuplicates(ml_joints)
mAxis_aim = VALID.simpleAxis(axisAim)
mAxis_up = VALID.simpleAxis(axisUp)
str_aim = mAxis_aim.p_string
str_up = mAxis_up.p_string
ml_delete = []
if str_aim == str_up:
raise ValueError,"axisAim and axisUp cannot be the same"
if len(ml_joints) < 3:
raise ValueError,"{0} > Need more than 3 joints".format(_str_func)
#First setup a dup chain of first and end, orient those ----------------------------------------------------------------
log.debug("|{0}| >> Setup tmp chain...".format(_str_func))
mStart = ml_joints[0].doDuplicate(parentOnly = True)
mEnd = ml_joints[-1].doDuplicate(parentOnly = True)
mEnd.parent = mStart
orientChain([mStart,mEnd], axisAim, axisUp, worldUpAxis, relativeOrient)
#Setup Loft curves and plane ----------------------------------------------------------------
log.debug("|{0}| >> Setup curves...".format(_str_func))
if planarMode == 'up':
crvUp = mAxis_up.p_string
crvDn = mAxis_up.inverse.p_string
else:
for a in 'xyz':
if a not in str_aim and a not in str_up:
mAxisCrv_tmp = VALID.simpleAxis(a+'+')
crvUp = mAxisCrv_tmp.p_string
crvDn = mAxisCrv_tmp.inverse.p_string
d_distance = DIST.get_distance_between_targets([mStart.mNode,mEnd.mNode])
l_crvs = []
for mObj in [mStart,mEnd]:
crv = mc.curve (d=1, ep = [DIST.get_pos_by_axis_dist(mObj.mNode, crvUp, d_distance),
DIST.get_pos_by_axis_dist(mObj.mNode, crvDn, d_distance)],
os=True)
log.debug("|{0}| >> Created: {1}".format(_str_func,crv))
l_crvs.append(crv)
_res_body = mc.loft(l_crvs, o = True, d = 1, po = 1 )
_inputs = mc.listHistory(_res_body[0],pruneDagObjects=True)
_tessellate = _inputs[0]
_d = {'format':2,#General
'polygonType':1,#'quads'
}
for a,v in _d.iteritems():
ATTR.set(_tessellate,a,v)
#Snap our joints ---------------------------------------------------------------------------------
for mJnt in ml_joints[1:-1]:
ml_children = mJnt.getChildren(asMeta=True)
for mChild in ml_children:
mChild.parent = False
SNAP.go(mJnt, _res_body[0], rotation=False, pivot='closestPoint')
for mChild in ml_children:
mChild.parent = mJnt
#Cleanup --------------------------------------------------------------------------------------------
if cleanUp:
mc.delete(_res_body + l_crvs)
mStart.delete()
orientChain(ml_joints, axisAim, axisUp, worldUpAxis, relativeOrient,progressBar)
return
l_start = []
l_end = []
mStartCrv = mc.curve()
mc.curve (d=1, ep = posList, os=True)
def snap_action(objects=None,
snapMode='point',
selectionMode='eachToLast',
**kws):
"""
"""
try:
_str_func = 'snap_action'
subKWS = {}
if objects is None:
objects = mc.ls(sl=True)
if snapMode == 'aim':
aim_axis = SHARED._l_axis_by_string[var_objDefaultAimAxis.value]
up_axis = SHARED._l_axis_by_string[var_objDefaultUpAxis.value]
subKWS = {
'aimAxis': aim_axis,
'upAxis': up_axis,
'mode': var_aimMode.value
}
if selectionMode == 'firstToRest':
MMCONTEXT.func_process(SNAP.aim_atMidPoint, objects,
selectionMode, 'Snap aim', **subKWS)
else:
MMCONTEXT.func_process(SNAP.aim, objects, selectionMode,
'Snap aim', **subKWS)
if selectionMode == 'eachToNext':
SNAP.aim(objects[-1], objects[-2],
VALID.simpleAxis(aim_axis).inverse.p_string, up_axis,
var_aimMode.value)
elif snapMode == 'ground':
MMCONTEXT.func_process(SNAP.to_ground, objects, 'each', 'Snap')
elif snapMode in [
'axisBox', 'boundingBox', 'boundingBoxShapes',
'boundingBoxEach', 'castCenter', 'castFar', 'castNear',
'castAllCenter', 'castAllFar', 'castAllNear'
]:
log.debug("|{0}| | special mode: {1}".format(_str_func, snapMode))
subKWS['mode'] = kws.get('mode', 'z+')
subKWS['arg'] = snapMode
if len(objects) == 1:
specialSnap(objects[0], **subKWS)
elif snapMode in ['boundingBox'] and selectionMode != 'each':
log.debug("|{0}| | bb each mode".format(_str_func, snapMode))
specialSnap(objects[0], objects, **subKWS)
else:
MMCONTEXT.func_process(specialSnap, objects, selectionMode,
'Snap Special', **subKWS)
else:
subKWS = {
'position': False,
'rotation': False,
'rotateAxis': False,
'rotateOrder': False,
'scalePivot': False,
'pivot': 'rp',
'space': 'w',
'mode': 'xform'
}
if snapMode in ['point', 'closestPoint']:
subKWS['position'] = True
elif snapMode == 'orient':
subKWS['rotation'] = True
elif snapMode == 'parent':
subKWS['position'] = True
subKWS['rotation'] = True
elif snapMode == 'aim':
subKWS['rotation'] = True
else:
raise ValueError, "Unknown mode!"
_pivotMode = var_snapPivotMode.value
if snapMode == 'closestPoint':
subKWS['pivot'] = 'closestPoint'
else:
if not _pivotMode: pass #0 handled by default
elif _pivotMode == 1:
subKWS['pivot'] = 'sp'
elif _pivotMode == 2:
subKWS['pivot'] = 'boundingBox'
else:
raise ValueError, "Uknown pivotMode: {0}".format(
_pivotMode)
MMCONTEXT.func_process(SNAP.go, objects, selectionMode, 'Snap',
**subKWS)
mc.select(objects)
return
except Exception, err:
cgmGEN.cgmExceptCB(Exception, err, msg=vars())
def test_axisToStrings(self):
for k, v in SHARED._d_axis_string_to_vector.iteritems():
self.assertEqual(validateArgs.simpleAxis(k).p_vector, v)
for k, v in SHARED._d_axis_string_to_vector.iteritems():
self.assertEqual(validateArgs.simpleAxis(v).p_string, k)
