def get_axisBox_size(targets=None, maxDistance=10000000, mark=False):
try:
_str_func = 'get_axisBox_size'
log.debug("|{0}| >> ".format(_str_func) + '-' * 80)
targets = VALID.listArg(targets)
_targets = VALID.mNodeStringList(targets)
if not _targets:
raise ValueError, "Must have targets!"
d_res = {'x': [], 'y': [], 'z': []}
for t in _targets:
log.debug("|{0}| >> On t: {1}".format(_str_func, t))
_proxy = CORERIG.create_axisProxy(t)
_startPoint = POS.get(_proxy, 'bb')
for k in d_res.keys():
log.debug("|{0}| >> On t: {1} | {2}".format(_str_func, t, k))
pos_positive = RAYS.get_cast_pos(t,
k + '+',
'near',
_proxy,
startPoint=_startPoint,
mark=False,
maxDistance=maxDistance)
pos_neg = RAYS.get_cast_pos(t,
k + '-',
'near',
_proxy,
startPoint=_startPoint,
mark=False,
maxDistance=maxDistance)
if mark:
LOCINATOR.LOC.create(position=pos_positive,
name="{0}_{1}Pos_loc".format(t, k))
LOCINATOR.LOC.create(position=pos_neg,
name="{0}_{1}Neg_loc".format(t, k))
dist = DIST.get_distance_between_points(pos_positive, pos_neg)
d_res[k].append(dist)
mc.delete(_proxy)
for k, v in d_res.iteritems():
d_res[k] = COREMATH.average(v)
return d_res['x'], d_res['y'], d_res['z']
except Exception, err:
cgmGEN.cgmExceptCB(Exception, err)
def set_weightsByDistance(constraint=None, vList=None):
"""
:parameters:
node(str): node to query
:returns
list of constraints(list)
"""
_str_func = 'set_weightsByDistance'
log.debug("|{0}| >> constraint: {1} ".format(_str_func, constraint))
#if vList:
#raise NotImplementedError,'Not yet'
_attrs = get_targetWeightsAttrs(constraint)
if not vList:
pos_obj = TRANS.position_get(get_driven(constraint))
targets = get_targets(constraint)
_l_dist = []
for t in targets:
_l_dist.append(
DIST.get_distance_between_points(pos_obj,
TRANS.position_get(t)))
vList = MATH.normalizeList(_l_dist)
log.debug("|{0}| >> targets: {1} ".format(_str_func, targets))
log.debug("|{0}| >> raw: {1} ".format(_str_func, _l_dist))
log.debug("|{0}| >> normalize: {1} ".format(_str_func, vList))
log.debug("|{0}| >> attrs: {1} ".format(_str_func, _attrs))
if len(_attrs) != len(vList):
raise ValueError, "Len of attrs and valueList do not match: {0} | {1}".format(
len(_attrs), len(vList))
for i, v in enumerate(vList):
ATTR.set(constraint, _attrs[i], v)
return vList
def snap(obj=None,
targets=None,
position=True,
rotation=True,
rotateAxis=False,
rotateOrder=False,
rotatePivot=False,
scalePivot=False,
objPivot='rp',
objMode=None,
objLoc=False,
targetPivot='rp',
targetMode=None,
targetLoc=False,
queryMode=False,
space='w',
mark=False,
**kws):
"""
Core snap functionality.
:parameters:
obj(str): Object to modify
target(str): Objects to snap to
objPivot
targetPivot
objMode =
targetMode
position
rotation
rotateAxis
rotateOrder
scalePivot
space
mark
:returns
success(bool)
"""
try:
_str_func = 'snap'
try:
obj = obj.mNode
except:
pass
_obj = VALID.mNodeString(obj)
if targets is None:
log.debug("|{0}| >> self target... ".format(_str_func))
_targets = [_obj]
else:
_targets = VALID.mNodeStringList(targets)
reload(VALID)
_pivotObj = VALID.kw_fromDict(objPivot,
SHARED._d_pivotArgs,
noneValid=True)
_pivotTar = VALID.kw_fromDict(targetPivot,
SHARED._d_pivotArgs,
noneValid=True)
_space = VALID.kw_fromDict(space,
SHARED._d_spaceArgs,
noneValid=False,
calledFrom=__name__ + _str_func +
">> validate space")
log.debug(
"|{0}| >> obj: {1}({2}-{3}) | target:({4}-{5})({6}) | space: {7}".
format(_str_func, _obj, _pivotObj, objMode, _pivotTar, targetMode,
_targets, _space))
log.debug(
"|{0}| >> position: {1} | rotation:{2} | rotateAxis: {3} | rotateOrder: {4}"
.format(_str_func, position, rotation, rotateAxis, rotateOrder))
kws_xform = {'ws': False, 'os': False}
if _space == 'world':
kws_xform['ws'] = True
else:
kws_xform['os'] = True
#Mode type defaults...
if objMode is None:
if _pivotObj is 'boundingBox':
objMode = 'center'
elif _pivotObj in ['castCenter', 'castFar', 'castNear', 'axisBox']:
objMode = 'z+'
if targetMode is None:
if _pivotTar is 'boundingBox':
targetMode = 'center'
elif _pivotTar in ['castCenter', 'castFar', 'castNear', 'axisBox']:
targetMode = 'z+'
if _pivotTar in ['castFar', 'castAllFar', 'castNear', 'castAllNear']:
if targetMode == 'center':
log.debug(
"|{0}| >> Center target mode invalid with {1}. Changing to 'z+' "
.format(_str_func, _pivotTar))
targetMode = 'z+'
#cgmGEN.func_snapShot(vars())
if position or objLoc or targetLoc or rotatePivot or scalePivot:
kws_xform_move = copy.copy(kws_xform)
if _pivotTar == 'sp':
kws_xform_move['spr'] = True
else:
kws_xform_move['rpr'] = True
#>>>Target pos ------------------------------------------------------------------------------
log.debug(
"|{0}| >> Position True. Getting target pivot pos {1} ".format(
_str_func, _pivotTar))
l_nameBuild = [
'_'.join([NAMES.get_base(o) for o in _targets]), _pivotTar
]
if targetMode and _pivotTar not in [
'sp', 'rp', 'closestPoint', 'groundPos'
]:
l_nameBuild.append(targetMode)
l_pos = []
if _pivotTar in ['sp', 'rp']:
log.debug("|{0}| >> xform query... ".format(_str_func))
for t in _targets:
l_pos.append(POS.get(t, _pivotTar, _space))
pos_target = DIST.get_average_position(l_pos)
elif _pivotTar == 'closestPoint':
log.debug("|{0}|...closestPoint...".format(_str_func))
pos_target = DIST.get_by_dist(_obj,
_targets,
resMode='pointOnSurface')
else:
log.debug("|{0}| >> special query... ".format(_str_func))
_targetsSpecial = copy.copy(_targets)
if _pivotTar not in [
'axisBox', 'groundPos', 'castCenter', 'boundingBox'
]:
_targetsSpecial.insert(0, _obj)
pos_target = get_special_pos(_targetsSpecial, _pivotTar,
targetMode)
if not pos_target:
return log.error("No position detected")
if targetLoc:
_loc = mc.spaceLocator()[0]
mc.move(pos_target[0],
pos_target[1],
pos_target[2],
_loc,
ws=True)
mc.rename(_loc, '{0}_loc'.format('_'.join(l_nameBuild)))
log.debug("|{0}| >> Target pivot: {1}".format(
_str_func, pos_target))
#>>>Obj piv ------------------------------------------------------------------------------
log.debug("|{0}| >> Getting obj pivot pos {1} ".format(
_str_func, _pivotObj))
l_nameBuild = [NAMES.get_base(_obj), _pivotObj]
if objMode and _pivotObj not in [
'sp', 'rp', 'closestPoint', 'groundPos'
]:
l_nameBuild.append(objMode)
l_pos = []
if _pivotObj in ['sp', 'rp']:
log.debug("|{0}| >> xform query... ".format(_str_func))
pos_obj = POS.get(_obj, _pivotObj, _space)
elif _pivotObj == 'closestPoint':
log.debug("|{0}|...closestPoint...".format(_str_func))
pos_obj = DIST.get_by_dist(_targets[0],
_obj,
resMode='pointOnSurface')
else:
log.debug("|{0}| >> special query... ".format(_str_func))
pos_obj = get_special_pos(_obj, _pivotObj, objMode)
if objLoc:
_loc = mc.spaceLocator()[0]
mc.move(pos_obj[0], pos_obj[1], pos_obj[2], _loc, ws=True)
mc.rename(_loc, '{0}_loc'.format('_'.join(l_nameBuild)))
log.debug("|{0}| >> Obj pivot: {1}".format(_str_func, pos_obj))
if queryMode:
pprint.pprint(vars())
log.warning("|{0}| >> Query mode. No snap".format(_str_func))
mc.select([_obj] + _targets)
return True
#>>>Obj piv ------------------------------------------------------------------------------
if position:
log.debug("|{0}| >> Positioning... ".format(_str_func))
if _pivotObj == 'rp':
TRANS.position_set(obj, pos_target)
#POS.set(_obj, pos_target)
else:
p_start = TRANS.position_get(_obj)
_vector_to_objPivot = COREMATH.get_vector_of_two_points(
p_start, pos_obj)
_dist_base = DIST.get_distance_between_points(
p_start, pos_obj) #...get our base distance
p_result = DIST.get_pos_by_vec_dist(
pos_target, _vector_to_objPivot, -_dist_base)
cgmGEN.func_snapShot(vars())
POS.set(_obj, p_result)
if rotateAxis:
log.debug("|{0}|...rotateAxis...".format(_str_func))
mc.xform(obj,
ra=mc.xform(_targets[0], q=True, ra=True, **kws_xform),
p=True,
**kws_xform)
if rotateOrder:
log.debug("|{0}|...rotateOrder...".format(_str_func))
mc.xform(obj, roo=mc.xform(_targets[0], q=True, roo=True), p=True)
if rotation:
log.debug("|{0}|...rotation...".format(_str_func))
_t_ro = ATTR.get_enumValueString(_targets[0], 'rotateOrder')
_obj_ro = ATTR.get_enumValueString(obj, 'rotateOrder')
if _t_ro != _obj_ro:
#Creating a loc to get our target space rotateOrder into new space
log.debug(
"|{0}|...rotateOrders don't match...".format(_str_func))
_loc = mc.spaceLocator(n='tmp_roTranslation')[0]
ATTR.set(_loc, 'rotateOrder', _t_ro)
rot = mc.xform(_targets[0], q=True, ro=True, **kws_xform)
mc.xform(_loc, ro=rot, **kws_xform)
mc.xform(_loc, roo=_obj_ro, p=True)
rot = mc.xform(_loc, q=True, ro=True, **kws_xform)
mc.delete(_loc)
else:
rot = mc.xform(_targets[0], q=True, ro=True, **kws_xform)
mc.xform(_obj, ro=rot, **kws_xform)
if rotatePivot:
log.debug("|{0}|...rotatePivot...".format(_str_func))
mc.xform(obj, rp=pos_target, p=True, **kws_xform)
if scalePivot:
log.debug("|{0}|...scalePivot...".format(_str_func))
mc.xform(obj, sp=pos_target, p=True, **kws_xform)
except Exception, err:
cgmGEN.cgmExceptCB(Exception, err)
def specialSnap(obj=None,
targets=None,
arg='axisBox',
mode='center',
castOffset=False):
"""
Special snap functionality
:parameters:
obj(str): Object to modify
target(str): Object to snap to
sourceObject(str): object to copy from
:returns
success(bool)
"""
try:
_str_func = 'specialSnap'
_obj = VALID.mNodeString(obj)
_targets = VALID.listArg(targets)
if not _targets:
_targets = [_obj]
if arg not in ['axisBox']:
_targets.insert(0, _obj)
p = get_special_pos(_targets, arg, mode, False)
if castOffset:
p_start = TRANS.position_get(_obj)
_vector_to_hit = COREMATH.get_vector_of_two_points(p_start, p)
_vector_to_start = COREMATH.get_vector_of_two_points(p, p_start)
_cast = RAYS.cast(startPoint=p_start, vector=_vector_to_hit)
_hit = _cast.get('near')
_dist_base = DIST.get_distance_between_points(
p_start, p) #...get our base distance
_dist_to_hit = DIST.get_distance_between_points(
p_start, _hit) #...get our base distance
p_result = DIST.get_pos_by_vec_dist(p_start, _vector_to_hit,
(_dist_base + _dist_to_hit))
#_cast = RayCast.cast(self.l_mesh, startPoint=_pos_obj,vector=_vec_obj)
#_nearHit = _cast['near']
#_dist_firstHit = DIST.get_distance_between_points(_pos_obj,_nearHit)
#log.debug("baseDist: {0}".format(_dist_base))
#log.debug("firstHit: {0}".format(_dist_firstHit))
"""
if not _m_normal:
if self.mode == 'far':
_dist_new = _dist_base + _dist_firstHit
else:
_dist_new = _dist_base - _dist_firstHit
_offsetPos = DIST.get_pos_by_vec_dist(_pos_obj,_vec_obj,(_dist_new))
else:
log.debug("|{0}| >> mesh normal offset!".format(_str_funcName))
_offsetPos = DIST.get_pos_by_vec_dist(_pos_base,_m_normal,(_dist_firstHit))"""
#cgmGEN.func_snapShot(vars())
POS.set(_obj, p_result)
return
POS.set(_obj, p)
except Exception, err:
cgmGEN.cgmExceptCB(Exception, err, msg=vars())
def alongLine(objList=None, mode='even', curve='linear', spans=2):
"""
Arrange a list of objects evenly along a vector from first to last
:parameters:
objList(list): objects to layout
mode(string)
'even' - evenly distributed along line
'spaced' - distribute along line as close as possible to current position
:returns
list of constraints(list)
"""
_str_func = 'onLine'
objList = VALID.mNodeStringList(objList)
log.info("|{0}| >> ObjList: {1} ".format(_str_func, objList))
_len = len(objList)
if _len < 3:
raise ValueError, "|{0}| >> Need at least 3 objects".format(_str_func)
_pos_start = POS.get(objList[0])
_pos_end = POS.get(objList[-1])
curveBuffer = []
if curve == 'linear':
if mode != 'even':
curveBuffer = mc.curve(d=1, ep=[_pos_start, _pos_end])
elif curve in ['cubic', 'cubicRebuild']:
l_pos = [POS.get(o) for o in objList]
knot_len = len(l_pos) + 3 - 1
crv1 = mc.curve(d=3,
ep=l_pos,
k=[i for i in range(0, knot_len)],
os=True)
curveBuffer = [crv1]
if curve == 'cubicRebuild':
curveBuffer.append(
mc.rebuildCurve(crv1,
ch=0,
rpo=0,
rt=0,
end=1,
kr=0,
kcp=0,
kep=1,
kt=0,
s=spans,
d=3,
tol=0.001)[0])
elif curve == 'cubicArc':
_mid = MATH.get_midIndex(_len)
log.info("|{0}| >> cubicArc | mid: {1} ".format(_str_func, _mid))
l_pos = [POS.get(o) for o in [objList[0], objList[_mid], objList[-1]]]
knot_len = len(l_pos) + 3 - 1
curveBuffer = mc.curve(d=3,
ep=l_pos,
k=[i for i in range(0, knot_len)],
os=True)
else:
raise ValueError, "|{0}| >>unknown curve setup: {1}".format(
_str_func, curve)
if mode == 'even':
if curve == 'linear':
_vec = MATH.get_vector_of_two_points(_pos_start, _pos_end)
_offsetDist = DIST.get_distance_between_points(
_pos_start, _pos_end) / (_len - 1)
_l_pos = [
DIST.get_pos_by_vec_dist(_pos_start, _vec, (_offsetDist * i))
for i in range(_len)
]
log.info("|{0}| >> offset: {1} ".format(_str_func, _offsetDist))
log.info("|{0}| >> l_pos: {1} ".format(_str_func, _l_pos))
for i, o in enumerate(objList[1:-1]):
POS.set(o, _l_pos[i + 1])
else:
_l_pos = CURVES.getUSplitList(curveBuffer, points=_len, rebuild=1)
for i, o in enumerate(objList[1:-1]):
POS.set(o, _l_pos[i + 1])
elif mode == 'spaced':
_l_pos = []
for i, o in enumerate(objList[1:-1]):
#SNAP.go(o,curveBuffer,pivot= 'closestPoint')
p = DIST.get_by_dist(o, curveBuffer, resMode='pointOnSurface')
POS.set(o, p)
_l_pos.append(p)
else:
try:
raise ValueError, "{0} >> mode not supported: {1}".format(
sys._getframe().f_code.co_name, mode)
except:
raise ValueError, "mode not supported: {0}".format(mode)
if curveBuffer:
mc.delete(curveBuffer)
return _l_pos
def build_chain(posList = [],
targetList = [],
curve = None,
axisAim = 'z+',
axisUp = 'y+',
worldUpAxis = [0,1,0],
count = None,
splitMode = 'curve',
parent = False,
orient = True,
progressBar = None,
relativeOrient=True,
asMeta = True):
"""
General build oriented skeleton from a position list, targets or curve
:parameters:
posList(list) | List of positions to build from
targetList(list) | List of targets to build from
curve(str) | Curve to split
worldUpAxis(vector) | World up direction for orientation
count(int) | number of joints for splitting (None) is default which doesn't resplit
splitMode(str)
linear - Resplit along a vector from the first to last posList point
curve - Resplit along a curve going through all of our points
sub - Resplit adding the number of joints between our points
:returns
created(list)
"""
_str_func = 'build_chain'
_axisAim = axisAim
_axisUp = axisUp
_axisWorldUp = worldUpAxis
_radius = 1
mc.select(cl=True)
#pprint.pprint(vars())
#>>Get positions ================================================================================
if not posList and targetList:
log.debug("|{0}| >> No posList provided, using targets...".format(_str_func))
posList = []
for t in targetList:
posList.append(POS.get(t))
if curve and not posList:
log.debug("|{0}| >> Generating posList from curve arg...".format(_str_func))
splitMode == 'curve'
posList = CURVES.returnSplitCurveList(curve,count)
if count is not None:
log.debug("|{0}| >> Resplit...".format(_str_func))
if splitMode == 'sub':
l_new = []
for i,p in enumerate(posList[:-1]):
#l_new.append(p)
l_new.extend(DIST.get_posList_fromStartEnd(p,posList[i+1], count +2) [:-1])
l_new.append(posList[-1])
posList = l_new
elif count != len(posList):
if splitMode == 'linear':
#_p_start = POS.get(_l_targets[0])
#_p_top = POS.get(_l_targets[1])
#posList = get_posList_fromStartEnd(posList[0],posList[-1],count)
_crv = CURVES.create_fromList(posList= posList, linear=True)
posList = CURVES.returnSplitCurveList(_crv,count)
mc.delete(_crv)
elif splitMode == 'curve':
if not curve:
log.debug("|{0}| >> Making curve...".format(_str_func))
_crv = CURVES.create_fromList(posList= posList)
posList = CURVES.returnSplitCurveList(_crv,count)
mc.delete(_crv)
else:
posList = CURVES.returnSplitCurveList(curve,count)
else:
raise ValueError, "Unknown splitMode: {0}".format(splitMode)
#>>Radius =======================================================================================
_len = len(posList)
if _len > 1:
_baseDist = DIST.get_distance_between_points(posList[0],posList[1])
_radius = _baseDist/4
#>>Create joints =================================================================================
ml_joints = []
log.debug("|{0}| >> pos list...".format(_str_func))
#progressBar = cgmUI.progressBar_start(progressBar, stepMaxValue=_len)
for i,p in enumerate(posList):
log.debug("|{0}| >> {1}:{2}".format(_str_func,i,p))
#cgmUI.progressBar_iter(progressBar,status='Creating: {0}'.format(p))
mJnt = cgmMeta.cgmObject(mc.joint (p=(p[0],p[1],p[2])))
mJnt.displayLocalAxis = 1
mJnt.radius = _radius
ml_joints.append ( mJnt )
if not parent:
mJnt.parent=False
"""if i > 0:
_mJnt.parent = _ml_joints[i-1]
else:
_mJnt.parent = False"""
#cgmUI.progressBar_end(progressBar)
#>>Orient chain...
if orient:
if _len == 1:
log.debug("|{0}| >> Only one joint. Can't orient chain".format(_str_func,_axisWorldUp))
else:
orientChain(ml_joints,axisAim,axisUp,worldUpAxis,relativeOrient)
if asMeta:
return ml_joints
return [mJnt.mNode for mJnt in ml_joints]
def split_blends(driven1 = None,
driven2 = None,
sealDriver1 = None,
sealDriver2 = None,
sealDriverMid = None,
nameSeal1 = 'left',
nameSeal2 = 'right',
nameSealMid = 'center',
maxValue = 10.0,
inTangent = 'auto',
outTangent = 'auto',
settingsControl = None,
buildNetwork = True):
"""
Split for blend data
"""
try:
_str_func = 'split_blends'
d_dat = {1:{'dist1':[],
'dist2':[],
'distMid':[]},
2:{'dist1':[],
'dist2':[],
'distMid':[]}}
_lock=False
_hidden=False
#>>> Verify ===================================================================================
log.debug("|{0}| >> driven1 [Check]...".format(_str_func))
d_dat[1]['driven'] = cgmMeta.validateObjListArg(driven1,
mType = 'cgmObject',
mayaType=['joint'], noneValid = False)
log.debug("|{0}| >> driven2 [Check]...".format(_str_func))
d_dat[2]['driven'] = cgmMeta.validateObjListArg(driven2,
mType = 'cgmObject',
mayaType=['joint'], noneValid = False)
mSettings = cgmMeta.validateObjArg(settingsControl,'cgmObject')
pprint.pprint(d_dat[1]['driven'])
pprint.pprint(d_dat[2]['driven'])
if buildNetwork:
log.debug("|{0}| >> buildNetwork | building driver attrs...".format(_str_func))
mPlug_sealMid = cgmMeta.cgmAttr(mSettings.mNode,
'seal_{0}'.format(nameSealMid),
attrType='float',
minValue=0.0,
maxValue = maxValue,
lock=False,
keyable=True)
mPlug_seal1 = cgmMeta.cgmAttr(mSettings.mNode,
'seal_{0}'.format(nameSeal1),
attrType='float',
minValue=0.0,
maxValue = maxValue,
lock=False,
keyable=True)
mPlug_seal2 = cgmMeta.cgmAttr(mSettings.mNode,
'seal_{0}'.format(nameSeal2),
attrType='float',
minValue=0.0,
maxValue = maxValue,
lock=False,
keyable=True)
pos1 = POS.get(sealDriver1)
pos2 = POS.get(sealDriver2)
posMid = POS.get(sealDriverMid)
normMin = maxValue * .1
normMax = maxValue - normMin
for idx,dat in d_dat.iteritems():
mDriven = dat['driven']
d_tmp = {'dist1':{'pos':pos1,
'res':dat['dist1']},
'dist2':{'pos':pos2,
'res':dat['dist2']},
'distMid':{'pos':posMid,
'res':dat['distMid']},
}
for mObj in mDriven:
for n,d in d_tmp.iteritems():
dTmp = DIST.get_distance_between_points(d['pos'],mObj.p_position)
if MATH.is_float_equivalent(dTmp,0.0):
dTmp = 0.0
d['res'].append(dTmp)
dat['dist1Norm'] = MATH.normalizeList(dat['dist1'],normMax)
dat['dist2Norm'] = MATH.normalizeList(dat['dist2'],normMax)
dat['distMidNorm'] = MATH.normalizeList(dat['distMid'],normMax)
dat['dist1On'] = [v + normMin for v in dat['dist1Norm']]
dat['dist2On'] = [v + normMin for v in dat['dist2Norm']]
dat['distMidOn'] = [v + normMin for v in dat['distMidNorm']]
if buildNetwork:
log.debug("|{0}| >> buildNetwork | building driver attrs...".format(_str_func))
dat['mPlugs'] = {'1':{},
'2':{},
'mid':{},
'on':{},
'off':{},
'sum':{}}
for i,mObj in enumerate(mDriven):
log.debug("|{0}| >> buildNetwork | On: {1}".format(_str_func,mObj) + cgmGEN._str_subLine)
dat['mPlugs']['1'][i] = cgmMeta.cgmAttr(mSettings,
'set{0}_idx{1}_blend{2}'.format(idx,i,'1'),
attrType='float',
keyable = False,lock=_lock,hidden=_hidden)
dat['mPlugs']['2'][i] = cgmMeta.cgmAttr(mSettings,
'set{0}_idx{1}_blend{2}'.format(idx,i,'2'),
attrType='float',
keyable = False,lock=_lock,hidden=_hidden)
dat['mPlugs']['mid'][i] = cgmMeta.cgmAttr(mSettings,
'set{0}_idx{1}_blend{2}'.format(idx,i,'mid'),
attrType='float',
keyable = False,lock=_lock,hidden=_hidden)
dat['mPlugs']['on'][i] = cgmMeta.cgmAttr(mSettings,
'set{0}_idx{1}_on'.format(idx,i),
attrType='float',
keyable = False,lock=_lock,hidden=_hidden)
dat['mPlugs']['off'][i] = cgmMeta.cgmAttr(mSettings,
'set{0}_idx{1}_off'.format(idx,i),
attrType='float',
keyable = False,lock=_lock,hidden=_hidden)
dat['mPlugs']['sum'][i] = cgmMeta.cgmAttr(mSettings,
'set{0}_idx{1}_sum'.format(idx,i),
attrType='float',
keyable = False,lock=_lock,hidden=_hidden)
args = []
args.append("{0} = {1} + {2} + {3}".format(dat['mPlugs']['sum'][i].p_combinedShortName,
dat['mPlugs']['1'][i].p_combinedShortName,
dat['mPlugs']['2'][i].p_combinedShortName,
dat['mPlugs']['mid'][i].p_combinedShortName))
args.append("{0} = clamp(0 , 1.0, {1}".format(dat['mPlugs']['on'][i].p_combinedShortName,
dat['mPlugs']['sum'][i].p_combinedShortName,))
args.append("{0} = 1.0 - {1}".format(dat['mPlugs']['off'][i].p_combinedShortName,
dat['mPlugs']['on'][i].p_combinedShortName,))
for a in args:
NODEFAC.argsToNodes(a).doBuild()
zeroMid = 0
zero1 = 0
zero2 = 0
"""
1
'dist1Norm': [9.0, 7.202468187218439, 4.077128668939619],
'dist1On': [10.0, 8.20246818721844, 5.077128668939619],
'dist2': [2.055457665682541, 3.632951746156667, 4.537290944991008],
'dist2Norm': [4.077128668939596, 7.206186711809993, 9.0],
'dist2On': [5.077128668939596, 8.206186711809993, 10.0],
2
'dist1On': [10.0, 7.77630635569009, 4.3748619466292595],
'dist2': [1.6982080013368184, 3.4097921203066526, 4.528739916989064],
'dist2Norm': [3.3748619466301477, 6.7763063556899725, 9.0],
'dist2On': [4.374861946630148, 7.7763063556899725, 10.0],
"""
try:zero1 = dat['dist1On'][i+1]
except:zero1 = 0
if i:
try:zero2 = dat['dist2On'][i-1]
except:zero2 = 0
#try:zeroMid = dat['distMidOn'][i-1]
#except:zeroMid= 0
#if i:
# zero1 = dat['dist1On'][i-1]
#try:zero2 = dat['dist2On'][i+1]
#except:zero2 = 0
#zero1 = MATH.Clamp(dat['dist1On'][i-1],normMin,maxValue)
#zero2 = MATH.Clamp(dat['dist2On'][i-1],normMin,maxValue)
mc.setDrivenKeyframe(dat['mPlugs']['1'][i].p_combinedShortName,
currentDriver = mPlug_seal1.p_combinedShortName,
itt=inTangent,ott=outTangent,
driverValue = zero1,value = 0.0)
mc.setDrivenKeyframe(dat['mPlugs']['1'][i].p_combinedShortName,
currentDriver = mPlug_seal1.p_combinedShortName,
itt=inTangent,ott=outTangent,
driverValue = dat['dist1On'][i],value = 1.0)
mc.setDrivenKeyframe(dat['mPlugs']['2'][i].p_combinedShortName,
currentDriver = mPlug_seal2.p_combinedShortName,
itt=inTangent,ott=outTangent,
driverValue = zero2,value = 0.0)
mc.setDrivenKeyframe(dat['mPlugs']['2'][i].p_combinedShortName,
currentDriver = mPlug_seal2.p_combinedShortName,
itt=inTangent,ott=outTangent,
driverValue = dat['dist2On'][i],value = 1.0)
last1 = dat['dist1On'][i]
last2 = dat['dist2On'][i]
mc.setDrivenKeyframe(dat['mPlugs']['mid'][i].p_combinedShortName,
currentDriver = mPlug_sealMid.p_combinedShortName,
itt=inTangent,ott=outTangent,
driverValue = zeroMid,value = 0.0)
mc.setDrivenKeyframe(dat['mPlugs']['mid'][i].p_combinedShortName,
currentDriver = mPlug_sealMid.p_combinedShortName,
itt=inTangent,ott=outTangent,
driverValue = dat['distMidOn'][i],value = 1.0)
pprint.pprint(d_dat)
#return d_dat
for idx,dat in d_dat.iteritems():
for plugSet,mSet in dat['mPlugs'].iteritems():
for n,mPlug in mSet.iteritems():
mPlug.p_lock=True
mPlug.p_hidden = True
return d_dat
except Exception,err:
cgmGEN.cgmExceptCB(Exception,err,msg=vars())
mi_distanceBuffer = mi_segmentCurve
#NewDynParent --------------------------------------------------------------------------------------
ml_shoulderDynParents.append(mi_go._i_puppet.masterNull.puppetSpaceObjectsGroup)
ml_shoulderDynParents.append(mi_go._i_puppet.masterNull.worldSpaceObjectsGroup)
#Uneeded...
#mi_go.collect_worldDynDrivers()
No more spline segment
#ml_segmentSplineJoints = mi_segmentCurve.msgList_get('driverJoints',asMeta = True)
#Twist driver distances
ml_blendJoints = self._i_rigNull.msgList_get('blendJoints')
fl_baseDist = DIST.get_distance_between_points(ml_blendJoints[0].p_position, ml_blendJoints[-1].p_position)
import cgm.core.lib.attribute_utils as ATTR
for o in mc.ls(type='joint'):
ATTR.set(o,'segmentScaleCompensate',0)
ATTR.set_default('l_glove_upr_pinky_end_jnt','tz', ATTR.get('l_glove_upr_pinky_end_jnt','tz'))
for o in mc.ls(sl=True):
mc.rename(o,o.replace('__','_'))
def leverBAK(self, ml_handles=None):
try:
_str_func = 'lever'
log_start(_str_func)
mBlock = self.mBlock
mRigNull = self.mRigNull
_offset = self.v_offset
_jointOrientation = self.d_orientation['str']
ml_formHandles = self.ml_formHandles
#Get our curves...
ml_targets = []
for i, mHandle in enumerate(ml_formHandles[:2]):
ml_targets.append(mHandle.loftCurve)
if i:
continue
ml_sub = mHandle.msgList_get('subShapers')
if ml_sub:
for mSub in ml_sub:
ml_targets.append(mSub)
ml_new = []
for mTar in ml_targets:
mDup = mTar.doDuplicate(po=False)
DIST.offsetShape_byVector(mDup.mNode, _offset)
mDup.p_parent = False
ml_new.append(mDup)
CURVES.connect([mTar.mNode for mTar in ml_new], mode='even')
return ml_new[0]
mLeverControlJoint = mRigNull.getMessageAsMeta('leverDirect')
mLeverControlFK = mRigNull.getMessageAsMeta('leverFK')
if not mLeverControlJoint:
mLeverControlJoint = mLeverControlFK
else:
mLeverControlJoint = mLeverControlJoint
log.debug("|{0}| >> mLeverControlJoint: {1}".format(
_str_func, mLeverControlJoint))
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 = mLeverControlJoint.doDuplicate()
mDup.p_parent = mLeverControlJoint
mDup.resetAttrs()
ATTR.set(mDup.mNode, 't{0}'.format(_jointOrientation[0]),
dist_lever * .8)
mDup2 = mDup.doDuplicate()
ATTR.set(mDup2.mNode, 't{0}'.format(_jointOrientation[0]),
dist_lever * .25)
ml_clavShapes = BUILDUTILS.shapes_fromCast(
self,
targets=[
mDup2.mNode,
#ml_fkJoints[0].mNode],
mDup.mNode
],
aimVector=self.d_orientation['vectorOut'],
offset=_offset,
f_factor=0,
mode='frameHandle')
mHandleFactory.color(ml_clavShapes[0].mNode, controlType='main')
CORERIG.shapeParent_in_place(mLeverControlFK.mNode,
ml_clavShapes[0].mNode,
True,
replaceShapes=True)
#CORERIG.shapeParent_in_place(mLeverFKJnt.mNode,ml_clavShapes[0].mNode, False, replaceShapes=True)
mc.delete([mShape.mNode
for mShape in ml_clavShapes] + [mDup.mNode, mDup2.mNode])
except Exception, err:
cgmGEN.cgmExceptCB(Exception, err, localDat=vars())
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 ik_bankRollShapes(self):
try:
_str_func = 'bankRollShapes'
log.debug(cgmGEN.logString_sub(_str_func))
mBlock = self.mBlock
mRigNull = self.mRigNull
mHandleFactory = self.mHandleFactory
_offset = self.v_offset
_jointOrientation = self.d_orientation['str']
ml_formHandles = self.ml_formHandles
ml_fkShapes = []
mBallFK = False
mToeFK = False
mToeIK = False
mBallIK = False
_minRot = -90,
_maxRot = 90
mMesh_tmp = self.mBlock.atUtils('get_castMesh', pivotEnd=1)
str_meshShape = mMesh_tmp.getShapes()[0]
#if self.mPivotHelper:
# size_pivotHelper = POS.get_bb_size(self.mPivotHelper.mNode)
#else:
# size_pivotHelper = POS.get_bb_size(ml_formHandles[-1].mNode)
#reload(SHAPECASTER)
_d_cast = {
'vectorOffset': _offset,
'points': 15,
#'minRot':-90,'maxRot':90,
'closedCurve': False
}
_max = None
if self.mBall:
try:
_max = RAYS.get_dist_from_cast_axis(
self.mBall.mNode,
self.d_orientation['str'][2],
shapes=str_meshShape)
except:
_max = 1
_d_cast['maxDistance'] = _max
crvBall = SHAPECASTER.createMeshSliceCurve(str_meshShape,
self.mBall.mNode,
**_d_cast)
if not self.mToe:
pos = RAYS.get_cast_pos(self.mBall.mNode,
shapes=mMesh_tmp.mNode)
pos_me = self.mBall.p_position
dist = DIST.get_distance_between_points(pos, pos_me) / 2
pos_end = DIST.get_pos_by_vec_dist(pos_me, [0, 0, 1], dist)
mDup = self.mBall.doDuplicate(po=True)
mDup.p_position = pos_end
crvBall2 = SHAPECASTER.createMeshSliceCurve(
str_meshShape, mDup.mNode, **_d_cast)
CURVES.connect([crvBall, crvBall2], 7)
mDup.delete()
mHandleFactory.color(crvBall, controlType='sub')
mBallFK = self.mBall.getMessageAsMeta('fkJoint')
CORERIG.shapeParent_in_place(mBallFK.mNode,
crvBall,
True,
replaceShapes=True)
if self.str_ikRollSetup == 'control':
log.debug(cgmGEN.logString_msg(_str_func,
"Ball Ik control..."))
mBallIK = self.mBall.doCreateAt(setClass=True)
CORERIG.shapeParent_in_place(mBallIK.mNode,
crvBall,
True,
replaceShapes=True)
mRigNull.connectChildNode(mBallIK, 'controlIKBall',
'rigNull') #Connect
mBallIK.doCopyNameTagsFromObject(self.mBall.mNode,
ignore=['cgmType'])
mBallIK.doStore('cgmTypeModifier', 'ik')
mBallIK.doName()
mBallIK.connectChildNode(self.mBall.fkJoint.blendJoint.mNode,
'blendJoint') #Connect
#Hinge ===================================================================
log.debug(
cgmGEN.logString_msg(_str_func,
"Ball Hinge Ik control..."))
#Need to make our cast locs
mStart = mBallIK.doCreateAt(setClass=1)
mEnd = mBallIK.doCreateAt(setClass=1)
pos1_start = self.mBall.getParent(asMeta=1).p_position
pos2_start = mEnd.p_position
vec_to_end = MATH.get_vector_of_two_points(
pos1_start, pos2_start)
vec_to_start = MATH.get_vector_of_two_points(
pos2_start, pos1_start)
mStart.p_position = DIST.get_average_position(
[pos1_start, pos2_start])
#DIST.get_pos_by_vec_dist(pos1_start,vec_to_end,_offset)#
mEnd.p_position = DIST.get_pos_by_vec_dist(
pos2_start, vec_to_start, _offset)
crv1 = SHAPECASTER.createMeshSliceCurve(
str_meshShape, mStart.mNode, **_d_cast)
crv2 = SHAPECASTER.createMeshSliceCurve(
str_meshShape, mEnd.mNode, **_d_cast)
CURVES.connect([crv1, crv2], 7)
mBallHingeIK = self.mBall.doCreateAt(setClass=True)
mRigNull.connectChildNode(mBallHingeIK, 'controlIKBallHinge',
'rigNull') #Connect
mBallHingeIK.connectChildNode(
self.mBall.fkJoint.blendJoint.mNode,
'blendJoint') #Connect
mHandleFactory.color(crv1, controlType='sub')
CORERIG.shapeParent_in_place(mBallHingeIK.mNode,
crv1,
True,
replaceShapes=True)
mBallHingeIK.doCopyNameTagsFromObject(self.mBall.mNode,
ignore=['cgmType'])
mBallHingeIK.doStore('cgmNameModifier', 'hinge')
mBallHingeIK.doStore('cgmTypeModifier', 'ik')
mBallHingeIK.doName()
for mObj in mStart, mEnd:
mObj.delete()
ml_fkShapes.append(cgmMeta.asMeta(crv1))
ml_fkShapes.append(cgmMeta.validateObjArg(crvBall, 'cgmObject'))
if self.mToe:
if not _max:
_max = RAYS.get_dist_from_cast_axis(
self.mToe.mNode,
self.d_orientation['str'][2],
shapes=str_meshShape)
_d_cast['maxDistance'] = _max
crv = SHAPECASTER.createMeshSliceCurve(str_meshShape,
self.mToe.mNode, **_d_cast)
"""
crv = CURVES.create_controlCurve(self.mToe.mNode, shape='circle',
direction = _jointOrientation[0]+'+',
sizeMode = 'fixed',
size = size_pivotHelper[0])"""
mHandleFactory.color(crv, controlType='sub')
mToeFK = self.mToe.getMessageAsMeta('fkJoint')
CORERIG.shapeParent_in_place(mToeFK.mNode,
crv,
True,
replaceShapes=True)
ml_fkShapes.append(cgmMeta.validateObjArg(crv, 'cgmObject'))
if self.str_ikRollSetup == 'control':
log.debug(cgmGEN.logString_msg(_str_func, "Toe Ik control..."))
mToeIK = self.mToe.doCreateAt(setClass=True)
CORERIG.shapeParent_in_place(mToeIK.mNode,
crv,
True,
replaceShapes=True)
mRigNull.connectChildNode(mToeIK, 'controlIKToe',
'rigNull') #Connect
mToeIK.doCopyNameTagsFromObject(self.mToe.mNode,
ignore=['cgmType'])
mToeIK.doStore('cgmTypeModifier', 'ik')
mToeIK.doName()
mToeIK.connectChildNode(self.mToe.fkJoint.blendJoint.mNode,
'blendJoint') #Connect
mMesh_tmp.delete()
return ml_fkShapes
except Exception, err:
cgmGEN.cgmExceptCB(Exception, err, localDat=vars())
hit = RayCast.cast(mesh,
mi_loc.mNode,
aimAxis,
offsetMode='vector',
offsetDistance=vectorOffset,
maxDistance=maxDistance).get('hit')
if not hit:
log.debug(
cgmGEN.logString_msg(
_str_func, "No hit, alternate method | {0}".format(
rotateValue)))
hit = DIST.get_pos_by_axis_dist(mi_loc.mNode, aimAxis,
maxDistance)
if hit:
if DIST.get_distance_between_points(pos_base,
hit) > maxDistance:
log.debug("Max distance exceeded. Using alternative")
hit = DIST.get_pos_by_axis_dist(
mi_loc.mNode, aimAxis, maxDistance)
#d_castReturn = RayCast.findMeshIntersectionFromObjectAxis(mesh, mi_loc.mNode, axis=aimAxis, #maxDistance = maxDistance, firstHit=False) or {}
# d_hitReturnFromValue[rotateValue] = d_castReturn
#if closestInRange:
#hit = d_castReturn.get('near') or False
#else:
#hit = d_castReturn.get('far') or False
#if not hit:log.info("{0} -- {1}".format(rotateValue,d_castReturn))
l_hits.append(hit)
d_processedHitFromValue[rotateValue] = hit
l_pos.append(hit)
if markHits:
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 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))
d_rawHitFromValue[rotateValue] = hit
except Exception,error:
for arg in error.args:
log.error(arg)
raise Exception,"createMeshSliceCurve>> error: %s"%error
log.debug("rotateValue %s | raw hit: %s"%(rotateValue,hit))
if hit and not cgmMath.isVectorEquivalent(hit,d_rawHitFromValue.get(l_rotateSettings[i-1])):
log.debug("last raw: %s"%d_rawHitFromValue.get(l_rotateSettings[i-1]))
if markHits or offsetMode != 'vector':
mi_tmpLoc = cgmMeta.cgmObject(mc.spaceLocator(n='loc_%s'%i)[0])
mc.move (hit[0],hit[1],hit[2], mi_tmpLoc.mNode,ws=True)
if offsetMode =='vector':
_baseVector = MATH.get_vector_of_two_points(pos_base,
hit)
_baseDist = DIST.get_distance_between_points(pos_base,
hit)
hit = DIST.get_pos_by_vec_dist(pos_base,_baseVector, _baseDist + vectorOffset)
elif posOffset:
constBuffer = mc.normalConstraint(mesh,mi_tmpLoc.mNode,
aimVector=[0,0,1],
upVector=[0,1,0],
worldUpType = 'scene')
mc.delete(constBuffer)
mc.move(posOffset[0],posOffset[1],posOffset[2], [mi_tmpLoc.mNode], r=True, rpr = True, os = True, wd = True)
hit = mi_tmpLoc.getPosition()
if not markHits:
mi_tmpLoc.delete()
l_pos.append(hit)
d_processedHitFromValue[rotateValue] = hit
else:#Gonna mark our max distance if no hit
