def orientChain(joints = None, axisAim = 'z+', axisUp = 'y+',
worldUpAxis = [0,1,0], relativeOrient = True,
progressBar = None,
baseName = None, asMeta = True):
"""
Given a series of positions, or objects, or a curve and a mesh - loft retopology it
:parameters:
:returns
created(list)
"""
_str_func = 'orientChain'
if baseName:raise NotImplementedError,"Remove these calls"
def orientJoint(mJnt):
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
if relativeOrient and mParent:
_axisWorldUp = MATH.get_obj_vector(mParent.mNode, axisUp)
else:
_axisWorldUp = worldUpAxis
SNAP.aim(mDup.mNode,_d_children[mJnt][0].mNode,
mAxis_aim.p_vector,mAxis_up.p_vector,
'vector',_axisWorldUp)
mJnt.rotate = 0,0,0
mJnt.jointOrient = mDup.rotate
mDup.delete()
def create_vectorCurveFromObj(obj=None,
vector='z+',
distance=1,
asEuclid=False):
try:
_vec = transformDirection(obj, vector)
except:
_vec = MATH.get_obj_vector(obj, vector, True)
return DIST.create_vectorCurve(
POS.get(obj), _vec, distance,
"{0}_{1}_vecLine".format(NAME.get_base(obj), vector))
def get_pos_by_axis_dist(obj, axis, distance=1):
"""
Get a point in space given an object, an axis and a distance
:parameters:
obj(string)
axis(str)
asEuclid(bool) - data return format
:returns
distance(float)
"""
obj = VALID.mNodeString(obj)
_vector = MATHUTILS.get_obj_vector(obj, axis, False)
return get_pos_by_vec_dist(POS.get(obj), _vector, distance)
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) )
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())
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
else:
vec = MATH.get_obj_vector(_sel[0], axis)
log.info("Found vector: {0}".format(vec))
uiFunc_setWorldUp(self, vec[0], vec[1], vec[2])
def uiFunc_setWorldUp(self, x=None, y=None, z=None):
_base_str = 'uiFF_worldUp'
#mUI.MelFloatField(_row , ut='cgmUISubTemplate', w= 60 ).setV
for i, arg in enumerate([x, y, z]):
if arg is not None:
mField = self.__dict__['{0}{1}'.format(_base_str,
'xyz'[i].capitalize())]
mField.setValue(arg)
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()
