def _setupLights( domeRig, isSpot, lights, numLights, lightConstraint, lightLocator ):
lightAttr = ( 'color', 'emitSpecular', 'coneAngle', 'penumbraAngle',
'dropoff', 'shadowColor', 'dmapResolution', 'dmapFilterSize',
'dmapBias', 'lightRadius', 'shadowRays', 'useDepthMapShadows',
'useRayTraceShadows' )
# Create intensity MD to divide each light's intensity to sum the user's intensity
intMD = cmds.shadingNode( 'multiplyDivide', asUtility=True, name=(domeRig + '_mdIntensity') )
cmds.setAttr( (intMD + ".operation"), 2 )
cmds.setAttr( (intMD + ".input2X"), numLights )
cmds.connectAttr( (domeRig + '.intensity'), (intMD + '.input1X') )
# Set up for individual lights in the rig
for l in lights:
# Connect intensity MD to each light's intensity
cmds.connectAttr( (intMD + '.outputX'), (l + '.intensity') )
# Constrain all lights to sphere
lp = cmds.listRelatives(l, parent=True)
cmds.geometryConstraint( lightConstraint, lp )
# Set all lights to point at locator
cmds.aimConstraint( lightLocator, lp[0], offset=[0,-90,0] )
# Connect group's extra attributes to each light's attributes
for attr in lightAttr:
if isSpot or ( not isSpot and attr not in ['coneAngle', 'penumbraAngle', 'dropoff']):
cmds.connectAttr( (domeRig + '.' + attr), (l + '.' + attr) )
# Connect sphere and light rig keyable attributes
attrs = cmds.listAttr(lightConstraint[0], keyable=True)
for attr in attrs:
cmds.setAttr( (lightConstraint[0] + '.' + attr), keyable=False, lock=True )
def crvTendon(curve,geo,precision=4,prefix='tendon'):
'''
'''
# rebuildCurve degree 1
baseCurve = mc.rebuildCurve(curve,ch=0,s=1,d=1,rpo=1,rt=0,end=1,kr=0,kcp=0,kep=1,kt=1)
# create cv locators
baseLocs = glTools.utils.curve.locatorCurve(baseCurve,prefix=prefix+'_baseCrv')
# generate geo constraint curve
geoCurve = mc.rebuildCurve(baseCurve,ch=1,s=precsion,d=1,rpo=0,rt=0,end=1,kr=0,kcp=0,kep=1,kt=1)
geoCurveLocs = glTools.utils.curve.locatorCurve(geoCurve,prefix=prefix+'_geoCrv')
# generate reference curve
refCurve = mc.rebuildCurve(baseCurve,ch=1,s=precsion,d=1,rpo=0,rt=0,end=1,kr=0,kcp=0,kep=1,kt=1)
refCurveInfo = mc.createNode('curveInfo',n=prefix+'_ref_curveInfo')
mc.connectAttr(refCurve+'.worldSpace[0]',refCurveInfo+'.inputCurve',f=True)
refCurveLocs = []
for i in range(precsion+1):
refNull = mc.group(em=True,n=prefix+'_ref'+str(i)+'_null')
mc.connectAttr(refCurveInfo+'.controlPoints['+str(i)+']',refNull+'.t')
refCurveLocs.append(refNull)
# Locator Constraints
for i in range(precsion+1):
mc.pointConstraint(refCurveLocs[i],geoCurveLocs[i])
mc.geometryConstraint(geo,geoCurveLocs[i])
# fitBspline
bSpline = mc.fitBspline(geoCurve,ch=1)
def constraintCar(asset, *args):
constraints = ['FR', 'FL', 'RR', 'RL']
attrList = [ \
asset+'_rig:CTRL_roue_RR_offset_parentConstraint1.Fit_to_ground_RRW0', \
asset+'_rig:CTRL_roue_RL_offset_parentConstraint1.Fit_to_ground_RLW0', \
asset+'_rig:CTRL_roue_FL_offset_parentConstraint1.Fit_to_ground_FLW0', \
asset+'_rig:CTRL_roue_FR_offset_parentConstraint1.Fit_to_ground_FRW0' ]
sel = cmds.ls(selection=True)
if len(sel) != 1:
cmds.warning('More than one object is selected')
return
sel = cmds.listRelatives(sel, shapes=True)
for attr in attrList:
cmds.setAttr(attr, 1)
for const in constraints:
cmds.select(asset + '_rig:Fit_to_ground_' + const + '_offset',
add=True)
cmds.geometryConstraint(weight=1)
cmds.select(asset + '_rig:Fit_to_ground_' + const + '_offset',
tgl=True)
cmds.setAttr(sel[0] + '.visibility', 0)
def _createLoc(self,
name=None,
baseTransform=None,
targetTransform=None,
plane=None):
if self.logger: self.logger.info('_createLoc(): Starting...')
# Create the locator
loc = cmds.spaceLocator(n=name + '_multiAxisRigLoc')[0]
# Snap to base
cmds.delete(cmds.pointConstraint(baseTransform, loc, mo=False))
# Constrain to plane
cmds.geometryConstraint(plane,
loc,
n=name + '_multiAxisRigLocGeoConst')
# pointConst to target
cmds.pointConstraint(targetTransform,
loc,
mo=True,
n=name + '+multiAxisRigLocPointConst')
if self.logger:
self.logger.info('_createLoc(): End...\nReturned: %s' % loc)
return loc
def geometryNormalConstraintRun(): currentSelection = cmds.ls(selection=True) if len(currentSelection) > 1: ground = currentSelection[len(currentSelection)- 1] for i in range(len(currentSelection) - 1): cmds.geometryConstraint(ground , currentSelection[i]) cmds.normalConstraint(ground , currentSelection[i], aim=[0,1,0], u=[0,1,0], wut="Vector", wu=[0,1,0]) else: cmds.confirmDialog(t="Warning", message="You must select at least two geometry objects. Last object will always be considered the ground target", button=["OK"], icon="warning")
def constrainToSurface_geometryConstraint(surface, target, xform, prefix):
"""
Use a point/geometry constraint to attach the specified transform to a target surface.
@param surface: Geometry to attach the transform to.
@type surface: str
@param target: Target transform that the constrained transform will try to match.
@type target: str
@param xform: Transform to constrainto the surface.
@type xform: str
@param prefix: Name prefix for created nodes.
@type prefix: str
"""
# Checks
if not cmds.objExists(surface):
raise Exception('Surface "' + surface + '" does not exist!')
if not cmds.objExists(target):
raise Exception('Target transform "' + target + '" does not exist!')
if not cmds.objExists(xform):
raise Exception('Constraint transform "' + xform + '" does not exist!')
# Create Constraints
pntCon = cmds.pointConstraint(target, xform, n=prefix + '_pointConstraint')
geoCon = cmds.geometryConstraint(surface, xform, n=prefix + '_geometryConstraint')
# Return Result
return [geoCon, pntCon]
def test_assertConstrained(self):
a = cmds.polySphere()[0]
b = cmds.polySphere()[0]
temp = cmds.parentConstraint(a,b)
self.assertTrue( self.lib.assertConstrained(a, b, type='parent') )
cmds.delete(temp)
temp = cmds.aimConstraint(a,b)
self.assertTrue( self.lib.assertConstrained(a, b, type='aim') )
cmds.delete(temp)
temp = cmds.pointConstraint(a,b)
self.assertTrue( self.lib.assertConstrained(a, b, type='point') )
cmds.delete(temp)
temp = cmds.orientConstraint(a,b)
self.assertTrue( self.lib.assertConstrained(a,b,type='orient') )
cmds.delete(temp)
temp = cmds.scaleConstraint(a,b)
self.assertTrue( self.lib.assertConstrained(a,b,type='scale') )
cmds.delete(temp)
temp = cmds.geometryConstraint(a,b)
self.assertTrue( self.lib.assertConstrained(a,b,type='geometry') )
cmds.delete(temp)
try:
self.lib.assertConstrained(a,b,type='parent')
except AssertionError:
pass
def targetAliasList(constraint):
'''
Return a list of targets (drivers) attribute aliases for the specified constraint node
@param constraint: The constraint node whose targets will be returned
@type constraint: str
'''
# Check Constraint
if not isConstraint(constraint):
raise Exception('Constraint "'+constraint+'" does not exist!!')
# Get Target List
targetList = []
constraintType = mc.objectType(constraint)
if constraintType == 'aimConstraint': targetList = mc.aimConstraint(constraint,q=True,weightAliasList=True)
elif constraintType == 'geometryConstraint': targetList = mc.geometryConstraint(constraint,q=True,weightAliasList=True)
elif constraintType == 'normalConstraint': targetList = mc.normalConstraint(constraint,q=True,weightAliasList=True)
elif constraintType == 'orientConstraint': targetList = mc.orientConstraint(constraint,q=True,weightAliasList=True)
elif constraintType == 'parentConstraint': targetList = mc.parentConstraint(constraint,q=True,weightAliasList=True)
elif constraintType == 'pointConstraint': targetList = mc.pointConstraint(constraint,q=True,weightAliasList=True)
elif constraintType == 'poleVectorConstraint': targetList = mc.poleVectorConstraint(constraint,q=True,weightAliasList=True)
elif constraintType == 'scaleConstraint': targetList = mc.scaleConstraint(constraint,q=True,weightAliasList=True)
elif constraintType == 'tangentConstraint': targetList = mc.tangentConstraint(constraint,q=True,weightAliasList=True)
# Check Target List
if not targetList: targetList = []
# Return Result
return targetList
def constrainToSurface_geometryConstraint(surface,target,xform,prefix):
'''
Use a point/geometry constraint to attach the specified transform to a target surface.
@param surface: Geometry to attach the transform to.
@type surface: str
@param target: Target transform that the constrained transform will try to match.
@type target: str
@param xform: Transform to constrainto the surface.
@type xform: str
@param prefix: Name prefix for created nodes.
@type prefix: str
'''
# Checks
if not mc.objExists(surface):
raise Exception('Surface "'+surface+'" does not exist!')
if not mc.objExists(target):
raise Exception('Target transform "'+target+'" does not exist!')
if not mc.objExists(xform):
raise Exception('Constraint transform "'+xform+'" does not exist!')
# Create Constraints
pntCon = mc.pointConstraint(target,xform,n=prefix+'_pointConstraint')
geoCon = mc.geometryConstraint(surface,xform,n=prefix+'_geometryConstraint')
# Return Result
return [geoCon,pntCon]
def buildLinearPoints( curve, numCtrl, useDistance = False, guideSrf = None, orient = False, prefix = None, suffix = None ): ''' Create locators along curve and project to mesh using geometry and normal constraints. ''' # ========== # - Checks - # ========== if not prefix: prefix = glTools.utils.stringUtils.stripSuffix(curve) if not suffix: suffix = 'jnt' # Build Controls ctrls = glTools.tools.createAlongCurve.create( curve, 'locator', objCount=numCtrl, parent=False, useDistance=useDistance, minPercent=0.0, maxPercent=1.0, spacing=1.0, prefix=prefix, suffix=suffix ) # Attach Controls for ctrl in ctrls: mc.select(ctrl) jnt = mc.joint() attach = glTools.utils.attach.attachToCurve( curve, ctrl, useClosestPoint=True, uAttr='param', prefix=prefix ) # Constrain to Guide if guideSrf: # Constrain Position geomConst = mc.geometryConstraint(guideSrf,ctrl)[0] # Constrain Orient if orient: normConst = mc.normalConstraint( guideSrf, ctrl, aimVector=(0,0,1), upVector=(-1,0,0), worldUpType='vector' )[0] mc.connectAttr(attach[0]+'.tangent',normConst+'.worldUpVector',f=True) # Return Result return ctrls
def NomalCylinder():
size = 0.5
obj = mc.ls(sl=True,fl=True)
if obj:
for i in obj:
val = 0
cy = mc.polyCylinder(r=size,h=2,sx=8,sy=1,sz=1,ax=(0,1,0),rcp=0,cuv=3,ch=1)
pos = mc.xform(i,q=True,t=True,ws=True)
for axis in ['X','Y','Z']:
mc.setAttr('%s.translate%s'%(cy[0],axis),pos[val])
val += 1
source = i.split('.')
mc.normalConstraint(source[0],cy,weight=1,aimVector=(0,1,0),upVector=(0,1,0),worldUpType="vector",worldUpVector=(0,1,0))
mc.geometryConstraint(source[0],cy,weight=1)
print 'Create!'
else:
print 'Not select'
def projectToSurface(curve, targetSurface, keepOriginal=False, prefix=''):
"""
Project the edit points of the specified nurbs curve to aa nurbs or polygon object
@param curve: Curve to project
@type curve: str
@param targetSurface: Surface to project onto
@type targetSurface: str
@param keepOriginal: Create new curve or replace original
@type keepOriginal: bool
@param prefix: Name prefix for all created nodes
@type prefix: str
@return: The curve parameter value closest to the input point
@returnType: float
"""
# Check curve
if not cmds.objExists(curve):
raise Exception('Curve "' + curve + '" does not exist!!')
if not isCurve(curve):
raise Exception('Object "' + curve + '" is not a valid nurbs curve!!')
# Check target surface
if not cmds.objExists(targetSurface):
raise Exception('Target surface "' + targetSurface +
'" does not exist!!')
# Check prefix
if not prefix: prefix = glTools.utils.stringUtils.stripSuffix(curve)
# Duplicate original curve
if keepOriginal:
curve = cmds.duplicate(curve, rc=True, rr=True)[0]
cmds.delete(
cmds.listRelatives(curve, c=True, type=['transform'], pa=True))
# Create curve group
grp = cmds.createNode('transform', n=prefix + '_group')
curve = cmds.parent(curve, grp)[0]
# Generate curve locators
curveLocList = locatorEpCurve(curve, locatorScale=0.05, prefix=prefix)
curveLocList = cmds.parent(curveLocList, grp)
# Create geometry constraints
geocmdsonstraintList = []
for loc in curveLocList:
geocmdsonstraint = cmds.geometryConstraint(targetSurface,
loc,
n=prefix +
'_geometryConstraint')
geocmdsonstraintList.append(geocmdsonstraint[0])
# Center group pivot
cmds.xform(grp, cp=True)
# Return result
return [curve, grp, curveLocList, geocmdsonstraintList]
def targetAliasList(constraint):
"""
Return a list of targets (drivers) attribute aliases for the specified constraint node
@param constraint: The constraint node whose targets will be returned
@type constraint: str
"""
# Check Constraint
if not isConstraint(constraint):
raise Exception('Constraint "' + constraint + '" does not exist!!')
# Get Target List
targetList = []
constraintType = cmds.objectType(constraint)
if constraintType == 'aicmdsonstraint':
targetList = cmds.aicmdsonstraint(constraint,
q=True,
weightAliasList=True)
elif constraintType == 'geometryConstraint':
targetList = cmds.geometryConstraint(constraint,
q=True,
weightAliasList=True)
elif constraintType == 'normalConstraint':
targetList = cmds.normalConstraint(constraint,
q=True,
weightAliasList=True)
elif constraintType == 'orientConstraint':
targetList = cmds.orientConstraint(constraint,
q=True,
weightAliasList=True)
elif constraintType == 'parentConstraint':
targetList = cmds.parentConstraint(constraint,
q=True,
weightAliasList=True)
elif constraintType == 'pointConstraint':
targetList = cmds.pointConstraint(constraint,
q=True,
weightAliasList=True)
elif constraintType == 'poleVectorConstraint':
targetList = cmds.poleVectorConstraint(constraint,
q=True,
weightAliasList=True)
elif constraintType == 'scaleConstraint':
targetList = cmds.scaleConstraint(constraint,
q=True,
weightAliasList=True)
elif constraintType == 'tangentConstraint':
targetList = cmds.tangentConstraint(constraint,
q=True,
weightAliasList=True)
# Check Target List
if not targetList: targetList = []
# Return Result
return targetList
def _createLoc(self,name=None,
baseTransform=None,
targetTransform=None,
plane=None):
if self.logger: self.logger.info('_createLoc(): Starting...')
# Create the locator
loc = cmds.spaceLocator(n=name+'_multiAxisRigLoc')[0]
# Snap to base
cmds.delete(cmds.pointConstraint(baseTransform,loc,mo=False))
# Constrain to plane
cmds.geometryConstraint( plane, loc, n=name+'_multiAxisRigLocGeoConst' )
# pointConst to target
cmds.pointConstraint( targetTransform, loc, mo=True, n=name+'+multiAxisRigLocPointConst' )
if self.logger: self.logger.info('_createLoc(): End...\nReturned: %s'%loc)
return loc
def constraintButton_Pressed(*arg):
global constraintground
constraintground = not constraintground
print constraintground
if (constraintground):
maya.button(constraintbutton, e=True, l='UnConstraint to Ground')
terrain = maya.ls(sl=True)
if not terrain:
maya.warning('please select a ground')
#if len(terrain)>1:
#maya.warning('please select one ground only')
else:
#for tank rigging only:
for child in children:
print child
maya.geometryConstraint(terrain[0], child, w=1)
else:
maya.button(constraintbutton, e=True, l='Constraint to Ground')
for child in children:
if maya.objExists(child + '_geometryConstraint*'):
maya.delete(child + '_geometryConstraint*')
def change(self, bounds, count, cookie):
x = random.uniform(bounds[0], bounds[3])
y = random.uniform(bounds[1], bounds[4])
z = random.uniform(bounds[2], bounds[5])
offset_z = z - (bounds[5] + bounds[2]) / 2
offset_x = x - (bounds[3] + bounds[0]) / 2
z = z + offset_x * math.tan(offset_z / offset_x)
pcore.move(x, y, z)
xRot = random.uniform(100, 160)
yRot = random.uniform(80, 130)
zRot = random.uniform(130, 180)
pcore.rotate(xRot, yRot, zRot)
scalingFactor = random.uniform(0.9, 1.2)
pcore.scale(scalingFactor, scalingFactor, scalingFactor)
cmds.geometryConstraint(cookie + '_constr', 'chip{}'.format(count))
def projectToSurface(curve,targetSurface,keepOriginal=False,prefix=''):
'''
Project the edit points of the specified nurbs curve to aa nurbs or polygon object
@param curve: Curve to project
@type curve: str
@param targetSurface: Surface to project onto
@type targetSurface: str
@param keepOriginal: Create new curve or replace original
@type keepOriginal: bool
@param prefix: Name prefix for all created nodes
@type prefix: str
@return: The curve parameter value closest to the input point
@returnType: float
'''
# Check curve
if not mc.objExists(curve):
raise Exception('Curve "'+curve+'" does not exist!!')
if not isCurve(curve):
raise Exception('Object "'+curve+'" is not a valid nurbs curve!!')
# Check target surface
if not mc.objExists(targetSurface):
raise Exception('Target surface "'+targetSurface+'" does not exist!!')
# Check prefix
if not prefix: prefix = glTools.utils.stringUtils.stripSuffix(curve)
# Duplicate original curve
if keepOriginal:
curve = mc.duplicate(curve,rc=True,rr=True)[0]
mc.delete(mc.listRelatives(curve,c=True,type=['transform'],pa=True))
# Create curve group
grp = mc.createNode('transform',n=prefix+'_group')
curve = mc.parent(curve,grp)[0]
# Generate curve locators
curveLocList = locatorEpCurve(curve,locatorScale=0.05,prefix=prefix)
curveLocList = mc.parent(curveLocList,grp)
# Create geometry constraints
geomConstraintList = []
for loc in curveLocList:
geomConstraint = mc.geometryConstraint(targetSurface,loc,n=prefix+'_geometryConstraint')
geomConstraintList.append(geomConstraint[0])
# Center group pivot
mc.xform(grp,cp=True)
# Return result
return[curve,grp,curveLocList,geomConstraintList]
def positionPoleVectorControl(startJoint, endJoint, poleVectorNode, distance):
"""NOTE: If each joint in your chain has more than 1 joint, make sure the joint that will be part of the IK chain,
are the first children, otherwise you will get bad results."""
#figure out all the joints between startJoint and endJoint
jointChainList = []
jointChainList.append(startJoint)
j = 0
currentJoint = startJoint
while j==0:
currentJointChildren = cmds.listRelatives(currentJoint, c=1, type="joint")
if len(currentJointChildren) > 1:
cmds.warning("whoo, the specified start joint has more than 1 children, please choose another start joint")
nextJoint = currentJointChildren[0]
if nextJoint == endJoint:
j=1
else:
jointChainList.append(nextJoint)
currentJoint = nextJoint
jointChainList.append(endJoint)
#get position in space of each joint so we can create the polygon
coordinatesList = []
for j in jointChainList:
jCoord = cmds.xform(j, q=1, ws=1, rp=1)
coord = tuple(jCoord)
coordinatesList.append(coord)
polyPlane = cmds.polyCreateFacet( p=coordinatesList )[0]
alignNodes(poleVectorNode, jointChainList[1])
cmds.delete(cmds.geometryConstraint(polyPlane, poleVectorNode))
cmds.delete(cmds.normalConstraint(polyPlane, poleVectorNode, upVector=[1, 0, 0], aimVector=[0, 0, 1]))
cmds.xform(poleVectorNode, objectSpace=1, relative=1, t=[distance, distance, 0])
cmds.delete(polyPlane)
def scatter_by_volume(self):
"""
Method to scatter node by target surface volume/area
"""
surface_wsp = cmds.xform(self.surface, query=True, worldSpace=True, boundingBox=True)
xmin, ymin, zmin, xmax, ymax, zmax = surface_wsp
for copy_num in range(1, self.copies + 1):
pos_x = random.uniform(xmin, xmax)
pos_y = random.uniform(ymin, ymax)
pos_z = random.uniform(zmin, zmax)
new_obj = self.copy_obj()
cmds.setAttr("%s.tx" % new_obj, float(pos_x))
cmds.setAttr("%s.ty" % new_obj, float(pos_y))
cmds.setAttr("%s.tz" % new_obj, float(pos_z))
random_scale = random.uniform(self.scale_min, self.scale_max)
cmds.setAttr("%s.scaleX" % new_obj, random_scale)
cmds.setAttr("%s.scaleY" % new_obj, random_scale)
cmds.setAttr("%s.scaleZ" % new_obj, random_scale)
g_constrain = cmds.geometryConstraint(self.surface, new_obj, weight=10)
n_constraint = cmds.normalConstraint(self.surface,
new_obj,
aimVector=[0, 1, 0],
upVector=[0,1,0],
worldUpType="scene")
cmds.delete(n_constraint)
cmds.delete(g_constrain)
self.randomize_wire_color(new_obj)
self.copied_nodes.append(new_obj)
def targetList(constraint):
''' Return a list of targets (drivers) for the specified constraint node
:param constraint str: The constraint node whose targets will be returned
:return: List of target drivers for specified constraint
:rtype: list
'''
# Check Constraint
if not isConstraint(constraint):
raise Exception('Constraint {0} does not exist!!'.format(constraint))
# Get Target List
targetList = []
constraintType = cmds.objectType(constraint)
if constraintType == 'aimConstraint':
targetList = cmds.aimConstraint(constraint, q=True, tl=True)
elif constraintType == 'geometryConstraint':
targetList = cmds.geometryConstraint(constraint, q=True, tl=True)
elif constraintType == 'normalConstraint':
targetList = cmds.normalConstraint(constraint, q=True, tl=True)
elif constraintType == 'orientConstraint':
targetList = cmds.orientConstraint(constraint, q=True, tl=True)
elif constraintType == 'parentConstraint':
targetList = cmds.parentConstraint(constraint, q=True, tl=True)
elif constraintType == 'pointConstraint':
targetList = cmds.pointConstraint(constraint, q=True, tl=True)
elif constraintType == 'poleVectorConstraint':
targetList = cmds.poleVectorConstraint(constraint, q=True, tl=True)
elif constraintType == 'scaleConstraint':
targetList = cmds.scaleConstraint(constraint, q=True, tl=True)
elif constraintType == 'tangentConstraint':
targetList = cmds.tangentConstraint(constraint, q=True, tl=True)
# Check Target List
if not targetList: targetList = []
# Return Result
return targetList
def targetList(constraint):
"""
Return a list of targets (drivers) for the specified constraint node
@param constraint: The constraint node whose targets will be returned
@type constraint: str
"""
# Check Constraint
if not isConstraint(constraint):
raise Exception('Constraint "' + constraint + '" does not exist!!')
# Get Target List
targetList = []
constraintType = cmds.objectType(constraint)
if constraintType == 'aicmdsonstraint':
targetList = cmds.aicmdsonstraint(constraint, q=True, tl=True)
elif constraintType == 'geometryConstraint':
targetList = cmds.geometryConstraint(constraint, q=True, tl=True)
elif constraintType == 'normalConstraint':
targetList = cmds.normalConstraint(constraint, q=True, tl=True)
elif constraintType == 'orientConstraint':
targetList = cmds.orientConstraint(constraint, q=True, tl=True)
elif constraintType == 'parentConstraint':
targetList = cmds.parentConstraint(constraint, q=True, tl=True)
elif constraintType == 'pointConstraint':
targetList = cmds.pointConstraint(constraint, q=True, tl=True)
elif constraintType == 'poleVectorConstraint':
targetList = cmds.poleVectorConstraint(constraint, q=True, tl=True)
elif constraintType == 'scaleConstraint':
targetList = cmds.scaleConstraint(constraint, q=True, tl=True)
elif constraintType == 'tangentConstraint':
targetList = cmds.tangentConstraint(constraint, q=True, tl=True)
# Check Target List
if not targetList: targetList = []
# Return Result
return targetList
def targetList(constraint):
'''
Return a list of targets (drivers) for the specified constraint node
@param constraint: The constraint node whose targets will be returned
@type constraint: str
'''
# Check Constraint
if not isConstraint(constraint):
raise Exception('Constraint "' + constraint + '" does not exist!!')
# Get Target List
targetList = []
constraintType = mc.objectType(constraint)
if constraintType == 'aimConstraint':
targetList = mc.aimConstraint(constraint, q=True, tl=True)
elif constraintType == 'geometryConstraint':
targetList = mc.geometryConstraint(constraint, q=True, tl=True)
elif constraintType == 'normalConstraint':
targetList = mc.normalConstraint(constraint, q=True, tl=True)
elif constraintType == 'orientConstraint':
targetList = mc.orientConstraint(constraint, q=True, tl=True)
elif constraintType == 'parentConstraint':
targetList = mc.parentConstraint(constraint, q=True, tl=True)
elif constraintType == 'pointConstraint':
targetList = mc.pointConstraint(constraint, q=True, tl=True)
elif constraintType == 'poleVectorConstraint':
targetList = mc.poleVectorConstraint(constraint, q=True, tl=True)
elif constraintType == 'scaleConstraint':
targetList = mc.scaleConstraint(constraint, q=True, tl=True)
elif constraintType == 'tangentConstraint':
targetList = mc.tangentConstraint(constraint, q=True, tl=True)
# Check Target List
if not targetList: targetList = []
# Return Result
return targetList
def targetList(constraint):
'''
Return a list of targets (drivers) for the specified constraint node
@param constraint: The constraint node whose targets will be returned
@type constraint: str
'''
# Check constraint
if not mc.objExists(constraint): raise UserInputError('Constraint '+constraint+' does not exist!!')
constraintType = mc.objectType(constraint)
# Get target list
targetList = []
if constraintType == 'aimConstraint': targetList = mc.aimConstraint(constraint,q=True,tl=True)
elif constraintType == 'geometryConstraint': targetList = mc.geometryConstraint(constraint,q=True,tl=True)
elif constraintType == 'normalConstraint': targetList = mc.normalConstraint(constraint,q=True,tl=True)
elif constraintType == 'orientConstraint': targetList = mc.orientConstraint(constraint,q=True,tl=True)
elif constraintType == 'parentConstraint': targetList = mc.parentConstraint(constraint,q=True,tl=True)
elif constraintType == 'pointConstraint': targetList = mc.pointConstraint(constraint,q=True,tl=True)
elif constraintType == 'poleVectorConstraint': targetList = mc.poleVectorConstraint(constraint,q=True,tl=True)
elif constraintType == 'scaleConstraint': targetList = mc.scaleConstraint(constraint,q=True,tl=True)
elif constraintType == 'tangentConstraint': targetList = mc.tangentConstraint(constraint,q=True,tl=True)
# Check target list
if not targetList: targetList = []
# Return result
return targetList
def projectToSurface(surface,
targetSurface,
direction='u',
keepOriginal=False,
prefix=''):
"""
Project the edit points of the specified nurbs surface to another nurbs or polygon object
@param surface: Surface to project
@type surface: str
@param targetSurface: Surface to project onto
@type targetSurface: str
@param direction: Surface direction to extract isoparm curves from
@type direction: str
@param keepOriginal: Create new surface or replace original
@type keepOriginal: bool
@param prefix: Name prefix for all created nodes
@type prefix: str
"""
# Check surface
if not cmds.objExists(surface):
raise Exception('Surface "' + surface + '" does not exist!!')
if not isSurface(surface):
raise Exception('Object "' + surface +
'" is not a valid nurbs surface!!')
# Check target surface
if not cmds.objExists(targetSurface):
raise Exception('Target surface "' + targetSurface +
'" does not exist!!')
# Check prefix
if not prefix: prefix = glTools.utils.stringUtils.stripSuffix(surface)
# Check direction
direction = direction.upper()
if (direction != 'U') and (direction != 'V'):
raise Exception(
'Invalid surface direction specified! Must specify either "u" or "v"!!'
)
# Get surface information
spans = cmds.getAttr(surface + '.spans' + direction)
minVal = cmds.getAttr(surface + '.minValue' + direction)
maxVal = cmds.getAttr(surface + '.maxValue' + direction)
# Create main surface group
mainGrp = cmds.createNode('transform', n=prefix + '_grp')
# Extract curves
curveList = []
curveGrpList = []
curveLocList = []
geocmdsonstraintList = []
spanInc = (maxVal - minVal) / spans
for i in range(spans + 1):
# Curve prefix
strInd = glTools.utils.stringUtils.stringIndex(i, 2)
crvPrefix = prefix + '_crv' + strInd
# Create curve group
curveGrp = crvPrefix + '_grp'
curveGrp = cmds.createNode('transform', n=curveGrp)
curveGrp = cmds.parent(curveGrp, mainGrp)[0]
curveGrpList.append(curveGrp)
# Get surface curve
srfCurveName = crvPrefix + '_crv'
srfCurve = cmds.duplicateCurve(surface + '.' + direction.lower() +
'[' + str(i * spanInc) + ']',
ch=0,
rn=0,
local=0,
n=srfCurveName)
srfCurve = cmds.parent(srfCurve[0], curveGrp)[0]
curveList.append(srfCurve)
# Generate curve locators
curveLocatorList = glTools.utils.curve.locatorEpCurve(
srfCurve, locatorScale=0.05, prefix=crvPrefix)
curveLocatorList = cmds.parent(curveLocatorList, curveGrp)
curveLocList.append(curveLocatorList)
# Create geometry constraints
for loc in curveLocatorList:
geocmdsonstraint = crvPrefix + '_geometryConstraint'
geocmdsonstraint = cmds.geometryConstraint(targetSurface,
loc,
n=geocmdsonstraint)
geocmdsonstraintList.append(geocmdsonstraint[0])
# Center group pivot
cmds.xform(curveGrp, cp=True)
# Delete original surface
surfaceName = prefix + '_surface'
if not keepOriginal:
surfaceName = surface
cmds.delete(surface)
# Loft new surface
surfaceLoft = cmds.loft(curveList,
ch=1,
u=1,
c=0,
ar=1,
d=3,
ss=1,
rn=0,
po=0,
rsn=True)
surface = cmds.rename(surfaceLoft[0], surface)
surface = cmds.parent(surface, mainGrp)[0]
cmds.reorder(surface, f=True)
loft = cmds.rename(surfaceLoft[1], prefix + '_loft')
# Return result
return [
surface, loft, curveList, curveGrpList, curveLocList,
geocmdsonstraintList
]
def process():
eye = cmds.polySphere()
light = cmds.spotLight()
locator = cmds.spaceLocator()
cmds.geometryConstraint( eye, locator )
def pointSampleWeight(samplePt, pntList, weightCalc=[True, True, True], prefix=''):
"""
"""
# Check prefix
if not prefix: prefix = 'triSampleWeight'
# Get tri points
posList = [cmds.xform(pntList[0], q=True, ws=True, rp=True),
cmds.xform(pntList[1], q=True, ws=True, rp=True),
cmds.xform(pntList[2], q=True, ws=True, rp=True)]
# Build pntFace mesh
pntFace = cmds.polyCreateFacet(p=posList, n=prefix + '_sample_mesh')[0]
cmds.setAttr(pntFace + '.inheritsTransform', 0, l=True)
# Attach triPt locator to pntFace mesh
pntLoc = glTools.utils.mesh.locatorMesh(pntFace, prefix=prefix)
# Attach follow pt
followLoc = cmds.spaceLocator(n=prefix + '_follow_locator')[0]
followGeoCon = cmds.geometryConstraint(pntFace, followLoc)
followPntCon = cmds.pointConstraint(samplePt, followLoc)
# Calculate triArea
triEdge1_pma = cmds.createNode('plusMinusAverage', n=prefix + '_triEdge1Vec_plusMinusAverage')
triEdge2_pma = cmds.createNode('plusMinusAverage', n=prefix + '_triEdge2Vec_plusMinusAverage')
cmds.setAttr(triEdge1_pma + '.operation', 2) # Subtract
cmds.setAttr(triEdge2_pma + '.operation', 2) # Subtract
cmds.connectAttr(pntLoc[1] + '.worldPosition[0]', triEdge1_pma + '.input3D[0]', f=True)
cmds.connectAttr(pntLoc[0] + '.worldPosition[0]', triEdge1_pma + '.input3D[1]', f=True)
cmds.connectAttr(pntLoc[2] + '.worldPosition[0]', triEdge2_pma + '.input3D[0]', f=True)
cmds.connectAttr(pntLoc[0] + '.worldPosition[0]', triEdge2_pma + '.input3D[1]', f=True)
triArea_vpn = cmds.createNode('vectorProduct', n=prefix + '_triArea_vectorProduct')
cmds.setAttr(triArea_vpn + '.operation', 2) # Cross Product
cmds.connectAttr(triEdge1_pma + '.output3D', triArea_vpn + '.input1', f=True)
cmds.connectAttr(triEdge2_pma + '.output3D', triArea_vpn + '.input2', f=True)
triArea_dist = cmds.createNode('distanceBetween', n=prefix + '_triArea_distanceBetween')
cmds.connectAttr(triArea_vpn + '.output', triArea_dist + '.point1', f=True)
# Calculate triPt weights
for i in range(3):
# Check weight calculation (bool)
if weightCalc[i]:
# Calculate triArea
pntEdge1_pma = cmds.createNode('plusMinusAverage', n=prefix + '_pt' + str(i) + 'Edge1Vec_plusMinusAverage')
pntEdge2_pma = cmds.createNode('plusMinusAverage', n=prefix + '_pt' + str(i) + 'Edge2Vec_plusMinusAverage')
cmds.setAttr(pntEdge1_pma + '.operation', 2) # Subtract
cmds.setAttr(pntEdge2_pma + '.operation', 2) # Subtract
cmds.connectAttr(pntLoc[(i + 1) % 3] + '.worldPosition[0]', pntEdge1_pma + '.input3D[0]', f=True)
cmds.connectAttr(followLoc + '.worldPosition[0]', pntEdge1_pma + '.input3D[1]', f=True)
cmds.connectAttr(pntLoc[(i + 2) % 3] + '.worldPosition[0]', pntEdge2_pma + '.input3D[0]', f=True)
cmds.connectAttr(followLoc + '.worldPosition[0]', pntEdge2_pma + '.input3D[1]', f=True)
pntArea_vpn = cmds.createNode('vectorProduct', n=prefix + '_pt' + str(i) + 'Area_vectorProduct')
cmds.setAttr(pntArea_vpn + '.operation', 2) # Cross Product
cmds.connectAttr(pntEdge1_pma + '.output3D', pntArea_vpn + '.input1', f=True)
cmds.connectAttr(pntEdge2_pma + '.output3D', pntArea_vpn + '.input2', f=True)
pntArea_dist = cmds.createNode('distanceBetween', n=prefix + '_pt' + str(i) + 'Area_distanceBetween')
cmds.connectAttr(pntArea_vpn + '.output', pntArea_dist + '.point1', f=True)
# Divide ptArea by triArea to get weight
pntWeight_mdn = cmds.createNode('multiplyDivide', n=prefix + '_pt' + str(i) + 'Weight_multiplyDivide')
cmds.setAttr(pntWeight_mdn + '.operation', 2) # Divide
cmds.connectAttr(pntArea_dist + '.distance', pntWeight_mdn + '.input1X', f=True)
cmds.connectAttr(triArea_dist + '.distance', pntWeight_mdn + '.input2X', f=True)
# Add weight attribute to pntLoc
cmds.addAttr(pntLoc[i], ln='weight', min=0.0, max=1.0, dv=0.0)
cmds.connectAttr(pntWeight_mdn + '.outputX', pntLoc[i] + '.weight', f=True)
# Group mesh locators
pntLoc_grp = cmds.group(pntLoc, n=prefix + '_3Point_grp')
cmds.parent(pntFace, pntLoc_grp)
# Return result
return [pntLoc, pntFace, pntLoc_grp]
def projectToSurface(surface,targetSurface,direction='u',keepOriginal=False,prefix=''):
'''
Project the edit points of the specified nurbs surface to another nurbs or polygon object
@param surface: Surface to project
@type surface: str
@param targetSurface: Surface to project onto
@type targetSurface: str
@param direction: Surface direction to extract isoparm curves from
@type direction: str
@param keepOriginal: Create new surface or replace original
@type keepOriginal: bool
@param prefix: Name prefix for all created nodes
@type prefix: str
'''
# Check surface
if not mc.objExists(surface):
raise UserInputError('Surface "'+surface+'" does not exist!!')
if not isSurface(surface):
raise UserInputError('Object "'+surface+'" is not a valid nurbs surface!!')
# Check target surface
if not mc.objExists(targetSurface):
raise UserInputError('Target surface "'+targetSurface+'" does not exist!!')
# Check prefix
if not prefix: prefix = glTools.utils.stringUtils.stripSuffix(surface)
# Check direction
direction = direction.upper()
if (direction != 'U') and (direction != 'V'):
raise UserInputError('Invalid surface direction specified! Must specify either "u" or "v"!!')
# Get surface information
spans = mc.getAttr(surface+'.spans'+direction)
minVal = mc.getAttr(surface+'.minValue'+direction)
maxVal = mc.getAttr(surface+'.maxValue'+direction)
# Create main surface group
mainGrp = mc.createNode('transform',n=prefix+'_grp')
# Extract curves
curveList = []
curveGrpList = []
curveLocList = []
geomConstraintList = []
spanInc = (maxVal - minVal)/spans
for i in range(spans+1):
# Curve prefix
strInd = glTools.utils.stringUtils.stringIndex(i,2)
crvPrefix = prefix+'_crv'+strInd
# Create curve group
curveGrp = crvPrefix+'_grp'
curveGrp = mc.createNode('transform',n=curveGrp)
curveGrp = mc.parent(curveGrp,mainGrp)[0]
curveGrpList.append(curveGrp)
# Get surface curve
srfCurveName = crvPrefix+'_crv'
srfCurve = mc.duplicateCurve(surface+'.'+direction.lower()+'['+str(i*spanInc)+']',ch=0,rn=0,local=0,n=srfCurveName)
srfCurve = mc.parent(srfCurve[0],curveGrp)[0]
curveList.append(srfCurve)
# Generate curve locators
curveLocatorList = glTools.utils.curve.locatorEpCurve(srfCurve,locatorScale=0.05,prefix=crvPrefix)
curveLocatorList = mc.parent(curveLocatorList,curveGrp)
curveLocList.append(curveLocatorList)
# Create geometry constraints
for loc in curveLocatorList:
geomConstraint = crvPrefix+'_geometryConstraint'
geomConstraint = mc.geometryConstraint(targetSurface,loc,n=geomConstraint)
geomConstraintList.append(geomConstraint[0])
# Center group pivot
mc.xform(curveGrp,cp=True)
# Delete original surface
surfaceName = prefix+'_surface'
if not keepOriginal:
surfaceName = surface
mc.delete(surface)
# Loft new surface
surfaceLoft = mc.loft(curveList,ch=1,u=1,c=0,ar=1,d=3,ss=1,rn=0,po=0,rsn=True)
surface = mc.rename(surfaceLoft[0],surface)
surface = mc.parent(surface,mainGrp)[0]
mc.reorder(surface,f=True)
loft = mc.rename(surfaceLoft[1],prefix+'_loft')
# Return result
return[surface,loft,curveList,curveGrpList,curveLocList,geomConstraintList]
def surfaceConstraint(obj,surface,point=True,orient=True,normalAxis='x',upAxis='y',upMode='',upVector=(0,1,0),upObject='',pointMode=0,prefix=''):
'''
@param obj: Target object that the surface constrained transform will goal to.
@type obj: str
@param surface: Surface to constrain to
@type surface: str
@param point: Constrain point (translate)
@type point: bool
@param orient: Constrain orient (rotate)
@type orient: bool
@param normalAxis: Constrained transform axis to align with surface normal
@type normalAxis: str
@param upAxis: Constrained transform axis to align with defined upVector
@type upAxis: str
@param upMode: Constraint upVector mode. Valid values are 'scene', 'object', 'objectrotation', 'vector' or 'none'.
@type upMode: str
@param upVector: Constraint upVector.
@type upVector: list or tuple
@param upObject: Constraint upVector object. Only needed for 'object' or 'objectrotation' upVector modes.
@type upObject: str
@param pointMode: Point (translate) constraint mode. 0 = geometryConstraint, 1 = boundaryConstraint.
@type pointMode: int
@param prefix: Name prefix for newly created nodes
@type prefix: str
'''
# Build axis dictionary
axisDict = {'x':(1,0,0),'y':(0,1,0),'z':(0,0,1),'-x':(-1,0,0),'-y':(0,-1,0),'-z':(0,0,-1)}
# ==========
# - Checks -
# ==========
if not mc.objExists(obj):
raise Exception('Object "'+obj+'" does not exist!')
if not mc.objExists(surface):
raise Exception('Surface "'+surface+'" does not exist!')
if not axisDict.keys().count(normalAxis):
raise Exception('Invalid normal axis specified "'+normalAxis+'"!')
if not axisDict.keys().count(upAxis):
raise Exception('Invalid up axis specified "'+upAxis+'"!')
if ((upMode == 'object') or (upMode == 'objectrotation')) and not mc.objExists(upObject):
raise Exception('Invalid up object specified "'+upObject+'"!')
# ===============================
# - Create Constraint Transform -
# ===============================
surfConnNode = mc.createNode('transform',n=prefix+'_surfConn_grp')
# ================================
# - Constraint point (translate) -
# ================================
if point:
if pointMode == 0:
# Geometry Constraint
pntConn = mc.pointConstraint(obj,surfConnNode,n=prefix+'_pointConstraint')
geoConn = mc.geometryConstraint(surface,surfConnNode,n=prefix+'_geometryConstraint')
else:
# =======================
# - Boundary Constraint -
# =======================
# World Position (vectorProduct)
vecProduct = mc.createNode('vectorProduct',n=prefix+'_worldPos_vectorProduct')
mc.setAttr(vecProduct+'.operation',4) # Point Matrix Product
mc.connectAttr(obj+'.worldMatrix',vecProduct+'.matrix',f=True)
# Closest Point On Surface
cposNode = mc.createNode('closestPointOnSurface',n=prefix+'_surfacePos_closestPointOnSurface')
mc.connectAttr(surface+'.worldSpace[0]',cposNode+'.inputSurface',f=True)
mc.connectAttr(vecProduct+'.output',cposNode+'.inPoint',f=True)
# Point On Surface Info
posiNode = mc.createNode('pointOnSurfaceInfo',n=prefix+'_surfacePt_pointOnSurfaceInfo')
mc.connectAttr(surface+'.worldSpace[0]',cposNode+'.inputSurface',f=True)
mc.connectAttr(cposNode+'.parameterU',posiNode+'.parameterU',f=True)
mc.connectAttr(cposNode+'.parameterV',posiNode+'.parameterV',f=True)
# Calculate Offset
offsetNode = mc.createNode('plusMinusAverage',n=prefix+'_surfaceOffset_plusMinusAverage')
mc.setAttr(offsetNode+'.operation',2) # Subtract
mc.connectAttr(vecProduct+'.output',offsetNode+'.input3D[0]',f=True)
mc.connectAttr(cposNode+'.position',offsetNode+'.input3D[1]',f=True)
# Offset * Normal (dotProduct)
dotProduct = mc.createNode('vectorProduct',n=prefix+'_dotProduct_vectorProduct')
mc.setAttr(dotProduct+'.operation',1) # Dot Product
mc.connectAttr(offsetNode+'.ouput3D',dotProduct+'.input1',f=True)
mc.connectAttr(posiNode+'.normal',dotProduct+'.input2',f=True)
# Boundary Condition
condition = mc.createNode('condition',n=prefix+'_condition')
mc.setAttr(condition+'.operation',2) # Greater Than
mc.connectAttr(dotProduct+'.outputX',condition+'.firstTerm',f=True)
mc.connectAttr(vecProduct+'.output',condition+'.colorIfTrue',f=True)
mc.connectAttr(cposNode+'.position',condition+'.colorIfFalse',f=True)
# Connect to transform
mc.connectAttr(condition+'.outColor',surfConnNode+'.t',f=True)
else:
# Point Constraint
pntConn = mc.pointConstraint(obj,surfConnNode,n=prefix+'_pointConstraint')
# =============================
# - Constrain Orient (rotate) -
# =============================
if orient:
# Normal Constraint
normConn = mc.normalConstraint(surface,surfConnNode,aim=axisDict[normalAxis],u=axisDict[upAxis],wut=upMode,wu=upVector,wuo=upObject,n=prefix+'_normalConstraint')
else:
# Orient Constraint
oriConn = mc.normalConstraint(obj,surfConnNode,n=prefix+'_orientConstraint')
# =================
# - Return Result -
# =================
return surfConnNode
def constrainToSurface(surface, objects):
for obj in objects:
cmds.geometryConstraint( surface, obj )
cmds.normalConstraint( surface, obj, aim=(0, 1, 0) )
def ctrlPointCurve( curve,
numCtrlPts = 3,
guideGeo = None,
meshIntersect = None,
prefix = None ):
'''
Create a control point (locator) curve and project to guide surface.
Control points are projected to guide using geometry constraints.
@param curve: Curve to create control points from.
@type curve: str
@param numCtrlPts: Number of curve control points to build.
@type numCtrlPts: str
@param guideGeo: Guide surface to constrain control points to.
@type guideGeo: str
@param meshIntersect: MeshIntersectArray node to attach to. If None, use geometryConstraint.
@type meshIntersect: str or None
@param prefix: Naming prefix.
@type prefix: str
'''
# ==========
# - Checks -
# ==========
if not prefix: prefix = glTools.utils.stringUtils.stripSuffix(curve)
# =========================
# - Create Control Points -
# =========================
paramList = glTools.utils.curve.sampleParam( curve = curve,
samples = numCtrlPts,
useDistance = True )
# Build Anchors
ctrlPts = []
for i in range(len(paramList)):
# Create Anchor
ind = glTools.utils.stringUtils.alphaIndex(i)
ctrlPt = glTools.tools.createAlongCurve.createAtParam( curve,
param = paramList[i],
objType = 'locator',
name = prefix+'_ctrlPt'+ind+'_loc' )
ctrlPts.append(ctrlPt)
# ===============
# - Build Curve -
# ===============
degree = 3
if numCtrlPts < 4: degree = 1
ctrlCrv = glTools.utils.curve.createFromLocators( locatorList = ctrlPts,
degree = degree,
attach = True,
prefix = prefix+'_ctrlPt' )
# Rebuild Degree 1 Curve
if degree == 1:
glTools.utils.shape.createIntermediate(ctrlCrv)
mc.rebuildCurve(ctrlCrv,d=3,s=0,rt=0,rpo=1,end=1,fitRebuild=0)
# Group Curve
grp = mc.group(ctrlCrv,ctrlPts,n=prefix+'_grp')
# =========================
# - Constrain to Geometry -
# =========================
geoConstraint = None
intersectPt = []
if guideGeo:
# Use meshIntersectArray
if meshIntersect:
for ctrlPt in ctrlPts:
#ctrlPtAttr = mc.listConnections(ctrlPt+'.worldPosition[0]',s=False,d=True,p=True)[0]
intersectPt.append( mc.duplicate(ctrlPt, name='%s_intersectPt_loc' % prefix)[0])
outputAttr = glTools.utils.meshIntersectArray.addIntersect(meshIntersect,intersectPt[-1]+'.worldPosition[0]')
mc.connectAttr(outputAttr[0],'%s.translate' % ctrlPt ,f=True)
# Use geometryConstraint
else:
geoConstraint = [mc.geometryConstraint(guideGeo,ctrlPt)[0] for ctrlPt in ctrlPts]
''' may want to add an option in the future for using follicles
uvList = []
for i, pt in enumerate(ctrlPts):
pos = mc.pointPosition(pt, world=True)
uv = glTools.utils.mesh.closestUV(guideGeo,point=pos)
uvList.append(uv)
follicleList.append( glTools.utils.follicle.create( targetGeo = guideGeo,
parameter = uv,
prefix = '%s_%s_follicle' % (prefix, i) ) )
mc.parent(pt, follicleList[-1])
mc.parent(follicleList[-1], grp)
mc.setAttr('%s.translate' % pt, *[0,0,0])
mc.setAttr('%s.rotate' % pt, *[0,0,0])
'''
# =================
# - Return Result -
# =================
result = {}
result['grp'] = grp
result['crv'] = ctrlCrv
result['pnt'] = ctrlPts
result['geoConstraint'] = geoConstraint
result['intersectPt'] = intersectPt
return result
def pointSampleWeight(samplePt,
pntList,
weightCalc=[True, True, True],
prefix=''):
"""
"""
# Check prefix
if not prefix: prefix = 'triSampleWeight'
# Get tri points
posList = [
cmds.xform(pntList[0], q=True, ws=True, rp=True),
cmds.xform(pntList[1], q=True, ws=True, rp=True),
cmds.xform(pntList[2], q=True, ws=True, rp=True)
]
# Build pntFace mesh
pntFace = cmds.polyCreateFacet(p=posList, n=prefix + '_sample_mesh')[0]
cmds.setAttr(pntFace + '.inheritsTransform', 0, l=True)
# Attach triPt locator to pntFace mesh
pntLoc = glTools.utils.mesh.locatorMesh(pntFace, prefix=prefix)
# Attach follow pt
followLoc = cmds.spaceLocator(n=prefix + '_follow_locator')[0]
followGeoCon = cmds.geometryConstraint(pntFace, followLoc)
followPntCon = cmds.pointConstraint(samplePt, followLoc)
# Calculate triArea
triEdge1_pma = cmds.createNode('plusMinusAverage',
n=prefix + '_triEdge1Vec_plusMinusAverage')
triEdge2_pma = cmds.createNode('plusMinusAverage',
n=prefix + '_triEdge2Vec_plusMinusAverage')
cmds.setAttr(triEdge1_pma + '.operation', 2) # Subtract
cmds.setAttr(triEdge2_pma + '.operation', 2) # Subtract
cmds.connectAttr(pntLoc[1] + '.worldPosition[0]',
triEdge1_pma + '.input3D[0]',
f=True)
cmds.connectAttr(pntLoc[0] + '.worldPosition[0]',
triEdge1_pma + '.input3D[1]',
f=True)
cmds.connectAttr(pntLoc[2] + '.worldPosition[0]',
triEdge2_pma + '.input3D[0]',
f=True)
cmds.connectAttr(pntLoc[0] + '.worldPosition[0]',
triEdge2_pma + '.input3D[1]',
f=True)
triArea_vpn = cmds.createNode('vectorProduct',
n=prefix + '_triArea_vectorProduct')
cmds.setAttr(triArea_vpn + '.operation', 2) # Cross Product
cmds.connectAttr(triEdge1_pma + '.output3D',
triArea_vpn + '.input1',
f=True)
cmds.connectAttr(triEdge2_pma + '.output3D',
triArea_vpn + '.input2',
f=True)
triArea_dist = cmds.createNode('distanceBetween',
n=prefix + '_triArea_distanceBetween')
cmds.connectAttr(triArea_vpn + '.output', triArea_dist + '.point1', f=True)
# Calculate triPt weights
for i in range(3):
# Check weight calculation (bool)
if weightCalc[i]:
# Calculate triArea
pntEdge1_pma = cmds.createNode('plusMinusAverage',
n=prefix + '_pt' + str(i) +
'Edge1Vec_plusMinusAverage')
pntEdge2_pma = cmds.createNode('plusMinusAverage',
n=prefix + '_pt' + str(i) +
'Edge2Vec_plusMinusAverage')
cmds.setAttr(pntEdge1_pma + '.operation', 2) # Subtract
cmds.setAttr(pntEdge2_pma + '.operation', 2) # Subtract
cmds.connectAttr(pntLoc[(i + 1) % 3] + '.worldPosition[0]',
pntEdge1_pma + '.input3D[0]',
f=True)
cmds.connectAttr(followLoc + '.worldPosition[0]',
pntEdge1_pma + '.input3D[1]',
f=True)
cmds.connectAttr(pntLoc[(i + 2) % 3] + '.worldPosition[0]',
pntEdge2_pma + '.input3D[0]',
f=True)
cmds.connectAttr(followLoc + '.worldPosition[0]',
pntEdge2_pma + '.input3D[1]',
f=True)
pntArea_vpn = cmds.createNode('vectorProduct',
n=prefix + '_pt' + str(i) +
'Area_vectorProduct')
cmds.setAttr(pntArea_vpn + '.operation', 2) # Cross Product
cmds.connectAttr(pntEdge1_pma + '.output3D',
pntArea_vpn + '.input1',
f=True)
cmds.connectAttr(pntEdge2_pma + '.output3D',
pntArea_vpn + '.input2',
f=True)
pntArea_dist = cmds.createNode('distanceBetween',
n=prefix + '_pt' + str(i) +
'Area_distanceBetween')
cmds.connectAttr(pntArea_vpn + '.output',
pntArea_dist + '.point1',
f=True)
# Divide ptArea by triArea to get weight
pntWeight_mdn = cmds.createNode('multiplyDivide',
n=prefix + '_pt' + str(i) +
'Weight_multiplyDivide')
cmds.setAttr(pntWeight_mdn + '.operation', 2) # Divide
cmds.connectAttr(pntArea_dist + '.distance',
pntWeight_mdn + '.input1X',
f=True)
cmds.connectAttr(triArea_dist + '.distance',
pntWeight_mdn + '.input2X',
f=True)
# Add weight attribute to pntLoc
cmds.addAttr(pntLoc[i], ln='weight', min=0.0, max=1.0, dv=0.0)
cmds.connectAttr(pntWeight_mdn + '.outputX',
pntLoc[i] + '.weight',
f=True)
# Group mesh locators
pntLoc_grp = cmds.group(pntLoc, n=prefix + '_3Point_grp')
cmds.parent(pntFace, pntLoc_grp)
# Return result
return [pntLoc, pntFace, pntLoc_grp]
def pointSampleWeight(samplePt, pntList, weightCalc=[True, True, True], prefix=""):
"""
"""
# Check prefix
if not prefix:
prefix = "triSampleWeight"
# Get tri points
posList = [
mc.xform(pntList[0], q=True, ws=True, rp=True),
mc.xform(pntList[1], q=True, ws=True, rp=True),
mc.xform(pntList[2], q=True, ws=True, rp=True),
]
# Build pntFace mesh
pntFace = mc.polyCreateFacet(p=posList, n=prefix + "_sample_mesh")[0]
mc.setAttr(pntFace + ".inheritsTransform", 0, l=True)
# Attach triPt locator to pntFace mesh
pntLoc = glTools.utils.mesh.locatorMesh(pntFace, prefix=prefix)
# Attach follow pt
followLoc = mc.spaceLocator(n=prefix + "_follow_locator")[0]
followGeoCon = mc.geometryConstraint(pntFace, followLoc)
followPntCon = mc.pointConstraint(samplePt, followLoc)
# Calculate triArea
triEdge1_pma = mc.createNode("plusMinusAverage", n=prefix + "_triEdge1Vec_plusMinusAverage")
triEdge2_pma = mc.createNode("plusMinusAverage", n=prefix + "_triEdge2Vec_plusMinusAverage")
mc.setAttr(triEdge1_pma + ".operation", 2) # Subtract
mc.setAttr(triEdge2_pma + ".operation", 2) # Subtract
mc.connectAttr(pntLoc[1] + ".worldPosition[0]", triEdge1_pma + ".input3D[0]", f=True)
mc.connectAttr(pntLoc[0] + ".worldPosition[0]", triEdge1_pma + ".input3D[1]", f=True)
mc.connectAttr(pntLoc[2] + ".worldPosition[0]", triEdge2_pma + ".input3D[0]", f=True)
mc.connectAttr(pntLoc[0] + ".worldPosition[0]", triEdge2_pma + ".input3D[1]", f=True)
triArea_vpn = mc.createNode("vectorProduct", n=prefix + "_triArea_vectorProduct")
mc.setAttr(triArea_vpn + ".operation", 2) # Cross Product
mc.connectAttr(triEdge1_pma + ".output3D", triArea_vpn + ".input1", f=True)
mc.connectAttr(triEdge2_pma + ".output3D", triArea_vpn + ".input2", f=True)
triArea_dist = mc.createNode("distanceBetween", n=prefix + "_triArea_distanceBetween")
mc.connectAttr(triArea_vpn + ".output", triArea_dist + ".point1", f=True)
# Calculate triPt weights
for i in range(3):
# Check weight calculation (bool)
if weightCalc[i]:
# Calculate triArea
pntEdge1_pma = mc.createNode("plusMinusAverage", n=prefix + "_pt" + str(i) + "Edge1Vec_plusMinusAverage")
pntEdge2_pma = mc.createNode("plusMinusAverage", n=prefix + "_pt" + str(i) + "Edge2Vec_plusMinusAverage")
mc.setAttr(pntEdge1_pma + ".operation", 2) # Subtract
mc.setAttr(pntEdge2_pma + ".operation", 2) # Subtract
mc.connectAttr(pntLoc[(i + 1) % 3] + ".worldPosition[0]", pntEdge1_pma + ".input3D[0]", f=True)
mc.connectAttr(followLoc + ".worldPosition[0]", pntEdge1_pma + ".input3D[1]", f=True)
mc.connectAttr(pntLoc[(i + 2) % 3] + ".worldPosition[0]", pntEdge2_pma + ".input3D[0]", f=True)
mc.connectAttr(followLoc + ".worldPosition[0]", pntEdge2_pma + ".input3D[1]", f=True)
pntArea_vpn = mc.createNode("vectorProduct", n=prefix + "_pt" + str(i) + "Area_vectorProduct")
mc.setAttr(pntArea_vpn + ".operation", 2) # Cross Product
mc.connectAttr(pntEdge1_pma + ".output3D", pntArea_vpn + ".input1", f=True)
mc.connectAttr(pntEdge2_pma + ".output3D", pntArea_vpn + ".input2", f=True)
pntArea_dist = mc.createNode("distanceBetween", n=prefix + "_pt" + str(i) + "Area_distanceBetween")
mc.connectAttr(pntArea_vpn + ".output", pntArea_dist + ".point1", f=True)
# Divide ptArea by triArea to get weight
pntWeight_mdn = mc.createNode("multiplyDivide", n=prefix + "_pt" + str(i) + "Weight_multiplyDivide")
mc.setAttr(pntWeight_mdn + ".operation", 2) # Divide
mc.connectAttr(pntArea_dist + ".distance", pntWeight_mdn + ".input1X", f=True)
mc.connectAttr(triArea_dist + ".distance", pntWeight_mdn + ".input2X", f=True)
# Add weight attribute to pntLoc
mc.addAttr(pntLoc[i], ln="weight", min=0.0, max=1.0, dv=0.0)
mc.connectAttr(pntWeight_mdn + ".outputX", pntLoc[i] + ".weight", f=True)
# Group mesh locators
pntLoc_grp = mc.group(pntLoc, n=prefix + "_3Point_grp")
mc.parent(pntFace, pntLoc_grp)
# Return result
return [pntLoc, pntFace, pntLoc_grp]
def ctrlPointCurve(curve,
numCtrlPts=3,
guideGeo=None,
meshIntersect=None,
prefix=None):
'''
Create a control point (locator) curve and project to guide surface.
Control points are projected to guide using geometry constraints.
@param curve: Curve to create control points from.
@type curve: str
@param numCtrlPts: Number of curve control points to build.
@type numCtrlPts: str
@param guideGeo: Guide surface to constrain control points to.
@type guideGeo: str
@param meshIntersect: MeshIntersectArray node to attach to. If None, use geometryConstraint.
@type meshIntersect: str or None
@param prefix: Naming prefix.
@type prefix: str
'''
# ==========
# - Checks -
# ==========
if not prefix: prefix = glTools.utils.stringUtils.stripSuffix(curve)
# =========================
# - Create Control Points -
# =========================
paramList = glTools.utils.curve.sampleParam(curve=curve,
samples=numCtrlPts,
useDistance=True)
# Build Anchors
ctrlPts = []
for i in range(len(paramList)):
# Create Anchor
ind = glTools.utils.stringUtils.alphaIndex(i)
ctrlPt = glTools.tools.createAlongCurve.createAtParam(
curve,
param=paramList[i],
objType='locator',
name=prefix + '_ctrlPt' + ind + '_loc')
ctrlPts.append(ctrlPt)
# ===============
# - Build Curve -
# ===============
degree = 3
if numCtrlPts < 4: degree = 1
ctrlCrv = glTools.utils.curve.createFromLocators(locatorList=ctrlPts,
degree=degree,
attach=True,
prefix=prefix + '_ctrlPt')
# Rebuild Degree 1 Curve
if degree == 1:
glTools.utils.shape.createIntermediate(ctrlCrv)
mc.rebuildCurve(ctrlCrv, d=3, s=0, rt=0, rpo=1, end=1, fitRebuild=0)
# Group Curve
grp = mc.group(ctrlCrv, ctrlPts, n=prefix + '_grp')
# =========================
# - Constrain to Geometry -
# =========================
geoConstraint = None
intersectPt = []
if guideGeo:
# Use meshIntersectArray
if meshIntersect:
for ctrlPt in ctrlPts:
#ctrlPtAttr = mc.listConnections(ctrlPt+'.worldPosition[0]',s=False,d=True,p=True)[0]
intersectPt.append(
mc.duplicate(ctrlPt,
name='%s_intersectPt_loc' % prefix)[0])
outputAttr = glTools.utils.meshIntersectArray.addIntersect(
meshIntersect, intersectPt[-1] + '.worldPosition[0]')
mc.connectAttr(outputAttr[0], '%s.translate' % ctrlPt, f=True)
# Use geometryConstraint
else:
geoConstraint = [
mc.geometryConstraint(guideGeo, ctrlPt)[0]
for ctrlPt in ctrlPts
]
''' may want to add an option in the future for using follicles
uvList = []
for i, pt in enumerate(ctrlPts):
pos = mc.pointPosition(pt, world=True)
uv = glTools.utils.mesh.closestUV(guideGeo,point=pos)
uvList.append(uv)
follicleList.append( glTools.utils.follicle.create( targetGeo = guideGeo,
parameter = uv,
prefix = '%s_%s_follicle' % (prefix, i) ) )
mc.parent(pt, follicleList[-1])
mc.parent(follicleList[-1], grp)
mc.setAttr('%s.translate' % pt, *[0,0,0])
mc.setAttr('%s.rotate' % pt, *[0,0,0])
'''
# =================
# - Return Result -
# =================
result = {}
result['grp'] = grp
result['crv'] = ctrlCrv
result['pnt'] = ctrlPts
result['geoConstraint'] = geoConstraint
result['intersectPt'] = intersectPt
return result
def buildLinearPoints(curve,
numCtrl,
useDistance=False,
guideSrf=None,
orient=False,
prefix=None,
suffix=None):
'''
Create locators along curve and project to mesh using geometry and normal constraints.
'''
# ==========
# - Checks -
# ==========
if not prefix: prefix = glTools.utils.stringUtils.stripSuffix(curve)
if not suffix: suffix = 'jnt'
# Build Controls
ctrls = glTools.tools.createAlongCurve.create(curve,
'locator',
objCount=numCtrl,
parent=False,
useDistance=useDistance,
minPercent=0.0,
maxPercent=1.0,
spacing=1.0,
prefix=prefix,
suffix=suffix)
# Attach Controls
for ctrl in ctrls:
mc.select(ctrl)
jnt = mc.joint()
attach = glTools.utils.attach.attachToCurve(curve,
ctrl,
useClosestPoint=True,
uAttr='param',
prefix=prefix)
# Constrain to Guide
if guideSrf:
# Constrain Position
geomConst = mc.geometryConstraint(guideSrf, ctrl)[0]
# Constrain Orient
if orient:
normConst = mc.normalConstraint(guideSrf,
ctrl,
aimVector=(0, 0, 1),
upVector=(-1, 0, 0),
worldUpType='vector')[0]
mc.connectAttr(attach[0] + '.tangent',
normConst + '.worldUpVector',
f=True)
# Return Result
return ctrls
def main(name="wheel", terrain=None, radius=1, scale=1):
if terrain == None:
l = mc.ls(sl=True, o=True) or []
for n in l:
if mc.nodeType(n) == "mesh":
terrain = n
break
else:
l2 = mc.listRelatives(n, pa=True, s=True, ni=True) or []
for n2 in l2:
if mc.nodeType(n2) == "mesh":
terrain = n
break
if terrain: break
grp, ctrl = common.control(name=name+"_placer", color=6, radius=radius*3, shape="square",
hideAttr=["tx","tz","rx","ry","rz","sx","sy","sz","v"],
lockAttr=["tx","tz","rx","ry","rz","sx","sy","sz"])
grp = mc.rename(grp, name+"_grp")
susp = mc.curve(d=1, p=[(0,-0.5,0),(0,0.5,0)], k=(0,1), n=name+"_susp")
mc.setAttr(susp+".template", True)
susp = mc.parent(susp, ctrl)[0]
grp2, ctrl2 = common.control(name=name, numOffsetGroups=1, color=13, radius=radius*1.25,
normal=(1,0,0), parent=grp, lockAttr=["tx","tz","rx"],
hideAttr=["tx","tz","rx","sx","sy","sz"])
tilt = mc.listRelatives(ctrl2, pa=True, p=True)[0]
tilt = mc.rename(tilt, name+"_tilt_grp")
mc.addAttr(ctrl2, ln="joints", at="bool", dv=True, k=True)
mc.addAttr(ctrl2, ln="editJoints", at="bool", k=True)
mc.addAttr(ctrl2, ln="placer", at="bool", dv=True, k=True)
mc.addAttr(ctrl2, ln="wheel", at="bool", dv=True, k=True)
mc.addAttr(ctrl2, ln="terrain", at="bool", dv=True, k=True)
mc.addAttr(ctrl2, ln="editTerrain", at="bool", dv=False, k=True)
mc.addAttr(ctrl2, ln="spin", at="double", k=True)
mc.addAttr(ctrl2, ln="tilt", at="double", dv=1, k=True)
mc.addAttr(ctrl2, ln="size", at="double", dv=1, min=0, k=True)
mc.addAttr(ctrl2, ln="terrainDetection", at="bool", dv=True, k=True)
mc.addAttr(ctrl2, ln="suspensionOffset", at="double", min=0, k=True)
mc.addAttr(ctrl2, ln="suspensionLength", at="double", dv=1, min=0, k=True)
mc.connectAttr(ctrl2+".placer", ctrl+"Shape.v")
wheel = mc.polyCylinder(h=0.5, ax=(1,0,0), sc=1, ch=False, n=name+"_pxy")[0]
mc.select(wheel+".e[0:19]", wheel+".e[20:39]")
mc.polyBevel(wheel+".e[0:39]", o=0.1, ch=False)
mc.setAttr(wheel+"Shape.overrideEnabled", True)
mc.setAttr(wheel+"Shape.overrideDisplayType", 2)
mc.setAttr(wheel+"Shape.overrideShading", 0)
mc.setAttr(wheel+"Shape.overrideColor", 1)
mc.setAttr(wheel+".castsShadows", 0)
mc.setAttr(wheel+".receiveShadows", 0)
mc.setAttr(wheel+".primaryVisibility", 0)
mc.setAttr(wheel+".visibleInReflections", 0)
mc.setAttr(wheel+".visibleInRefractions", 0)
mc.setAttr(wheel+".doubleSided", 0)
mc.connectAttr(ctrl2+".wheel", wheel+"Shape.v")
mc.parent(wheel, ctrl)
jnt = mc.createNode("joint", n=name+"_jnt", p=ctrl, ss=True)
mc.connectAttr(wheel+".t", jnt+".t")
mc.connectAttr(wheel+".r", jnt+".r")
mc.connectAttr(ctrl2+".joints", jnt+".v")
mc.setAttr(jnt+".radius", radius*0.5)
common.selectable(ctrl2+".editJoints", jnt)
common.sets("wheel", jnt, None, None)
if terrain == None:
terrain = _terrain.main(name=name, parent=grp)
mc.connectAttr(ctrl2+".terrain", terrain+".v")
r = mc.createNode("reverse", ss=True)
mc.connectAttr(ctrl2+".editTerrain", r+".inputX")
mc.connectAttr(r+".outputX", terrain+".template")
ter_ted = mc.createNode("transform", p=ctrl, n=name+"_terrain_detection", ss=True)
pc = mc.parentConstraint(ctrl2, wheel)[0]
mc.pointConstraint(susp, ter_ted)
gc = mc.geometryConstraint(terrain, ter_ted)[0]
mc.connectAttr(ctrl2+".terrainDetection", gc+"."+terrain+"W0")
susp_orig = mc.createNode("transform", p=ctrl, n=name+"_suspension_origin", ss=True)
mc.pointConstraint(ter_ted, susp_orig)
mc.geometryConstraint(susp, susp_orig)
sPntConst = mc.pointConstraint(susp_orig, grp2)[0]
mc.connectAttr(ctrl2+".suspensionOffset", susp+".ty")
mc.connectAttr(ctrl2+".suspensionLength", susp+".sy")
mc.connectAttr(ctrl2+".placer", susp+".v")
adl = mc.createNode("addDoubleLinear", ss=True)
mc.connectAttr(ctrl2+".spin", adl+".input1")
mc.connectAttr(adl+".output", pc+".target[0].targetOffsetRotateX")
adl = mc.createNode("addDoubleLinear", ss=True)
mc.connectAttr(ctrl2+".tilt", adl+".input1")
md = mc.createNode("multiplyDivide", ss=True)
mc.setAttr(md+".input2Y", -1)
mc.connectAttr(ctrl2+".size", md+".input1Y")
mc.connectAttr(md+".outputY", tilt+".rotatePivotY")
mc.connectAttr(md+".outputY", tilt+".scalePivotY")
mc.connectAttr(ctrl2+".s", wheel+".s")
mc.connectAttr(ctrl2+".size", sPntConst+".oy")
mc.connectAttr(ctrl2+".size", ctrl2+".sx")
mc.connectAttr(ctrl2+".size", ctrl2+".sy")
mc.connectAttr(ctrl2+".size", ctrl2+".sz")
mc.setAttr(ctrl2+".s", l=True)
mc.move(0, -1, 0, tilt+".scalePivot", tilt+".rotatePivot", r=True)
mc.expression(s=tilt+".rz = "+ctrl2+".ry * -"+adl+".output * 0.25", o="", ae=True, uc="all", n=name+"_wheel_exp")
common.sets("wheel", None, [ctrl, ctrl2], None)
mc.select(grp)
mc.dgdirty(a=True)
return grp, ctrl, ctrl2, wheel
def create_rocks(self, rocks_name, rocks_amount, mat_name, color, normal,
hue, brightness_range, saturation_range):
"""
This function creates certain amount of rocks with a set name
Parameters:
rocks_name: The name that rocks will have
rocks_amount: The amount of rocks that are going to be generated
mat_name: The name for Rocks' Blinn
color: Color map used by the Blinn
normal: Normal map used
hue: The hue selected for the rocks to use in the ambient color
brightness_range: range given by the user to set the ambient color
"""
if logger.level == logging.DEBUG:
start_time = time.time()
# Disable softSelection to avoid errors in other functions
cmds.softSelect(sse=False)
# Get a percentage of the size compared to original rock
size_multiplier = self.gridDimensions / 100.0
# Assign a group name based on the name selected
rocks_group = rocks_name + "_grp"
# Variable used in for loop to check if there is an existing terrain
terrain_verification = 1
# Assign material
material = create_material(mat_name, color, normal)
switch_node = cmds.shadingNode("tripleShadingSwitch", asUtility=True)
cmds.connectAttr("%s.output" % switch_node,
"%s.ambientColor" % material)
# Rock creation
for i in range(rocks_amount):
# Set new radius using the multiplier
sphere_radius = self.sphereStartRadius * size_multiplier
# Create sphere as base for rocks
new_sphere = cmds.polySphere(name=rocks_name,
radius=sphere_radius,
subdivisionsAxis=20,
subdivisionsHeight=20)
# Deform newly created sphere
self.deform_rock(new_sphere[0], sphere_radius)
# Disable softSelection to avoid errors in other functions
cmds.softSelect(sse=False)
# Select sphere again
cmds.select(new_sphere)
# Variations to scale
random_scale_x = rand(.2, 1)
random_scale_y = random_scale_x + rand(
-.1, .1) # Small variations on other axes
random_scale_z = random_scale_x + rand(
-.1, .1) # Small variations on other axes
# Scale using variables
cmds.scale(random_scale_x, random_scale_y, random_scale_z)
# Freeze transformations
cmds.makeIdentity(apply=True)
# Random numbers locations based on terrain size
random_position_x = rand(-self.gridDimensions / 2,
self.gridDimensions / 2)
random_position_z = rand(-self.gridDimensions / 2,
self.gridDimensions / 2)
# Move sphere inside range defined by terrain
cmds.move(random_position_x, 0, random_position_z)
# Try to snap rocks to terrain only if there is a terrain
if terrain_verification > 0:
try:
# Select actual terrain
cmds.select(self.gridObject, new_sphere)
# Constraint to Terrain's Geometry
cmds.geometryConstraint(weight=True)
# Constraint to Terrain's normals to make rocks point the right direction
cmds.normalConstraint(weight=True,
aimVector=(0, 1, 0),
upVector=(1, 0, 0),
worldUpType=0)
# Delete constraints
cmds.delete(
cmds.listRelatives(new_sphere, children=True)[1:])
except ValueError:
logger.warn(
"No terrain was previously created, or got deleted. Spawning rocks randomly..."
)
terrain_verification -= 1
# Try to select the group, if its not possible, then create it
try:
cmds.select(new_sphere, rocks_group)
except ValueError:
cmds.group(name=rocks_group, empty=True)
cmds.select(new_sphere, rocks_group)
# Parent rocks to group and save rock's new name
actual_rock = cmds.parent()
# Connect shape to switch Node
sphere_shape = cmds.listRelatives(actual_rock[0], shapes=True)[0]
cmds.connectAttr("%s.instObjGroups[0]" % sphere_shape,
"%s.input[%i].inShape" % (switch_node, i))
# Create color nodes
random_brightness = rand(brightness_range[0], brightness_range[1])
random_saturation = rand(saturation_range[0], saturation_range[1])
color = colorsys.hsv_to_rgb(hue / 360.0, random_saturation,
random_brightness * 1.0)
logger.debug("HUE is {}".format(hue))
logger.debug("Rock is having {} color".format(color))
color_node = cmds.shadingNode("colorConstant", asUtility=True)
cmds.setAttr("%s.inColor" % color_node,
color[0],
color[1],
color[2],
type="double3")
cmds.connectAttr("%s.outColor" % color_node,
"%s.input[%i].inTriple" % (switch_node, i))
# Assign material to rock
cmds.select(actual_rock)
cmds.hyperShade(assign=material)
if logger.level == logging.DEBUG:
logger.debug("--- ROCK CREATION took: {} ---".format(time.time() -
start_time))
def edo_addSkeletonBall(jnt,
autoConstraint=0,
parents=None,
rotation=None,
axis=4):
#sel,1,pajnt,rotation
#jnt='joint2'
#parents=None
#rotation=None
#autoConstraint=1
#axis=8
dbs = cmds.sphere(ch=1,
o=1,
po=0,
ax=[1, 0, 0],
r=1.0,
nsp=4,
esw=180,
n=jnt + '_dn_drivenBall')
dnball = dbs[0]
cmds.delete(dbs[1])
dbs = cmds.sphere(ch=1,
o=1,
po=0,
ax=[1, 0, 0],
r=1.0,
nsp=4,
ssw=180,
esw=360,
n=jnt + '_up_drivenBall')
upball = dbs[0]
cmds.delete(dbs[1])
#edo_gdcfrig2012_createCtrl(jnt+'_FRAME',shape='box',colorid=17)
edo_createFacialCtrl.edo_addFacialCtrlCmd(jnt, '', 1, '_CONNECT')
#cmds.file(filepath,i=1)
cmd = 'source "' + filepath + '"'
mel.eval(cmd)
cmds.setAttr('GRP_' + jnt + '_FRAME.rx', 90)
curveshapes = cmds.listRelatives('SKELETONBALL_FRAME', s=1, pa=1)
cmds.parent(curveshapes, jnt + '_FRAME', r=1, s=1)
#cmds.setAttr(jnt+'_FRAME.sx',2)
#cmds.setAttr(jnt+'_FRAME.sy',2)
#cmds.setAttr(jnt+'_FRAME.sz',2)
for cs in curveshapes:
cmds.rename(cs, cs.replace('SKELETONBALL_FRAME', jnt + '_FRAME'))
curveshapes = cmds.listRelatives('SKELETONBALL_FRAME', s=1, pa=1)
cmds.makeIdentity(jnt + '_FRAME', apply=1, t=1, r=1, s=1, n=0)
cmds.connectAttr(jnt + '_FRAME.sy', jnt + '_FRAME.sx', f=1)
cmds.connectAttr(jnt + '_FRAME.sy', jnt + '_FRAME.sz', f=1)
cmds.setAttr(jnt + '_FRAME.sx', e=1, k=0)
cmds.setAttr(jnt + '_FRAME.sz', e=1, k=0)
cmds.aliasAttr('globalScale', jnt + '_FRAME.sy')
cmds.addAttr(jnt + '_FRAME', ln='front', at='double')
cmds.setAttr(jnt + '_FRAME.front', e=1, k=0)
cmds.addAttr(jnt + '_FRAME', ln='back', at='double')
cmds.setAttr(jnt + '_FRAME.back', e=1, k=0)
cmds.addAttr(jnt + '_FRAME', ln='left', at='double')
cmds.setAttr(jnt + '_FRAME.left', e=1, k=0)
cmds.addAttr(jnt + '_FRAME', ln='right', at='double')
cmds.setAttr(jnt + '_FRAME.right', e=1, k=0)
cmds.addAttr(jnt + '_FRAME', ln='tip', at='double')
cmds.setAttr(jnt + '_FRAME.tip', e=1, k=1)
cmds.addAttr(jnt + '_FRAME', ln='frontValue', at='double')
cmds.setAttr(jnt + '_FRAME.frontValue', e=1, k=1)
cmds.addAttr(jnt + '_FRAME', ln='backValue', at='double')
cmds.setAttr(jnt + '_FRAME.backValue', e=1, k=1)
cmds.addAttr(jnt + '_FRAME', ln='leftValue', at='double')
cmds.setAttr(jnt + '_FRAME.leftValue', e=1, k=1)
cmds.addAttr(jnt + '_FRAME', ln='rightValue', at='double')
cmds.setAttr(jnt + '_FRAME.rightValue', e=1, k=1)
cmds.addAttr(jnt + '_FRAME', ln='maxAngle', at='double', min=45, max=180)
cmds.setAttr(jnt + '_FRAME.maxAngle', e=1, k=1)
cmds.setAttr(jnt + '_FRAME.maxAngle', 150)
cmds.addAttr(jnt + '_FRAME', ln='maxAngleRange', at='double')
cmds.setAttr(jnt + '_FRAME.maxAngleRange', e=1, k=0)
ar = cmds.createNode('multiplyDivide', n=jnt + '_angleMultiplyDivide')
cmds.setAttr(jnt + '_angleMultiplyDivide.input1X', 180)
cmds.connectAttr(jnt + '_FRAME.maxAngle',
jnt + '_angleMultiplyDivide.input2X',
f=1)
cmds.setAttr(jnt + '_angleMultiplyDivide.operation', 2)
cmds.connectAttr(jnt + '_angleMultiplyDivide.outputX',
jnt + '_FRAME.maxAngleRange',
f=1)
#addLoactor
#fl=cmds.spaceLocator(n=jnt+'_frontLoc',p=[0,0,1])[0]
#bl=cmds.spaceLocator(n=jnt+'_backLoc',p=[0,0,-1])[0]
#ll=cmds.spaceLocator(n=jnt+'_leftLoc',p=[1,0,0])[0]
#rl=cmds.spaceLocator(n=jnt+'_rightLoc',p=[-1,0,0])[0]
tl = cmds.spaceLocator(n=jnt + '_tipLoc', p=[0, 1, 0])[0]
dbl = cmds.spaceLocator(n=jnt + '_dnBallLoc', p=[0, -1, 0])[0]
ubl = cmds.spaceLocator(n=jnt + '_upBallLoc', p=[0, 0, 1])[0]
cl = cmds.spaceLocator(n=jnt + '_centerLoc', p=[0, 0, 0])[0]
#cmds.select([fl,bl,ll,rl,tl,dbl,ubl,cl],r=1)
cmds.select([tl, dbl, ubl, cl], r=1)
cmds.CenterPivot()
cmds.geometryConstraint(dnball, dbl)
cmds.parentConstraint(cl, dbl, mo=1)
cmds.setAttr(cl + '.rx', -90)
cmds.geometryConstraint(upball, ubl)
cmds.parentConstraint(cl, ubl, mo=1)
#== add 8 axis function
if axis == 8:
print '8 axis model...'
cmds.addAttr(jnt + '_FRAME',
ln='Axis_4_or_8',
at='float',
dv=1,
minValue=0,
maxValue=1)
cmds.setAttr(jnt + '_FRAME.Axis_4_or_8', e=1, k=1)
eap = edo_createEightDirPlane.edo_createEightDirPlane(jnt)
cmds.setAttr(eap + '.ry', -90)
cmds.setAttr(eap + '.rx', 180)
cmds.parent(eap, jnt + '_FRAME')
#add 4up 8up
md = cmds.createNode('multiplyDivide')
bd = cmds.createNode('blendTwoAttr')
cmds.connectAttr(jnt + '_FRAME.Axis_4_or_8', bd + '.attributesBlender')
cmds.connectAttr(eap + '.up_Weight_8', md + '.input1X')
cmds.connectAttr(jnt + '_FRAME.tip', md + '.input2X')
cmds.connectAttr(eap + '.up_Weight_4', md + '.input1Y')
cmds.connectAttr(jnt + '_FRAME.tip', md + '.input2Y')
cmds.connectAttr(md + '.outputY', bd + '.input[0]')
cmds.connectAttr(md + '.outputX', bd + '.input[1]')
cmds.connectAttr(bd + '.output', jnt + '_FRAME.up', f=1)
#add 4lf 8lf
md = cmds.createNode('multiplyDivide')
bd = cmds.createNode('blendTwoAttr')
cmds.connectAttr(jnt + '_FRAME.Axis_4_or_8', bd + '.attributesBlender')
cmds.connectAttr(eap + '.lf_Weight_8', md + '.input1X')
cmds.connectAttr(jnt + '_FRAME.tip', md + '.input2X')
cmds.connectAttr(eap + '.lf_Weight_4', md + '.input1Y')
cmds.connectAttr(jnt + '_FRAME.tip', md + '.input2Y')
cmds.connectAttr(md + '.outputY', bd + '.input[0]')
cmds.connectAttr(md + '.outputX', bd + '.input[1]')
cmds.connectAttr(bd + '.output', jnt + '_FRAME.lf', f=1)
#add 4dn 8dn
md = cmds.createNode('multiplyDivide')
bd = cmds.createNode('blendTwoAttr')
cmds.connectAttr(jnt + '_FRAME.Axis_4_or_8', bd + '.attributesBlender')
cmds.connectAttr(eap + '.dn_Weight_8', md + '.input1X')
cmds.connectAttr(jnt + '_FRAME.tip', md + '.input2X')
cmds.connectAttr(eap + '.dn_Weight_4', md + '.input1Y')
cmds.connectAttr(jnt + '_FRAME.tip', md + '.input2Y')
cmds.connectAttr(md + '.outputY', bd + '.input[0]')
cmds.connectAttr(md + '.outputX', bd + '.input[1]')
cmds.connectAttr(bd + '.output', jnt + '_FRAME.dn', f=1)
#add 4rt 8rt
md = cmds.createNode('multiplyDivide')
bd = cmds.createNode('blendTwoAttr')
cmds.connectAttr(jnt + '_FRAME.Axis_4_or_8', bd + '.attributesBlender')
cmds.connectAttr(eap + '.rt_Weight_8', md + '.input1X')
cmds.connectAttr(jnt + '_FRAME.tip', md + '.input2X')
cmds.connectAttr(eap + '.rt_Weight_4', md + '.input1Y')
cmds.connectAttr(jnt + '_FRAME.tip', md + '.input2Y')
cmds.connectAttr(md + '.outputY', bd + '.input[0]')
cmds.connectAttr(md + '.outputX', bd + '.input[1]')
cmds.connectAttr(bd + '.output', jnt + '_FRAME.rt', f=1)
#add 4lfup 8lfup
md = cmds.createNode('multiplyDivide')
bd = cmds.createNode('blendTwoAttr')
cmds.connectAttr(jnt + '_FRAME.Axis_4_or_8', bd + '.attributesBlender')
cmds.connectAttr(eap + '.lfup_Weight_8', md + '.input1X')
cmds.connectAttr(jnt + '_FRAME.tip', md + '.input2X')
cmds.setAttr(bd + '.input[0]', 0)
cmds.connectAttr(md + '.outputX', bd + '.input[1]')
cmds.connectAttr(bd + '.output', jnt + '_FRAME.lfup', f=1)
#add 4lfdn 8lfdn
md = cmds.createNode('multiplyDivide')
bd = cmds.createNode('blendTwoAttr')
cmds.connectAttr(jnt + '_FRAME.Axis_4_or_8', bd + '.attributesBlender')
cmds.connectAttr(eap + '.lfdn_Weight_8', md + '.input1X')
cmds.connectAttr(jnt + '_FRAME.tip', md + '.input2X')
cmds.setAttr(bd + '.input[0]', 0)
cmds.connectAttr(md + '.outputX', bd + '.input[1]')
cmds.connectAttr(bd + '.output', jnt + '_FRAME.lfdn', f=1)
#add 4rtup 8rtup
md = cmds.createNode('multiplyDivide')
bd = cmds.createNode('blendTwoAttr')
cmds.connectAttr(jnt + '_FRAME.Axis_4_or_8', bd + '.attributesBlender')
cmds.connectAttr(eap + '.rtup_Weight_8', md + '.input1X')
cmds.connectAttr(jnt + '_FRAME.tip', md + '.input2X')
cmds.setAttr(bd + '.input[0]', 0)
cmds.connectAttr(md + '.outputX', bd + '.input[1]')
cmds.connectAttr(bd + '.output', jnt + '_FRAME.rtup', f=1)
#add 4rtdn 8rtdn
md = cmds.createNode('multiplyDivide')
bd = cmds.createNode('blendTwoAttr')
cmds.connectAttr(jnt + '_FRAME.Axis_4_or_8', bd + '.attributesBlender')
cmds.connectAttr(eap + '.rtdn_Weight_8', md + '.input1X')
cmds.connectAttr(jnt + '_FRAME.tip', md + '.input2X')
cmds.setAttr(bd + '.input[0]', 0)
cmds.connectAttr(md + '.outputX', bd + '.input[1]')
cmds.connectAttr(bd + '.output', jnt + '_FRAME.rtdn', f=1)
#breakUnusedAttr
cmds.setAttr(jnt + '_FRAME.fourAxis_up', e=1, cb=0)
cmds.setAttr(jnt + '_FRAME.fourAxis_dn', e=1, cb=0)
cmds.setAttr(jnt + '_FRAME.fourAxis_lf', e=1, cb=0)
cmds.setAttr(jnt + '_FRAME.fourAxis_rt', e=1, cb=0)
cmds.setAttr(jnt + '_FRAME.fourAxis_up_Vis', e=1, cb=0)
cmds.setAttr(jnt + '_FRAME.fourAxis_dn_Vis', e=1, cb=0)
cmds.setAttr(jnt + '_FRAME.fourAxis_lf_Vis', e=1, cb=0)
cmds.setAttr(jnt + '_FRAME.fourAxis_rt_Vis', e=1, cb=0)
cmds.deleteAttr(jnt + '_FRAME.frontValue')
cmds.deleteAttr(jnt + '_FRAME.backValue')
cmds.deleteAttr(jnt + '_FRAME.leftValue')
cmds.deleteAttr(jnt + '_FRAME.rightValue')
cmds.deleteAttr(jnt + '_FRAME.maxAngle')
#clearUpNode
cmds.setAttr('GRP_' + jnt + '_CONNECT.visibility', 0)
#cmds.delete(jnt+'_CTRL_fourAxisup',jnt+'_CTRL_fourAxisdn',jnt+'_CTRL_fourAxislf',jnt+'_CTRL_fourAxisrt')
loc = eap.replace('curve', 'CLoc')
cmds.setAttr(loc + '.tx', 1)
cmds.parentConstraint(dbl, loc, mo=0)
cmds.connectAttr(jnt + '_FRAME.globalScale', eap + '.globalScale')
cmds.setAttr(loc + '.visibility', 0)
#add record attributes
cmds.addAttr(jnt + '_FRAME', ln='up_data', dt='string')
cmds.addAttr(jnt + '_FRAME', ln='dn_data', dt='string')
cmds.addAttr(jnt + '_FRAME', ln='lf_data', dt='string')
cmds.addAttr(jnt + '_FRAME', ln='rt_data', dt='string')
cmds.addAttr(jnt + '_FRAME', ln='lfup_data', dt='string')
cmds.addAttr(jnt + '_FRAME', ln='lfdn_data', dt='string')
cmds.addAttr(jnt + '_FRAME', ln='rtup_data', dt='string')
cmds.addAttr(jnt + '_FRAME', ln='rtdn_data', dt='string')
cmds.setAttr(cl + '.rx', 0)
tdis = edo_createDistanceNode(ubl, tl, disname=jnt + '_tipDis')
#fdis=edo_createDistanceNode(dbl,fl,disname=jnt+'_frontDis')
#bdis=edo_createDistanceNode(dbl,bl,disname=jnt+'_backDis')
#ldis=edo_createDistanceNode(dbl,ll,disname=jnt+'_leftDis')
#rdis=edo_createDistanceNode(dbl,rl,disname=jnt+'_rightDis')
#addTipSetRangeValue
tdism = cmds.createNode('multiplyDivide', n=jnt + '_tipDisMultiply')
dis = cmds.getAttr(tdis + '.distance')
tiprange = cmds.createNode('setRange', n=jnt + '_tipRange')
cmds.connectAttr(tdis + '.distance', tiprange + '.valueX', f=1)
cmds.setAttr(tiprange + '.minX', 2)
cmds.setAttr(tiprange + '.maxX', 1)
cmds.connectAttr(tiprange + '.outValueX', jnt + '_FRAME.tip')
cmds.connectAttr(jnt + '_FRAME.sy', tdism + '.input1Y', f=1)
cmds.setAttr(tdism + '.input2Y', dis)
cmds.connectAttr(tdism + '.outputY', tiprange + '.oldMaxX', f=1)
#addFrontSetRangeValue
#fdism=cmds.createNode('multiplyDivide',n=jnt+'_frontDisMultiply')
#dis=cmds.getAttr(fdis+'.distance')
#frontrange=cmds.createNode('setRange',n=jnt+'_frontRange')
#cmds.connectAttr(fdis+'.distance',frontrange+'.valueX',f=1)
#cmds.setAttr(frontrange+'.minX',1)
#cmds.connectAttr(frontrange+'.outValueX',jnt+'_FRAME.front',f=1)
#fm=cmds.createNode('multiplyDivide',n=jnt+'_frontMultiply')
#cmds.connectAttr(jnt+'_FRAME.front',fm+'.input1X',f=1)
#cmds.connectAttr(jnt+'_FRAME.tip',fm+'.input2X',f=1)
#cmds.connectAttr(fm+'.outputX',frontrange+'.valueY',f=1)
#cmds.setAttr(frontrange+'.oldMinY',0)
#cmds.setAttr(frontrange+'.oldMaxY',2)
#cmds.connectAttr(frontrange+'.outValueY',jnt+'_FRAME.frontValue',f=1)
#cmds.connectAttr(jnt+'_FRAME.maxAngleRange',frontrange+'.maxY',f=1)
#cmds.connectAttr(jnt+'_FRAME.sy',fdism+'.input1Y',f=1)
#cmds.setAttr(fdism+'.input2Y',dis)
#cmds.connectAttr(fdism+'.outputY',frontrange+'.oldMaxX',f=1)
#addBackSetRangeValue
#bdism=cmds.createNode('multiplyDivide',n=jnt+'_backDisMultiply')
#dis=cmds.getAttr(bdis+'.distance')
#backrange=cmds.createNode('setRange',n=jnt+'_backRange')
#cmds.connectAttr(bdis+'.distance',backrange+'.valueX',f=1)
#cmds.setAttr(backrange+'.minX',1)
#cmds.connectAttr(backrange+'.outValueX',jnt+'_FRAME.back',f=1)
#bm=cmds.createNode('multiplyDivide',n=jnt+'_backMultiply')
#cmds.connectAttr(jnt+'_FRAME.back',bm+'.input1X',f=1)
#cmds.connectAttr(jnt+'_FRAME.tip',bm+'.input2X',f=1)
#cmds.connectAttr(bm+'.outputX',backrange+'.valueY',f=1)
#cmds.setAttr(backrange+'.oldMinY',0)
#cmds.setAttr(backrange+'.oldMaxY',2)
#cmds.connectAttr(backrange+'.outValueY',jnt+'_FRAME.backValue',f=1)
#cmds.connectAttr(jnt+'_FRAME.maxAngleRange',backrange+'.maxY',f=1)
#cmds.connectAttr(jnt+'_FRAME.sy',bdism+'.input1Y',f=1)
#cmds.setAttr(bdism+'.input2Y',dis)
#cmds.connectAttr(bdism+'.outputY',backrange+'.oldMaxX',f=1)
#addLeftSetRangeValue
#ldism=cmds.createNode('multiplyDivide',n=jnt+'_leftDisMultiply')
#dis=cmds.getAttr(ldis+'.distance')
#leftrange=cmds.createNode('setRange',n=jnt+'_leftRange')
#cmds.connectAttr(ldis+'.distance',leftrange+'.valueX',f=1)
#cmds.setAttr(leftrange+'.minX',1)
#cmds.connectAttr(leftrange+'.outValueX',jnt+'_FRAME.left',f=1)
#lm=cmds.createNode('multiplyDivide',n=jnt+'_leftMultiply')
#cmds.connectAttr(jnt+'_FRAME.left',lm+'.input1X',f=1)
#cmds.connectAttr(jnt+'_FRAME.tip',lm+'.input2X',f=1)
#cmds.connectAttr(lm+'.outputX',leftrange+'.valueY',f=1)
#cmds.setAttr(leftrange+'.oldMinY',0)
#cmds.setAttr(leftrange+'.oldMaxY',2)
#leftblend=cmds.createNode('blendColors',n=leftrange+'_blend')
#cmds.connectAttr(leftrange+'.outValueY',leftblend+'.color2R',f=1)
#cmds.connectAttr(leftblend+'.outputR',jnt+'_FRAME.leftValue',f=1)
#cmds.connectAttr(jnt+'_FRAME.maxAngleRange',leftrange+'.maxY',f=1)
#cmds.connectAttr(jnt+'_FRAME.sy',ldism+'.input1Y',f=1)
#cmds.setAttr(ldism+'.input2Y',dis)
#cmds.connectAttr(ldism+'.outputY',leftrange+'.oldMaxX',f=1)
#addRightSetRangeValue
#rdism=cmds.createNode('multiplyDivide',n=jnt+'_rightDisMultiply')
#dis=cmds.getAttr(rdis+'.distance')
#rightrange=cmds.createNode('setRange',n=jnt+'_rightRange')
#cmds.connectAttr(rdis+'.distance',rightrange+'.valueX',f=1)
#cmds.setAttr(rightrange+'.minX',1)
#cmds.connectAttr(rightrange+'.outValueX',jnt+'_FRAME.right',f=1)
#rm=cmds.createNode('multiplyDivide',n=jnt+'_rightMultiply')
#cmds.connectAttr(jnt+'_FRAME.right',rm+'.input1X',f=1)
#cmds.connectAttr(jnt+'_FRAME.tip',rm+'.input2X',f=1)
#cmds.connectAttr(rm+'.outputX',rightrange+'.valueY',f=1)
#cmds.setAttr(rightrange+'.oldMinY',0)
#cmds.setAttr(rightrange+'.oldMaxY',2)
#rightblend=cmds.createNode('blendColors',n=rightrange+'_blend')
#cmds.connectAttr(rightrange+'.outValueY',rightblend+'.color2R',f=1)
#cmds.connectAttr(rightblend+'.outputR',jnt+'_FRAME.rightValue',f=1)
#cmds.connectAttr(jnt+'_FRAME.maxAngleRange',rightrange+'.maxY',f=1)
#cmds.connectAttr(jnt+'_FRAME.sy',rdism+'.input1Y',f=1)
#cmds.setAttr(rdism+'.input2Y',dis)
#cmds.connectAttr(rdism+'.outputY',rightrange+'.oldMaxX',f=1)
#addYZplaneMirrorAttr
#cmds.addAttr(jnt+'_FRAME',ln='direction',at='enum',en='left:right')
#cmds.setAttr(jnt+'_FRAME.direction',e=1,k=1)
#cmds.setAttr(jnt+'_FRAME.direction',e=1,k=1)
#cmds.connectAttr(rightrange+'.outValueY',leftblend+'.color1R',f=1)
#cmds.connectAttr(leftrange+'.outValueY',rightblend+'.color1R',f=1)
#cmds.connectAttr(jnt+'_FRAME.direction',leftblend+'.blender',f=1)
#cmds.connectAttr(jnt+'_FRAME.direction',rightblend+'.blender',f=1)
#Dag
cmds.parent(jnt + '_FRAME', w=1)
cmds.delete('GRP_' + jnt + '_FRAME')
#cmds.parent(fl,jnt+'_FRAME')
#cmds.parent(bl,jnt+'_FRAME')
#cmds.parent(ll,jnt+'_FRAME')
#cmds.parent(rl,jnt+'_FRAME')
cmds.parent(tl, jnt + '_FRAME')
cmds.parent(ubl, jnt + '_FRAME')
cmds.parent(dbl, jnt + '_FRAME')
cmds.parent(cl, jnt + '_FRAME')
cmds.parent(upball, jnt + '_FRAME')
cmds.parent(dnball, jnt + '_FRAME')
cmds.select(jnt + '_FRAME', r=1)
#connect driving frame
#dvpl=cmds.createNode('plusMinusAverage',n=jnt+'_drivingPL')
#cmds.connectAttr(jnt+'_FRAME.leftValue',dvpl+'.input3D[0].input3Dx',f=1)
#cmds.connectAttr(jnt+'_FRAME.frontValue',dvpl+'.input3D[0].input3Dy',f=1)
#cmds.setAttr(dvpl+'.operation',2)
#cmds.connectAttr(jnt+'_FRAME.rightValue',dvpl+'.input3D[1].input3Dx',f=1)
#cmds.connectAttr(jnt+'_FRAME.backValue',dvpl+'.input3D[1].input3Dy',f=1)
#cmds.connectAttr(dvpl+'.output3Dx',jnt+'_CTRL.tx',f=1)
#cmds.connectAttr(dvpl+'.output3Dy',jnt+'_CTRL.ty',f=1)
#hideLocator
cmds.setAttr(upball + '.v', 0)
cmds.setAttr(dnball + '.v', 0)
#cmds.setAttr(fl+'.v',0)
#cmds.setAttr(bl+'.v',0)
#cmds.setAttr(ll+'.v',0)
#cmds.setAttr(rl+'.v',0)
cmds.setAttr(tl + '.v', 0)
cmds.setAttr(ubl + '.v', 0)
cmds.setAttr(dbl + '.v', 0)
cmds.setAttr(cl + '.overrideEnabled', 1)
cmds.setAttr(cl + '.ovc', 13)
#cmds.setAttr(jnt+'_CTRL.v',0)
#addglobalScaleAttr
edo_addSkeletonBallGlobalScaleAttr(jnt + '_FRAME')
cmds.setAttr(jnt + '_FRAME_globalScaleLoc.v', 0)
#delete nodes
cmds.delete('SKELETONBALL_FRAME')
if cmds.objExists(jnt):
#cmds.parent()
#position
cmds.parent(jnt + '_FRAME', jnt)
cmds.setAttr(jnt + '_FRAME.tx', 0)
cmds.setAttr(jnt + '_FRAME.ty', 0)
cmds.setAttr(jnt + '_FRAME.tz', 0)
cmds.setAttr(jnt + '_FRAME.rx', 0)
cmds.setAttr(jnt + '_FRAME.ry', 90)
cmds.setAttr(jnt + '_FRAME.rz', 0)
cmds.parent(jnt + '_FRAME', w=1)
if not rotation == None:
for r in rotation:
#r=rotation[1]
if str(type(r)) == "<type 'str'>":
if cmds.objExists(r):
cmds.delete(
cmds.orientConstraint(r, jnt + '_FRAME', mo=0))
else:
cmds.rotate(float(r[0]),
float(r[1]),
float(r[2]),
jnt + '_FRAME',
r=1,
os=1)
if not parents == None:
if cmds.objExists(parents):
cmds.parent(jnt + '_FRAME', parents)
if autoConstraint == 1:
cmds.orientConstraint(jnt, cl, mo=1)
def crvTendon(curve, geo, precision=4, prefix='tendon'):
"""
"""
# rebuildCurve degree 1
baseCurve = cmds.rebuildCurve(curve,
ch=0,
s=1,
d=1,
rpo=1,
rt=0,
end=1,
kr=0,
kcp=0,
kep=1,
kt=1)
# create cv locators
baseLocs = glTools.utils.curve.locatorCurve(baseCurve,
prefix=prefix + '_baseCrv')
# generate geo constraint curve
geoCurve = cmds.rebuildCurve(baseCurve,
ch=1,
s=precsion,
d=1,
rpo=0,
rt=0,
end=1,
kr=0,
kcp=0,
kep=1,
kt=1)
geoCurveLocs = glTools.utils.curve.locatorCurve(geoCurve,
prefix=prefix + '_geoCrv')
# generate reference curve
refCurve = cmds.rebuildCurve(baseCurve,
ch=1,
s=precsion,
d=1,
rpo=0,
rt=0,
end=1,
kr=0,
kcp=0,
kep=1,
kt=1)
refCurveInfo = cmds.createNode('curveInfo', n=prefix + '_ref_curveInfo')
cmds.connectAttr(refCurve + '.worldSpace[0]',
refCurveInfo + '.inputCurve',
f=True)
refCurveLocs = []
for i in range(precsion + 1):
refNull = cmds.group(em=True, n=prefix + '_ref' + str(i) + '_null')
cmds.connectAttr(refCurveInfo + '.controlPoints[' + str(i) + ']',
refNull + '.t')
refCurveLocs.append(refNull)
# Locator Constraints
for i in range(precsion + 1):
cmds.pointConstraint(refCurveLocs[i], geoCurveLocs[i])
cmds.geometryConstraint(geo, geoCurveLocs[i])
# fitBspline
bSpline = cmds.fitBspline(geoCurve, ch=1)
def surfaceConstraint(obj,
surface,
point=True,
orient=True,
normalAxis='x',
upAxis='y',
upMode='',
upVector=(0, 1, 0),
upObject='',
pointMode=0,
prefix=''):
'''
@param obj: Target object that the surface constrained transform will goal to.
@type obj: str
@param surface: Surface to constrain to
@type surface: str
@param point: Constrain point (translate)
@type point: bool
@param orient: Constrain orient (rotate)
@type orient: bool
@param normalAxis: Constrained transform axis to align with surface normal
@type normalAxis: str
@param upAxis: Constrained transform axis to align with defined upVector
@type upAxis: str
@param upMode: Constraint upVector mode. Valid values are 'scene', 'object', 'objectrotation', 'vector' or 'none'.
@type upMode: str
@param upVector: Constraint upVector.
@type upVector: list or tuple
@param upObject: Constraint upVector object. Only needed for 'object' or 'objectrotation' upVector modes.
@type upObject: str
@param pointMode: Point (translate) constraint mode. 0 = geometryConstraint, 1 = boundaryConstraint.
@type pointMode: int
@param prefix: Name prefix for newly created nodes
@type prefix: str
'''
# Build axis dictionary
axisDict = {
'x': (1, 0, 0),
'y': (0, 1, 0),
'z': (0, 0, 1),
'-x': (-1, 0, 0),
'-y': (0, -1, 0),
'-z': (0, 0, -1)
}
# ==========
# - Checks -
# ==========
if not mc.objExists(obj):
raise Exception('Object "' + obj + '" does not exist!')
if not mc.objExists(surface):
raise Exception('Surface "' + surface + '" does not exist!')
if not axisDict.keys().count(normalAxis):
raise Exception('Invalid normal axis specified "' + normalAxis + '"!')
if not axisDict.keys().count(upAxis):
raise Exception('Invalid up axis specified "' + upAxis + '"!')
if ((upMode == 'object') or
(upMode == 'objectrotation')) and not mc.objExists(upObject):
raise Exception('Invalid up object specified "' + upObject + '"!')
# ===============================
# - Create Constraint Transform -
# ===============================
surfConnNode = mc.createNode('transform', n=prefix + '_surfConn_grp')
# ================================
# - Constraint point (translate) -
# ================================
if point:
if pointMode == 0:
# Geometry Constraint
pntConn = mc.pointConstraint(obj,
surfConnNode,
n=prefix + '_pointConstraint')
geoConn = mc.geometryConstraint(surface,
surfConnNode,
n=prefix + '_geometryConstraint')
else:
# =======================
# - Boundary Constraint -
# =======================
# World Position (vectorProduct)
vecProduct = mc.createNode('vectorProduct',
n=prefix + '_worldPos_vectorProduct')
mc.setAttr(vecProduct + '.operation', 4) # Point Matrix Product
mc.connectAttr(obj + '.worldMatrix',
vecProduct + '.matrix',
f=True)
# Closest Point On Surface
cposNode = mc.createNode('closestPointOnSurface',
n=prefix +
'_surfacePos_closestPointOnSurface')
mc.connectAttr(surface + '.worldSpace[0]',
cposNode + '.inputSurface',
f=True)
mc.connectAttr(vecProduct + '.output',
cposNode + '.inPoint',
f=True)
# Point On Surface Info
posiNode = mc.createNode('pointOnSurfaceInfo',
n=prefix +
'_surfacePt_pointOnSurfaceInfo')
mc.connectAttr(surface + '.worldSpace[0]',
cposNode + '.inputSurface',
f=True)
mc.connectAttr(cposNode + '.parameterU',
posiNode + '.parameterU',
f=True)
mc.connectAttr(cposNode + '.parameterV',
posiNode + '.parameterV',
f=True)
# Calculate Offset
offsetNode = mc.createNode('plusMinusAverage',
n=prefix +
'_surfaceOffset_plusMinusAverage')
mc.setAttr(offsetNode + '.operation', 2) # Subtract
mc.connectAttr(vecProduct + '.output',
offsetNode + '.input3D[0]',
f=True)
mc.connectAttr(cposNode + '.position',
offsetNode + '.input3D[1]',
f=True)
# Offset * Normal (dotProduct)
dotProduct = mc.createNode('vectorProduct',
n=prefix + '_dotProduct_vectorProduct')
mc.setAttr(dotProduct + '.operation', 1) # Dot Product
mc.connectAttr(offsetNode + '.ouput3D',
dotProduct + '.input1',
f=True)
mc.connectAttr(posiNode + '.normal',
dotProduct + '.input2',
f=True)
# Boundary Condition
condition = mc.createNode('condition', n=prefix + '_condition')
mc.setAttr(condition + '.operation', 2) # Greater Than
mc.connectAttr(dotProduct + '.outputX',
condition + '.firstTerm',
f=True)
mc.connectAttr(vecProduct + '.output',
condition + '.colorIfTrue',
f=True)
mc.connectAttr(cposNode + '.position',
condition + '.colorIfFalse',
f=True)
# Connect to transform
mc.connectAttr(condition + '.outColor',
surfConnNode + '.t',
f=True)
else:
# Point Constraint
pntConn = mc.pointConstraint(obj,
surfConnNode,
n=prefix + '_pointConstraint')
# =============================
# - Constrain Orient (rotate) -
# =============================
if orient:
# Normal Constraint
normConn = mc.normalConstraint(surface,
surfConnNode,
aim=axisDict[normalAxis],
u=axisDict[upAxis],
wut=upMode,
wu=upVector,
wuo=upObject,
n=prefix + '_normalConstraint')
else:
# Orient Constraint
oriConn = mc.normalConstraint(obj,
surfConnNode,
n=prefix + '_orientConstraint')
# =================
# - Return Result -
# =================
return surfConnNode
