def uiFunc_valuesTweak(self, mode='+'):
_str_func = 'uiFunc_valuesTweak'
if mode == 'zero':
log.info("|{0}| >> Zeroing ".format(_str_func))
for a in 'XYZ':
self.__dict__['uiff_transformTweak{0}'.format(a)].setValue(0)
for k, cb in self._d_transformCBs.iteritems():
cb.setValue(0)
return
_ml_targets = uiFunc_getTargets(self)
if not _ml_targets:
raise ValueError, "Must have targets"
_l_toTweak = []
for k, cb in self._d_transformCBs.iteritems():
if cb.getValue():
_l_toTweak.append(k)
_tweak = []
for a in 'XYZ':
_tweak.append(
self.__dict__['uiff_transformTweak{0}'.format(a)].getValue())
pprint.pprint([mode, _l_toTweak, _tweak])
if mode == '+':
_tweak_call = MATH.list_add
else:
_tweak_call = MATH.list_subtract
for mObj in _ml_targets:
for attr in _l_toTweak:
if attr in [
'translate', 'rotate', 'scale', 'jointOrient', 'rotateAxis'
]:
_v = ATTR.get(mObj.mNode, attr)
log.info("|{0}| >> pre tweak: [{1}] ".format(_str_func, _v))
_v = _tweak_call(_v, _tweak)
log.info("|{0}| >> post tweak: [{1}] ".format(_str_func, _v))
ATTR.set(mObj.mNode, attr, _v)
elif attr == 'position':
_v = TRANS.position_get(mObj.mNode)
log.info("|{0}| >> pre tweak: [{1}] ".format(_str_func, _v))
_v = _tweak_call(_v, _tweak)
log.info("|{0}| >> post tweak: [{1}] ".format(_str_func, _v))
TRANS.position_set(mObj.mNode, _v)
elif attr == 'orient':
_v = TRANS.orient_get(mObj.mNode)
log.info("|{0}| >> pre tweak: [{1}] ".format(_str_func, _v))
_v = _tweak_call(_v, _tweak)
log.info("|{0}| >> post tweak: [{1}] ".format(_str_func, _v))
TRANS.orient_set(mObj.mNode, _v)
else:
log.warning("|{0}| >> Haven't setup for {1}...".format(
_str_func, _s))
pass
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 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 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())
for a,v in _d_fieldValues.iteritems():
_a = _s + a
log.info("|{0}| >> Trying attr: {1} | v: {2}... ".format(_str_func,_a,v))
for mObj in _ml_targets:
if not ATTR.has_attr(mObj.mNode,_s):
log.info("|{0}| >> Object lacks {2} attr : {1}... ".format(_str_func,mObj.mNode,_s))
return
log.info("|{0}| >> Trying Object: {1}... ".format(_str_func,mObj.mNode))
try:ATTR.set(mObj.mNode,_a,v)
except Exception,err:
log.error("|{0}| >> Failed to get set data. Object: {0} | a: {1} | v: {2}...".format(_str_func,mObj.mNode,_a,v))
log.error(err)
elif _s == 'position':
for mObj in _ml_targets:
log.info("|{0}| >> Trying Object: {1} | [{2}]... ".format(_str_func,mObj.mNode,_s))
pos = TRANS.position_get(mObj.mNode)
log.info("|{0}| >> pre pos: [{1}] ".format(_str_func,pos))
for k,v in _d_fieldValues.iteritems():
pos['XYZ'.index(k)] = v
log.info("|{0}| >> pos pos: [{1}] ".format(_str_func,pos))
try:
TRANS.position_set(mObj.mNode, pos)
except Exception,err:
log.error("|{0}| >> Failed to get set data. Object: {0} | section: {2}...".format(_str_func,mObj.mNode,_s))
log.error(err)
elif _s == 'orient':
for mObj in _ml_targets:
log.info("|{0}| >> Trying Object: {1} | [{2}]... ".format(_str_func,mObj.mNode,_s))
val = TRANS.orient_get(mObj.mNode)
log.info("|{0}| >> pre val: [{1}] ".format(_str_func,val))
def create_at(obj=None,
create='null',
midPoint=False,
l_pos=[],
baseName='created'):
"""
Create a null matching a given obj
:parameters:
obj(str): Object to modify
create(str): What to create
:returns
name(str)
"""
_str_func = 'create_at'
obj = VALID.mNodeString(obj)
_create = create
log.debug("|{0}| >> obj:{1}".format(_str_func, obj))
log.debug("|{0}| >> create:{1}".format(_str_func, _create))
if midPoint:
_d = TRANS.POS.get_midPointDict(obj)
objTrans = _d['position']
objRot = _d['rotation']
objRotAxis = None
elif _create in ['null', 'joint']:
objTrans = TRANS.position_get(
obj) #mc.xform (obj, q=True, ws=True, rp=True)
objRot = TRANS.orient_get(
obj) #mc.xform (obj, q=True, ws=True, ro=True)
objRotAxis = mc.xform(obj, q=True, ws=True, ra=True)
if _create == 'null':
_created = mc.group(w=True, empty=True)
if not midPoint:
mc.xform(_created, roo=mc.xform(obj, q=True,
roo=True)) #...match rotateOrder
mc.move(objTrans[0], objTrans[1], objTrans[2], [_created])
mc.xform(_created, ws=True, ro=objRot, p=False)
if objRotAxis:
mc.xform(_created, ws=True, ra=objRotAxis, p=False)
elif _create == 'joint':
mc.select(cl=True)
_created = mc.joint()
if not midPoint:
mc.xform(_created, roo=mc.xform(obj, q=True,
roo=True)) #...match rotateOrder
mc.move(objTrans[0], objTrans[1], objTrans[2], [_created])
mc.xform(_created, ws=True, ro=objRot, p=False)
if objRotAxis:
mc.xform(_created, ws=True, ra=objRotAxis, p=False)
elif _create in ['curve', 'curveLinear', 'linearTrack', 'cubicTrack']:
if not l_pos:
l_pos = []
#_sel = mc.ls(sl=True,flatten=True)
for i, o in enumerate(obj):
p = TRANS.position_get(o)
log.debug("|{0}| >> {3}: {1} | pos: {2}".format(
_str_func, o, p, i))
l_pos.append(p)
if len(l_pos) <= 1:
raise ValueError, "Must have more than one position to create curve"
if _create in ['linearTrack', 'cubicTrack']:
_d = 1
if _create == 'cubicTrack':
_d = 3
_trackCurve = mc.curve(d=1, p=l_pos)
_trackCurve = mc.rename(_trackCurve,
"{0}_trackCurve".format(baseName))
l_clusters = []
#_l_clusterParents = [mStartHandle,mEndHandle]
for i, cv in enumerate(
mc.ls(['{0}.cv[*]'.format(_trackCurve)], flatten=True)):
_res = mc.cluster(cv, n='{0}_{1}_cluster'.format(baseName, i))
TRANS.parent_set(_res[1], obj[i])
ATTR.set(_res[1], 'visibility', 0)
l_clusters.append(_res)
ATTR.set(_res[1], 'visibility', False)
return _trackCurve, l_clusters
elif _create == 'curve':
knot_len = len(l_pos) + 3 - 1
_created = mc.curve(d=3,
ep=l_pos,
k=[i for i in range(0, knot_len)],
os=True)
else:
_created = mc.curve(d=1,
ep=l_pos,
k=[i for i in range(0, len(l_pos))],
os=True)
log.debug("|{0}| >> created: {1}".format(_str_func, _created))
elif _create == 'locator':
raise NotImplementedError, "locators not done yet"
else:
raise NotImplementedError, "|{0}| >> unknown mode: {1}".format(
_str_func, _create)
mc.select(_created)
return _created
import maya.cmds as mc
from cgm.core.lib import transform_utils as TRANS
from cgm.core.lib import position_utils as POS
reload(TRANS)
reload(POS)
_root = 'node'
_euclid = False
#...gets...
TRANS.translate_get(_root,_euclid)
TRANS.position_get(_root,asEuclid = _euclid)
TRANS.rotate_get(_root,_euclid)
TRANS.eulerAngles_get(_root)
TRANS.orient_get(_root,_euclid)
TRANS.orient_get(_root,_euclid)
TRANS.orientObject_get(_root,_euclid)
TRANS.rotateAxis_get(_root,_euclid)
TRANS.worldMatrix_get(_root,_euclid)
TRANS.scaleLocal_get(_root,_euclid)
TRANS.scaleLossy_get(_root,_euclid)
#...sets...
_pos = [0,1,1]
_rot = [10,66,80]
_scale = [1,2,1]
_rot = TRANS.rotate_get('NotBatman_master_block1',True)
