def define(self):
_short = self.mNode
_str_func = '[{0}] define'.format(_short)
ATTR.set_alias(_short, 'sy', 'blockScale')
self.setAttrFlags(attrs=['sx', 'sz', 'sz'])
self.doConnectOut('sy', ['sx', 'sz'])
ATTR.set_hidden(_short, 'baseSize', True)
_shapes = self.getShapes()
if _shapes:
log.debug("|{0}| >> Removing old shapes...".format(_str_func))
mc.delete(_shapes)
_size = self.atUtils('defineSize_get')
#_sizeSub = _size / 2.0
log.debug("|{0}| >> Size: {1}".format(_str_func, _size))
_crv = CURVES.create_fromName(name='locatorForm',
direction='z+',
size=_size * 2.0)
SNAP.go(_crv, self.mNode)
CORERIG.override_color(_crv, 'white')
CORERIG.shapeParent_in_place(self.mNode, _crv, False)
mHandleFactory = self.asHandleFactory()
self.addAttr('cgmColorLock', True, lock=True, hidden=True)
if self.cgmName == 'default':
self.cgmName = 'eyeLook'
self.doName()
def bakeTempLocator(self, startTime=None, endTime=None):
_str_func = 'PostBake.bakeTempLocator'
if startTime is None:
startTime = self.startTime
if endTime is None:
endTime = self.endTime
ct = mc.currentTime(q=True)
self._bakedLoc = cgmMeta.asMeta(LOC.create(name='bakeLoc'))
self._bakedLoc.rotateOrder = self.obj.rotateOrder
SNAP.matchTarget_set(self._bakedLoc.mNode, self.obj.mNode)
_len = endTime - startTime
_progressBar = cgmUI.doStartMayaProgressBar(_len, "Processing...")
_obj = VALID.objString(self._bakedLoc.mNode, noneValid=False)
_target = VALID.objString(
self.obj.mNode, noneValid=False
) #ATTR.get_message(_obj, 'cgmMatchTarget','cgmMatchDat',0)
ak = mc.autoKeyframe(q=True, state=True)
mc.autoKeyframe(state=False)
mc.refresh(su=True)
completed = True
for i in range(startTime, endTime + 1):
mc.currentTime(i)
SNAP.go(_obj, _target, True, True, pivot='rp')
mc.setKeyframe(_obj, at=['translate', 'rotate'])
if _progressBar:
if mc.progressBar(_progressBar, query=True, isCancelled=True):
log.warning('Bake cancelled!')
completed = False
break
mc.progressBar(_progressBar,
edit=True,
status=("{0} On frame {1}".format(_str_func,
i)),
step=1,
maxValue=_len)
mc.refresh(su=False)
mc.autoKeyframe(state=ak)
cgmUI.doEndMayaProgressBar(_progressBar)
mc.currentTime(ct)
return completed
def snap_action(self,mode = 'point'):
_str_func = 'snap_action'
for o in self._l_sel[:-1]:
_msg = "|{0}| >> mode: {1} | obj: {2} |target: {3}".format(_str_func,mode,o,self._l_sel[-1])
try:
kws = {'obj' : o, 'target' : self._l_sel[-1],
'position' : False, 'rotation' : False, 'rotateAxis' : False,'rotateOrder' : False,'scalePivot' : False,
'pivot' : 'rp', 'space' : 'w', 'mode' : 'xform'}
if mode == 'point':
kws['position'] = True
elif mode == 'orient':
kws['rotation'] = True
elif mode == 'parent':
kws['position'] = True
kws['rotation'] = True
else:
raise ValueError,"Unknown mode!"
_pivotMode = self.var_snapPivotMode.value
if not _pivotMode:pass#0 handled by default
elif _pivotMode == 1:
kws['pivot'] = 'sp'
elif _pivotMode == 2:
kws['pivot'] = 'boundingBox'
else:
raise ValueError,"Uknown pivotMode: {0}".format(_pivotMode)
self.action_logged( SNAP.go(**kws), _msg )
except Exception,err:
log.error("{0} ||| Failure >>> err:s[{1}]".format(_msg,err))
def orientByPlane(joints = None, axisAim = 'z+', axisUp = 'y+',
worldUpAxis = [0,1,0], planarMode = 'up', relativeOrient = True,
progressBar=None,
baseName = None, cleanUp = True, asMeta = True):
"""
Given a chain of joints, setup
:parameters:
planarMode - up/out - What plane to use
:returns
created(list)
"""
_str_func = 'orientPlane'
ml_joints = cgmMeta.validateObjListArg(joints,mayaType=['joint'],noneValid=False)
ml_joints = LISTS.get_noDuplicates(ml_joints)
mAxis_aim = VALID.simpleAxis(axisAim)
mAxis_up = VALID.simpleAxis(axisUp)
str_aim = mAxis_aim.p_string
str_up = mAxis_up.p_string
ml_delete = []
if str_aim == str_up:
raise ValueError,"axisAim and axisUp cannot be the same"
if len(ml_joints) < 3:
raise ValueError,"{0} > Need more than 3 joints".format(_str_func)
#First setup a dup chain of first and end, orient those ----------------------------------------------------------------
log.debug("|{0}| >> Setup tmp chain...".format(_str_func))
mStart = ml_joints[0].doDuplicate(parentOnly = True)
mEnd = ml_joints[-1].doDuplicate(parentOnly = True)
mEnd.parent = mStart
orientChain([mStart,mEnd], axisAim, axisUp, worldUpAxis, relativeOrient)
#Setup Loft curves and plane ----------------------------------------------------------------
log.debug("|{0}| >> Setup curves...".format(_str_func))
if planarMode == 'up':
crvUp = mAxis_up.p_string
crvDn = mAxis_up.inverse.p_string
else:
for a in 'xyz':
if a not in str_aim and a not in str_up:
mAxisCrv_tmp = VALID.simpleAxis(a+'+')
crvUp = mAxisCrv_tmp.p_string
crvDn = mAxisCrv_tmp.inverse.p_string
d_distance = DIST.get_distance_between_targets([mStart.mNode,mEnd.mNode])
l_crvs = []
for mObj in [mStart,mEnd]:
crv = mc.curve (d=1, ep = [DIST.get_pos_by_axis_dist(mObj.mNode, crvUp, d_distance),
DIST.get_pos_by_axis_dist(mObj.mNode, crvDn, d_distance)],
os=True)
log.debug("|{0}| >> Created: {1}".format(_str_func,crv))
l_crvs.append(crv)
_res_body = mc.loft(l_crvs, o = True, d = 1, po = 1 )
_inputs = mc.listHistory(_res_body[0],pruneDagObjects=True)
_tessellate = _inputs[0]
_d = {'format':2,#General
'polygonType':1,#'quads'
}
for a,v in _d.iteritems():
ATTR.set(_tessellate,a,v)
#Snap our joints ---------------------------------------------------------------------------------
for mJnt in ml_joints[1:-1]:
ml_children = mJnt.getChildren(asMeta=True)
for mChild in ml_children:
mChild.parent = False
SNAP.go(mJnt, _res_body[0], rotation=False, pivot='closestPoint')
for mChild in ml_children:
mChild.parent = mJnt
#Cleanup --------------------------------------------------------------------------------------------
if cleanUp:
mc.delete(_res_body + l_crvs)
mStart.delete()
orientChain(ml_joints, axisAim, axisUp, worldUpAxis, relativeOrient,progressBar)
return
l_start = []
l_end = []
mStartCrv = mc.curve()
mc.curve (d=1, ep = posList, os=True)
def resize_masterShape(self, sizeBy=None, resize=False):
try:
_short = self.p_nameShort
_str_func = '[{0}] resize_masterShape'.format(_short)
log.debug("|{0}| >> ".format(_str_func) + '-' * 80)
_sel = mc.ls(sl=True)
_bb = False
_bb = self.baseSize
if resize:
if _sel:
_bb = TRANS.bbSize_get(_sel, False)
#elif self.getBlockChildren():
# sizeBy = mc.ls(self.getBlockChildren(asMeta=False))
# _bb = TRANS.bbSize_get(sizeBy,False)
self.baseSize = _bb
log.debug("|{0}| >> _bb: {1}".format(_str_func, _bb))
mHandleFactory = self.asHandleFactory(_short)
mc.delete(self.getShapes())
_average = MATH.average([_bb[0], _bb[2]])
_size = _average * 1.5
_offsetSize = _average * .01
_blockScale = self.blockScale
mFormNull = self.atUtils('stateNull_verify', 'form')
mNoTransformNull = self.atUtils('noTransformNull_verify', 'form')
if resize or self.controlOffset == .9999:
self.controlOffset = _offsetSize
#Main curve ===========================================================================
_crv = CURVES.create_fromName(name='circle', direction='y+', size=1)
mCrv = cgmMeta.asMeta(_crv)
SNAP.go(mCrv.mNode, self.mNode, rotation=False)
TRANS.scale_to_boundingBox(mCrv.mNode, [_bb[0], None, _bb[2]])
#mDup = mCrv.doDuplicate(po=False)
#mDup.p_position = MATH.list_add(mDup.p_position, [0,_offsetSize,0])
RIG.shapeParent_in_place(self.mNode, _crv, False)
#RIG.shapeParent_in_place(self.mNode,mDup.mNode,False)
mHandleFactory.color(self.mNode, 'center', 'main', transparent=False)
#Bounding box ==================================================================
if self.getMessage('bbHelper'):
self.bbHelper.delete()
_bb_shape = CURVES.create_controlCurve(self.mNode,
'cubeOpen',
size=1,
sizeMode='fixed')
_bb_newSize = MATH.list_mult(self.baseSize,
[_blockScale, _blockScale, _blockScale])
TRANS.scale_to_boundingBox(_bb_shape, _bb_newSize)
mBBShape = cgmMeta.validateObjArg(_bb_shape,
'cgmObject',
setClass=True)
mBBShape.p_parent = mFormNull
mBBShape.inheritsTransform = False
mc.parentConstraint(self.mNode, mBBShape.mNode, maintainOffset=False)
SNAPCALLS.snap(mBBShape.mNode,
self.mNode,
objPivot='axisBox',
objMode='y-')
CORERIG.copy_pivot(mBBShape.mNode, self.mNode)
self.doConnectOut('baseSize', "{0}.scale".format(mBBShape.mNode))
#mHandleFactory.color(mBBShape.mNode,controlType='sub')
mBBShape.setAttrFlags()
mBBShape.doStore('cgmName', self)
mBBShape.doStore('cgmType', 'bbVisualize')
mBBShape.doName()
mBBShape.template = True
self.connectChildNode(mBBShape.mNode, 'bbHelper')
#Offset visualize ==================================================================
if self.getMessage('offsetHelper'):
self.offsetHelper.delete()
#Need to guess our offset size based on bounding box volume
mShape = self.getShapes(asMeta=True)[0]
l_return = mc.offsetCurve(mShape.mNode, distance=1, ch=True)
#pprint.pprint(l_return)
mHandleFactory.color(l_return[0], 'center', 'sub', transparent=False)
mOffsetShape = cgmMeta.validateObjArg(l_return[0],
'cgmObject',
setClass=True)
mOffsetShape.p_parent = mNoTransformNull
#mOffsetShape.doSnapTo(self)
#mc.pointConstraint(self.mNode,mOffsetShape.mNode,maintainOffset=True)
#mc.orientConstraint(self.mNode,mOffsetShape.mNode,maintainOffset=True)
mOffsetShape.inheritsTransform = False
mOffsetShape.dagLock()
_arg = '{0}.distance = -{1}.controlOffset'.format(
l_return[1], self.mNode)
NODEFACTORY.argsToNodes(_arg).doBuild()
#self.doConnectOut('controlOffset',"{0}.distance".format(l_return[1]))
mOffsetShape.doStore('cgmName', self)
mOffsetShape.doStore('cgmType', 'offsetVisualize')
mOffsetShape.doName()
self.connectChildNode(mOffsetShape.mNode, 'offsetHelper')
return
#Offset visualize ==================================================================
if self.getMessage('offsetHelper'):
self.offsetHelper.delete()
mShape = self.getShapes(asMeta=True)[0]
l_return = mc.offsetCurve(mShape.mNode, distance=1, ch=True)
#pprint.pprint(l_return)
mHandleFactory.color(l_return[0], 'center', 'sub', transparent=False)
mOffsetShape = cgmMeta.validateObjArg(l_return[0],
'cgmObject',
setClass=True)
mOffsetShape.p_parent = mFormNull
mOffsetShape.inheritsTransform = False
mc.parentConstraint(self.mNode,
mOffsetShape.mNode,
maintainOffset=False)
#mOffsetShape.setAttrFlags()
_arg = '{0}.distance = -{1}.controlOffset * {1}.blockScale'.format(
l_return[1], self.mNode)
NODEFACTORY.argsToNodes(_arg).doBuild()
#self.doConnectOut('controlOffset',"{0}.distance".format(l_return[1]))
mOffsetShape.doStore('cgmName', self)
mOffsetShape.doStore('cgmType', 'offsetVisualize')
mOffsetShape.doName()
self.connectChildNode(mOffsetShape.mNode, 'offsetHelper')
return
_crv = CURVES.create_fromName(name='squareOpen',
direction='y+',
size=1)
TRANS.scale_to_boundingBox(_crv, [_bb[0], None, _bb[2]])
mHandleFactory.color(_crv, 'center', 'sub', transparent=False)
mCrv = cgmMeta.validateObjArg(_crv, 'cgmObject')
l_offsetCrvs = []
for shape in mCrv.getShapes():
offsetShape = mc.offsetCurve(shape, distance=-_offsetSize,
ch=True)[0]
mHandleFactory.color(offsetShape,
'center',
'main',
transparent=False)
l_offsetCrvs.append(offsetShape)
RIG.combineShapes(l_offsetCrvs + [_crv], True)
SNAP.go(_crv, self.mNode)
RIG.shapeParent_in_place(self.mNode, _crv, True)
self.baseSize = _bb
#Bounding box ==================================================================
if self.getMessage('offsetVisualize'):
self.bbVisualize.delete()
_bb_shape = CURVES.create_controlCurve(self.mNode,
'cubeOpen',
size=1.0,
sizeMode='fixed')
mBBShape = cgmMeta.validateObjArg(_bb_shape,
'cgmObject',
setClass=True)
mBBShape.p_parent = mFormNull
SNAPCALLS.snap(mBBShape.mNode,
self.mNode,
objPivot='axisBox',
objMode='y-')
CORERIG.copy_pivot(mBBShape.mNode, self.mNode)
self.doConnectOut('baseSize', "{0}.scale".format(mBBShape.mNode))
mHandleFactory.color(mBBShape.mNode, controlType='sub')
mBBShape.setAttrFlags()
mBBShape.doStore('cgmName', self)
mBBShape.doStore('cgmType', 'bbVisualize')
mBBShape.doName()
self.connectChildNode(mBBShape.mNode, 'bbHelper')
return True
except Exception, err:
cgmGEN.cgmExceptCB(Exception, err, localDat=vars())
def createWrapControlShape(
targetObjects,
targetGeo=None,
latheAxis='z',
aimAxis='y+',
objectUp='y+',
points=8,
curveDegree=1,
insetMult=None, #Inset multiplier
minRotate=None,
maxRotate=None,
posOffset=[],
rootOffset=[], #offset root before cast
rootRotate=None,
joinMode=False,
extendMode=None,
closedCurve=True,
l_specifiedRotates=None,
maxDistance=1000,
closestInRange=True,
vectorOffset=None,
midMeshCast=False,
subSize=None, #For ball on loli for example
rotateBank=None,
joinHits=None, #keys to processed hits to see what to join
axisToCheck=['x', 'y'],
**kws): #'segment,radial,disc'
"""
This function lathes an axis of an object, shoot rays out the aim axis at the provided mesh and returning hits.
it then uses this information to build a curve shape.
:parameters:
mesh(string) | Surface to cast at
mi_obj(string/mObj) | our casting object
latheAxis(str) | axis of the objec to lathe TODO: add validation
aimAxis(str) | axis to shoot out of
points(int) | how many points you want in the curve
curveDegree(int) | specified degree
minRotate(float) | let's you specify a valid range to shoot
maxRotate(float) | let's you specify a valid range to shoot
posOffset(vector) | transformational offset for the hit from a normalized locator at the hit. Oriented to the surface
markHits(bool) | whether to keep the hit markers
returnDict(bool) | whether you want all the infomation from the process.
rotateBank (float) | let's you add a bank to the rotation object
l_specifiedRotates(list of values) | specify where to shoot relative to an object. Ignores some other settings
maxDistance(float) | max distance to cast rays
closestInRange(bool) | True by default. If True, takes first hit. Else take the furthest away hit in range.
:returns:
Dict ------------------------------------------------------------------
'source'(double3) | point from which we cast
'hit'(double3) | world space points | active during single return
'hits'(list) | world space points | active during multi return
'uv'(double2) | uv on surface of hit | only works for mesh surfaces
:raises:
Exception | if reached
"""
_str_func = "createWrapControlShape"
log.debug(">> %s >> " % (_str_func) + "=" * 75)
_joinModes = []
_extendMode = []
if type(targetObjects) not in [list, tuple]:
targetObjects = [targetObjects]
targetGeo = VALID.objStringList(targetGeo, calledFrom=_str_func)
assert type(points) is int, "Points must be int: %s" % points
assert type(curveDegree) is int, "Points must be int: %s" % points
assert curveDegree > 0, "Curve degree must be greater than 1: %s" % curveDegree
if posOffset is not None and len(posOffset) and len(posOffset) != 3:
raise StandardError, "posOffset must be len(3): %s | len: %s" % (
posOffset, len(posOffset))
if rootOffset is not None and len(rootOffset) and len(rootOffset) != 3:
raise StandardError, "rootOffset must be len(3): %s | len: %s" % (
rootOffset, len(rootOffset))
if rootRotate is not None and len(rootRotate) and len(rootRotate) != 3:
raise StandardError, "rootRotate must be len(3): %s | len: %s" % (
rootRotate, len(rootRotate))
if extendMode in ['loliwrap', 'cylinder', 'disc'] and insetMult is None:
insetMult = 1
for axis in ['x', 'y', 'z']:
if axis in latheAxis.lower(): latheAxis = axis
log.debug("targetObjects: %s" % targetObjects)
if len(aimAxis) == 2: single_aimAxis = aimAxis[0]
else: single_aimAxis = aimAxis
mAxis_aim = VALID.simpleAxis(aimAxis)
log.debug("Single aim: %s" % single_aimAxis)
log.debug("createWrapControlShape>> midMeshCast: %s" % midMeshCast)
log.debug("|{0}| >> extendMode: {1}".format(_str_func, extendMode))
#>> Info
l_groupsBuffer = []
il_curvesToCombine = []
l_sliceReturns = []
#Need to do more to get a better size
#>> Build curves
#=================================================================
#> Root curve #
log.debug("RootRotate: %s" % rootRotate)
mi_rootLoc = cgmMeta.cgmNode(targetObjects[0]).doLoc()
if rootOffset:
log.debug("rootOffset: %s" % rootOffset)
mc.move(rootOffset[0],
rootOffset[1],
rootOffset[2], [mi_rootLoc.mNode],
r=True,
rpr=True,
os=True,
wd=True)
if rootRotate is not None and len(rootRotate):
log.debug("rootRotate: %s" % rootRotate)
mc.rotate(rootRotate[0],
rootRotate[1],
rootRotate[2], [mi_rootLoc.mNode],
os=True,
r=True)
#>> Root
mi_rootLoc.doGroup() #Group to zero
if extendMode == 'segment':
log.debug("segment mode. Target len: %s" % len(targetObjects[1:]))
if len(targetObjects) < 2:
log.warning(
"Segment build mode only works with two objects or more")
else:
if insetMult is not None:
rootDistanceToMove = distance.returnDistanceBetweenObjects(
targetObjects[0], targetObjects[1])
log.debug("rootDistanceToMove: %s" % rootDistanceToMove)
mi_rootLoc.__setattr__('t%s' % latheAxis,
rootDistanceToMove * insetMult)
#mi_rootLoc.tz = (rootDistanceToMove*insetMult)#Offset it
#Notes -- may need to play with up object for aim snapping
#mi_upLoc = cgmMeta.cgmNode(targetObjects[0]).doLoc()
#mi_upLoc.doGroup()#To zero
objectUpVector = dictionary.returnStringToVectors(objectUp)
log.debug("objectUpVector: %s" % objectUpVector)
#mi_uploc
for i, obj in enumerate(targetObjects[1:]):
log.debug("i: %s" % i)
#> End Curve
mi_endLoc = cgmMeta.cgmNode(obj).doLoc()
aimVector = dictionary.returnStringToVectors(latheAxis + '-')
log.debug("segment aimback: %s" % aimVector)
#Snap.go(mi_endLoc.mNode,mi_rootLoc.mNode,move=False,aim=True,aimVector=aimVector,upVector=objectUpVector)
#Snap.go(mi_endLoc.mNode,mi_rootLoc.mNode,move=False,orient=True)
SNAP.go(mi_endLoc.mNode,
mi_rootLoc.mNode,
position=False,
rotation=True)
mi_endLoc.doGroup()
if i == len(targetObjects[1:]) - 1:
if insetMult is not None:
log.debug("segment insetMult: %s" % insetMult)
distanceToMove = distance.returnDistanceBetweenObjects(
targetObjects[-1], targetObjects[0])
log.debug("distanceToMove: %s" % distanceToMove)
#mi_endLoc.tz = -(distanceToMove*insetMult)#Offset it
mi_endLoc.__setattr__('t%s' % latheAxis,
-(distanceToMove * insetMult))
log.debug("segment lathe: %s" % latheAxis)
log.debug("segment aim: %s" % aimAxis)
log.debug("segment rotateBank: %s" % rotateBank)
d_endCastInfo = createMeshSliceCurve(
targetGeo,
mi_endLoc,
midMeshCast=midMeshCast,
curveDegree=curveDegree,
latheAxis=latheAxis,
aimAxis=aimAxis,
posOffset=posOffset,
points=points,
returnDict=True,
closedCurve=closedCurve,
maxDistance=maxDistance,
closestInRange=closestInRange,
rotateBank=rotateBank,
l_specifiedRotates=l_specifiedRotates,
axisToCheck=axisToCheck)
l_sliceReturns.append(d_endCastInfo)
mi_end = cgmMeta.cgmObject(d_endCastInfo['curve'])
il_curvesToCombine.append(mi_end)
mc.delete(mi_endLoc.parent) #delete the loc
elif extendMode == 'radial':
log.debug("|{0}| >> radial...".format(_str_func))
d_handleInner = createMeshSliceCurve(
targetGeo,
mi_rootLoc,
midMeshCast=midMeshCast,
curveDegree=curveDegree,
latheAxis=latheAxis,
aimAxis=aimAxis,
posOffset=0,
points=points,
returnDict=True,
closedCurve=closedCurve,
maxDistance=maxDistance,
closestInRange=closestInRange,
rotateBank=rotateBank,
l_specifiedRotates=l_specifiedRotates,
axisToCheck=axisToCheck)
mi_buffer = cgmMeta.cgmObject(d_handleInner['curve']) #instance curve
l_sliceReturns.append(d_handleInner)
il_curvesToCombine.append(mi_buffer)
elif extendMode == 'disc':
log.debug("|{0}| >> disc...".format(_str_func))
d_size = returnBaseControlSize(mi_rootLoc, targetGeo,
axis=[aimAxis]) #Get size
#discOffset = d_size[ d_size.keys()[0]]*insetMult
size = False
l_absSize = [abs(i) for i in posOffset]
if l_absSize: size = max(l_absSize)
if not size:
d_size = returnBaseControlSize(mi_rootLoc,
targetGeo,
axis=[aimAxis]) #Get size
log.debug("d_size: %s" % d_size)
size = d_size[d_size.keys()[0]] * insetMult
discOffset = size
log.debug("d_size: %s" % d_size)
log.debug("discOffset is: %s" % discOffset)
mi_rootLoc.__setattr__('t%s' % latheAxis, discOffset)
if posOffset:
tmp_posOffset = [
posOffset[0] * .5, posOffset[1] * .5, posOffset[2] * .5
]
d_handleInnerUp = createMeshSliceCurve(
targetGeo,
mi_rootLoc,
curveDegree=curveDegree,
midMeshCast=midMeshCast,
latheAxis=latheAxis,
aimAxis=aimAxis,
posOffset=tmp_posOffset,
points=points,
returnDict=True,
closedCurve=closedCurve,
maxDistance=maxDistance,
closestInRange=closestInRange,
rotateBank=rotateBank,
l_specifiedRotates=l_specifiedRotates,
axisToCheck=axisToCheck)
mi_buffer = cgmMeta.cgmObject(
d_handleInnerUp['curve']) #instance curve
l_sliceReturns.append(d_handleInnerUp)
il_curvesToCombine.append(mi_buffer)
mi_rootLoc.__setattr__('t%s' % latheAxis, -discOffset)
d_handleInnerDown = createMeshSliceCurve(
targetGeo,
mi_rootLoc,
curveDegree=curveDegree,
midMeshCast=midMeshCast,
latheAxis=latheAxis,
aimAxis=aimAxis,
posOffset=tmp_posOffset,
points=points,
returnDict=True,
closedCurve=closedCurve,
maxDistance=maxDistance,
closestInRange=closestInRange,
rotateBank=rotateBank,
l_specifiedRotates=l_specifiedRotates,
axisToCheck=axisToCheck)
mi_buffer = cgmMeta.cgmObject(
d_handleInnerDown['curve']) #instance curve
l_sliceReturns.append(d_handleInnerDown)
il_curvesToCombine.append(mi_buffer)
mi_rootLoc.tz = 0
elif extendMode == 'cylinder':
log.debug("|{0}| >> cylinder...".format(_str_func))
d_size = returnBaseControlSize(mi_rootLoc, targetGeo,
axis=[aimAxis]) #Get size
discOffset = d_size[d_size.keys()[0]] * insetMult
log.debug("d_size: %s" % d_size)
log.debug("discOffset is: %s" % discOffset)
mi_rootLoc.__setattr__('t%s' % latheAxis, discOffset)
d_handleInnerUp = createMeshSliceCurve(
targetGeo,
mi_rootLoc,
curveDegree=curveDegree,
midMeshCast=midMeshCast,
latheAxis=latheAxis,
aimAxis=aimAxis,
posOffset=posOffset,
points=points,
returnDict=True,
closedCurve=closedCurve,
maxDistance=maxDistance,
closestInRange=closestInRange,
rotateBank=rotateBank,
l_specifiedRotates=l_specifiedRotates,
axisToCheck=axisToCheck)
mi_buffer = cgmMeta.cgmObject(
d_handleInnerUp['curve']) #instance curve
l_sliceReturns.append(d_handleInnerUp)
il_curvesToCombine.append(mi_buffer)
mi_rootLoc.__setattr__('t%s' % latheAxis, 0)
elif extendMode == 'loliwrap':
log.debug("|{0}| >> lolipop...".format(_str_func))
#l_absSize = [abs(i) for i in posOffset]
size = False
#if l_absSize:
#log.debug("l_absSize: %s"%l_absSize)
#size = max(l_absSize)*1.25
if subSize is not None:
size = subSize
if not size:
d_size = returnBaseControlSize(mi_rootLoc,
targetGeo,
axis=[aimAxis]) #Get size
log.info("d_size: %s" % d_size)
l_size = d_size[single_aimAxis]
size = l_size / 3
log.info("loli size: %s" % size)
i_ball = cgmMeta.cgmObject(
curves.createControlCurve('sphere', size=size))
elif extendMode == 'endCap':
log.debug("|{0}| >> endCap...".format(_str_func))
returnBuffer1 = createMeshSliceCurve(
targetGeo,
mi_rootLoc.mNode,
aimAxis='{0}+'.format(latheAxis),
latheAxis=objectUp[0],
curveDegree=curveDegree,
maxDistance=maxDistance,
closestInRange=closestInRange,
closedCurve=False,
l_specifiedRotates=[-90, -60, -30, 0, 30, 60, 90],
posOffset=posOffset)
mi_rootLoc.rotate = [0, 0, 0]
mi_rootLoc.__setattr__('r%s' % latheAxis, 90)
returnBuffer2 = createMeshSliceCurve(
targetGeo,
mi_rootLoc.mNode,
aimAxis='{0}+'.format(latheAxis),
latheAxis=objectUp[0],
curveDegree=curveDegree,
maxDistance=maxDistance,
closedCurve=False,
closestInRange=closestInRange,
l_specifiedRotates=[-90, -60, -30, 0, 30, 60, 90],
posOffset=posOffset)
l_sliceReturns.extend([returnBuffer1, returnBuffer2])
il_curvesToCombine.append(cgmMeta.cgmObject(returnBuffer1))
il_curvesToCombine.append(cgmMeta.cgmObject(returnBuffer2))
mi_rootLoc.rotate = [0, 0, 0]
#Now cast our root since we needed to move it with segment mode before casting
if extendMode == 'cylinder':
log.debug("|{0}| >> cylinder move...".format(_str_func))
mi_rootLoc.__setattr__('t%s' % latheAxis, -discOffset)
log.debug("|{0}| >> Rootcast...".format(_str_func))
d_rootCastInfo = createMeshSliceCurve(
targetGeo,
mi_rootLoc,
curveDegree=curveDegree,
minRotate=minRotate,
maxRotate=maxRotate,
latheAxis=latheAxis,
midMeshCast=midMeshCast,
aimAxis=aimAxis,
posOffset=posOffset,
points=points,
vectorOffset=vectorOffset,
returnDict=True,
closedCurve=closedCurve,
maxDistance=maxDistance,
closestInRange=closestInRange,
rotateBank=rotateBank,
l_specifiedRotates=l_specifiedRotates,
axisToCheck=axisToCheck)
#d_rootCastInfo = createMeshSliceCurve(targetGeo,mi_rootLoc,**kws)
log.debug("|{0}| >> Rootcast done".format(_str_func) + cgmGEN._str_subLine)
if extendMode == 'disc':
l_sliceReturns.insert(1, d_rootCastInfo)
else:
l_sliceReturns.insert(0, d_rootCastInfo)
#Special loli stuff
if extendMode == 'loliwrap':
SNAP.go(i_ball.mNode, mi_rootLoc.mNode, True,
True) #Snap to main object
#log.debug("hitReturns: %s"%d_rootCastInfo['hitReturns'])
#cgmGEN.walk_dat(d_rootCastInfo['hitReturns'],'hitReturns')
mi_crv = cgmMeta.cgmObject(d_rootCastInfo['curve'])
"""
d_return = RayCast.findMeshIntersectionFromObjectAxis(targetGeo,mi_rootLoc.mNode,mAxis_aim.p_string) or {}
if not d_return.get('hit'):
log.info(d_return)
raise ValueError,"No hit on loli check"
pos = d_return.get('hit')
dist = distance.returnDistanceBetweenPoints(i_ball.getPosition(),pos) * 2"""
if vectorOffset is not None:
dist = vectorOffset + subSize * 4
else:
dist = max(posOffset) + subSize * 4
if '-' in aimAxis:
distM = -dist
else:
distM = dist
log.debug("distM: %s" % distM)
#Move the ball
pBuffer = i_ball.doGroup()
i_ball.__setattr__('t%s' % single_aimAxis, distM)
i_ball.parent = False
mc.delete(pBuffer)
uPos = distance.returnClosestUPosition(i_ball.mNode, mi_crv.mNode)
SNAP.aim(i_ball.mNode, mi_rootLoc.mNode, aimAxis='z-')
#if posOffset:
#mc.move(posOffset[0]*3,posOffset[1]*3,posOffset[2]*3, [i_ball.mNode], r = True, rpr = True, os = True, wd = True)
#Make the curve between the two
mi_traceCrv = cgmMeta.cgmObject(
mc.curve(degree=1, ep=[uPos, i_ball.getPosition()]))
#Combine
il_curvesToCombine.extend([i_ball, mi_traceCrv])
mi_root = cgmMeta.cgmObject(d_rootCastInfo['curve']) #instance curve
il_curvesToCombine.append(mi_root)
mc.delete(mi_rootLoc.parent) #delete the loc
l_curvesToCombine = [mi_obj.mNode for mi_obj in il_curvesToCombine
] #Build our combine list before adding connectors
log.debug("|{0}| >> processed: {1}".format(
_str_func, d_rootCastInfo['processedHits']))
if joinMode and extendMode not in ['loliwrap', 'endCap'
] and len(l_sliceReturns) > 1:
if joinHits:
keys = d_rootCastInfo['processedHits'].keys()
keys.sort()
#goodDegrees = []
#for i,key in enumerate(keys):
#if i in joinHits:
#goodDegrees.append(key)
goodDegrees = [key for i, key in enumerate(keys) if i in joinHits]
log.debug("joinHits: %s" % joinHits)
log.debug("goodDegrees: %s" % goodDegrees)
else:
goodDegrees = [
key for key in d_rootCastInfo['processedHits'].keys()
]
#> Side Curves
for degree in goodDegrees:
l_pos = []
for d in l_sliceReturns:
l_pos.append(d['processedHits'].get(degree) or False)
while False in l_pos:
l_pos.remove(False)
log.debug("l_pos: %s" % l_pos)
if len(l_pos) >= 2:
try:
l_curvesToCombine.append(
mc.curve(d=curveDegree, ep=l_pos,
os=True)) #Make the curve
except:
log.debug(
"createWrapControlShape>>> skipping curve fail: %s" %
(degree))
#>>Combine the curves
newCurve = curves.combineCurves(l_curvesToCombine)
mi_crv = cgmMeta.cgmObject(rigging.groupMeObject(targetObjects[0], False))
curves.parentShapeInPlace(mi_crv.mNode, newCurve) #Parent shape
mc.delete(newCurve)
#>>Copy tags and name
mi_crv.doCopyNameTagsFromObject(targetObjects[0],
ignore=['cgmType', 'cgmTypeModifier'])
mi_crv.addAttr('cgmType',
attrType='string',
value='controlCurve',
lock=True)
mi_crv.doName()
#Store for return
return {'curve': mi_crv.mNode, 'instance': mi_crv}
def create_localAxisProxyBAK(obj=None):
"""
Make a local axis box around a given object so that you can then
"""
try:
_str_func = 'create_localAxisProxy'
_dag = VALID.getTransform(obj)
if not _dag:
raise ValueError, "Must have a dag node"
l_shapes = TRANS.shapes_get(_dag)
_dup = mc.duplicate(l_shapes, po=False, rc=True)[0]
#_dup = TRANS.parent_set(_dup,False)
#Get some values...
t = ATTR.get(_dup, 'translate')
r = ATTR.get(_dup, 'rotate')
s = ATTR.get(_dup, 'scale')
o = TRANS.orient_get(_dup)
shear = ATTR.get(_dup, 'shear')
_scaleLossy = TRANS.scaleLossy_get(_dag)
#Reset our stuff before we make our bb...
TRANS.orient_set(_dup, (0, 0, 0))
ATTR.set(_dup, 'scale', [1, 1, 1])
_size = POS.get_bb_size(_dup, True)
import cgm.core.lib.math_utils as COREMATH
reload(COREMATH)
#_proxy = create_proxyGeo('cube',COREMATH.list_div(_scaleLossy,_size))
_proxy = create_proxyGeo('cube', _size)
mc.makeIdentity(_proxy, apply=True, scale=True)
return
#mc.xform(_proxy, scale = _size, worldSpace = True, absolute = True)
#Parent it to the dup...
_proxy = TRANS.parent_set(_proxy, _dup)
ATTR.reset(_proxy, ['t', 'r', 'shear'])
#_dup = TRANS.parent_set(_dup, TRANS.parents_get(_dag))
SNAP.go(_dup, _dag)
ATTR.set(_dup, 'shear', shear)
#TRANS.scaleLocal_set(_dup, s)
#mc.delete(_dup)
#_scaleLossy = TRANS.scaleLossy_get(_dag)
#import cgm.core.lib.math_utils as COREMATH
#TRANS.scaleLocal_set(_dup, COREMATH.list_mult([-1.0,-1.0,-1.0],_scaleLossy,))
#proxy = TRANS.parent_set(_proxy, False)
cgmGEN.func_snapShot(vars())
#ATTR.set(_dup,'translate',t)
#ATTR.set(_dup,'rotate',r)
#SNAP.go(_proxy[0],_dag)
#ATTR.set(_proxy[0],'scale',_scaleLossy)
#TRANS.scaleLocal_set(_dup,[1,1,1])
#ATTR.set(_dup,'shear',[0,0,0])
#_proxy = TRANS.parent_set(_proxy, False)
#TRANS.scaleLocal_set(_proxy,_scaleLossy)
#ATTR.set(_dup,'scale',s)
return mc.rename(_proxy,
"{0}_localAxisProxy".format(NAMES.get_base(_dag)))
except Exception, err:
cgmGEN.cgmExceptCB(Exception, err, msg=vars())
def create_axisProxy(obj=None):
"""
Make a local axis box around a given object so that you can then
"""
try:
_str_func = 'create_axisProxy'
_dag = VALID.getTransform(obj)
if not _dag:
raise ValueError, "Must have a dag node. Obj: {0}".format(obj)
if VALID.is_shape(obj):
l_shapes = [obj]
else:
l_shapes = TRANS.shapes_get(_dag, True)
_parent = TRANS.parent_get(_dag)
_dup = mc.duplicate(l_shapes, po=False, rc=True)[0]
#TRANS.pivots_recenter(_dup)
_dup = TRANS.parent_set(_dup, False)
ATTR.set_standardFlags(_dup, lock=False, keyable=True)
#Get some values...
l_reset = ['t', 'r', 's', 'shear', 'rotateAxis']
t = ATTR.get(_dup, 'translate')
r = ATTR.get(_dup, 'rotate')
s = ATTR.get(_dup, 'scale')
ra = ATTR.get(_dup, 'rotateAxis')
if ATTR.has_attr(_dup, 'jointOrient'):
l_reset.append('jointOrient')
jo = ATTR.get(_dup, 'jointOrient')
o = TRANS.orient_get(_dup)
shear = ATTR.get(_dup, 'shear')
_scaleLossy = TRANS.scaleLossy_get(_dag)
#Reset our stuff before we make our bb...
ATTR.reset(_dup, l_reset)
_size = POS.get_bb_size(_dup, True)
#_proxy = create_proxyGeo('cube',COREMATH.list_div(_scaleLossy,_size))
_proxy = create_proxyGeo('cube', _size)
mc.makeIdentity(_proxy, apply=True, scale=True)
#Now Put it back
_dup = TRANS.parent_set(_dup, TRANS.parent_get(_dag))
_proxy = TRANS.parent_set(_proxy, _dup)
#_dup = TRANS.parent_set(_dup, TRANS.parents_get(_dag))
SNAP.go(_dup, _dag)
#ATTR.set(_dup,'s',(0,0,0))
ATTR.reset(_dup, ['s', 'shear'])
ATTR.reset(_proxy, ['t', 'r', 's', 'shear', 'rotateAxis'])
_proxy = TRANS.parent_set(_proxy, _dag)
ATTR.reset(_proxy, ['t', 'r', 's', 'shear', 'rotateAxis'])
#match_transform(_proxy,_dag)
#SNAP.go(_proxy,_dag,pivot='bb')
#cgmGEN.func_snapShot(vars())
_proxy = TRANS.parent_set(_proxy, False)
mc.delete(_dup)
#match_transform(_proxy,_dag)
return mc.rename(_proxy,
"{0}_localAxisProxy".format(NAMES.get_base(_dag)))
except Exception, err:
cgmGEN.cgmExceptCB(Exception, err, msg=vars())
def shapeParent_in_place(obj,
shapeSource,
keepSource=True,
replaceShapes=False,
snapFirst=False):
"""
Shape parent a curve in place to a obj transform
:parameters:
obj(str): Object to modify
shapeSource(str): Curve to shape parent
keepSource(bool): Keep the curve shapeParented as well
replaceShapes(bool): Whether to remove the obj's original shapes or not
snapFirst(bool): whether to snap source to obj before transfer
:returns
success(bool)
"""
_str_func = 'shapeParent_in_place'
l_shapes = VALID.listArg(shapeSource)
obj = VALID.mNodeString(obj)
log.debug(
"|{0}| >> obj: {1} | shapeSource: {2} | keepSource: {3} | replaceShapes: {4}"
.format(_str_func, obj, shapeSource, keepSource, replaceShapes))
if replaceShapes:
_l_objShapes = mc.listRelatives(obj, s=True, fullPath=True)
if _l_objShapes:
log.debug("|{0}| >> Removing obj shapes...| {1}".format(
_str_func, _l_objShapes))
mc.delete(_l_objShapes)
mc.select(cl=True)
#mc.refresh()
for c in l_shapes:
try:
_shapeCheck = SEARCH.is_shape(c)
if not _shapeCheck and not mc.listRelatives(
c, f=True, shapes=True, fullPath=True):
raise ValueError, "Has no shapes"
if coreNames.get_long(obj) == coreNames.get_long(c):
raise ValueError, "Cannot parentShape self"
if VALID.get_mayaType(c) == 'nurbsCurve':
mc.ls(['%s.ep[*]' % (c)], flatten=True)
#This is for a really weird bug in 2016 where offset curve shapes don't work right unless they're components are queried.
if _shapeCheck:
_dup_curve = duplicate_shape(c)[0]
log.debug("|{0}| >> shape duplicate".format(_str_func))
if snapFirst:
SNAP.go(_dup_curve, obj)
else:
log.debug("|{0}| >> regular duplicate".format(_str_func))
_dup_curve = mc.duplicate(c)[0]
for child in TRANS.children_get(_dup_curve, True):
mc.delete(child)
if snapFirst:
SNAP.go(_dup_curve, obj)
_l_parents = SEARCH.get_all_parents(obj)
ATTR.set_standardFlags(_dup_curve,
lock=False,
visible=True,
keyable=True)
_dup_curve = parent_set(_dup_curve, False)
copy_pivot(_dup_curve, obj)
#piv_pos = mc.xform(obj, q=True, ws=True, rp = True)
#mc.xform(_dup_curve,ws=True, rp = piv_pos)
pos = mc.xform(obj, q=True, os=True, rp=True)
curveScale = mc.xform(_dup_curve, q=True, s=True, r=True)
objScale = mc.xform(obj, q=True, s=True, r=True)
#account for freezing
#mc.makeIdentity(_dup_curve,apply=True,translate =True, rotate = True, scale=False)
# make our zero out group
#group = rigging.groupMeObject(obj,False)
group = create_at(obj, 'null')
_dup_curve = mc.parent(_dup_curve, group)[0]
# zero out the group
mc.xform(group, ws=True, t=pos)
#mc.xform(group,roo = 'xyz', p=True)
mc.xform(group, ra=[0, 0, 0], p=False)
mc.xform(group, ro=[0, 0, 0], p=False)
mc.makeIdentity(_dup_curve,
apply=True,
translate=True,
rotate=True,
scale=False)
#main scale fix
baseMultiplier = [0, 0, 0]
baseMultiplier[0] = (curveScale[0] / objScale[0])
baseMultiplier[1] = (curveScale[1] / objScale[1])
baseMultiplier[2] = (curveScale[2] / objScale[2])
mc.setAttr(_dup_curve + '.sx', baseMultiplier[0])
mc.setAttr(_dup_curve + '.sy', baseMultiplier[1])
mc.setAttr(_dup_curve + '.sz', baseMultiplier[2])
#parent scale fix
if _l_parents:
_l_parents.reverse()
multiplier = [
baseMultiplier[0], baseMultiplier[1], baseMultiplier[2]
]
for p in _l_parents:
scaleBuffer = mc.xform(p, q=True, s=True, r=True)
multiplier[0] = ((multiplier[0] / scaleBuffer[0]))
multiplier[1] = ((multiplier[1] / scaleBuffer[1]))
multiplier[2] = ((multiplier[2] / scaleBuffer[2]))
mc.setAttr(_dup_curve + '.sx', multiplier[0])
mc.setAttr(_dup_curve + '.sy', multiplier[1])
mc.setAttr(_dup_curve + '.sz', multiplier[2])
_dup_curve = parent_set(_dup_curve, False)
mc.delete(group)
#freeze for parent shaping
mc.makeIdentity(_dup_curve,
apply=True,
translate=True,
rotate=True,
scale=True)
shape = mc.listRelatives(_dup_curve,
f=True,
shapes=True,
fullPath=True)
mc.parent(shape, obj, add=True, shape=True)
mc.delete(_dup_curve)
if not keepSource:
mc.delete(c)
except Exception, err:
cgmGEN.cgmExceptCB(Exception, err, msg=vars())
