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 get_special_pos(targets=None, arg='rp', mode=None, mark=False):
"""
This had to move here for import loop considerations
:parameters:
obj(str): Object to modify
target(str): Object to snap to
sourceObject(str): object to copy from
arg
rp
sp
boundingBoxEach
boundingBoxAll - all targets bounding box cumulative
axisBox
castFar
castNear
groundPos
mode - Relative to
center
front
x
:returns
success(bool)
"""
try:
_str_func = 'get_special_pos'
_sel = mc.ls(sl=True) or []
targets = VALID.listArg(targets)
_targets = VALID.mNodeStringList(targets)
if not _targets:
raise ValueError, "Must have targets!"
_arg = VALID.kw_fromDict(arg,
SHARED._d_pivotArgs,
noneValid=True,
calledFrom=__name__ + _str_func +
">> validate pivot")
if _arg is None:
_arg = arg
if _arg == 'cast':
_arg = 'castNear'
if mode is None:
if _arg in ['boundingBox']:
mode = 'center'
else:
mode = 'z+'
l_nameBuild = ['_'.join([NAMES.get_base(o) for o in _targets]), _arg]
if mode:
l_nameBuild.append(mode)
l_res = []
if _arg in ['rp', 'sp']:
for t in _targets:
l_res.append(POS.get(t, _arg, 'world'))
elif _arg == 'boundingBox':
l_res.append(POS.get_bb_pos(_targets, False, mode))
elif _arg == 'boundingBoxShapes':
l_res.append(POS.get_bb_pos(_targets, True, mode))
elif _arg == 'boundingBoxEach':
for t in _targets:
l_res.append(POS.get_bb_pos(t, False, mode))
elif _arg == 'boundingBoxEachShapes':
for t in _targets:
l_res.append(POS.get_bb_pos(t, True, mode))
elif _arg == 'groundPos':
for t in targets:
pos = TRANS.position_get(t)
l_res.append([pos[0], 0.0, pos[2]])
elif _arg.startswith('castAll'):
_type = _arg.split('castAll')[-1].lower()
log.debug("|{0}| >> castAll mode: {1} | {2}".format(
_str_func, mode, _type))
pos = RAYS.get_cast_pos(_targets[0],
mode,
_type,
None,
mark=False,
maxDistance=100000)
l_res.append(pos)
elif _arg.startswith('cast'):
_type = _arg.split('cast')[-1].lower()
log.debug("|{0}| >> cast mode: {1} | {2}".format(
_str_func, mode, _type))
if len(_targets) > 1:
log.debug("|{0}| >> more than one target...".format(_str_func))
pos = RAYS.get_cast_pos(_targets[0],
mode,
_type,
_targets[1:],
mark=False,
maxDistance=100000)
else:
pos = RAYS.get_cast_pos(_targets[0],
mode,
_type,
_targets,
mark=False,
maxDistance=100000)
if not pos:
return False
l_res.append(pos)
elif _arg == 'axisBox':
log.warning("|{0}| >> axisBox mode is still wip".format(_str_func))
if not targets:
raise ValueError, "No targets in axisBox cast!"
for t in targets:
log.debug("|{0}| >> AxisBox cast: {1} ".format(_str_func, t))
_proxy = CORERIG.create_axisProxy(t)
#Start point is bb center because rp can sometimes be in odd places and we care about the axisBox
pos = RAYS.get_cast_pos(t,
mode,
'near',
_proxy,
startPoint=POS.get(_proxy, 'bb'),
mark=False,
maxDistance=100000)
log.debug("|{0}| >> AxisBox dat: {1}".format(_str_func, pos))
#if not pos:
# pprint.pprint(vars())
l_res.append(pos)
mc.delete(_proxy)
else:
raise ValueError, "|{0}| >> Unknown mode: {1}".format(
_str_func, _arg)
#cgmGEN.func_snapShot(vars())
if len(l_res) > 1:
_res = DIST.get_average_position(l_res)
else:
_res = l_res[0]
if mark:
_loc = mc.spaceLocator()[0]
mc.move(_res[0], _res[1], _res[2], _loc, ws=True)
mc.rename(_loc, '{0}_loc'.format('_'.join(l_nameBuild)))
if _sel and not mark:
mc.select(_sel)
return _res
except Exception, err:
cgmGEN.cgmExceptCB(Exception, err)
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())
