def offsetShape_byVector(dag=None,
distance=1,
origin=None,
component='cv',
vector=None,
mode='origin',
factor=.5,
offsetMode='fixed'):
"""
Attempt for more consistency
If origin is None, juse the center of each shape
"""
_str_func = 'offsetShape_byVector'
log.debug(
"|{0}| >> dag: {1} | distance: {2} | origin: {3} | component: {4}".
format(_str_func, dag, distance, origin, component))
_originUse = None
if VALID.isListArg(origin):
_originUse = origin
elif VALID.objString(origin, noneValid=True):
log.debug(
"|{0}| >> Getting origin from transform of origin string: {1}".
format(_str_func, origin))
_originUse = POS.get(origin)
if VALID.is_shape(dag):
l_shapes = [dag]
else:
l_shapes = mc.listRelatives(dag, shapes=True, fullPath=True)
for i, s in enumerate(l_shapes):
log.debug("|{0}| >> On shape: {1}".format(_str_func, s))
if _originUse is None:
#_trans = VALID.getTransform(dag)
_origin = POS.get_bb_center(s)
log.debug("|{0}| >> Getting origin from center of s: {1}".format(
_str_func, _origin))
else:
_origin = _originUse
_l_source = mc.ls("{0}.{1}[*]".format(s, component),
flatten=True,
long=True)
for ii, c in enumerate(_l_source):
log.debug("|{0}| >> Shape {1} | Comp: {2} | {3}".format(
_str_func, i, ii, c))
if offsetMode == 'fixed':
set_vectorOffset(c, _origin, distance, vector, mode=mode)
else:
pMe = POS.get(c)
_vec = MATHUTILS.get_vector_of_two_points(_origin, pMe)
d = get_distance_between_points(_origin, pMe)
newPos = get_pos_by_vec_dist(POS.get(c), _vec, d * factor)
POS.set(c, newPos)
return True
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 get_pos_by_linearPct(point1,point2,f=.5):
"""
Get the pct distance between two points by vector distance
:parameters:
pos1
pos2
pct
:returns
pos(double3)
"""
vec = MATHUTILS.get_vector_of_two_points(point1,point2)
d = get_distance_between_points(point1,point2)
return get_pos_by_vec_dist(point1,vec,d*f)
def uiFunc_getVectorOfSelected(self, axis='x+'):
if axis == 'between':
_sel = MMCONTEXT.get_list()
else:
_sel = MMCONTEXT.get_list(getTransform=True)
if not _sel:
return log.error('Nothing selected')
if axis == 'between':
if not len(_sel) >= 2:
raise ValueError, 'Must have more than two objects selected for between mode'
try:
vec = MATH.get_vector_of_two_points(POS.get(_sel[0]),
POS.get(_sel[-1]))
except Exception, err:
log.error("Query fail: {0}".format(_sel))
raise Exception, err
def get_vector_between_targets(targetList=None):
"""
"""
_str_func = 'get_vector_between_targets'
if not targetList:
targetList = mc.ls(sl=True,flatten = False)
l_pos = []
l_vec = []
for o in targetList:
l_pos.append(POS.get(o))
if len(l_pos) <= 1:
raise ValueError("|{0}| >> Must have more positions. targetList: {1}".format(_str_func,targetList))
for i,p in enumerate(l_pos[:-1]):
d = MATHUTILS.get_vector_of_two_points(p,l_pos[i+1])
log.debug("|{0}| >> {1} |---------| {2} : {3}".format(_str_func,targetList[i],targetList[i+1],d))
l_vec.append(d)
return l_vec
def get_vectorOffset(obj=None, origin=None, distance=0, asEuclid=False):
"""
Get the vector offset of a given object with a distance. Designed as a replacment
for maya's curve offset as it's finicky coupled with
:parameters:
obj(str): obj to query
origin(d3) - origin to calculate vector from
distance(f)
asEuclid(bool) - whether to return as Vector or not
:returns
pos(list/Vector3)
"""
_str_func = 'get_vectorOffset'
pos = POS.get(obj)
vec = MATHUTILS.get_vector_of_two_points(origin, pos)
newPos = get_pos_by_vec_dist(pos, vec, distance)
if asEuclid:
return MATHUTILS.Vector3(newPos[0], newPos[1], newPos[2])
return newPos
def get_posList_fromStartEnd(start=[0,0,0],end=[0,1,0],split = 1):
_str_func = 'get_posList_fromStartEnd'
#>>Get positions ==================================================================================
_l_pos = []
if split == 1:
_l_pos = [get_average_position([start,end])]
elif split == 2:
_l_pos = [start,end]
else:
_vec = MATHUTILS.get_vector_of_two_points(start, end)
_max = get_distance_between_points(start,end)
log.debug("|{0}| >> start: {1} | end: {2} | vector: {3}".format(_str_func,start,end,_vec))
_split = _max/(split-1)
for i in range(split-1):
_p = get_pos_by_vec_dist(start, _vec, _split * i)
_l_pos.append( _p)
_l_pos.append(end)
_radius = _split/4
return _l_pos
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 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())
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 orientJoint(mJnt):
try:
if mJnt not in ml_cull:
log.debug("|{0}| >> Aready done: {1}".format(
_str_func, mJnt.mNode))
return
log.debug("|{0}| >> Orienting: {1}".format(
_str_func, mJnt.mNode))
mParent = _d_parents[mJnt]
if mParent and mParent in ml_cull:
return
log.debug("|{0}| >> Orienting parent: {1}".format(
_str_func, mParent.mNode))
orientJoint(mParent)
if mJnt in ml_world:
log.debug("|{0}| >> World joint: {1}".format(
_str_func, mJnt.mNode))
try:
axisWorldOrient = SHARED._d_axisToJointOrient[str_aim][
str_up]
except Exception, err:
log.error("{0}>> World axis query. {1} | {2}".format(
_str_func, str_aim, str_up))
raise Exception, err
log.debug("|{0}| >> World joint: {1} | {2}".format(
_str_func, mJnt.mNode, axisWorldOrient))
mJnt.rotate = 0, 0, 0
mJnt.jointOrient = axisWorldOrient[0], axisWorldOrient[
1], axisWorldOrient[2]
elif mJnt not in ml_ends:
log.debug("|{0}| >> Reg joint: {1}".format(
_str_func, mJnt.mNode))
mDup = mJnt.doDuplicate(parentOnly=True)
mc.makeIdentity(mDup.mNode, apply=1, jo=1) #Freeze
b_rotFix = False
if relativeOrient and mParent:
p_child = _d_children[mJnt][0].p_position
p_me = mJnt.p_position
p_parent = mParent.p_position
_axisWorldUp = MATH.get_obj_vector(
mParent.mNode, axisUp)
_vecToChild = MATH.get_vector_of_two_points(
p_child, p_me)
_vecToParent = MATH.get_vector_of_two_points(
p_me, p_parent)
_vecFromParent = MATH.get_vector_of_two_points(
p_parent, p_me)
_angleVec = MATH.angleBetweenVectors(
_axisWorldUp, _vecToChild)
#_angle = MATH.angleBetweenVectors(_vecFromParent,_vecToChild)
_angle = MATH.angleBetween(p_child, p_me, p_parent)
#except:_angle = 0
_cross = MATH.dotproduct(_vecToChild, _vecToParent)
#pprint.pprint(vars())
log.debug(
cgmGEN.logString_msg(
_str_func,
"{0} | vec: {1} | angle: {2} | cross: {3}".
format(mJnt.mNode, _angleVec, _angle, _cross)))
if _angle > 70:
log.warning(
cgmGEN.logString_msg(
_str_func,
"{0} | dangerous angles vec: {1} | angle: {2} "
.format(mJnt.mNode, _angleVec, _angle)))
#log.info(cgmGEN.logString_msg(_str_func,"dangerous cross: {0} ".format(_cross)))
#_axisWorldUp = MATH.get_obj_vector(mParent.mNode, axisBackup)
if _cross < 0:
_axisWorldUp = [-1 * v for v in _vecToParent]
else:
pass
#_axisWorldUp = _vecToParent
#_axisWorldUp = _lastVecUp
#v = MATH.transform_direction(
b_rotFix = True
"""
if _angleVec < 1.0:
_axisWorldUp = MATH.averageVectors(_axisWorldUp,_vecToChild)
_axisWorldUp = MATH.averageVectors(_axisWorldUp,worldUpAxis)#.average in the world value
log.warning(cgmGEN.logString_msg(_str_func,"To child | postfix: {0} ".format(_axisWorldUp)))
else:
_vecToParent = MATH.get_vector_of_two_points(p_me, p_parent)
_axisWorldUp = MATH.averageVectors(_axisWorldUp,_vecToParent)
_axisWorldUp = MATH.averageVectors(_axisWorldUp,worldUpAxis)#.average in the world value
log.warning(cgmGEN.logString_msg(_str_func,"To parent | postfix: {0} ".format(_axisWorldUp)))"""
else:
_axisWorldUp = worldUpAxis
mDup.rotateOrder = 0
SNAP.aim(mDup.mNode, _d_children[mJnt][0].mNode,
mAxis_aim.p_vector, mAxis_up.p_vector, 'vector',
_axisWorldUp)
if b_rotFix:
pass
"""
a = 'r{0}'.format(axisAim[0])
v = ATTR.get(mDup.mNode,a)
log.warning(cgmGEN.logString_msg(_str_func,"{0} | rotFix | a: {1} | v: {2}".format(mJnt.mNode,a,v)))
ATTR.set(mDup.mNode,a,90)"""
mJnt.rotate = 0, 0, 0
mJnt.jointOrient = mDup.p_orient
mDup.delete()
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))
log.debug("From %s: %s" %(rotateValue,d_castReturn))"""
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)
