def get_planeIntersect(planeSource=None,
target=None,
planeAxis='z+',
objAxis='z+',
mark=False):
_str_func = 'get_planeIntersect'
if target:
mTarget = cgmMeta.asMeta(target)
else:
mTarget = cgmMeta.asMeta(mc.ls(sl=1))
if not mTarget:
return log.error(cgmGEN.logString_msg(_str_func, 'No Target'))
mTarget = mTarget[0]
mObj = cgmMeta.asMeta(planeSource)
planePoint = VALID.euclidVector3Arg(mObj.p_position)
planeNormal = VALID.euclidVector3Arg(mObj.getAxisVector(planeAxis))
rayPoint = VALID.euclidVector3Arg(mTarget.p_position)
rayDirection = VALID.euclidVector3Arg(mTarget.getAxisVector(objAxis))
plane = EUCLID.Plane(
EUCLID.Point3(planePoint.x, planePoint.y, planePoint.z),
EUCLID.Point3(planeNormal.x, planeNormal.y, planeNormal.z))
pos = plane.intersect(
EUCLID.Line3(
EUCLID.Point3(rayPoint.x, rayPoint.y, rayPoint.z),
EUCLID.Vector3(rayDirection.x, rayDirection.y, rayDirection.z)))
if mark:
LOC.create(position=pos, name='pewpew_planeIntersect')
return pos
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 gather_worldStuff(groupTo = 'worldStuff',parent=True):
ml = []
for mObj in cgmMeta.asMeta(mc.ls('|*', type = 'transform')):
if mObj.p_nameBase in ['cgmLightGroup','master','main','cgmRigBlocksGroup']:
continue
_type = mObj.getMayaType()
if _type in ['camera']:
continue
if mObj.isReferenced():
continue
print mObj
print _type
ml.append(mObj)
if ml and parent:
if not mc.objExists(groupTo):
mGroup = cgmMeta.asMeta(mc.group(em=True))
mGroup.rename(groupTo)
else:
mGroup = cgmMeta.asMeta(groupTo)
for mObj in ml:
log.info("Parenting to {0} | {1} | {2}".format(groupTo, mObj.p_nameShort, mObj.getMayaType()))
mObj.p_parent = mGroup
pprint.pprint(ml)
return ml
def driven_connect(driven = None, driver = None, mode = 'best'):
"""
:parameters:
l_jointChain1 - First set of objects
:returns:
:raises:
Exception | if reached
"""
_str_func = 'driven_connect'
mDriven = cgmMeta.asMeta(driven)
mDriver = cgmMeta.asMeta(driver)
if mode == 'best':
mode = 'rigDefault'
if mode == 'rigDefault':
mc.pointConstraint(mDriver.mNode,mDriven.mNode,maintainOffset=False,weight=1)
mc.orientConstraint(mDriver.mNode,mDriven.mNode,maintainOffset=False,weight=1)
mc.scaleConstraint(mDriver.mNode,mDriven.mNode,maintainOffset=False,weight=1)
else:
pprint.pprint(vars())
raise ValueError,"Unknown mode: {0}".format(mode)
def ratio(nodes=[], mode='finger', move=True):
if not nodes:
nodes = mc.ls(sl=1)
mNodes = cgmMeta.asMeta(nodes)
if mode == 'finger':
assert len(mNodes) == 4, "Need 4 handles"
l_finger = [1.618, 1, 1]
s = 3.618
#First get our distances...
l_dist = []
ml_pairs = LISTS.get_listPairs(mNodes)
l_vectors = []
for mSet in ml_pairs:
_p = [mSet[0].p_position, mSet[1].p_position]
l_dist.append(DIST.get_between_points(_p[0], _p[1]))
l_vectors.append(MATH.get_vector_of_two_points(_p[0], _p[1]))
log.info("Distances: {0}".format(l_dist))
f_dist = sum(l_dist)
f_factor = f_dist / s
l_new = [x * f_factor for x in l_finger]
#l_new = MATH.normalizeList(l_finger, f_dist)
log.info("New: {0}".format(l_new))
#Now move them...
if move:
for i, mSet in enumerate(ml_pairs):
p = mSet[0].p_position
p_res = DIST.get_pos_by_vec_dist(p, l_vectors[i], l_new[i])
#LOC.create(position= p_res,name="ratio_{0}".format(i))
mSet[1].p_position = p_res
mc.select(nodes)
return
raise ValueError, "Unknown Mode: {0}".format(mode)
_res = {}
mNodes = cgmMeta.asMeta(nodes)
for mNode in mNodes:
try:
_res[mNode.mNode] = {
'pos': mNode.p_position,
'orient': mNode.p_orient
}
except Exception, err:
log.error("{0} | {1}".format(mNode, err))
def update(self, deltaTime=.04):
#log.info("Updating")
self.dir = self._bakedLoc.getTransformDirection(
self.aimFwd.p_vector) * self.objectScale
wantedTargetPos = (
(VALID.euclidVector3Arg(self.obj.p_position) + self.dir) - self.obj
.p_position).normalized() * self.objectScale + self.obj.p_position
wantedUp = self._bakedLoc.getTransformDirection(
self.aimUp.p_vector) * self.objectScale
self.positionForce = self.positionForce + (
(wantedTargetPos - self.aimTargetPos) * self.springForce)
self.positionForce = self.positionForce * (1.0 - self.damp)
self.angularForce = self.angularForce + (
(wantedUp - self.upTargetPos) * self.angularSpringForce)
self.angularForce = self.angularForce * (1.0 - self.angularDamp)
self.aimTargetPos = self.aimTargetPos + (self.positionForce *
deltaTime)
self.upTargetPos = self.upTargetPos + (self.angularForce * deltaTime)
SNAP.aim_atPoint(obj=self.obj.mNode,
mode='matrix',
position=self.aimTargetPos,
aimAxis=self.aimFwd.p_string,
upAxis=self.aimUp.p_string,
vectorUp=self.upTargetPos.normalized())
if self.debug:
if not self._debugLoc:
self._debugLoc = cgmMeta.asMeta(LOC.create(name='debug_loc'))
self._debugLoc.p_position = self.aimTargetPos
mc.setKeyframe(self._debugLoc.mNode, at='translate')
if not self._wantedUpLoc:
self._wantedUpLoc = cgmMeta.asMeta(
LOC.create(name='wanted_up_loc'))
self._wantedUpLoc.p_position = self.obj.p_position + self.upTargetPos
mc.setKeyframe(self._wantedUpLoc.mNode, at='translate')
if not self._wantedPosLoc:
self._wantedPosLoc = cgmMeta.asMeta(
LOC.create(name='wanted_pos_loc'))
self._wantedPosLoc.p_position = wantedTargetPos
mc.setKeyframe(self._wantedPosLoc.mNode, at='translate')
def get_rigGeo(self):
"""
First pass on qss verification
"""
_str_func = 'get_rigGeo'
log.debug("|{0}| >> ...".format(_str_func) + cgmGEN._str_hardBreak)
log.debug(self)
mMasterNull = self.masterNull
_res = []
_l_base = [o for o in mc.ls(type='mesh', visible=True, long=True)]
_l_dags = [VALID.getTransform(o) for o in _l_base]
_l_dags = LISTS.get_noDuplicates(_l_dags)
for o in _l_dags:
mObj = cgmMeta.asMeta(o)
if mObj.getMayaAttr('mClass') == 'cgmControl':
log.debug("|{0}| >> Invalid obj: {1}".format(_str_func, o))
continue
if mObj.getMayaAttr('cgmType') in [
'jointApprox', 'rotatePlaneVisualize'
]:
log.debug("|{0}| >> Invalid obj: {1}".format(_str_func, o))
continue
if 'proxy_geo' in o:
continue
if 'proxyGeo' in o:
continue
_res.append(mObj)
log.debug("|{0}| >> Visible shapes: {1} | dags: {2} | res: {3} ".format(
_str_func, len(_l_base), len(_l_dags), len(_res)))
return _res
def get_nodeSnapShot(asMeta = 1):
_str_func = 'get_nodeSnapShot'
#return mc.ls(l=True,dag=True)
_res = mc.ls(l=True)
if asMeta:
return cgmMeta.asMeta(_res)
return _res
def get_lights(self):
_str_func = 'factory.get_lights'
_profile = d_profiles.get(self.profile)
self.ml_lights = []
self.ml_lightDags = []
for n,d in _profile.iteritems():
_type = d.get('type')
try:_light = d_lightCalls[_type]()
except:
log.error("|{0}| >> Light create fail {1} | {2}".format(_str_func,n,_type))
continue
mLight = cgmMeta.asMeta(_light)
mLight.addAttr('cgmType','cgmLight',lock=True)
mDag = mLight.getTransform(asMeta=True)
mDag.rename("{0}_cgmLight".format(n))
for a,v in d['settings'].iteritems():
log.debug("|{0}| >> setting {1} | {2}:{3}".format(_str_func,n,a,v))
ATTR.set(mLight.mNode,a,v)
mDag.p_position = d['dag']['position']
mDag.p_orient = d['dag']['orient']
log.debug("|{0}| >> setting {1} | position:{2}".format(_str_func,n,d['dag']['position']))
log.debug("|{0}| >> setting {1} | orient:{2}".format(_str_func,n,d['dag']['orient']))
self.ml_lightDags.append(mDag)
self.ml_lights.append(mLight)
def _validate(self):
assert type(self.d_kws['addExtraGroups']) in [int, bool]
assert type(self.d_kws['addSpacePivots']) in [int, bool]
i_obj = self.mi_control
self.mi_control = cgmMeta.asMeta(i_obj,
'cgmControl',
setClass=True)
self.str_mirrorAxis = VALID.stringArg(
self.d_kws['mirrorAxis'], calledFrom=self._str_funcCombined)
self.str_mirrorSide = VALID.stringArg(
self.d_kws['mirrorSide'], calledFrom=self._str_funcCombined)
self.b_makeMirrorable = VALID.boolArg(
self.d_kws['makeMirrorable'],
calledFrom=self._str_funcCombined)
self._addMirrorAttributeBridges = self.d_kws.get(
'addMirrorAttributeBridges') or False
if self._addMirrorAttributeBridges:
if type(self._addMirrorAttributeBridges) not in [list, tuple]:
raise StandardError, "[Bad addMirrorAttributeBridge arg]{arg: %s}" % self._addMirrorAttributeBridge
for i, l in enumerate(self._addMirrorAttributeBridges):
if type(l) not in [list, tuple]:
raise StandardError, "[Bad addMirrorAttributeBridge arg: %s]{arg: %s}" % (
i, l)
# Running lists ------------------------------------------------------------------------------------------
self.ml_groups = [] #Holder for groups
self.ml_constraintGroups = []
self.ml_spacePivots = []
def profile_load(target = None, arg = None, module = dynFKPresets, clean = True):
_str_func = 'profile_apply'
mTar = cgmMeta.asMeta(target, noneValid = True)
if not mTar:
return log.error(cgmGEN.logString_msg(_str_func, "No valid target"))
_type = mTar.getMayaType()
_key = d_shortHand.get(_type,_type)
log.info(cgmGEN.logString_msg(_str_func,"mTar: {0} | {1}".format(_type, mTar)))
_d_profile = profile_get(arg,module)
if not _d_profile:
log.warning("Invalid profile: {0}".format(arg))
return False
_d_type = _d_profile.get(_key)
if not _d_type:
log.warning("No {0} dat".format(_type))
return False
if clean:
d_use = profile_get('base',module).get(_key)
d_use.update(_d_type)
else:
d_use = _d_type
_node = mTar.mNode
for a,v in d_use.iteritems():
log.debug("{0} || {1} | {2}".format(_type, a,v))
try:
ATTR.set(_node, a, v)
#mNucleus.__setattr__(a,v)
except Exception,err:
log.warning("{3} | Failed to set: {0} | {1} | {2}".format(a,v,err, _type))
def block_getFromSelected():
_str_func = 'block_getFromSelected'
_res = []
mL = cgmMeta.asMeta(sl=1, noneValid=True) or []
for mObj in mL:
if mObj.getMayaAttr('mClass') == 'cgmRigBlock':
return mObj
_found = SEARCH.seek_upStream(mObj.mNode,
matchAttrValue={'mClass': 'cgmRigBlock'})
log.info(_found)
if _found:
return cgmMeta.asMeta(_found)
return False
def get_dat(surface=None, uKnots=True, vKnots=True):
"""
Function to split a curve up u positionally
:parameters:
'curve'(None) -- Curve to split
:returns
list of values(list)
hat tip: http://ewertb.soundlinker.com/mel/mel.074.php
"""
_str_func = 'get_dat'
log.debug("|{0}| >> ".format(_str_func) + '-' * 80)
surface = VALID.shapeArg(surface, 'nurbsSurface', True)
mSurfaceInfo = False
_res = {}
_short = NAMES.short(surface)
mSurfaceInfo = cgmMeta.asMeta(NODES.create(_short, 'surfaceInfo'))
mSurfaceInfo.doConnectIn('inputSurface', '{0}.worldSpace'.format(surface))
if uKnots:
_res['uKnots'] = [u for u in mSurfaceInfo.knotsU[0]]
if vKnots:
_res['vKnots'] = [u for u in mSurfaceInfo.knotsV[0]]
if mSurfaceInfo: mSurfaceInfo.delete()
return _res
def get_dat(target = None, differential=False, module = dynFKPresets):
_str_func = 'get_dat'
mTar = cgmMeta.asMeta(target, noneValid = True)
if not mTar:
return log.error(cgmGEN.logString_msg(_str_func, "No valid target"))
_type = mTar.getMayaType()
_key = d_shortHand.get(_type,_type)
log.info(cgmGEN.logString_msg(_str_func,"mTar: {0} | {1}".format(_type, mTar)))
#_d = ATTR.get_attrsByTypeDict(mTar.mNode)
#pprint.pprint(_d)
_res = {}
_tar = mTar.mNode
for section,l in d_attrMap.get(_key).iteritems():
log.debug(cgmGEN.logString_msg(_str_func,section))
for a in l:
if a in l_ignore:
continue
try:
_v = ATTR.get(_tar,a)
log.debug(cgmGEN.logString_msg(_str_func,"{0} | {1}".format(a,_v)))
except Exception,err:
log.error("Failed to query: {0} | {1} | {2}".format(_tar, a, err))
if _v is not None:
_res[str(a)] = _v
def constructPlaneInfo(self):
self._currentPlaneObject = cgmMeta.asMeta(self.planeObject) if (
self.planeObject and self.plane == 'custom') else cgmMeta.asMeta(
self.recordableObjs[0].obj)
self._offsetUpVector = self.aimUp.p_vector
if self.plane == 'planeX':
self.planeNormal = MATHUTILS.Vector3.right()
self.keyableAttrs = ['ty', 'tz']
elif self.plane == 'planeY':
self.planeNormal = MATHUTILS.Vector3.up()
self.keyableAttrs = ['tx', 'tz']
elif self.plane == 'planeZ':
self.planeNormal = MATHUTILS.Vector3.forward()
self.keyableAttrs = ['tx', 'ty']
elif self.plane == 'axisX':
self.planeNormal = VALID.euclidVector3Arg(
self.cam.getTransformDirection(MATHUTILS.Vector3.forward()))
self.keyableAttrs = ['tx']
elif self.plane == 'axisY':
self.planeNormal = VALID.euclidVector3Arg(
self.cam.getTransformDirection(MATHUTILS.Vector3.forward()))
self.keyableAttrs = ['ty']
elif self.plane == 'axisZ':
self.planeNormal = VALID.euclidVector3Arg(
self.cam.getTransformDirection(MATHUTILS.Vector3.forward()))
self.keyableAttrs = ['tz']
elif self.plane == 'custom':
if self.planeObject:
self.planeNormal = MATHUTILS.Vector3.up()
self._offsetUpVector = self.planeObject.getTransformInverseDirection(
self.recordableObjs[0].obj.getTransformDirection(
self.aimUp.p_vector))
self.keyableAttrs = ['tx', 'ty', 'tz']
else:
log.error(
"|{0}| >> Custom plane not found. Please input and try again"
.format(_str_func))
return
elif self.plane == 'object':
self.planeNormal = VALID.euclidVector3Arg(self.aimUp.p_vector)
self.keyableAttrs = ['tx', 'ty', 'tz']
else:
self.planeNormal = VALID.euclidVector3Arg(
self.cam.getTransformDirection(MATHUTILS.Vector3.forward()))
self.keyableAttrs = ['tx', 'ty', 'tz']
def __init__(self, obj=None):
self.obj = cgmMeta.asMeta(obj)
self.dataDict = {}
self._bakedLoc = None
self._animStoreLoc = None
self.hasSavedKeys = False
self._prevDataDict = {}
def bakeTempLocator(self, startTime=None, endTime=None):
_str_func = 'PostBake.bakeTempLocator'
if startTime is None:
startTime = self.startTime
if endTime is None:
endTime = self.endTime
ct = mc.currentTime(q=True)
self._bakedLoc = cgmMeta.asMeta(LOC.create(name='bakeLoc'))
self._bakedLoc.rotateOrder = self.obj.rotateOrder
SNAP.matchTarget_set(self._bakedLoc.mNode, self.obj.mNode)
_len = endTime - startTime
_progressBar = cgmUI.doStartMayaProgressBar(_len, "Processing...")
_obj = VALID.objString(self._bakedLoc.mNode, noneValid=False)
_target = VALID.objString(
self.obj.mNode, noneValid=False
) #ATTR.get_message(_obj, 'cgmMatchTarget','cgmMatchDat',0)
ak = mc.autoKeyframe(q=True, state=True)
mc.autoKeyframe(state=False)
mc.refresh(su=True)
completed = True
for i in range(startTime, endTime + 1):
mc.currentTime(i)
SNAP.go(_obj, _target, True, True, pivot='rp')
mc.setKeyframe(_obj, at=['translate', 'rotate'])
if _progressBar:
if mc.progressBar(_progressBar, query=True, isCancelled=True):
log.warning('Bake cancelled!')
completed = False
break
mc.progressBar(_progressBar,
edit=True,
status=("{0} On frame {1}".format(_str_func,
i)),
step=1,
maxValue=_len)
mc.refresh(su=False)
mc.autoKeyframe(state=ak)
cgmUI.doEndMayaProgressBar(_progressBar)
mc.currentTime(ct)
return completed
def setupWheelRoll(dat = _d_wheels):
for m,d in dat.iteritems():
mModule = cgmMeta.asMeta(m)
mRigNull = mModule.rigNull
mPivot = mRigNull.getMessageAsMeta('pivotResultDriver')
mSettings = mRigNull.getMessageAsMeta('settings')
mAttr = cgmMeta.cgmAttr(mSettings, 'wheelSpin','float',hidden=False,keyable=True)
mAttr.doConnectOut("{0}.rx".format(mPivot.mNode))
def objectDat_set(dat={}, position=True, orient=True):
for Node, d in dat.iteritems():
try:
log.info(Node)
mNode = cgmMeta.asMeta(Node)
if position:
mNode.p_position = d['pos']
if orient:
mNode.p_orient = d['orient']
except Exception, err:
log.error("{0} | {1}".format(mNode, err))
def preBake(self):
self.bakeTempLocator()
points = []
ks = [0]
k = -1
mc.refresh(su=not self.showBake)
for i in range(self.startTime, self.endTime + 1):
mc.currentTime(i)
points.append(self._bakedLoc.p_position)
ks.append(min(max(k, 0), self.endTime - self.startTime - 2))
k = k + 1
mc.refresh(su=False)
ks.append(ks[-1])
self.motionCurve = cgmMeta.asMeta(
mc.curve(name='motionCurve', d=3, p=points, k=ks))
mc.rebuildCurve(self.motionCurve.mNode,
ch=False,
rpo=True,
rt=0,
end=1,
kr=0,
kcp=1,
kep=1,
kt=0,
s=4,
d=3,
tol=3.28084e-06)
mc.cutKey(self.obj.mNode, at=['tx', 'ty', 'tz'], clear=True)
self.motionPath = cgmMeta.asMeta(
mc.pathAnimation(self.obj.mNode,
self.motionCurve.mNode,
fractionMode=False,
follow=False,
startTimeU=self.startTime,
endTimeU=self.endTime))
def rename_deformers(nodes=[], deformerTypes='all'):
if not nodes:
nodes = mc.ls(sl=1)
ml_nodes = cgmMeta.asMeta(nodes)
for mObj in ml_nodes:
for mDef in mObj.getDeformers(deformerTypes, True):
log.info("Renaming: {0}".format(mDef))
mc.rename(
mDef.mNode,
"{0}_{1}".format(mObj.p_nameBase,
SEARCH.get_tagInfoShort(mDef.getMayaType())))
def distanceMeasure(start=None, end=None, baseName='measureThis', asMeta=True):
"""
Get the the closest return based on a source and target and variable modes
:parameters:
:start(str): Our start obj
:end(str): End obj
:baseName(str):What mode are we checking data from
:asMeta(bool)
:returns
{shape,dag,loc_start,loc_end,start,end}
"""
try:
_str_func = 'create_distanceMeasure'
_res = DIST.create_distanceMeasure(start, end, baseName)
if not asMeta:
return _res
_res['mShape'] = cgmMeta.asMeta(_res['shape'])
_res['mDag'] = cgmMeta.asMeta(_res['dag'])
_res['mStart'] = cgmMeta.asMeta(_res['start'])
_res['mEnd'] = cgmMeta.asMeta(_res['end'])
if _res.get('loc_start'):
_res['mLoc_start'] = cgmMeta.asMeta(_res['loc_start'])
if _res.get('loc_end'):
_res['mLoc_end'] = cgmMeta.asMeta(_res['loc_end'])
return _res
except Exception, err:
cgmGEN.cgmExceptCB(Exception, err)
def get_planeIntersect(self,
target=None,
planeAxis='z+',
objAxis='z+',
mark=True):
_short = self.mNode
_str_func = '[{0}] get_planeIntersect'.format(_short)
if target:
mTarget = cgmMeta.asMeta(target)
else:
mTarget = cgmMeta.asMeta(mc.ls(sl=1))
if not mTarget:
return log.error(cgmGEN.logString_msg(_str_func, 'No Target'))
mTarget = mTarget[0]
if not self.atUtils('is_rigged'):
mObj = self
else:
mObj = self.moduleTarget.eyeLook
planePoint = VALID.euclidVector3Arg(mObj.p_position)
planeNormal = VALID.euclidVector3Arg(mObj.getAxisVector(planeAxis))
rayPoint = VALID.euclidVector3Arg(mTarget.p_position)
rayDirection = VALID.euclidVector3Arg(mTarget.getAxisVector(objAxis))
plane = EUCLID.Plane(
EUCLID.Point3(planePoint.x, planePoint.y, planePoint.z),
EUCLID.Point3(planeNormal.x, planeNormal.y, planeNormal.z))
pos = plane.intersect(
EUCLID.Line3(
EUCLID.Point3(rayPoint.x, rayPoint.y, rayPoint.z),
EUCLID.Vector3(rayDirection.x, rayDirection.y, rayDirection.z)))
if mark:
LOC.create(position=pos, name='pewpew')
return pos
def bakeLoc(self, obj=None):
if obj is None:
obj = self.obj
self._bakedLoc = cgmMeta.asMeta(
LOC.create(name='{0}_bakeLoc'.format(self.obj.mNode)))
SNAP.matchTarget_set(self._bakedLoc.mNode, obj.mNode)
ct = mc.currentTime(q=True)
SNAP.matchTarget_snap(self._bakedLoc.mNode)
mc.currentTime(ct)
def cards_outSnap(nodes=None):
if not nodes:
mNodes = cgmMeta.asMeta(sl=1)
else:
mNodes = cgmMeta.asMeta(nodes)
_current = mc.currentTime(q=True)
for mObj in mNodes:
mc.currentTime(_current)
mObj.doSnapTo('holdem_sockets:socket_wheel')
mObj.scaleY = .5
mc.setKeyframe(mObj.mNode)
mc.currentTime(_current + 1)
mObj.doSnapTo('holdem_sockets:startScoket')
mObj.scaleY = .25
mc.setKeyframe(mObj.mNode)
_current = mc.currentTime(q=True)
def layers_getUnused(delete=False):
ml = []
for mObj in cgmMeta.asMeta(mc.ls(type = 'displayLayer')):
if not mc.editDisplayLayerMembers(mObj.mNode, q=True):
ml.append(mObj)
if delete:
for mObj in ml:
if not mObj.isReferenced():
log.info("Deleting empty layer {0} ".format(mObj))
mObj.delete()
return True
return ml
def LoadAnimList(self):
# Find anim list node
animListNodes = mc.ls("*.subAnimList")
if len(animListNodes) > 0:
self.animListNode = cgmMeta.asMeta(animListNodes)[0]
animListString = self.animListNode.subAnimList
if animListString:
self.animDict = animListString #json.loads(animListString)
for key in self.animDict:
if len(self.animDict[key]) == 2:
self.animDict[key].append(self.animDict[key][1] -
self.animDict[key][0])
def get_meshFromNurbs(nurbSurface = None, mode = 'default', uNumber = 10, vNumber = 10):
mMesh = cgmMeta.validateObjArg(nurbSurface,mayaType='nurbsSurface')
mDup = mMesh.doDuplicate(po=False)
#mNew = self.doCreateAt(setClass='cgmObject')
newShapes = []
for mShape in mDup.getShapes(asMeta=1):
if mode == 'default':
d_kws = {}
_res = mc.nurbsToPoly(mShape.mNode, mnd=1,ch=0,f=3,pt =1,pc =200,
chr =0.9,ft =0.01,mel =0.001,d =0.1,ut =1,un =3,
vt =1,vn =3,uch =0,ucr =0,cht =0.2,es =0,ntr =0,
mrt =0,uss =1)
elif mode == 'general':
d_kws = {'mnd' :1,
'ch':0 ,
'f': 2,
'pt': 1,#quad
'pc':200,
'chr':0.9,
'ft':0.01,
'mel': 0.001,
'd':0.1,
'ut': 1,
'un': uNumber,
'vt':1,
'vn': vNumber,
'uch': 0,
'ucr':0,
'cht':0.2,
'es':0,
'ntr':0,
'mrt':0,
'uss':1}
_res = mc.nurbsToPoly(mShape.mNode, **d_kws)
else:
raise ValueError,"get_meshFromNurbs | Unknown mode: {0}".format(mode)
newShapes.append(_res[0])
if len(newShapes)>1:
_mesh = mc.polyUnite(newShapes,ch=False)[0]
else:
_mesh = newShapes[0]
mNew = cgmMeta.asMeta(_mesh)
#for s in newShapes:
mDup.delete()
return mNew
def _create(self):
#>> Quick links ============================================================================
d_closestInfo = self.d_closestInfo
self.paramU = d_closestInfo[
'parameterU'] #d_closestInfo['normalizedU']
self.paramV = d_closestInfo[
'parameterV'] #d_closestInfo['normalizedV']
if self.b_attachControlLoc or not self.b_createControlLoc:
try: #>>> Follicle ============================================================================
l_follicleInfo = NODES.createFollicleOnMesh(
self.mi_targetSurface.mNode)
mi_follicleAttachTrans = cgmMeta.asMeta(l_follicleInfo[1],
'cgmObject',
setClass=True)
mi_follicleAttachShape = cgmMeta.asMeta(
l_follicleInfo[0], 'cgmNode')
#> Name ----------------------------------------------------------------------------------
mi_follicleAttachTrans.doStore('cgmName', self.mi_obj)
mi_follicleAttachTrans.addAttr('cgmTypeModifier',
'attach',
lock=True)
mi_follicleAttachTrans.doName()
#>Set follicle value ---------------------------------------------------------------------
mi_follicleAttachShape.parameterU = self.paramU
mi_follicleAttachShape.parameterV = self.paramV
self.mi_follicleAttachTrans = mi_follicleAttachTrans #link
self.mi_follicleAttachShape = mi_follicleAttachShape #link
self.mi_obj.connectChildNode(mi_follicleAttachTrans,
"follicleAttach",
"targetObject")
self.md_return["follicleAttach"] = mi_follicleAttachTrans
self.md_return[
"follicleAttachShape"] = mi_follicleAttachShape
except Exception, error:
raise StandardError, "!Attach Follicle! | %s" % (error)
def objectDat_get(nodes=[]):
if not nodes:
nodes = mc.ls(sl=1)
_res = {}
mNodes = cgmMeta.asMeta(nodes)
for mNode in mNodes:
try:
_res[mNode.mNode] = {
'pos': mNode.p_position,
'orient': mNode.p_orient
}
except Exception, err:
log.error("{0} | {1}".format(mNode, err))
def _shapeParent(self):
shapeParentTo = self.d_kws['shapeParentTo']
if shapeParentTo:
try:
i_target = cgmMeta.validateObjArg(shapeParentTo,cgmMeta.cgmObject)
curves.parentShapeInPlace(i_target.mNode,self.mi_control.mNode)
i_target = cgmMeta.asMeta(i_target,'cgmControl',setClass = True)
#self.mi_control.delete()
self.mi_control = i_target#replace the control with the joint
except Exception,error:raise StandardError,"shapeParentTo | %s"%error
useShape = self.d_kws['useShape']
if useShape is not None:
try:
i_shape = cgmMeta.validateObjArg(useShape,cgmMeta.cgmObject,mayaType='nurbsCurve')
curves.parentShapeInPlace(self.mi_control.mNode,i_shape.mNode)
except Exception,error:raise StandardError,"useShape | %s"%error
def _copyTransform(self):
copyTransform = self.d_kws['copyTransform']
if copyTransform is not None:
if issubclass(type(copyTransform),cgmMeta.cgmNode):
i_target = copyTransform
elif mc.objExists(copyTransform):
i_target = cgmMeta.cgmObject(copyTransform)
else:
raise StandardError,"Failed to find suitable copyTransform object: '%s"%copyTransform
#Need to move this to default cgmNode stuff
mBuffer = self.mi_control
i_newTransform = cgmMeta.cgmObject( rigging.groupMeObject(i_target.mNode,False) )
for a in mc.listAttr(self.mi_control.mNode, userDefined = True):
attributes.doCopyAttr(self.mi_control.mNode,a,i_newTransform.mNode)
curves.parentShapeInPlace(i_newTransform.mNode,self.mi_control.mNode)#Parent shape
i_newTransform.parent = self.mi_control.parent#Copy parent
self.mi_control = cgmMeta.asMeta(i_newTransform,'cgmControl', setClass=True)
mc.delete(mBuffer.mNode)
def _validate(self):
assert type(self.d_kws['addExtraGroups']) in [int,bool]
assert type(self.d_kws['addSpacePivots']) in [int,bool]
i_obj = self.mi_control
self.mi_control = cgmMeta.asMeta(i_obj,'cgmControl', setClass=True)
self.str_mirrorAxis = cgmValid.stringArg(self.d_kws['mirrorAxis'],calledFrom = self._str_funcCombined)
self.str_mirrorSide = cgmValid.stringArg(self.d_kws['mirrorSide'],calledFrom = self._str_funcCombined)
self.b_makeMirrorable = cgmValid.boolArg(self.d_kws['makeMirrorable'],calledFrom = self._str_funcCombined)
self._addMirrorAttributeBridges = self.d_kws.get('addMirrorAttributeBridges') or False
if self._addMirrorAttributeBridges :
if type(self._addMirrorAttributeBridges ) not in [list,tuple]:raise StandardError,"[Bad addMirrorAttributeBridge arg]{arg: %s}"%self._addMirrorAttributeBridge
for i,l in enumerate(self._addMirrorAttributeBridges):
if type(l) not in [list,tuple]:raise StandardError,"[Bad addMirrorAttributeBridge arg: %s]{arg: %s}"%(i,l)
# Running lists ------------------------------------------------------------------------------------------
self.ml_groups = []#Holder for groups
self.ml_constraintGroups = []
self.ml_spacePivots = []
def _create(self):
#>> Quick links ============================================================================
d_closestInfo = self.d_closestInfo
if self.b_attachControlLoc or not self.b_createControlLoc:
try:#>>> Follicle ============================================================================
l_follicleInfo = nodes.createFollicleOnMesh(self.mi_targetSurface.mNode)
mi_follicleAttachTrans = cgmMeta.asMeta(l_follicleInfo[1],'cgmObject',setClass=True)
mi_follicleAttachShape = cgmMeta.asMeta(l_follicleInfo[0],'cgmNode')
#> Name ----------------------------------------------------------------------------------
mi_follicleAttachTrans.doStore('cgmName',self.mi_obj.mNode)
mi_follicleAttachTrans.addAttr('cgmTypeModifier','attach',lock=True)
mi_follicleAttachTrans.doName()
#>Set follicle value ---------------------------------------------------------------------
mi_follicleAttachShape.parameterU = d_closestInfo['normalizedU']
mi_follicleAttachShape.parameterV = d_closestInfo['normalizedV']
self.mi_follicleAttachTrans = mi_follicleAttachTrans#link
self.mi_follicleAttachShape = mi_follicleAttachShape#link
self.mi_obj.connectChildNode(mi_follicleAttachTrans,"follicleAttach","targetObject")
self.md_return["follicleAttach"] = mi_follicleAttachTrans
self.md_return["follicleAttachShape"] = mi_follicleAttachShape
except Exception,error:raise StandardError,"!Attach Follicle! | %s"%(error)
if not self.b_createControlLoc:#If we don't have a control loc setup, we're just attaching to the surface
try:#Groups =======================================================================================
mi_followGroup = self.mi_obj.doDuplicateTransform(True)
mi_followGroup.doStore('cgmName',self.mi_obj.mNode)
mi_followGroup.addAttr('cgmTypeModifier','follow',lock=True)
mi_followGroup.doName()
mi_followGroup.parent = mi_follicleAttachTrans
if self.b_parentToFollowGroup:
#raise StandardError,"shouldn't be here"
self.mi_obj.parent = mi_followGroup
self.md_return["followGroup"] = mi_followGroup
else:
#Driver loc -----------------------------------------------------------------------
mi_driverLoc = self.mi_obj.doLoc()
mi_driverLoc.doStore('cgmName',self.mi_obj.mNode)
mi_driverLoc.addAttr('cgmTypeModifier','driver',lock=True)
mi_driverLoc.doName()
self.mi_driverLoc = mi_driverLoc
mi_driverLoc.parent = mi_followGroup
mi_driverLoc.visibility = False
self.md_return["driverLoc"] = mi_driverLoc
#Constrain =====================================================================
#mc.pointConstraint(self.mi_driverLoc.mNode, self.mi_obj.mNode, maintainOffset = True)
#mc.orientConstraint(self.mi_driverLoc.mNode, self.mi_obj.mNode, maintainOffset = True)
if self.b_pointAttach:
mc.pointConstraint(self.mi_driverLoc.mNode, self.mi_obj.mNode, maintainOffset = True)
else:
mc.parentConstraint(self.mi_driverLoc.mNode, self.mi_obj.mNode, maintainOffset = True)
except Exception,error:raise StandardError,"!Groups - no control Loc setup! | %s"%(error)
else:#Setup control loc stuff
try:#>>> Follicle ============================================================================
l_follicleInfo = nodes.createFollicleOnMesh(self.mi_targetSurface.mNode)
mi_follicleFollowTrans = cgmMeta.asMeta(l_follicleInfo[1],'cgmObject',setClass=True)
mi_follicleFollowShape = cgmMeta.asMeta(l_follicleInfo[0],'cgmNode')
#> Name ----------------------------------------------------------------------------------
mi_follicleFollowTrans.doStore('cgmName',self.mi_obj.mNode)
mi_follicleFollowTrans.addAttr('cgmTypeModifier','follow',lock=True)
mi_follicleFollowTrans.doName()
#>Set follicle value ---------------------------------------------------------------------
mi_follicleFollowShape.parameterU = d_closestInfo['normalizedU']
mi_follicleFollowShape.parameterV = d_closestInfo['normalizedV']
self.mi_follicleFollowTrans = mi_follicleFollowTrans#link
self.mi_follicleFollowShape = mi_follicleFollowShape#link
self.md_return["follicleFollow"] = mi_follicleFollowTrans
self.md_return["follicleFollowShape"] = mi_follicleFollowShape
self.mi_obj.connectChildNode(mi_follicleFollowTrans,"follicleFollow")
#Groups =======================================================================================
mi_followGroup = mi_follicleFollowTrans.duplicateTransform()
mi_followGroup.doStore('cgmName',self.mi_obj.mNode)
mi_followGroup.addAttr('cgmTypeModifier','follow',lock=True)
mi_followGroup.doName()
self.mi_followGroup = mi_followGroup
self.mi_followGroup.parent = mi_follicleFollowTrans
self.md_return["followGroup"] = mi_followGroup
except Exception,error:raise StandardError,"!Follicle - attach Loc setup! | %s"%(error)
mi_offsetGroup = self.mi_obj.duplicateTransform()
mi_offsetGroup.doStore('cgmName',self.mi_obj.mNode)
mi_offsetGroup.addAttr('cgmTypeModifier','offset',lock=True)
mi_offsetGroup.doName()
mi_offsetGroup.parent = mi_followGroup
self.mi_offsetGroup = mi_offsetGroup
self.md_return["offsetGroup"] = mi_offsetGroup
if self.b_attachControlLoc:mi_follicleFollowTrans.connectChildNode(mi_offsetGroup,"followOffsetGroup","follicle")
mi_zeroGroup = cgmMeta.asMeta( mi_offsetGroup.doGroup(True),'cgmObject',setClass=True)
mi_zeroGroup.doStore('cgmName',self.mi_obj.mNode)
mi_zeroGroup.addAttr('cgmTypeModifier','zero',lock=True)
mi_zeroGroup.doName()
mi_zeroGroup.parent = mi_followGroup
self.mi_zeroGroup = mi_zeroGroup
self.md_return["zeroGroup"] = mi_zeroGroup
#Driver loc -----------------------------------------------------------------------
mi_driverLoc = self.mi_obj.doLoc()
mi_driverLoc.doStore('cgmName',self.mi_obj.mNode)
mi_driverLoc.addAttr('cgmTypeModifier','driver',lock=True)
mi_driverLoc.doName()
self.mi_driverLoc = mi_driverLoc
mi_driverLoc.parent = mi_offsetGroup
mi_driverLoc.visibility = False
self.md_return["driverLoc"] = mi_driverLoc
#Closest setup =====================================================================
mi_controlLoc = self.mi_obj.doLoc()
mi_controlLoc.doStore('cgmName',self.mi_obj.mNode)
mi_controlLoc.addAttr('cgmTypeModifier','control',lock=True)
mi_controlLoc.doName()
self.mi_controlLoc = mi_controlLoc
self.md_return["controlLoc"] = mi_controlLoc
if self.b_attachControlLoc:
mi_group = cgmMeta.asMeta( mi_controlLoc.doGroup(),'cgmObject',setClass=True )
mi_group.parent = mi_follicleAttachTrans
#Create decompose node --------------------------------------------------------------
mi_worldTranslate = cgmMeta.cgmNode(nodeType = 'decomposeMatrix')
mi_worldTranslate.doStore('cgmName',self.mi_obj.mNode)
mi_worldTranslate.doName()
self.mi_worldTranslate = mi_worldTranslate
attributes.doConnectAttr("%s.worldMatrix"%(mi_controlLoc.mNode),"%s.%s"%(mi_worldTranslate.mNode,'inputMatrix'))
#Create node --------------------------------------------------------------
mi_cpos = NodeF.createNormalizedClosestPointNode(self.mi_obj,self.mi_targetSurface)
attributes.doConnectAttr ((mi_cpos.mNode+'.out_uNormal'),(mi_follicleFollowShape.mNode+'.parameterU'))
attributes.doConnectAttr ((mi_cpos.mNode+'.out_vNormal'),(mi_follicleFollowShape.mNode+'.parameterV'))
#attributes.doConnectAttr ((mi_controlLoc.mNode+'.translate'),(mi_cpos.mNode+'.inPosition'))
attributes.doConnectAttr ((mi_worldTranslate.mNode+'.outputTranslate'),(mi_cpos.mNode+'.inPosition'))
#Constrain =====================================================================
#mc.pointConstraint(self.mi_driverLoc.mNode, self.mi_obj.mNode, maintainOffset = True)
#mc.orientConstraint(self.mi_driverLoc.mNode, self.mi_obj.mNode, maintainOffset = True)
if self.b_pointAttach:
mc.pointConstraint(self.mi_driverLoc.mNode, self.mi_obj.mNode, maintainOffset = True)
else:
mc.parentConstraint(self.mi_driverLoc.mNode, self.mi_obj.mNode, maintainOffset = True)
if self.b_attachControlLoc:
for attr in self.mi_orientation.p_string[0]:
attributes.doConnectAttr ((mi_controlLoc.mNode+'.t%s'%attr),(mi_offsetGroup.mNode+'.t%s'%attr))
if self.b_createUpLoc:#Make our up loc =============================================================
mi_upLoc = mi_zeroGroup.doLoc()
mi_upLoc.doStore('cgmName',self.mi_obj.mNode)
mi_upLoc.addAttr('cgmTypeModifier','up',lock=True)
mi_upLoc.doName()
mi_upLoc.parent = mi_zeroGroup
self.md_return["upLoc"] = mi_upLoc
mi_follicleFollowTrans.connectChildNode(mi_upLoc,"followUpLoc","follicle")
#Move it ----------------------------------------------------------------------------------------
mi_upLoc.__setattr__("t%s"%self.mi_orientation.p_string[0],self.f_offset)
if self.md_return.get("follicleFollow"):
mi_follicleFollowTrans.connectChild(mi_driverLoc,"driverLoc","follicle")
return self.md_return
def build(self):#================================================================================
#>>>Get data
ml_controlsFK = self._go._i_rigNull.msgList_get('controlsFK')
ml_rigJoints = self._go._i_rigNull.msgList_get('rigJoints')
ml_blendJoints = self._go._i_rigNull.msgList_get('blendJoints')
ml_fkJoints = self._go._i_rigNull.msgList_get('fkJoints')
ml_ikJoints = self._go._i_rigNull.msgList_get('ikJoints')
mi_settings = self._go._i_rigNull.settings
aimVector = dictionary.stringToVectorDict.get("%s+"%self._go._jointOrientation[0])
upVector = dictionary.stringToVectorDict.get("%s+"%self._go._jointOrientation[1])
outVector = dictionary.stringToVectorDict.get("%s+"%self._go._jointOrientation[2])
mi_controlIK = self._go._i_rigNull.controlIK
for chain in [ml_ikJoints,ml_blendJoints]:
chain[0].parent = self._go._i_constrainNull.mNode
self.ml_fkAttachJoints = []
if self._go._str_mirrorDirection == 'Right':#mirror control setup
self.ml_fkAttachJoints = self._go._i_rigNull.msgList_get('fkAttachJoints')
#for more stable ik, we're gonna lock off the lower channels degrees of freedom
for chain in [ml_ikJoints]:
for axis in self._go._jointOrientation[:2]:
log.info(axis)
for i_j in chain[1:]:
attributes.doSetAttr(i_j.mNode,"jointType%s"%axis.upper(),1)
#=============================================================
try:#>>>Finger Root Control and root follow
for attr in ['tx','ty','tz']:#Unlock a few things
i_attr = cgmMeta.cgmAttr(ml_fkJoints[0],attr)
i_attr.p_keyable = True
i_attr.p_locked = False
#we have to rebuild a little so that we can use our fk base control both for fk and ik
#Create a orient group that tracks the module constrain null
if self._go._partType == 'finger':
buffer_fkGroup = ml_fkJoints[0].parent
i_orientGroup = cgmMeta.asMeta( ml_fkJoints[1].doGroup(True),'cgmObject',setClass=True )
i_orientGroup.addAttr('cgmTypeModifier','toOrient')
i_orientGroup.doName()
#constrain it
str_orConst = mc.orientConstraint(self._go._i_constrainNull.mNode,i_orientGroup.mNode,maintainOffset = True)[0]
self._go._i_constrainNull.connectChildNode(i_orientGroup,'fingerRoot','owner')#Connect
i_orientGroup.parent = self._go._i_constrainNull.mNode
attributes.doSetLockHideKeyableAttr(i_orientGroup.mNode)#lockNHide
i_parentGroup = cgmMeta.asMeta( i_orientGroup.doGroup(True),'cgmObject',setClass=True )
i_parentGroup.addAttr('cgmTypeModifier','toParent')
i_parentGroup.doName()
str_prntConst = mc.parentConstraint( ml_fkJoints[0].mNode,i_parentGroup.mNode,maintainOffset = True)[0]
i_parentGroup.parent = buffer_fkGroup
#attributes.doSetLockHideKeyableAttr(ml_fkJoints[0].mNode,lock = False, visible=True, keyable=True, channels=['tx','ty','tz'])
#Constrain ik base to fk base
mc.orientConstraint(ml_fkJoints[0].mNode,ml_ikJoints[0].mNode,maintainOffset = True)
ml_fkJoints[0].parent = self._go._i_constrainNull.mNode
except Exception,error:
raise Exception,"%s.build_FKIK>>> Finger Root Control error: %s"%(self._go._strShortName,error)
