def get_rigGeo(self):
"""
First pass on qss verification
"""
_str_func = 'get_rigGeo'
log.debug("|{0}| >> ...".format(_str_func) + cgmGEN._str_hardBreak)
log.debug(self)
mMasterNull = self.masterNull
_res = []
_l_base = [o for o in mc.ls(type='mesh', visible=True, long=True)]
_l_dags = [VALID.getTransform(o) for o in _l_base]
_l_dags = LISTS.get_noDuplicates(_l_dags)
for o in _l_dags:
mObj = cgmMeta.asMeta(o)
if mObj.getMayaAttr('mClass') == 'cgmControl':
log.debug("|{0}| >> Invalid obj: {1}".format(_str_func, o))
continue
if mObj.getMayaAttr('cgmType') in [
'jointApprox', 'rotatePlaneVisualize'
]:
log.debug("|{0}| >> Invalid obj: {1}".format(_str_func, o))
continue
if 'proxy_geo' in o:
continue
if 'proxyGeo' in o:
continue
_res.append(mObj)
log.debug("|{0}| >> Visible shapes: {1} | dags: {2} | res: {3} ".format(
_str_func, len(_l_base), len(_l_dags), len(_res)))
return _res
def get_constraintsFrom(node=None, fullPath = True):
"""
Get the constraints a given node drives
:parameters:
node(str): node to query
fullPath(bool): How you want list
:returns
list of constraints(list)
"""
_str_func = 'get_constraintsFrom'
node = VALID.mNodeString(node)
_res = mc.listConnections(node,source = False, destination = True,skipConversionNodes = True, type='constraint') or []
_res = LISTS.get_noDuplicates(_res)
#_l_objectConstraints = get(node)
#for c in _l_objectConstraints:
#if c in _res:_res.remove(c)
if fullPath:
return [NAMES.long(o) for o in _res]
return _res
def get_constraintsTo(node=None,
fullPath=True,
typeFilter=None,
typeMask=None):
"""
Get the constraints on a given node
:parameters:
node(str): node to query
fullPath(bool): How you want list
:returns
list of constraints(list)
"""
_str_func = 'get_constraintsTo'
node = VALID.mNodeString(node)
_res = mc.listRelatives(node, type='constraint', fullPath=fullPath) or []
_res = LISTS.get_noDuplicates(_res)
if typeFilter:
typeFilter = VALID.listArg(typeFilter)
for i, t in enumerate(typeFilter):
if 'Constraint' not in t:
typeFilter[i] = t + 'Constraint'
log.debug(
cgmGEN.logString_msg(_str_func,
'typeFilter: {0}'.format(typeFilter)))
_res_filter = []
for o in _res:
_type = VALID.get_mayaType(o)
if _type in typeFilter:
_res_filter.append(o)
_res = _res_filter
if typeMask:
typeMask = VALID.listArg(typeMask)
for i, t in enumerate(typeMask):
if 'Constraint' not in t:
typeMask[i] = t + 'Constraint'
log.debug(
cgmGEN.logString_msg(_str_func, 'typeMask: {0}'.format(typeMask)))
for o in _res:
_type = VALID.get_mayaType(o)
if _type in typeMask:
_res.remove(o)
log.debug(
cgmGEN.logString_msg(_str_func, 'removing: {0}'.format(o)))
if fullPath:
return [NAMES.long(o) for o in _res]
return _res
def get_driver(driven=None, getPlug=True, select=True):
"""
Get the driver objects or plugs by following the anim curve out of our intial driven
:parameters:
driven(str): Attribute to map. If none provided, checks selection
getPlug(bool): Whether to get plug or node
select(bool): Select the result
:returns
driven
"""
_str_func = 'get_driver'
driven = VALID.listArg(driven)
if not driven:
driven = SEARCH.get_selectedFromChannelBox(False) or []
log.debug("|{0}| >> Driven: {1}".format(_str_func, driven))
if not driven:
log.error(
"|{0}| >> No driven found or offered. Try selecting an attribute that is an sdk driven"
.format(_str_func))
return False
l_driver = []
for d in driven:
_buffer = mc.listConnections(d, scn=True, s=True, d=False) or []
if not _buffer:
log.error("|{0}| >> Driven: {1} | No data found".format(
_str_func, d))
for c in _buffer:
log.debug("|{0}| >> Checking: {1}".format(_str_func, c))
#b_transform = VALID.is_transform(c)
#if not b_transform:
l_driver.append(
SEARCH.seek_upStream(c, mode='isTransform', getPlug=getPlug))
l_driver = LISTS.get_noDuplicates(l_driver)
if not l_driver:
log.error("|{0}| >> No driver found".format(_str_func))
return False
if select:
mc.select(l_driver)
pprint.pprint(l_driver)
return l_driver
def get_constraintsTo(node=None, fullPath = True):
"""
Get the constraints on a given node
:parameters:
node(str): node to query
fullPath(bool): How you want list
:returns
list of constraints(list)
"""
_str_func = 'get_constraintsTo'
node = VALID.mNodeString(node)
_res = mc.listRelatives(node,type='constraint',fullPath=fullPath) or []
_res = LISTS.get_noDuplicates(_res)
if fullPath:
return [NAMES.long(o) for o in _res]
return _res
def driven_disconnect(driven = None, driver = None, mode = 'best'):
"""
:parameters:
l_jointChain1 - First set of objects
:returns:
:raises:
Exception | if reached
"""
_str_func = 'driven_disconnect'
mDriven = cgmMeta.asMeta(driven)
_short = mDriven.mNode
l_drivers = []
for a in ['tx','ty','tz','rx','ry','rz','sx','sy','sz']:
l_drivers.append(ATTR.get_driver(_short,a,True))
l_drivers = LISTS.get_noDuplicates(l_drivers)
log.debug("|{0}| >> drivers: {1}".format(_str_func,l_drivers))
mc.delete(l_drivers)
def get_constraintsFrom(node=None,
fullPath=True,
typeFilter=None,
typeMask=None):
"""
Get the constraints a given node drives
:parameters:
node(str): node to query
fullPath(bool): How you want list
:returns
list of constraints(list)
"""
_str_func = 'get_constraintsFrom'
node = VALID.mNodeString(node)
_res = mc.listConnections(node,
source=False,
destination=True,
skipConversionNodes=True,
type='constraint') or []
_res = LISTS.get_noDuplicates(_res)
#_l_objectConstraints = get(node)
#for c in _l_objectConstraints:
#if c in _res:_res.remove(c)
if typeFilter:
typeFilter = VALID.listArg(typeFilter)
for i, t in enumerate(typeFilter):
if 'Constraint' not in t:
typeFilter[i] = t + 'Constraint'
log.debug(
cgmGEN.logString_msg(_str_func,
'typeFilter: {0}'.format(typeFilter)))
_res_filter = []
for o in _res:
_type = VALID.get_mayaType(o)
if _type in typeFilter:
_res_filter.append(o)
_res = _res_filter
if typeMask:
typeMask = VALID.listArg(typeMask)
for i, t in enumerate(typeMask):
if 'Constraint' not in t:
typeMask[i] = t + 'Constraint'
log.debug(
cgmGEN.logString_msg(_str_func, 'typeMask: {0}'.format(typeMask)))
for o in _res:
_type = VALID.get_mayaType(o)
if _type in typeMask:
_res.remove(o)
log.debug(
cgmGEN.logString_msg(_str_func, 'removing: {0}'.format(o)))
if fullPath:
return [NAMES.long(o) for o in _res]
return _res
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)
#log.debug("|{0}| >> reparenting: {1} | {2}".format(_str_func,mJnt.mNode, _d_parents[mJnt]))
#cgmUI.progressBar_iter(progressBar,status='Reparenting: {0}'.format(mJnt.mNode))
mJnt.parent = _d_parents[mJnt]
for mChild in _d_children[mJnt]:
#if mChild not in ml_joints:
#log.debug("|{0}| >> reparenting child: {1}".format(_str_func,mChild.mNode))
mChild.parent = mJnt
if mJnt in ml_ends and mJnt not in ml_world:
log.debug("|{0}| >> End joint. No world: {1}".format(_str_func,mJnt))
mJnt.jointOrient = 0,0,0
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)
_axisWorldUp = worldUpAxis
str_aim = mAxis_aim.p_string
str_up = mAxis_up.p_string
if str_aim == str_up:
raise ValueError,"axisAim and axisUp cannot be the same"
_len = len(ml_joints)
_d_parents = {}
_d_children = {}
ml_roots = []
ml_ends = []
def eyeLook_verify(self):
_str_func = 'eyeLook_verify'
try:
log.debug("|{0}| >> ".format(_str_func)+ '-'*80)
log.debug("{0}".format(self))
mBlock = self.mBlock
mModule = self.mModule
mRigNull = self.mRigNull
mPuppet = self.mPuppet
mHandleFactory = mBlock.asHandleFactory()
_eyeLook = eyeLook_get(self)
if _eyeLook:
log.debug("|{0}| >> Found existing eyeLook...".format(_str_func))
return _eyeLook
if mBlock.blockType not in ['eye']:
raise ValueError,"blocktype must be eye. Found {0} | {1}".format(mBlock.blockType,mBlock)
#Data... -----------------------------------------------------------------------
log.debug("|{0}| >> Get data...".format(_str_func))
#_size = mHandleFactory.get_axisBox_size(mBlock.getMessage('bbHelper'))
try:
_size = self.v_baseSize
_sizeAvg = self.f_sizeAvg
except:
_size = [mBlock.blockScale * v for v in mBlock.baseSize]
_sizeAvg = MATH.average(_size)
#Create shape... -----------------------------------------------------------------------
log.debug("|{0}| >> Creating shape...".format(_str_func))
mCrv = cgmMeta.asMeta( CURVES.create_fromName('arrow4Fat',
direction = 'z+',
size = _sizeAvg ,
absoluteSize=False),'cgmObject',setClass=True)
mCrv.doSnapTo(mBlock.mNode,rotation=False)
pos = mBlock.getPositionByAxisDistance('z+',
_sizeAvg * 8)
mCrv.p_position = 0,pos[1],pos[2]
mBlockParent = mBlock.p_blockParent
if mBlockParent:
mCrv.doStore('cgmName',mBlockParent.cgmName + '_eyeLook')
mBlockParent.asHandleFactory().color(mCrv.mNode)
else:
mCrv.doStore('cgmName','eyeLook')
mHandleFactory.color(mCrv.mNode)
mCrv.doName()
#Register control... -----------------------------------------------------------------------
log.debug("|{0}| >> Registering Control... ".format(_str_func))
d_buffer = MODULECONTROL.register(mCrv,
mirrorSide= 'center',
mirrorAxis="translateX,rotateY,rotateZ",
addSpacePivots = 2)
mCrv = d_buffer['mObj']
#Dynparent... -----------------------------------------------------------------------
log.debug("|{0}| >> Dynparent setup.. ".format(_str_func))
ml_dynParents = copy.copy(self.ml_dynParentsAbove)
mHead = False
for mParent in ml_dynParents:
log.debug("|{0}| >> mParent: {1}".format(_str_func,mParent))
if mParent.getMayaAttr('cgmName') == 'head':
log.debug("|{0}| >> found head_direct...".format(_str_func))
mHead = mParent
break
if mHead:
ml_dynParents.insert(0,mHead)
#if mBlock.attachPoint == 'end':
#ml_dynParents.reverse()
ml_dynParents.extend(mCrv.msgList_get('spacePivots'))
ml_dynParents.extend(copy.copy(self.ml_dynEndParents))
ml_dynParents = LISTS.get_noDuplicates(ml_dynParents)
mDynParent = cgmRIGMETA.cgmDynParentGroup(dynChild=mCrv,dynMode=0)
for o in ml_dynParents:
mDynParent.addDynParent(o)
mDynParent.rebuild()
#Connections... -----------------------------------------------------------------------
log.debug("|{0}| >> Connections... ".format(_str_func))
mModule.connectChildNode(mCrv,'eyeLook')
mPuppet.msgList_append('eyeLook',mCrv,'puppet')
if mBlockParent:
log.debug("|{0}| >> Adding to blockParent...".format(_str_func))
mModuleParent = mBlockParent.moduleTarget
mModuleParent.connectChildNode(mCrv,'eyeLook')
if mModuleParent.mClass == 'cgmRigModule':
mBlockParentRigNull = mModuleParent.rigNull
mBlockParentRigNull.msgList_append('controlsAll',mCrv)
mBlockParentRigNull.moduleSet.append(mCrv)
mRigNull.faceSet.append(mCrv)
mCrv.connectParentNode(mBlockParentRigNull,'rigNull')
else:
mModuleParent.puppetSet.append(mCrv)
mModuleParent.msgList_append('controlsAll',mCrv)
mModuleParent.faceSet.append(mCrv)
#Connections... -----------------------------------------------------------------------
log.debug("|{0}| >> Heirarchy... ".format(_str_func))
mCrv.masterGroup.p_parent = self.mDeformNull
for link in 'masterGroup','dynParentGroup':
if mCrv.getMessage(link):
mCrv.getMessageAsMeta(link).dagLock(True)
mCrv.addAttr('cgmControlDat','','string')
mCrv.cgmControlDat = {'tags':['ik']}
return mCrv
except Exception,error:
cgmGEN.cgmExceptCB(Exception,error,msg=vars())
def rig_cleanUp(self):
try:
_short = self.d_block['shortName']
_str_func = 'rig_cleanUp'.format(_short)
log.debug("|{0}| >> ".format(_str_func) + '-' * 80)
log.debug("{0}".format(self))
#_start = time.clock()
mBlock = self.mBlock
mMasterControl = self.d_module['mMasterControl']
mMasterDeformGroup = self.d_module['mMasterDeformGroup']
mMasterNull = self.d_module['mMasterNull']
mPlug_globalScale = self.d_module['mPlug_globalScale']
_spacePivots = mBlock.numSpacePivots
ml_controlsAll = []
#DynParents =============================================================================
self.UTILS.get_dynParentTargetsDat(self)
log.debug(cgmGEN._str_subLine)
mModule = self.mModule
mRigNull = self.mRigNull
mPuppet = self.mPuppet
mHandleFactory = mBlock.asHandleFactory()
"""
_eyeLook = eyeLook_get(self)
if _eyeLook:
log.debug("|{0}| >> Found existing eyeLook...".format(_str_func))
return _eyeLook
if mBlock.blockType not in ['eye']:
raise ValueError,"blocktype must be eye. Found {0} | {1}".format(mBlock.blockType,mBlock)
"""
#Data... -----------------------------------------------------------------------
log.debug("|{0}| >> Get data...".format(_str_func))
#_size = mHandleFactory.get_axisBox_size(mBlock.getMessage('bbHelper'))
try:
_size = self.v_baseSize
_sizeAvg = self.f_sizeAvg
except:
_size = [mBlock.blockScale * v for v in mBlock.baseSize]
_sizeAvg = MATH.average(_size)
#Create shape... -----------------------------------------------------------------------
log.debug("|{0}| >> Creating shape...".format(_str_func))
mCrv = cgmMeta.asMeta(CURVES.create_fromName('arrow4Fat',
direction='z+',
size=_sizeAvg,
absoluteSize=False),
'cgmObject',
setClass=True)
mCrv.doSnapTo(mBlock.mNode, rotation=False)
pos = mBlock.p_position
mCrv.p_position = pos
mBlockParent = mBlock.p_blockParent
if mBlockParent:
_parentName = mBlockParent.getMayaAttr(
'cgmName') or mBlockParent.p_nameShort
mCrv.doStore('cgmName', _parentName + '_eyeLook')
mBlockParent.asHandleFactory().color(mCrv.mNode)
else:
mCrv.doStore('cgmName', 'eyeLook')
mHandleFactory.color(mCrv.mNode)
mCrv.doName()
#Register control... -----------------------------------------------------------------------
log.debug("|{0}| >> Registering Control... ".format(_str_func))
d_controlSpaces = self.atBuilderUtils('get_controlSpaceSetupDict')
d_buffer = MODULECONTROL.register(
mCrv,
mirrorSide='center',
mirrorAxis="translateX,rotateY,rotateZ",
**d_controlSpaces)
mCrv = d_buffer['mObj']
#Dynparent... -----------------------------------------------------------------------
log.debug("|{0}| >> Dynparent setup.. ".format(_str_func))
ml_dynParents = copy.copy(self.ml_dynParentsAbove)
mHead = False
for mParent in ml_dynParents:
log.debug("|{0}| >> mParent: {1}".format(_str_func, mParent))
if mParent.getMayaAttr('cgmName') == 'head':
log.debug("|{0}| >> found head_direct...".format(_str_func))
mHead = mParent
break
if mHead:
ml_dynParents.insert(0, mHead)
#if mBlock.attachPoint == 'end':
#ml_dynParents.reverse()
ml_dynParents.extend(mCrv.msgList_get('spacePivots'))
ml_dynParents.extend(copy.copy(self.ml_dynEndParents))
ml_dynParents = LISTS.get_noDuplicates(ml_dynParents)
mDynParent = cgmRIGMETA.cgmDynParentGroup(dynChild=mCrv, dynMode=0)
for o in ml_dynParents:
mDynParent.addDynParent(o)
mDynParent.rebuild()
#Connections... -----------------------------------------------------------------------
log.debug("|{0}| >> Connections... ".format(_str_func))
mModule.connectChildNode(mCrv, 'eyeLook')
mPuppet.msgList_append('eyeLook', mCrv, 'puppet')
if mBlockParent:
log.debug("|{0}| >> Adding to blockParent...".format(_str_func))
mModuleParent = mBlockParent.moduleTarget
mModuleParent.connectChildNode(mCrv, 'eyeLook')
if mModuleParent.mClass == 'cgmRigModule':
mBlockParentRigNull = mModuleParent.rigNull
mBlockParentRigNull.msgList_append('controlsAll', mCrv)
mBlockParentRigNull.moduleSet.append(mCrv)
#mRigNull.faceSet.append(mCrv)
#mCrv.connectParentNode(mBlockParentRigNull,'rigNull')
else:
mModuleParent.puppetSet.append(mCrv)
mModuleParent.msgList_append('controlsAll', mCrv)
#mModuleParent.faceSet.append(mCrv)
#Connections... -----------------------------------------------------------------------
log.debug("|{0}| >> Heirarchy... ".format(_str_func))
mCrv.masterGroup.p_parent = self.mDeformNull
for link in 'masterGroup', 'dynParentGroup':
if mCrv.getMessage(link):
mCrv.getMessageAsMeta(link).dagLock(True)
mCrv.addAttr('cgmControlDat', '', 'string')
mCrv.cgmControlDat = {'tags': ['ik']}
mBlock.template = True
return True
try: #moduleParent Stuff =======================================================
if mi_moduleParent:
try:
for mCtrl in self.ml_controlsAll:
mi_parentRigNull.msgList_append('controlsAll', mCtrl)
except Exception, error:
raise Exception, "!Controls all connect!| %s" % error
try:
mi_parentRigNull.moduleSet.extend(self.ml_controlsAll)
except Exception, error:
raise Exception, "!Failed to set module objectSet! | %s" % error
except Exception, error:
raise Exception, "!Module Parent registration! | %s" % (error)
def get_splitValues(surface=None,
values=[],
mode='u',
knotIndices=[],
insertMin=False,
insertMax=False,
preInset=None,
postInset=None,
offset=None,
curvesCreate=False,
curvesConnect=False,
connectionPoints=9):
"""
Function to split a curve up u positionally
:parameters:
'curve'(None) -- Curve to split
curvesCreate(bool) - create new curves from the new values
curvesConnect(bool) - whether to connect the first and last curves
connectionPoints(int) - how many points of connection to use
:returns
list of values(list)
hat tip: http://ewertb.soundlinker.com/mel/mel.074.php
"""
_str_func = 'get_splitValues'
log.debug("|{0}| >> ".format(_str_func) + '-' * 80)
_shape = SHAPES.get_nonintermediate(surface)
if mode == 'u':
l_base = get_dat(_shape, uKnots=True)['uKnots']
minKnot = ATTR.get(_shape, 'minValueU')
maxKnot = ATTR.get(_shape, 'maxValueU')
else:
l_base = get_dat(_shape, vKnots=True)['vKnots']
minKnot = ATTR.get(_shape, 'minValueV')
maxKnot = ATTR.get(_shape, 'maxValueV')
l_sets = []
log.debug("|{0}| >> l_base: {1}".format(_str_func, l_base))
if knotIndices:
values = [l_base[v] for v in knotIndices]
for i, v in enumerate(values):
log.debug("|{0}| >> Processing: {1} | {2}".format(_str_func, i, v) +
"-" * 40)
_last = False
if v == values[-1]:
log.debug("|{0}| >> last...".format(_str_func))
_last = True
if preInset:
v += preInset
log.debug("|{0}| >> preinset: {1}".format(_str_func, v))
_l = [v]
_stop = False
for knot in l_base:
if _stop or MATH.is_float_equivalent(knot, v) == v: continue
log.debug("|{0}| >> checking knot: {1}".format(_str_func, knot))
if _last:
if knot > v:
_stop = True
_l.append(knot)
if knot > v or knot < v:
if _last != True and knot < values[i + 1] and knot > v:
_l.append(knot)
log.debug("|{0}| >> knot add: {1}".format(_str_func, _l))
"""
if v == values[-1]:
if knot < maxKnot:
_l.append(knot)
elif _last != True and knot < values[i+1]:
_l.append(knot)"""
if _last and insertMax:
l_add = []
for v2 in l_base:
if v2 > _l[-1]:
l_add.append(v2)
for v2 in l_add:
_l.append(v2)
_l.append(maxKnot)
if _last != True:
_l.append(values[i + 1])
if insertMin and i == 0:
_l.insert(0, minKnot)
if postInset:
vPost = _l[-1] + postInset
if vPost < _l[-2]:
log.debug("|{0}| >> alternate postInset".format(_str_func))
vPost = _l[-2] + postInset
log.debug("|{0}| >> postInset: {1} | new: {2}".format(
_str_func, _l[-1], vPost))
if len(_l) > 1:
if vPost > max(_l[:-1]):
log.debug(
"|{0}| >> v post creater the max".format(_str_func))
_l[-1] = vPost
else:
_l = _l[:-1]
else:
_l.append(vPost)
"""
if _last != True:
for v2 in _l:
if v2 > v:
_l.remove(v2)"""
_l = LISTS.get_noDuplicates(_l)
_l.sort()
l_sets.append(_l)
log.debug("|{0}| >> result: {1} | {2} | {3}".format(
_str_func, i, v, _l))
l_pre = copy.copy(l_sets)
#pprint.pprint(vars())
if not curvesCreate:
return l_sets
log.debug("|{0}| >> creating curves...".format(_str_func))
l_newCurves = []
d_curves = {}
l_finalCurves = []
def getCurve(uValue, l_newCurves):
_crv = d_curves.get(uValue)
if _crv: return _crv
_crv = mc.duplicateCurve("{0}.u[{1}]".format(_shape, uValue),
ch=0,
rn=0,
local=0)[0]
if offset:
DIST.offsetShape_byVector(_crv, offset, component='cv')
d_curves[uValue] = _crv
log.debug("|{0}| >> created: {1} ...".format(_str_func, _crv))
l_newCurves.append(_crv)
return _crv
for i, uSet in enumerate(l_sets):
_loftCurves = [getCurve(uValue, l_newCurves) for uValue in uSet]
"""
if len(uSet)<2:
l_finalCurves.append(mc.duplicate(_loftCurves[0])[0])
continue"""
log.debug("|{0}| >> {1} | u's: {2}".format(_str_func, i, uSet))
"""
if i == 0 and str_start:
_pair = [str_start,c,l_newCurves[i+1]]
else:
_pair = [c,l_newCurves[i+1]]"""
if len(_loftCurves) == 1:
l_mainCurves = [mc.duplicate(_loftCurves[0])[0]]
else:
crvBase = mc.duplicate(_loftCurves[0])[0]
crvEnd = mc.duplicate(_loftCurves[-1])[0]
l_mainCurves = [crvBase, crvEnd]
if curvesConnect:
log.debug("|{0}| >> {1} | Making connectors".format(
_str_func, i))
d_epPos = {}
for i, crv in enumerate(_loftCurves):
_l = CURVES.getUSplitList(crv,
connectionPoints,
rebuild=True,
rebuildSpans=30)[:-1]
for ii, p in enumerate(_l):
if not d_epPos.get(ii):
d_epPos[ii] = []
_l = d_epPos[ii]
_l.append(p)
for k, points in d_epPos.iteritems():
log.debug("|{0}| >> {1} | k: {1} | points: {2}".format(
_str_func, k, points))
try:
crv_connect = mc.curve(d=1, ep=points, os=True)
#CURVES.create_fromList(posList=points)
l_mainCurves.append(crv_connect)
except Exception, err:
print err
for crv in l_mainCurves[1:]:
CORERIG.shapeParent_in_place(l_mainCurves[0], crv, False)
#ml_shapes.append(cgmMeta.validateObjArg(l_mainCurves[0]))
l_finalCurves.append(l_mainCurves[0])
def curve_tightenEnds(curve,
start=None,
end=None,
blendLength=3,
hardLength=2,
mode='twoBlend'):
"""
mode
'twoBlend' - blend between a start and end joint typically. Created for ribbon work
"""
_str_func = 'curve_tightenEnds'
mCurve = cgmMeta.asMeta(curve)
l_cvs = mCurve.getComponents('cv')
ml_skinClusters = mCurve.getDeformers(deformerTypes='skinCluster',
asMeta=True)
if len(ml_skinClusters) > 1:
raise ValueError, "Only know how to deal with one skin cluster. Found: {0}".format(
ml_skinClusters)
mSkin = ml_skinClusters[0]
#Get our influences --------------------------------------------------
l_influenceObjects = CORESKIN.get_influences_fromCluster(mSkin.mNode)
if not mSkin and l_influenceObjects:
raise StandardError, "controlSurfaceSmoothWeights failed. Not enough info found"
l_cvsUse = [int(cv.split('[')[-1].split(']')[0]) for cv in l_cvs]
#cvEnds = [int(cv.split('[')[-2].split(']')[0]) for cv in l_cvs]
pprint.pprint(vars())
l_cvsUse = LISTS.get_noDuplicates(l_cvsUse)
#cvEnds = LISTS.get_noDuplicates(cvEnds)
if mode == 'twoBlend':
log.debug("|{0}| >> twoBlend mode".format(_str_func))
blendLength = len(l_cvsUse) - hardLength
blendFactor = 1.0 / (blendLength + hardLength)
log.debug("|{0}| >> BlendFactor: {1}".format(_str_func, blendFactor))
if start is None or end is None:
log.debug(
"|{0}| >> No start or end. Figuring out one or another".format(
_str_func))
if start is None:
pos_start = POS.get(l_cvs[0])
start = DIST.get_closestTarget(pos_start, l_influenceObjects)
log.warning("|{0}| >> No start arg, guessed: {1}".format(
_str_func, start))
if end is None:
pos_end = POS.get(l_cvs[-1])
end = DIST.get_closestTarget(pos_end, l_influenceObjects)
log.warning("|{0}| >> No end arg, guessed: {1}".format(
_str_func, end))
#>>>Tie down start and ends
#build our args....
d_dat = {}
for influence in [start, end]:
if influence == start:
cvBlendEnds = l_cvsUse[:blendLength]
if influence == end:
cvBlendEnds = l_cvsUse[-(blendLength):]
cvBlendEnds.reverse()
log.debug("|{0}| >> Influence: {1} | blendEnds: {2}".format(
_str_func, influence, cvBlendEnds))
for i, cv in enumerate(cvBlendEnds):
k = "{0}.cv[{1}]".format(mCurve.mNode, cv)
if not d_dat.get(k):
l = list()
d_dat[k] = l
else:
l = d_dat[k]
d = d_dat[k]
if i < hardLength:
l.append([influence, 1.0])
else:
l.append(
[influence,
MATH.Clamp(
1 - ((i) * blendFactor),
0,
1.0,
)])
#l.append([influence,MATH.Clamp(1 - ( (i-hardLength)*blendFactor), 0,1.0,)])
#pprint.pprint(vars())
#pprint.pprint(d_dat)
#return
for k, dat in d_dat.iteritems():
#log.debug("|{0}| >> key: {1} | dat: {2}".format(_str_func,k,dat))
l_vs = []
for i, dat2 in enumerate(dat):
l_vs.append(dat2[1])
if sum(l_vs) > 1.0:
#log.debug("|{0}| >> before: {1} ".format(_str_func,l_vs))
l_vs = MATH.normalizeListToSum(l_vs)
#log.debug("|{0}| >> after: {1} ".format(_str_func,l_vs))
for i, dat2 in enumerate(dat):
dat2[1] = l_vs[i]
mc.skinPercent(mSkin.mNode, (k), tv=dat, normalize=1)
