def verify_aimAttrs(obj=None, aim=None, up=None, checkOnly=False):
"""
Make sure an object has aim attributes.
:parameters:
obj(str): Object to modify
aim(arg): Value to set with on call
up(arg): Value to set with on call
out(arg): Value to set with on call
checkOnly(bool): Check only, no adding attrs
:returns
success(bool)
"""
_str_func = 'verify_aimAttrs'
_str_enum = 'x+:y+:z+:x-:y-:z-'
_obj = VALID.objString(obj,
noneValid=False,
calledFrom=__name__ + _str_func + ">> validate obj")
_l = [aim, up]
_l_defaults = [aim or 2, up or 1]
for i, a in enumerate(['axisAim', 'axisUp']):
_d = ATTR.validate_arg(_obj, a)
_good = False
if mc.objExists(_d['combined']):
if ATTR.get_type(_d) == 'enum':
if ATTR.get_enum(_d) == _str_enum:
_good = True
if not _good:
if checkOnly:
return False
log.debug("|{0}| >> {1} not a good attr. Must rebuild".format(
_str_func, _d['combined']))
ATTR.delete(_d)
ATTR.add(_d, 'enum', enumOptions=_str_enum, hidden=False)
ATTR.set(_d, value=_l_defaults[i])
ATTR.set_keyable(_d, False)
_v = _l[i]
if _v is not None:
ATTR.set(_d, value=_v)
return True
def aim_atPoint(obj = None, position = [0,0,0], aimAxis = "z+", upAxis = "y+", mode = 'local',vectorUp = None,ignoreAimAttrs = False):
"""
Aim functionality.
:parameters:
obj(str): Object to modify
position(array): object to copy from
aimAxis(str): axis that is pointing forward
upAxis(str): axis that is pointing up
mode(str):
'local'-- use standard maya aiming with local axis
'world' -- use standard maya aiming with world axis
'matrix' -- use Bokser's fancy method
'vector' -- maya standard with vector up axis
'object' -- maya standard with object
:returns
success(bool)
"""
try:
_str_func = 'aimAtPoint'
_loc = False
_obj = VALID.objString(obj, noneValid=False, calledFrom = __name__ + _str_func + ">> validate obj")
try:position = position.x,position.y,position.z
except:pass
try:vectorUp = vectorUp.x,vectorUp.y,vectorUp.z
except:pass
log.debug("|{0}| >> obj: {1} | position:{2} | mode: {3}".format(_str_func,_obj,position,mode))
if not ignoreAimAttrs:
_d_aim = ATTR.validate_arg(_obj,'axisAim')
_d_up =ATTR.validate_arg(_obj,'axisUp')
if ATTR.has_attr(_d_aim) and ATTR.has_attr(_d_up):
aimAxis = ATTR.get_enumValueString(_d_aim)
upAxis = ATTR.get_enumValueString(_d_up)
log.debug("|{0}| >> obj: {1} aimable from attrs. aim: {2} | up: {3}".format(_str_func,_obj,aimAxis,upAxis))
if mode == 'matrix':
'''Rotate transform based on look vector'''
# get source and target vectors
objPos = POS.get(_obj, asEuclid=True)
targetPos = MATH.Vector3.Create(position)
aim = (targetPos - objPos).normalized()
if not vectorUp:
upVector = MATH.Vector3.up()
if upAxis == "y-":
upVector = MATH.Vector3.down()
elif upAxis == "z+":
upVector = MATH.Vector3.forward()
elif upAxis == "z-":
upVector = MATH.Vector3.back()
elif upAxis == "x+":
upVector = MATH.Vector3.right()
elif upAxis == "x-":
upVector = MATH.Vector3.left()
else:
upVector = MATH.Vector3.up()
vectorUp = MATH.transform_direction( _obj, upVector )
wantedAim, wantedUp = MATH.convert_aim_vectors_to_different_axis(aim, vectorUp, aimAxis, upAxis)
xformPos = mc.xform(_obj, q=True, matrix = True, ws=True)
pos = MATH.Vector3(xformPos[12], xformPos[13], xformPos[14])
rot_matrix = EUCLID.Matrix4.new_look_at(MATH.Vector3.zero(), -wantedAim, wantedUp)
s = MATH.Vector3.Create( mc.xform(_obj, q=True, ws=True, s=True) )
scale_matrix = EUCLID.Matrix4()
scale_matrix.a = s.x
scale_matrix.f = s.y
scale_matrix.k = s.z
scale_matrix.p = 1
result_matrix = rot_matrix * scale_matrix
transform_matrix = result_matrix[0:12] + [pos.x, pos.y, pos.z, 1.0]
mc.xform(_obj, matrix = transform_matrix , roo="xyz", ws=True)
"""elif mode == 'world':
_loc = mc.spaceLocator()[0]
mc.move (position[0],position[1],position[2], _loc, ws=True)
mAxis_aim = VALID.simpleAxis(aimAxis)
mAxis_up = VALID.simpleAxis(upAxis)
_constraint = mc.aimConstraint(_loc,_obj,
maintainOffset = False,
aimVector = mAxis_aim.p_vector,
upVector = mAxis_up.p_vector,
worldUpType = 'scene',)
mc.delete(_constraint + [_loc])"""
elif mode in ['local','world','vector','object']:
_loc = mc.spaceLocator(name='test')[0]
_loc_snap = POS.create_loc(_obj)
mc.move (position[0],position[1],position[2], _loc, ws=True)
mAxis_aim = VALID.simpleAxis(aimAxis)
mAxis_up = VALID.simpleAxis(upAxis)
if mode == 'world':
_constraint = mc.aimConstraint(_loc,_loc_snap,
maintainOffset = False,
aimVector = mAxis_aim.p_vector,
upVector = mAxis_up.p_vector,
worldUpType = 'scene',)
elif mode == 'object':
vectorUp = VALID.mNodeString(vectorUp)
_constraint = mc.aimConstraint(_loc,_loc_snap,
maintainOffset = False,
aimVector = mAxis_aim.p_vector,
upVector = mAxis_up.p_vector,
worldUpType = 'object',
worldUpObject = vectorUp)
#worldUpVector = _vUp)
else:
if mode == 'vector':
_vUp = vectorUp
else:
_vUp = MATH.get_obj_vector(_obj,upAxis)
_constraint = mc.aimConstraint(_loc,_loc_snap,
maintainOffset = False,
aimVector = mAxis_aim.p_vector,
upVector = mAxis_up.p_vector,
worldUpType = 'vector',
worldUpVector = _vUp)
go(obj,_loc_snap)
mc.delete(_constraint,_loc_snap)
else:
raise NotImplementedError,"mode: {0}".format(mode)
if _loc:mc.delete(_loc)
return True
except Exception,err:
try:mc.delete(_loc)
except:pass
log.error( "aim_atPoint | obj: {0} | err: {1}".format(obj,err) )