def bake(connection_data, start, end):
bake_range = range( int(math.floor(start)), int(math.floor(end+1)))
if end < start:
bake_range = range(int(math.floor(end)),int(math.floor(start+1)))
bake_range.reverse()
for i in bake_range:
mc.currentTime(i)
for conn in connection_data:
source_pos = POS.get(conn['source'])
if conn['setPosition']:
positionOffset = euclid.Vector3(0,0,0)
if 'positionOffset' in conn:
pos = conn['positionOffset']
positionOffset = euclid.Vector3(pos[0], pos[1], pos[2])
wanted_position = source_pos + positionOffset
POS.set(conn['target'], [wanted_position.x, wanted_position.y, wanted_position.z])
mc.setKeyframe('%s.translate' % conn['target'])
target_pos = POS.get(conn['target'])
if conn['setRotation']:
offsetForward = euclid.Vector3(0,0,1)
if 'offsetForward' in conn:
fwd = conn['offsetForward']
offsetForward = euclid.Vector3(fwd[0], fwd[1], fwd[2])
offsetUp = euclid.Vector3(0,1,0)
if 'offsetUp' in conn:
up = conn['offsetUp']
offsetUp = euclid.Vector3(up[0], up[1], up[2])
fwd = TRANS.transformDirection(conn['source'], offsetForward)
up = TRANS.transformDirection(conn['source'], offsetUp)
SNAP.aim_atPoint(conn['target'], target_pos + fwd, vectorUp=up, mode='matrix')
mc.setKeyframe('%s.rotate' % conn['target'])
def update(self, deltaTime=.04):
#dir = self.obj.getTransformDirection(self.aimFwd.p_vector)
self.dir = self._bakedLoc.getTransformDirection(
self.aimFwd.p_vector) * self.objectScale
if self.translate:
self.obj.p_position = MATH.Vector3.Lerp(
VALID.euclidVector3Arg(self.previousPosition),
VALID.euclidVector3Arg(self._bakedLoc.p_position),
deltaTime * self.damp)
if self.rotate:
wantedTargetPos = (
(VALID.euclidVector3Arg(self.obj.p_position) + self.dir) -
self.obj.p_position
).normalized() * self.objectScale + self.obj.p_position
self.lastUp = MATH.Vector3.Lerp(
self.lastUp,
self._bakedLoc.getTransformDirection(self.aimUp.p_vector),
min(deltaTime * self.damp, 1.0)).normalized()
self.aimTargetPos = (
MATH.Vector3.Lerp(self.aimTargetPos, wantedTargetPos,
deltaTime * self.damp) - self.obj.p_position
).normalized() * self.objectScale + self.obj.p_position
self.upTargetPos = (
MATH.Vector3.Lerp(self.aimTargetPos, wantedTargetPos,
deltaTime * self.damp) - self.obj.p_position
).normalized() * self.objectScale + self.obj.p_position
self.lastFwd = MATH.Vector3.Lerp(
self.lastFwd,
self._bakedLoc.getTransformDirection(self.aimFwd.p_vector),
min(deltaTime * self.damp, 1.0)).normalized()
SNAP.aim_atPoint(obj=self.obj.mNode,
mode='matrix',
position=self.aimTargetPos,
aimAxis=self.aimFwd.p_string,
upAxis=self.aimUp.p_string,
vectorUp=self.lastUp)
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')
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 update(self, deltaTime=.04):
self.lastUp = MATH.Vector3.Lerp(
self.lastUp,
self._bakedLoc.getTransformDirection(self.aimUp.p_vector),
min(deltaTime * self.damp, 1.0)).normalized()
self.lastFwd = MATH.Vector3.Lerp(self.lastFwd,
self.velocity.normalized(),
min(deltaTime * self.damp,
1.0)).normalized()
SNAP.aim_atPoint(obj=self.obj.mNode,
mode='vector',
position=self.obj.p_position + self.lastFwd,
aimAxis=self.aimFwd.p_string,
upAxis=self.aimUp.p_string,
vectorUp=self.lastUp)
def restoreBakedLocFromData(self, frame=None):
if frame is None:
frame = int(mc.currentTime(q=True))
if self._bakedLoc and frame in self._prevDataDict:
self._bakedLoc.p_position = self._prevDataDict[frame]['p']
SNAP.aim_atPoint(obj=self._bakedLoc.mNode,
mode='matrix',
position=self._prevDataDict[frame]['p'] +
self._prevDataDict[frame]['f'],
aimAxis='z+',
upAxis='y+',
vectorUp=self._prevDataDict[frame]['u'])
return True
return False
def projectOntoPlane(self, vector):
_str_func = 'LiveRecord.projectOntoPlane'
camPos = VALID.euclidVector3Arg(self.cam.p_position)
planeNormal = self.planeNormal
if self.plane in ['custom', 'object']:
planeNormal = VALID.euclidVector3Arg(
self._currentPlaneObject.getTransformDirection(
self.planeNormal))
log.info('Current plane object : {0}'.format(self._currentPlaneObject))
self.planePoint = VALID.euclidVector3Arg(
self._currentPlaneObject.p_position)
rayPoint = VALID.euclidVector3Arg(self.cam.p_position)
rayDirection = VALID.euclidVector3Arg(vector)
plane = EUCLID.Plane(
EUCLID.Point3(self.planePoint.x, self.planePoint.y,
self.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 self._debugPlane:
self._debugPlane.p_position = self.planePoint
SNAP.aim_atPoint(obj=self._debugPlane.mNode,
mode='matrix',
position=self.planePoint + planeNormal,
aimAxis='y+',
upAxis='z+',
vectorUp=planeNormal.cross(
EUCLID.Vector3(0, 1, .01)))
return pos
def aimObjToPlane(self, vector):
_str_func = 'LiveRecord.aimObjToPlane'
wantedPos = self.projectOntoPlane(vector)
vectorUp = VALID.euclidVector3Arg(
self._currentPlaneObject.getTransformDirection(
self._offsetUpVector))
for recordable in self.recordableObjs:
SNAP.aim_atPoint(obj=recordable.obj,
mode='matrix',
position=wantedPos,
aimAxis=self.aimFwd.p_string,
upAxis=self.aimUp.p_string,
vectorUp=vectorUp)
mc.setKeyframe([x.obj.mNode for x in self.recordableObjs],
at=self.keyableAttrs)
if self._debugLoc:
self._debugLoc.p_position = wantedPos
mc.setKeyframe(self._debugLoc.mNode, at='translate')
def lever(self, ball=False):
try:
_str_func = 'lever_digit'
log_start(_str_func)
mBlock = self.mBlock
mRigNull = self.mRigNull
_offset = self.v_offset
_jointOrientation = self.d_orientation['str']
ml_formHandles = self.ml_formHandles
ml_prerigHandles = self.ml_prerigHandles
mHandleFactory = self.mHandleFactory
#Mesh shapes ----------------------------------------------------------
mMesh_tmp = self.mBlock.atUtils('get_castMesh')
str_meshShape = mMesh_tmp.getShapes()[0]
#Figure out our knots ----------------------------------------------------
mMain = self.ml_formHandlesUse[0]
mMainLoft = mMain.loftCurve
idxMain = self.ml_shapers.index(mMainLoft)
minU = ATTR.get(str_meshShape, 'minValueU')
maxU = ATTR.get(str_meshShape, 'maxValueU')
f_factor = (maxU - minU) / (20)
pprint.pprint(vars())
#reload(SURF)
#Meat ==============================================================
mLeverDirect = mRigNull.getMessageAsMeta('leverDirect')
mLeverFK = mRigNull.getMessageAsMeta('leverFK')
mLeverControlCast = mLeverDirect
if not mLeverControlCast:
mLeverControlCast = mLeverFK
log.debug("|{0}| >> mLeverControlCast: {1}".format(
_str_func, mLeverControlCast))
dist_lever = DIST.get_distance_between_points(
ml_prerigHandles[0].p_position, ml_prerigHandles[1].p_position)
log.debug("|{0}| >> Lever dist: {1}".format(_str_func, dist_lever))
#Dup our rig joint and move it
mDup = mLeverControlCast.doDuplicate(po=True)
mDup.p_parent = mLeverControlCast
mDup.resetAttrs()
ATTR.set(mDup.mNode, 't{0}'.format(_jointOrientation[0]),
dist_lever * .5)
l_lolis = []
l_starts = []
_mTar = mDup
if ball:
#Loli ===============================================================
mDefineLeverObj = mBlock.defineLeverHelper
_mVectorLeverUp = MATH.get_obj_vector(mDefineLeverObj.mNode,
'y+',
asEuclid=True)
#mOrientHelper = mBlock.orientHelper
#_mVectorLeverUp = MATH.get_obj_vector(mOrientHelper.mNode,'y+',asEuclid=True)
mBall_tmp = mBlock.atUtils('get_castMesh')
str_ballShape = mBall_tmp.getShapes()[0]
pos = RAYS.cast(str_ballShape,
startPoint=_mTar.p_position,
vector=_mVectorLeverUp).get('near')
#pos = RAYS.get_cast_pos(_mTar.mNode,_mVectorLeverUp,shapes = str_ballShape)
#SNAPCALLS.get_special_pos([_mTar,str_ballShape],'castNear',str_settingsDirections,False)
vec = MATH.get_vector_of_two_points(_mTar.p_position, pos)
newPos = DIST.get_pos_by_vec_dist(pos, vec, _offset * 4)
ball = CURVES.create_fromName('sphere', _offset * 2)
mBall = cgmMeta.cgmObject(ball)
mBall.p_position = newPos
SNAP.aim_atPoint(
mBall.mNode,
_mTar.p_position,
aimAxis=_jointOrientation[0] + '+',
mode='vector',
vectorUp=_mTar.getAxisVector(_jointOrientation[0] + '-'))
line = mc.curve(d=1, ep=[pos, newPos], os=True)
l_lolis.extend([ball, line])
ATTR.set(mDup.mNode, 't{0}'.format(_jointOrientation[0]),
dist_lever * .8)
CORERIG.shapeParent_in_place(mLeverFK.mNode, l_lolis, False)
mBall_tmp.delete()
#Main clav section ========================================
"""
ml_clavShapes = BUILDUTILS.shapes_fromCast(self,
targets= [mLeverControlCast.mNode,
mDup.mNode],
aimVector= self.d_orientation['vectorOut'],
connectionPoints = 5,
f_factor=0,
offset=_offset,
mode = 'frameHandle')"""
l_curves = SURF.get_splitValues(str_meshShape,
knotIndices=[0, idxMain],
mode='u',
insertMax=False,
preInset=f_factor * .5,
postInset=-f_factor * .5,
curvesCreate=True,
curvesConnect=True,
connectionPoints=6,
offset=self.v_offset)
ml_shapes = cgmMeta.validateObjListArg(l_curves)
mHandleFactory.color(mLeverFK.mNode, controlType='sub')
CORERIG.shapeParent_in_place(mLeverFK.mNode,
ml_shapes[0].mNode,
False,
replaceShapes=False)
mDup.delete()
for mShape in ml_shapes:
try:
mShape.delete()
except:
pass
mMesh_tmp.delete()
except Exception, err:
cgmGEN.cgmExceptCB(Exception, err, localDat=vars())
def settings(self, settingsPlace=None, ml_targets=None):
try:
_str_func = 'rp'
log_start(_str_func)
log.debug("|{0}| >> settings: {1}...".format(_str_func, settingsPlace))
mBlock = self.mBlock
mRigNull = self.mRigNull
_offset = self.v_offset
_jointOrientation = self.d_orientation['str']
if settingsPlace == None:
settingsPlace = mBlock.getEnumValueString('settingsPlace')
if settingsPlace == 'cog':
mCog = mRigNull.getMessageAsMeta('rigRoot')
if mCog:
log.debug("|{0}| >> Settings is cog...".format(_str_func))
mRigNull.connectChildNode(mCog, 'settings',
'rigNull') #Connect
return mCog
else:
log.warning(
"|{0}| >> Settings. Cog option but no cog found...".format(
_str_func))
settingsPlace = 'start'
mSettingsHelper = mBlock.getMessageAsMeta('settingsHelper')
if settingsPlace in ['start', 'end']:
if settingsPlace == 'start':
_mTar = ml_targets[0]
else:
_mTar = ml_targets[self.int_handleEndIdx]
#_settingsSize = _offset * 2
if not mSettingsHelper:
mMesh_tmp = mBlock.atUtils('get_castMesh')
str_meshShape = mMesh_tmp.getShapes()[0]
d_directions = {
'up': 'y+',
'down': 'y-',
'in': 'x+',
'out': 'x-'
}
str_settingsDirections = d_directions.get(
mBlock.getEnumValueString('settingsDirection'), 'y+')
pos = RAYS.get_cast_pos(_mTar.mNode,
str_settingsDirections,
shapes=str_meshShape)
if not pos:
log.debug(
cgmGEN.logString_msg(_str_func, 'standard IK end'))
pos = _mTar.getPositionByAxisDistance(
str_settingsDirections, _offset * 5)
vec = MATH.get_vector_of_two_points(_mTar.p_position, pos)
newPos = DIST.get_pos_by_vec_dist(pos, vec, _offset * 4)
_settingsSize = _offset * 2
mSettingsShape = cgmMeta.validateObjArg(CURVES.create_fromName(
'gear',
_settingsSize,
'{0}+'.format(_jointOrientation[2]),
baseSize=1.0),
'cgmObject',
setClass=True)
mSettingsShape.doSnapTo(_mTar.mNode)
#SNAPCALLS.get_special_pos([_mTar,str_meshShape],'castNear',str_settingsDirections,False)
mSettingsShape.p_position = newPos
mMesh_tmp.delete()
SNAP.aim_atPoint(
mSettingsShape.mNode,
_mTar.p_position,
aimAxis=_jointOrientation[0] + '+',
mode='vector',
vectorUp=_mTar.getAxisVector(_jointOrientation[0] + '-'))
else:
mSettingsShape = mSettingsHelper.doDuplicate(po=False)
mSettingsShape.parent = _mTar
mSettings = mSettingsShape
CORERIG.match_orientation(mSettings.mNode, _mTar.mNode)
ATTR.copy_to(self.mModule.mNode,
'cgmName',
mSettings.mNode,
driven='target')
mSettings.doStore('cgmTypeModifier', 'settings')
mSettings.doName()
self.mHandleFactory.color(mSettings.mNode, controlType='sub')
mRigNull.connectChildNode(mSettings, 'settings',
'rigNull') #Connect
#cgmGEN.func_snapShot(vars())
#mSettings.select()
else:
raise ValueError, "Unknown settingsPlace: {1}".format(
settingsPlace)
return mSettings
except Exception, err:
cgmGEN.cgmExceptCB(Exception, err, localDat=vars())
def chain_create(self, objs = None,
fwd = None, up=None,
name = None,
upSetup = "guess",
extendStart = None,
extendEnd = True,
mNucleus=None,
upControl = None,
aimUpMode = None,
**kws):
_str_func = 'chain_create'
if not objs:
_sel = mc.ls(sl=1)
if _sel:objs = _sel
ml = cgmMeta.asMeta( objs, noneValid = True )
ml_baseTargets = copy.copy(ml)
if not ml:
return log.warning("No objects passed. Unable to chain_create")
if not name:
name = ml[-1].p_nameBase
_idx = self.get_nextIdx()
#Make our sub group...
mGrp = self.doCreateAt(setClass=1)
mGrp.p_parent = self
mGrp.rename("chain_{0}_grp".format(name))
mGrp.dagLock()
self.connectChildNode(mGrp.mNode,'chain_{0}'.format(_idx),'owner')
#holders and dat...
ml_targets = []
ml_posLocs = []
ml_aim_locs = []
fwd = fwd or self.fwd
up = up or self.up
upSetup = upSetup or self.upSetup
extendStart = extendStart or self.extendStart
extendEnd = extendEnd or self.extendEnd
upControl = upControl or self.upControl
aimUpMode = aimUpMode or self.aimUpMode
#fwdAxis = simpleAxis(fwd)
#upAxis = simpleAxis(up)
fwdAxis = TRANS.closestAxisTowardObj_get(ml[0], ml[1])
upAxis = TRANS.crossAxis_get(fwdAxis)
mGrp.doStore('fwd', fwdAxis.p_string)
mGrp.doStore('up', upAxis.p_string)
#Curve positions...
l_pos = []
if upSetup == 'manual':
if len(ml) < 2:
log.debug(cgmGEN.logString_msg(_str_func, 'Single count. Adding extra handle.'))
mLoc = ml[0].doLoc()
mLoc.rename("chain_{0}_end_loc".format(name))
_size = DIST.get_bb_size(ml[0],True,'max')
mLoc.p_position = ml[0].getPositionByAxisDistance(fwdAxis.p_string,_size)
ml.append(mLoc)
mLoc.p_parent = mGrp
for obj in ml:
l_pos.append(obj.p_position)
_v_baseDist = DIST.get_distance_between_points(l_pos[-1],l_pos[-2])
_v_baseDist = MATHUTILS.Clamp(_v_baseDist, .5,None)
_p_baseExtend = DIST.get_pos_by_axis_dist(ml[-1],
fwdAxis.p_string,
_v_baseDist)
if extendEnd:
log.debug(cgmGEN.logString_msg(_str_func, 'extendEnd...'))
extendEnd = VALID.valueArg(extendEnd)
if issubclass(type(extendEnd),bool):#VALID.boolArg(extendEnd):
log.debug(cgmGEN.logString_msg(_str_func, 'extendEnd | guess'))
l_pos.append(_p_baseExtend)
elif extendEnd:
log.debug(cgmGEN.logString_msg(_str_func, 'extendEnd | {0}'.format(extendEnd)))
l_pos.append( DIST.get_pos_by_axis_dist(ml[-1],
fwdAxis.p_string,
extendEnd ))
else:
l_pos.append( _p_baseExtend)
if extendStart:
f_extendStart = VALID.valueArg(extendStart)
if f_extendStart:
l_pos.insert(0, DIST.get_pos_by_axis_dist(ml[0],
fwdAxis.inverse.p_string,
f_extendStart ))
else:
log.debug(cgmGEN.logString_msg(_str_func, 'Resolving aim'))
if len(ml) < 2:
return log.error(cgmGEN.logString_msg(_str_func, 'Single count. Must use manual upSetup and aim/up args'))
for obj in ml:
l_pos.append(obj.p_position)
_vecEnd = MATHUTILS.get_vector_of_two_points(l_pos[-2],l_pos[-1])
if extendEnd:
log.debug(cgmGEN.logString_msg(_str_func, 'extendEnd...'))
extendEnd = VALID.valueArg(extendEnd)
if issubclass(type(extendEnd),bool):#VALID.boolArg(extendEnd):
log.debug(cgmGEN.logString_msg(_str_func, 'extendEnd | guess'))
l_pos.append( DIST.get_pos_by_vec_dist(l_pos[-1], _vecEnd,
(DIST.get_distance_between_points(l_pos[-2],l_pos[-1])/2)))
elif extendEnd:
log.debug(cgmGEN.logString_msg(_str_func, 'extendStart | {0}'.format(extendEnd)))
l_pos.append( DIST.get_pos_by_vec_dist(l_pos[-1], _vecEnd,
extendEnd))
if extendStart:
f_extendStart = VALID.valueArg(extendStart)
if f_extendStart:
log.debug(cgmGEN.logString_msg(_str_func, 'extendStart...'))
_vecStart = MATHUTILS.get_vector_of_two_points(l_pos[1],l_pos[0])
l_pos.insert(0, DIST.get_pos_by_vec_dist(l_pos[0],
_vecStart,
f_extendStart))
#pprint.pprint(l_pos)
#for i,p in enumerate(l_pos):
# LOC.create(position=p,name='p_{0}'.format(i))
crv = CORERIG.create_at(create='curve',l_pos= l_pos, baseName = name)
mInCrv = cgmMeta.asMeta(crv)
mInCrv.rename("{0}_inCrv".format(name))
mGrp.connectChildNode(mInCrv.mNode,'mInCrv')
mc.select(cl=1)
# make the dynamic setup
log.debug(cgmGEN.logString_sub(_str_func,'dyn setup'))
b_existing = False
b_existing_nucleus = False
mHairSys = self.getMessageAsMeta('mHairSysShape')
if mHairSys:
mHairSysDag = mHairSys.getTransform(asMeta=1)
log.info(cgmGEN.logString_msg(_str_func,'Using existing system: {0}'.format(mHairSys.mNode)))
mc.select(mHairSysDag.mNode, add=True)
b_existing = True
if self.useExistingNucleus or mNucleus:
mNucleus = self.get_nucleus(mNucleus)
if mNucleus:
#mc.select(mNucleus.mNode,add=1)
b_existing_nucleus = True
log.info(cgmGEN.logString_msg(_str_func,'Using existing nucleus: {0}'.format(mNucleus.mNode)))
self.connectChildNode(mNucleus.mNode,'mNucleus')
mc.select(mInCrv.mNode,add=True)
mel.eval('makeCurvesDynamic 2 { "0", "0", "1", "1", "0" }')
# get relevant nodes
follicle = mc.listRelatives(mInCrv.mNode,parent=True)[0]
mFollicle = cgmMeta.asMeta(follicle)
mFollicle.rename("{0}_foll".format(name))
parent = mFollicle.getParent(asMeta=1)
mFollicle.p_parent = mGrp
mFollicleShape = mFollicle.getShapes(1)[0]
mc.delete(parent.mNode)
_follicle = mFollicle.mNode
mGrp.connectChildNode(mFollicle.mNode,'mFollicle','group')
follicleShape = mFollicleShape.mNode#mc.listRelatives(mFollicle.mNode, shapes=True)[0]
_hairSystem = mc.listRelatives( mc.listConnections('%s.currentPosition' % follicleShape)[0],
shapes=True)[0]
if not b_existing:
mHairSys = cgmMeta.asMeta(_hairSystem)
mHairSysDag = mHairSys.getTransform(asMeta=1)
mHairSysDag.rename("{0}_hairSys".format(self.baseName))
self.connectChildNode(mHairSysDag.mNode,'mHairSysDag','owner')
self.connectChildNode(mHairSys.mNode,'mHairSysShape','owner')
mHairSysDag.p_parent = self
_hairSystem = mHairSys.mNode
outCurve = mc.listConnections('%s.outCurve' % _follicle)[0]
mCrv = cgmMeta.asMeta(outCurve)
parent = mCrv.getParent(asMeta=1)
outCurveShape = mc.listRelatives(mCrv.mNode, shapes=True)[0]
mCrv.p_parent = mGrp.mNode
mc.delete(parent.mNode)
_nucleus = mc.listConnections( '%s.currentState' % mHairSys.mNode )[0]
if not b_existing_nucleus:
mNucleus = cgmMeta.asMeta(_nucleus)
mNucleus.rename("cgmDynFK_nucleus")
#self.connectChildNode(mNucleus.mNode,'mNucleus','owner')
self.connectChildNode(mNucleus.mNode,'mNucleus')
if self.startFrame is not None:
mNucleus.startFrame = self.startFrame
else:
#Because maya is crappy we gotta manually wire the existing nucleus
##startFrame out to startFrame in
##outputObjects[x] - nextState
##shape.currentState>inputActive[x]
##shape.startState>inputActiveStart[x]
if cgmMeta.asMeta(_nucleus).mNode != mNucleus.mNode:
mc.delete(_nucleus)
_useNucleus = mNucleus.mNode
"""
_useIdx = ATTR.get_nextCompoundIndex(mNucleus.mNode,'outputObjects')
log.info("useIdx: {0}".format(_useIdx))
ATTR.connect('{0}.outputObjects[{1}]'.format(_useNucleus,_useIdx),'{0}.nextState'.format(_hairSystem))
ATTR.connect('{0}.currentState'.format(_hairSystem),'{0}.inputActive[{1}]'.format(_useNucleus,_useIdx))
ATTR.connect('{0}.startState'.format(_hairSystem),'{0}.inputActiveStart[{1}]'.format(_useNucleus,_useIdx))"""
mParent = ml[0].getParent(asMeta=1)
if not mParent:
mParent = ml[0].doGroup(1,1,
asMeta=True,
typeModifier = 'dynFKParent',
setClass='cgmObject')
#else:
#mParent.getParent(asMeta=1)
mGrp.connectChildNode(mCrv.mNode,'mOutCrv','group')
#self.follicles.append(follicle)
#self.outCurves.append(outCurve)
# set default properties
mFollicleShape.pointLock = 1
#mc.setAttr( '%s.pointLock' % follicleShape, 1 )
mc.parentConstraint(ml[0].getParent(), _follicle, mo=True)
# create locators on objects
locators = []
prs = []
ml_locs = []
ml_aims = []
ml_prts = []
_upVector = None
if upSetup == 'guess':
log.debug(cgmGEN.logString_msg(_str_func, 'Resolving up/aim'))
poci_base = CURVES.create_pointOnInfoNode(mInCrv.mNode,1)
mPoci_base = cgmMeta.asMeta(poci_base)
_upVector = mPoci_base.normalizedNormal
log.debug(cgmGEN.logString_msg(_str_func, "upVector: {0}".format(_upVector)))
#Let's make an up object as the parent of the root isn't good enough
mUp = ml[0].doCreateAt(setClass=1)
mUp.rename("chain_{0}_up".format(name))
mUp.p_parent = mGrp
if _upVector:
SNAP.aim_atPoint(mUp.mNode,
DIST.get_pos_by_vec_dist(mUp.p_position,
_upVector,
10),aimAxis='y+',upAxis='z+')
if upControl:
log.debug(cgmGEN.logString_msg(_str_func,'upControl'))
if len(ml_baseTargets)>1:
sizeControl = DIST.get_distance_between_targets([mObj.mNode for mObj in ml_baseTargets],True)
else:
sizeControl = DIST.get_bb_size(ml[0],True,'max')
crv = CURVES.create_controlCurve(mUp.mNode,'arrowSingle', size= sizeControl, direction = 'y+')
CORERIG.shapeParent_in_place(mUp.mNode, crv, False)
mUpGroup = mUp.doGroup(True,True,
asMeta=True,
typeModifier = 'master',
setClass='cgmObject')
mc.parentConstraint(ml[0].getParent(), mUpGroup.mNode, mo=True)
else:
mc.parentConstraint(ml[0].getParent(), mUp.mNode, mo=True)
# create control joint chain
mc.select(cl=True)
chain = []
for obj in ml:
if len(chain) > 0:
mc.select(chain[-1])
jnt = mc.joint(name='%s_%s_jnt' % (name, obj.p_nameBase))
SNAP.matchTarget_set(jnt, obj.mNode)
mObj = cgmMeta.asMeta(jnt)
mObj.doSnapTo(mObj.getMessageAsMeta('cgmMatchTarget'))
chain.append(jnt)
mc.parent(chain[0], _follicle)
mInCrv.p_parent = mGrp
mc.bindSkin(mInCrv.mNode, chain[0], ts=True)
log.debug(cgmGEN.logString_msg(_str_func,'aimUpMode: {0}'.format(aimUpMode)))
for i, mObj in enumerate(ml):
if not i:
mUpUse = mUp
else:
mUpUse = ml_locs[-1]
mLoc = cgmMeta.asMeta( LOC.create(mObj.getNameLong()) )
loc = mLoc.mNode
ml_locs.append(mLoc)
#loc = LOC.create(mObj.getNameLong())
mAim = mLoc.doGroup(False,False,
asMeta=True,
typeModifier = 'aim',
setClass='cgmObject')
ml_aims.append(mAim)
#aimNull = mc.group(em=True)
#aimNull = mc.rename('%s_aim' % mObj.getShortName())
poc = CURVES.create_pointOnInfoNode(outCurveShape)
#mc.createNode('pointOnCurveInfo', name='%s_pos' % loc)
mPoci_obj = cgmMeta.asMeta(poc)
mPoci_obj.rename('%s_pos' % loc)
pocAim = CURVES.create_pointOnInfoNode(outCurveShape)
#mc.createNode('pointOnCurveInfo', name='%s_aim' % loc)
pr = CURVES.getUParamOnCurve(loc, outCurve)
mPoci_obj.parameter = pr
#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(ml)-1:
nextpr = CURVES.getUParamOnCurve(ml[i+1], outCurve)
mc.setAttr('%s.parameter' % pocAim, (nextpr))# + pr))# * .5)
else:
if extendStart:
mc.setAttr( '%s.parameter' % pocAim, len(ml)+1 )
else:
mc.setAttr( '%s.parameter' % pocAim, len(ml) )
mLocParent = mLoc.doGroup(False,False,
asMeta=True,
typeModifier = 'pos',
setClass='cgmObject')
ml_prts.append(mLocParent)
#locParent = mc.group(em=True)
#locParent = mc.rename( '%s_pos' % mObj.getShortName() )
mc.connectAttr( '%s.position' % mPoci_obj.mNode, '%s.translate' % mLocParent.mNode)
mc.connectAttr( '%s.position' % pocAim, '%s.translate' % mAim.mNode)
if aimUpMode == 'master':
aimConstraint = mc.aimConstraint( mAim.mNode,
mLocParent.mNode,
aimVector=fwdAxis.p_vector,
upVector = upAxis.p_vector,
worldUpType = "objectrotation",
worldUpVector = upAxis.p_vector,
worldUpObject = mUp.mNode )
elif aimUpMode == 'orientToMaster':
mc.orientConstraint( mUp.mNode,
mLocParent.mNode,
maintainOffset = 1)
elif aimUpMode == 'sequential':
aimConstraint = mc.aimConstraint( mAim.mNode,
mLocParent.mNode,
aimVector=fwdAxis.p_vector,
upVector = upAxis.p_vector,
worldUpType = "objectrotation",
worldUpVector = upAxis.p_vector,
worldUpObject = mUpUse.mNode )
elif aimUpMode == 'joint':
aimConstraint = mc.aimConstraint( mAim.mNode,
mLocParent.mNode,
aimVector=fwdAxis.p_vector,
upVector = upAxis.p_vector,
worldUpType = "objectrotation",
worldUpVector = upAxis.p_vector,
worldUpObject = chain[i] )
elif aimUpMode == 'curveNormal':
mUpLoc = mLoc.doGroup(False,False,
asMeta=True,
typeModifier = 'up',
setClass='cgmObject')
mUpLoc.p_parent = mLocParent
aimConstraint = mc.aimConstraint( mAim.mNode,
mLocParent.mNode,
aimVector=fwdAxis.p_vector,
upVector = upAxis.p_vector,
worldUpType = "object")
mPlusMinusAverage = cgmMeta.cgmNode(name="{0}_pma".format(mObj.p_nameBase),
nodeType = 'plusMinusAverage')
mPlusMinusAverage.operation = 3
mPoci_obj.doConnectOut('position','{0}.input3D[0]'.format(mPlusMinusAverage.mNode))
mPoci_obj.doConnectOut('normalizedNormal','{0}.input3D[1]'.format(mPlusMinusAverage.mNode))
mUpLoc.doConnectIn('translate','{0}.output3D'.format(mPlusMinusAverage.mNode))
mLoc.p_parent = mLocParent
mAim.p_parent = mGrp
mLocParent.p_parent = mGrp
#mc.parent(loc, locParent)
mCrv.rename("{0}_outCrv".format(name))
mCrvParent = mCrv.getParent(asMeta=1)
mCrvParent.p_parent = mGrp
mGrp.msgList_connect('mLocs',ml_locs)
mGrp.msgList_connect('mAims',ml_aims)
mGrp.msgList_connect('mParents',ml_prts)
mGrp.msgList_connect('mTargets',ml)
mGrp.msgList_connect('mBaseTargets',ml_baseTargets)
mGrp.msgList_connect('mObjJointChain',chain)
mGrp.doStore('cgmName', name)
mNucleus.doConnectOut('startFrame',"{0}.startFrame".format(mHairSys.mNode))