def evenlyDivideCurve( curve, numDiv ):
""" Divides a curve into numDiv.
Assumes there are two CVs at the start and end of the curve """
# first, move the curve to the origin
translation = mc.xform(curve, q=True, ws=True, translation=True)
rotation = mc.xform(curve, q=True, ws=True, rotation=True)
mc.move(0, 0, 0, curve)
mc.rotate(0, 0, 0, curve)
# get the curve info node
infoNode = getCurveInfoNode(curve)
Knots = list( mc.getAttr( infoNode+".knots" )[0] )
CVs = mc.getAttr( curve+".cv[*]" )
numOrigCVs = len(CVs)
numOrigKnots = len(Knots)
if( not numOrigCVs == 4 ):
print("ERROR: original curve must have exactly 4 CVs")
return
else:
for p in range(0,(numDiv-numOrigCVs+4+1)):
percent = (p-1)/float(numDiv-2)
u = findParamAtArcPercent( curve, percent )
if p < 2 or p >= (numDiv-numOrigCVs+3):
CVs[p] = tuple(mc.pointOnCurve(curve, parameter=u))
else:
CVs.insert(p, tuple(mc.pointOnCurve(curve, parameter=u)) )
Knots.insert(p+1, u)
curve = mc.curve( curve,r=True, p=CVs, k=Knots)
mc.move(translation[0], translation[1], translation[2], curve)
mc.rotate(rotation[0], rotation[1], rotation[2], curve)
return curve
def addTube(selection, tubesubdivs=8):
dt = pm.dt
worldUp = dt.Vector([0, 1, 0])
selShape = mc.listRelatives(selection, shapes=1, ad=1, f=1)[0]
curveBaseNormal = mc.pointOnCurve(sel, pr=0, nn=1, top=1)
curveBasePosition = mc.pointOnCurve(sel, pr=0, p=1, top=1)
curveBasePosition_UpRef = mc.pointOnCurve(sel, pr=0.1, p=1, top=1)
# creates vector datatype so we get helper functions like cross product from pymel
base = dt.Vector(curveBasePosition)
normal = dt.Vector(curveBaseNormal)
up = dt.Vector(curveBasePosition_UpRef)
up = -(up - normal).normal()
aim = dt.cross(up, normal)
# locators at reference frame vectors
referenceframe = {"normal": normal, "up": up, "aim": aim}
[pm.spaceLocator(p=base + v, n=k) for k, v in referenceframe.items()]
# create polycylinder
axis = referenceframe["aim"]
subdivisionsx = tubesubdivs
subdivisionsy = tubesubdivs
subdivisionsz = tubesubdivs
cylinder = mc.polyCylinder(axis=axis, radius=1, height=1, sx=subdivisionsx, sy=subdivisionsy, sz=subdivisionsz, cuv=3)
return cylinder
def nurbsCurve_reverse(*args):
'''{'path':'Surfaces/EditNURBS/nurbsCurve_reverse( )',
'icon':':/reverse.png',
'usage':"""
#先选择曲线，再选择一个物体，这个命令根据曲线和物体的远近，对这些曲线进行reverse操作
$fun( )"""
}
'''
if len(args):
curvesNode = args[0]
refPos = args[1]
else:
curvesNode = cmds.ls(sl=True, l=True)[:-1]
refPos = cmds.objectCenter(cmds.ls(sl=True, l=True)[-1])
for obj in curvesNode:
try:
startPos = cmds.pointOnCurve(obj, pr=0, ch=False, p=True)
endPos = cmds.pointOnCurve(obj, pr=1, ch=False, p=True)
startLen = math.sqrt(
math.pow(refPos[0] - startPos[0], 2) +
math.pow(refPos[1] - startPos[1], 2) +
math.pow(refPos[2] - startPos[2], 2))
endLen = math.sqrt(
math.pow(refPos[0] - endPos[0], 2) +
math.pow(refPos[1] - endPos[1], 2) +
math.pow(refPos[2] - endPos[2], 2))
if startLen > endLen:
cmds.reverseCurve(obj, ch=False, rpo=True)
print 'Reversed %s' % obj
except:
print obj, " is not nurbscurve!"
def pointMode():
for p in range(1, pointsNumber):
if p == 1:
cmds.spaceLocator(p=cmds.pointOnCurve(curve, pr=0.0, p=True),
n=nameBuilder_locator + str(p))
#joint
cmds.spaceLocator(p=cmds.pointOnCurve(curve, pr=spacing * p, p=True),
n=nameBuilder_locator + str(p))
def createRig(self):
# Create a Cube for test cases
mc.polySphere(name='mySphere')
objCenter = mc.objectCenter('mySphere', l=True)
# Get the bounding box for the selected ojbject
XYZ = mc.xform('mySphere', bb=True, q=True)
rad = XYZ[3] / 2 * self.settings.radius
strltPos = self.settings.lightPos
lightP = 0.0
if strltPos == "High":
lightP = 5.0
elif strltPos == "Low":
lightP = -5.0
else:
lightP = 0.0
# Create a circle to place three point lights
mc.circle(n='curveLights', nr=(0, 1, 0), c=(0, 0, 0), sections=9, radius=rad)
# Create lights in three positions on the curve
loc = mc.pointOnCurve('curveLights', pr=0.0, p=True)
#_item = mc.spotLight(name='FillLight', coneAngle=45)
_item = self.createLight(self.fillLight, "FillLight")
mc.move(loc[0], loc[1]+lightP, loc[2], _item, ls=True)
loc = mc.pointOnCurve('curveLights', pr=3.0, p=True)
#_item = mc.spotLight(name='KeyLight', coneAngle=45)
_item = self.createLight(self.keyLight, "KeyLight")
mc.move(loc[0], loc[1]+lightP, loc[2], _item, ls=True)
loc = mc.pointOnCurve('curveLights', pr=6.0, p=True)
#_item = mc.spotLight(name='RimLight', coneAngle=45)
_item = self.createLight(self.rimLight, "RimLight")
mc.move(loc[0], loc[1]+lightP, loc[2], _item, ls=True)
# Create space locator and aimConstraints
mc.spaceLocator(n='fillLocator', p=(objCenter[0], objCenter[1], objCenter[2]))
mc.aimConstraint('fillLocator', 'FillLight', aimVector=(0.0, 0.0, -1.0))
mc.parent('fillLocator', 'curveLights', relative=True)
mc.spaceLocator(n='keyLocator', p=(objCenter[0], objCenter[1], objCenter[2]))
mc.aimConstraint('keyLocator', 'KeyLight', aimVector=(0.0, 0.0, -1.0))
mc.parent('keyLocator', 'curveLights', relative=True)
mc.spaceLocator(n='rimLocator', p=(objCenter[0], objCenter[1], objCenter[2]))
mc.aimConstraint('rimLocator', 'RimLight', aimVector=(0.0, 0.0, -1.0))
mc.parent('rimLocator', 'curveLights', relative=True)
# Create lights main locator
mc.spaceLocator(n='lightsMainLocator', p=(objCenter[0], objCenter[1], objCenter[2]))
mc.parent('FillLight', 'lightsMainLocator', relative=True)
mc.parent('KeyLight', 'lightsMainLocator', relative=True)
mc.parent('RimLight', 'lightsMainLocator', relative=True)
# Create Main Group for the entire light rig
mc.group('curveLights', 'lightsMainLocator', n='LightRigGroup')
def pointOnCur(self, cur1, cur2):
inStr = raw_input()
f = float(inStr)
pf = 1.0 / f
i = 0.0
while i < 1.0:
cur1_p = cmd.pointOnCurve(cur1, pr=i, p=1, top=1)
cur2_p = cmd.pointOnCurve(cur2, pr=i, p=1, top=1)
cur_p = [(x + y) / 2.0 for x, y in zip(cur1_p, cur2_p)]
self.point.append(cur_p)
i = i + pf
def __makeMesh(self,curva):
scale_0 = self.ui.spin_radius.value()
scale_1 = self.ui.spin_radius_1.value()
scale = self.ui.spin_radius.value()
if (scale_0 >= scale_1):
tempMaior = scale_0
tempMenor = scale_1
else:
tempMaior = scale_1
tempMenor = scale_0
scale_extrude = tempMenor/tempMaior
position = cmds.pointOnCurve(curva, top=True, pr=0, position=True)
tangent = cmds.pointOnCurve(curva, top=True, pr=0, normalizedTangent=True)
angle = cmds.angleBetween(er=True, v1=(0.0, 1.0, 0.0), v2=tangent)
circle = cmds.circle(nr=(0, 1, 0), c=(0, 0, 0), degree=3, sections=16, r = 0.5)
cmds.scale(tempMaior,
tempMaior,
tempMaior,
circle[0])
cmds.move(position[0],
position[1],
position[2],
circle[0])
cmds.rotate(angle[0],
angle[1],
angle[2],
circle[0])
extrude = cmds.extrude(circle[0],
curva,
constructionHistory = True,
range = True,
polygon = 0,
extrudeType = 2,
useComponentPivot = 0,
fixedPath = 0,
useProfileNormal = 1,
rotation = 0,
scale = scale_extrude,
reverseSurfaceIfPathReversed = 1)
poly = cmds.nurbsToPoly(extrude[0], matchNormalDir = True, constructionHistory = False, format = 2, polygonType = 1, uType = 3, uNumber = 1, vType = 3, vNumber = 3)
cmds.delete(circle, extrude[0])
print poly
return poly
def __braid(self):
steps, porcent = self.__voltas()
increment = porcent
eight = self.__makeEight()
list = range(int(steps))
offset = self.ui.spin_offset.value()
offset_normalize = offset/360.0
self.ui.progress_Create.setRange(0,len(list))
scale_0 = self.ui.spin_radius.value()
scale_1 = self.ui.spin_radius_1.value()
if (scale_0 >= scale_1):
scale_maior = scale_0
scale_menor = scale_1
else:
scale_maior = scale_1
scale_menor = scale_0
diference = scale_maior-scale_menor
percent = diference/steps
scale = scale_maior
if (self.ui.btn_reverse.isChecked()):
curva = self.ui.ln_path.text()
cmds.reverseCurve(curva,ch = False, replaceOriginal = True)
for i in list:
self.ui.progress_Create.setValue(i)
self.__next(porcent,eight,scale)
porcent += increment
_pos_A = (i*0.0625)%1.0 + offset_normalize
_pos_B = (i*0.0625+0.333333)%1.0 + offset_normalize
_pos_C = (i*0.0625+0.666666666)%1.0 + offset_normalize
self.__pt_position_A.append(cmds.pointOnCurve( eight[0],top = True, pr= _pos_A, p=True ))
self.__pt_position_B.append(cmds.pointOnCurve( eight[0],top = True, pr= _pos_B, p=True ))
self.__pt_position_C.append(cmds.pointOnCurve( eight[0],top = True, pr= _pos_C, p=True ))
scale -= percent
self.ui.progress_Create.reset()
#cmds.delete(self.__circle[0])
# return self.__pt_position
self.__curve()
cmds.delete(eight[0])
def MakeRailPiece(curve="", height=1.0, width=1.0):
pos = mc.pointOnCurve(curve, pr=0, top=True)
tan = mc.pointOnCurve(curve, pr=0, t=True, top=True)
rot = math.degrees(math.atan2(tan[0], tan[2]))
railPiece = mc.polyPlane(w=width, h=height, sx=1, sy=1)
mc.move(pos[0], pos[1], pos[2])
mc.rotate(90, rot, 0)
mc.select(railPiece[0] + '.f[0]', leftCurve[0])
div = distSleepers * 4
mc.polyExtrudeFacet(railPiece[0] + '.f[0]',
inputCurve=curve,
divisions=div)
mc.delete(railPiece[0], constructionHistory=True)
return railPiece[0]
def getPointOnCurveMatrix(curve, percent, tangentAxis="Y", normalAxis="Z", fakeNormal=None, invert=False): # get the point information pos = cmds.pointOnCurve(curve, ch=False, pr=percent, p=True) tan = cmds.pointOnCurve(curve, ch=False, pr=percent, nt=True) nor = cmds.pointOnCurve(curve, ch=False, pr=percent, nn=True) #not used # convert the point pos to internal unots pos[0] = units.unitsConvertUItoInternal(pos[0]) pos[1] = units.unitsConvertUItoInternal(pos[1]) pos[2] = units.unitsConvertUItoInternal(pos[2]) # normalize the other vectors tan = mathext.normalize(tan) fakeNor = nor if fakeNormal is not None: fakeNor = fakeNormal # creating binormal and normal from bin = mathext.normalize(mathext.cross(tan, fakeNor)) nor = mathext.normalize(mathext.cross(bin, tan)) # creates the new matrix xVec = bin yVec = bin zVec = bin if tangentAxis == "X": xVec = tan elif tangentAxis == "Y": yVec = tan elif tangentAxis == "Z": zVec = tan if normalAxis == "X": xVec = nor elif normalAxis == "Y": yVec = nor elif normalAxis == "Z": zVec = nor mtx = [xVec[0], xVec[1], xVec[2], 0.0, yVec[0], yVec[1], yVec[2], 0.0, zVec[0], zVec[1], zVec[2], 0.0, pos[0], pos[1], pos[2], 1.0] if invert: for i in range(len(mtx)): mtx[i] = -mtx[i] # mtx = [[0 for x in range(4)] for x in range(4)] # mtx[0] = [bin[0], bin[1], bin[2], 0.0] # mtx[1] = [tan[0], tan[1], tan[2], 0.0] # mtx[2] = [nor[0], nor[1], nor[2], 0.0] # mtx[3] = [pos[0], pos[1], pos[2], 1.0] # return the new matrix return mtx
def joint_on_curve_parameter(curve, parameter, name):
position = mc.pointOnCurve(curve, parameter=parameter)
mc.select(clear=True)
joint = mc.joint(name=name)
mc.xform(joint, translation=position, worldSpace=True)
return joint
def extrude(self,caps=True):
""" extrudes a tube along the NURBS curve """
self.curve2 = mc.duplicate(self.origCurve, name=self.origCurve+"_copy")[0]
# select the first CV of the path (curve)
mc.select("%s.cv[0]"%self.curve2,replace=True)
# figure out where to put the circle and which way to point it
circleCenter = mc.xform(q=True,ws=True,t=True)
circleNormal = mc.pointOnCurve(self.curve2, parameter=0, tangent=True)
# create a circle to use for extrusion
circle = mc.circle(radius=self.radius, center=circleCenter, normal=circleNormal)[0]
# extrude!
extrusion = mc.extrude( circle, self.curve2, n="nurbsTubeTrace", extrudeType=2, range=True )[0]
self.traceBits = [extrusion, self.curve2, self.origCurve, circle]
if caps:
# select the first isoparm
mc.select(extrusion+".v[%f]"%cu.findParamAtArcPercent( self.origCurve, 0.0))
# create planar surface
begCap = mc.planarSrf(n="cap1")[0]
# select the last isoparm
mc.select(extrusion+".v[%f]"%cu.findParamAtArcPercent( self.origCurve, 1.0))
# create planar surface
endCap = mc.planarSrf(n="cap2")[0]
mc.setKeyframe( endCap+".visibility", t=self.timeSpan[1]-1, v=0.0 )
mc.setKeyframe( endCap+".visibility", t=self.timeSpan[1], v=1.0 )
# add the caps to the traceBits list
self.traceBits.extend([begCap,endCap])
return extrusion
def createAtParam(curve, param=0.0, objType='locator', name=None):
'''
Create an object at the specified point on a curve.
@param curve: Input nurbs curve curve
@type curve: str
@param param: Curve parameter to create object at.
@type param: str or tuple or list
@param objType: Type of object to create and place along curve
@type objType: str
@param name: New object name
@type name: str or None
'''
# Check Curve
if not glTools.utils.curve.isCurve(curve):
raise Exception('Object "' + curve + '" is not a valid nurbs curve!')
# Check Name
if not name:
name = glTools.utils.stringUtils.stripSuffix(curve) + '_' + objType
# Create Object
obj = mc.createNode(objType)
if not glTools.utils.transform.isTransform(obj):
obj = mc.listRelatives(obj, p=True, pa=True)[0]
obj = mc.rename(obj, name)
# Position Object
pos = mc.pointOnCurve(curve, pr=param)
mc.xform(obj, t=pos, ws=True)
# Return Result
return obj
def processWebIntricacy(curvesForIntricacy):
global nextWebId
pointsPerCurve = webIntricacy + 1
incriment = 1.0 / float(pointsPerCurve)
ns = "Web" + str(nextWebId)
length = len(curvesForIntricacy)
cmds.select(curvesForIntricacy, r=True)
webCurves = determineSelectedCurves()
''' loop through each web marked for extra intricacy and make list of points along those curves '''
pointList = []
for web in webCurves:
distanceAlongLine = 0
for i in range(0, pointsPerCurve):
randomScaler = randomizeMe(2.5, 0.2, False)
pointOnLine = cmds.pointOnCurve(web,
top=True,
pr=distanceAlongLine *
randomScaler,
p=True)
''' ignore first point because it is on the geometry, otherwise append the points from this curve to the pointList '''
if (i != 0):
pointList.append(pointOnLine)
distanceAlongLine = distanceAlongLine + incriment
cmds.rename(web, ns)
''' match points with their closest neighbor to create start/end points '''
pairs = matchIntricacyPoints(pointList)
return pairs
def buildNurbsRibbon(self): if self.guideSpline: guideDeg = cmds.getAttr(self.guideSpline + '.degree' ) guideSpan = cmds.getAttr(self.guideSpline + '.spans' ) oneCurvePoints = [] otherCurvePoints = [] for i in xrange(guideDeg + guideSpan): cvPos = cmds.pointPosition(self.guideSpline + '.cv[' + str(i) + "]", w=True ) newPara = cmds.closestPointOnCurve(self.guideSpline, ip=cvPos, paramU=True) #Find the parameter Value newParaVal = cmds.getAttr(newPara + ".paramU") cmds.delete(newPara) infoNode = cmds.pointOnCurve(self.guideSpline, ch=True, pr=newParaVal) #Now find the Position and tangent! posy = (cmds.getAttr(infoNode + ".position"))[0] # returns the position posy = MVector(posy[0],posy[1],posy[2]) normy = (cmds.getAttr(infoNode + ".tangent"))[0] normy = MVector(normy[0],normy[1],normy[2]) #Use MVector from maya.openMaya normy = normy.normal() vertVect = MVector(0,1,0) sideMove = normy^vertVect #This is the notation for a cross product. Pretty cool. Should be a normal movement sideMove = sideMove.normal() * 0.5 sideMovePos = posy + sideMove otherSideMovePos = posy - sideMove oneCurvePoints.append([sideMovePos[0],sideMovePos[1],sideMovePos[2]]) otherCurvePoints.append([otherSideMovePos[0],otherSideMovePos[1],otherSideMovePos[2]]) oneSideCurve = cmds.curve(editPoint = oneCurvePoints, degree=3) OtherSideCurve = cmds.curve(editPoint = otherCurvePoints, degree=3) self.tempConstructionParts.append(oneSideCurve) self.tempConstructionParts.append(OtherSideCurve) #Now we loft the surface between the two Curves! nameStart = nameBase(self.totalMarkerList[0].getName(), self.searchString, "loc", "nbs") nameStart += "ribbonSurface" self.guideNurbsRibbon = cmds.loft(oneSideCurve, OtherSideCurve, name = nameStart, constructionHistory = True, uniform = True, close = False, autoReverse = True, degree = 3, sectionSpans = 1, range = False, polygon = 0, reverseSurfaceNormals = True) self.guideNurbsRibbon = self.guideNurbsRibbon[0] self.ribbonParts.append(self.guideNurbsRibbon)
def oscillateCurve( curve, start=0.0, end=1.0, freq=1.0, ease=0.5, strength=1.0 ):
""" Oscillates a given curve by moving each vertex in an alternating
direction based on the normal. This process takes place over the
range defined by "start" and "end" as percentages of arc length.
Oscillation eases to full strength as determined by the "ease" and
"strength" arguments. """
if(ease > (end-start)*0.5):
ease = (end-start)*0.5
if(start < end):
CVs = mc.getAttr( curve+".cv[*]" )
newCVs = findCVsInRange(curve, start, end)
for (I,U,L) in newCVs:
interp = (L-start)/(end-start)
osc = sin(freq*interp)
scale = pulse(start+ease, end, ease, L) # ease must be between 0 and 0.5
## Don't use Maya's normalized normal -- it flip flops with curvature so it's not good for oscillating offset
# normal = Vector(mc.pointOnCurve(curve, parameter=cv[1], normalizedNormal=True))
# if(normal.mag() == 0.0):
# print "Getting normal from up x tangent"
normal = Vector(0,1,0)**Vector(mc.pointOnCurve(curve, parameter=U, tangent=True))
normal = normal.norm()
pos = Vector(CVs[I])
pos = pos+normal*scale*strength*osc
CVs[I] = pos.asTuple()
for i,cv in enumerate(CVs):
mc.setAttr(curve+".cv[%d]"%i, cv[0], cv[1], cv[2])
return curve
def createAtParam( curve,
param = 0.0,
objType = 'locator',
name = None ):
'''
Create an object at the specified point on a curve.
@param curve: Input nurbs curve curve
@type curve: str
@param param: Curve parameter to create object at.
@type param: str or tuple or list
@param objType: Type of object to create and place along curve
@type objType: str
@param name: New object name
@type name: str or None
'''
# Check Curve
if not glTools.utils.curve.isCurve(curve):
raise Exception('Object "'+curve+'" is not a valid nurbs curve!')
# Check Name
if not name: name = glTools.utils.stringUtils.stripSuffix(curve)+'_'+objType
# Create Object
obj = mc.createNode(objType)
if not glTools.utils.transform.isTransform(obj):
obj = mc.listRelatives(obj,p=True,pa=True)[0]
obj = mc.rename(obj,name)
# Position Object
pos = mc.pointOnCurve(curve,pr=param)
mc.xform(obj,t=pos,ws=True)
# Return Result
return obj
def _build_fk_chain(self):
"""
Based on defined parameter list, creates joint chain using a curve for position.
:return:
"""
for n, parameter in enumerate(self.parameter_list):
position = mc.pointOnCurve(self.curve, parameter=parameter)
mc.select(clear=True)
joint = mc.joint(radius=self.joint_radius,
name=self.tp_name.build(name=self.module_name,
side=self.module_side,
index=n + 1,
node_type='joint'))
mc.xform(joint, translation=position, worldSpace=True)
self.fk_joint_list.append(joint)
tpu.parent_in_list_order(self.fk_joint_list)
# orient joints
for joint in self.fk_joint_list:
mc.joint(joint,
edit=True,
orientJoint="xyz",
secondaryAxisOrient="yup",
children=True,
zeroScaleOrient=True)
self.module_group_dict['joint'].append(self.fk_joint_list[0])
def buildNurbsRibbon(self):
if self.guideSpline:
guideDeg = cmds.getAttr(self.guideSpline + '.degree')
guideSpan = cmds.getAttr(self.guideSpline + '.spans')
oneCurvePoints = []
otherCurvePoints = []
for i in xrange(guideDeg + guideSpan):
cvPos = cmds.pointPosition(self.guideSpline + '.cv[' + str(i) +
"]",
w=True)
newPara = cmds.closestPointOnCurve(
self.guideSpline, ip=cvPos,
paramU=True) #Find the parameter Value
newParaVal = cmds.getAttr(newPara + ".paramU")
cmds.delete(newPara)
infoNode = cmds.pointOnCurve(
self.guideSpline, ch=True,
pr=newParaVal) #Now find the Position and tangent!
posy = (cmds.getAttr(infoNode +
".position"))[0] # returns the position
posy = MVector(posy[0], posy[1], posy[2])
normy = (cmds.getAttr(infoNode + ".tangent"))[0]
normy = MVector(normy[0], normy[1],
normy[2]) #Use MVector from maya.openMaya
normy = normy.normal()
vertVect = MVector(0, 1, 0)
sideMove = normy ^ vertVect #This is the notation for a cross product. Pretty cool. Should be a normal movement
sideMove = sideMove.normal() * 0.5
sideMovePos = posy + sideMove
otherSideMovePos = posy - sideMove
oneCurvePoints.append(
[sideMovePos[0], sideMovePos[1], sideMovePos[2]])
otherCurvePoints.append([
otherSideMovePos[0], otherSideMovePos[1],
otherSideMovePos[2]
])
oneSideCurve = cmds.curve(editPoint=oneCurvePoints, degree=3)
OtherSideCurve = cmds.curve(editPoint=otherCurvePoints, degree=3)
self.tempConstructionParts.append(oneSideCurve)
self.tempConstructionParts.append(OtherSideCurve)
#Now we loft the surface between the two Curves!
nameStart = nameBase(self.totalMarkerList[0].getName(),
self.searchString, "loc", "nbs")
nameStart += "ribbonSurface"
self.guideNurbsRibbon = cmds.loft(oneSideCurve,
OtherSideCurve,
name=nameStart,
constructionHistory=True,
uniform=True,
close=False,
autoReverse=True,
degree=3,
sectionSpans=1,
range=False,
polygon=0,
reverseSurfaceNormals=True)
self.guideNurbsRibbon = self.guideNurbsRibbon[0]
self.ribbonParts.append(self.guideNurbsRibbon)
def create(curve,objType,objCount=0,parent=False,useDistance=False,minPercent=0.0,maxPercent=1.0,prefix='',suffix=''):
'''
Create objects along a curve
@param curve: Input nurbs curve curve
@type curve: str
@param objType: Type of objects to create and place along curve
@type objType: str
@param objCount: Number of objects to create along curve. If objCount=0, number of edit points will be used.
@type objCount: int
@param parent: Parent each new object to the previously created object. eg. Joint chain
@type parent: bool
@param useDistance: Use distance along curve instead of parametric length for sample distribution
@type useDistance: bool
@param minPercent: Percent along the curve to start placing objects
@type minPercent: float
@param maxPercent: Percent along the curve to stop placing objects
@type maxPercent: float
@param prefix: Name prefix for builder created nodes. If left at default ("") prefix will be derived from curve name.
@type prefix: str
'''
# Check Path
if not glTools.utils.curve.isCurve(curve):
raise Exception('Object "'+curve+'" is not a valid nurbs curve!')
# Check prefix
if not prefix: prefix = glTools.utils.stringUtils.stripSuffix(curve)
# Check suffix
if not suffix: suffix = objType
# Check object count
if not objCount: objCount = mc.getAttr(curve+'.spans') + 1
# Get curve sample points
paramList = glTools.utils.curve.sampleParam(curve,objCount,useDistance,minPercent,maxPercent)
# Create object along curve
objList = []
for i in range(objCount):
# Create object
obj = mc.createNode(objType)
if not glTools.utils.transform.isTransform(obj):
obj = mc.listRelatives(obj,p=True,pa=True)[0]
ind = glTools.utils.stringUtils.stringIndex(i+1)
obj = mc.rename(obj,prefix+ind+'_'+suffix)
# Position object
pos = mc.pointOnCurve(curve,pr=paramList[i])
mc.xform(obj,t=pos,ws=True)
# Parent
if parent and i: obj = mc.parent(obj,objList[-1])[0]
# Append result
objList.append(str(obj))
# Return result
return objList
def expression():
grps = cmds.listRelatives(root,
children=True,
type='transform',
fullPath=True)
random.seed(cmds.currentTime(q=True))
length = cmds.getAttr(root + '.length')
for g in grps:
#print(g)
children = cmds.listRelatives(g,
children=True,
type='transform',
fullPath=True)
lightning = None
for c in children:
if cmds.attributeQuery('isLightning', n=c, ex=True):
lightning = c
if not lightning:
print('lightning not found for %s. something is wrong' % g)
continue
#print(lightning)
lifespan = cmds.getAttr(lightning + '.lifespan')
age = cmds.getAttr(lightning + '.age')
lsrc = cmds.listConnections(g + '.srcLocator')
ldst = cmds.listConnections(g + '.dstLocator')
if age >= lifespan:
lifespan = random.uniform(0, 3)
age = 0
#print(lsrc,ldst)
rpos = random.uniform(0.0, 1.0)
curve = cmds.listConnections(lightning + '.curve')[0]
maxVal = cmds.getAttr(curve + '.maxValue')
spos = cmds.pointOnCurve(curve, pr=rpos * maxVal, p=True)
rlen = random.uniform(0.0, length)
drpos = rpos * maxVal + rlen
if drpos > maxVal:
drpos = maxVal
dpos = cmds.pointOnCurve(curve, pr=drpos, p=True)
cmds.xform(lsrc, translation=spos)
cmds.xform(ldst, translation=dpos)
else:
age += 1
cmds.xform(lsrc, r=True, translation=[0.001, 0.001, 0.001])
cmds.xform(ldst, r=True, translation=[0.001, 0.001, 0.001])
cmds.setAttr(lightning + '.age', age)
cmds.setAttr(lightning + '.lifespan', lifespan)
def getPosCurvePoint(curve, pCurve):
"""Get the position of a point on the curve
pCurve is the parameter of the curve
"""
infoNode = cmds.pointOnCurve(curve, ch=True, pr=pCurve)
pPos = np.array(cmds.getAttr(infoNode + ".position")[0]) # returns the position
return pPos
def getAngleCurvePoint(curve, pCurve):
"""Get the tangent angle of a point on the curve
pCurve is the parameter of the curve
"""
infoNode = cmds.pointOnCurve(curve, ch=True, pr=pCurve)
tang = list(cmds.getAttr(infoNode + ".normalizedTangent")[0]) # returns the tangent vector
xzAngle = getAngle(tang)
return xzAngle
def __next(self, porcentagem, circle):
position = cmds.pointOnCurve(self.ui.ln_path.text(),
top=True,
pr=porcentagem,
position=True)
tangent = cmds.pointOnCurve(self.ui.ln_path.text(),
top=True,
pr=porcentagem,
tangent=True)
angle = cmds.angleBetween(er=True, v1=(0.0, 1.0, 0.0), v2=tangent)
cmds.scale((self.ui.spin_radius.value() * random.uniform(
(1 - self.ui.spin_random.value()), 1.0)),
(self.ui.spin_radius.value() * random.uniform(
(1 - self.ui.spin_random.value()), 1.0)),
(self.ui.spin_radius.value() * random.uniform(
(1 - self.ui.spin_random.value()), 1.0)), circle[0])
cmds.move(position[0], position[1], position[2], circle[0])
cmds.rotate(angle[0], angle[1], angle[2], circle[0])
def getTanCurvePoint(curve, pCurve):
"""Get the noramlised tangent vector of a point on the curve
pCurve is the parameter of the curve
"""
# infoNode = cmds.pointOnCurve(curve, ch=True, pr=pCurve, nt=True)
# tan = list(cmds.getAttr(infoNode + ".normalizedTangent")[0]) # returns the tangent vector
tan = np.array(cmds.pointOnCurve(curve, pr=pCurve, nt=True))
ntan = np.linalg.norm(tan)
return tan/ntan
def ok(self, obj, *args):
n = cmds.intSlider(obj, value=True, query=True) #Query slider
z = cmds.ls(selection=True) #Line Selection
for i in range(0, n): #From i to N
x = cmds.pointOnCurve(z,
pr=float(i) / float(n),
turnOnPercentage=True)
y = cmds.duplicate(self.f) #place Group
cmds.move(x[0], x[1], x[2], y[0],
absolute=True) #Move Group to point
def orientToCurve(curve,
obj,
uValue=0.0,
useClosestPoint=False,
upVector=(0, 1, 0),
tangentAxis='x',
upAxis='y'):
'''
Orient object to a specified point on a curve.
@param curve: Curve to orient object to
@type curve: str
@param obj: Object to orient
@type obj: str
@param uValue: Paramater value of the curve to orient to
@type uValue: float
@param useClosestPoint: Use the closest point on the curve instead of the specified uv parameter
@type useClosestPoint: bool
@param upVector: upVector needed to calculate rotation matrix
@type upVector: tuple
@param tangentAxis: Basis axis that will be derived from the tangent of the curve point
@type tangentAxis: str
@param upAxis: Basis axis that will be derived from the upVector
@type upAxis: str
'''
# Check curve
if not isCurve(curve):
raise Exception('Object ' + curve + ' is not a valid curve!!')
# Check uValue
minu = mc.getAttr(curve + '.minValue')
maxu = mc.getAttr(curve + '.maxValue')
# Closest Point
if useClosestPoint:
pos = mc.xform(obj, q=True, ws=True, rp=True)
uValue = closestPoint(curve, pos)
# Verify surface parameter
if uValue < minu or uValue > maxu:
raise Exception('U paramater ' + str(uValue) +
' is not within the parameter range for ' + curve +
'!!')
# Check object
if not mc.objExists(obj):
raise Exception('Object ' + obj + ' does not exist!!')
rotateOrder = mc.getAttr(obj + '.ro')
# Get tangent at curve point
tan = mc.pointOnCurve(curve, pr=uValue, nt=True)
# Build rotation matrix
mat = glTools.utils.matrix.buildRotation(tan, upVector, tangentAxis,
upAxis)
rot = glTools.utils.matrix.getRotation(mat, rotateOrder)
# Orient object to curve
mc.rotate(rot[0], rot[1], rot[2], obj, a=True, ws=True)
def getCurvatureCurvePoint(curve, pCurve):
"""Get the curvature of a point on the curve
pCurve is the parameter of the curve
"""
infoNode = cmds.pointOnCurve(curve, ch=True, pr=pCurve)
radius = np.array(cmds.getAttr(infoNode + ".curvatureRadius")) # returns the curvature
if radius == 0:
return 0
else:
return 1/radius
def __next(self, porcentagem,eight,scale):
#print porcentagem
curva = self.ui.ln_path.text()
position = cmds.pointOnCurve(curva, top=True, pr=porcentagem, position=True)
tangent = cmds.pointOnCurve(curva, top=True, pr=porcentagem, tangent=True)
angle = cmds.angleBetween(er=True, v1=(0.0, 1.0, 0.0), v2=tangent)
cmds.scale((scale * random.uniform((1-self.ui.spin_random.value()), 1.0)),
(scale * random.uniform((1-self.ui.spin_random.value()), 1.0)),
(scale * random.uniform((1-self.ui.spin_random.value()), 1.0)),
eight[0])
cmds.move(position[0],
position[1],
position[2],
eight[0])
cmds.rotate(angle[0],
angle[1],
angle[2],
eight[0])
def duplicateAlongCurve(density):
selection = cmds.ls(sl=True)
if len(selection)!=2:
print("Please select the object, then the curve")
return
obj=selection[0]
myCurve=selection[1]
#print selection[0]
infoNode = cmds.pointOnCurve(myCurve, ch=True, pr=0.0)
#pos = cmds.getAttr(infoNode + ".position")
#cmds.move(pos[0][0], pos[0][1], pos[0][2], 'pPlane1', absolute=True)
cmds.connectAttr( infoNode+'.position', 'pPlane1.translate')
step = 0.1
min = cmds.getAttr(myCurve+'.minValue')
max = cmds.getAttr(myCurve+'.maxValue')
for i in fRange(min+step, max, density):
cmds.select(obj)
infoNode = cmds.pointOnCurve(myCurve, ch=True, pr=i)
dup = cmds.duplicate();
cmds.connectAttr( infoNode+'.position', dup[0]+'.translate')
def polyAttach(sel):
edgeInfo=mc.polyInfo(sel,ve=1)[0]
edge=sel.split('.')[0]+'.e[%s]'%(edgeInfo.split()[3])
parameter=2
if sel.find(mc.polyInfo(edge,ev=1)[0].split()[2])!=-1:
parameter=1
curveInfo=mc.pointOnCurve(edge,ch=1,pr=parameter,p=1)
attachLoc=mc.spaceLocator(n=sel.split('.')[0]+'_Loc#')[0]
mc.connectAttr(curveInfo+'.position',attachLoc+'.t')
normalCstrt=mc.normalConstraint(sel.split('.')[0],attachLoc,weight=1,aimVector=[0,0,1],upVector=[1,0,0],worldUpType='vector',worldUpVector=[1,0,0])[0]
mc.connectAttr(curveInfo+'.tangent',normalCstrt+'.worldUpVector')
return attachLoc
def creatPointOnCurve(self, curve, nodeName):
print "im in creatPointOnCurve"
cmds.undoInfo(openChunk=True)
print "poc"
try:
poc = cmds.pointOnCurve(curve, ch=True)
poc = cmds.rename(poc, nodeName)
cmds.setAttr(poc + ".turnOnPercentage", 1)
print poc
return poc
except Exception as e:
print 'creatPointOnCurve something wrong...'
cmds.undoInfo(closeChunk=True)
def fromRefCurve(curve,refCurve,rebuildToRef=True): ''' ''' # Get start and end reference points stRef = mc.pointOnCurve(refCurve,top=True,pr=0.0,p=True) enRef = mc.pointOnCurve(refCurve,top=True,pr=1.0,p=True) # Get boundary parameters stParam = glTools.utils.curve.closestPoint(curve,stRef) enParam = glTools.utils.curve.closestPoint(curve,enRef) # SubCurve subCurve = mc.detachCurve(curve,p=[stParam,enParam],replaceOriginal=False,ch=False) mc.delete(subCurve[0],subCurve[2]) subCurve = mc.rename(subCurve[1],curve+'_subCurve') if rebuildToRef: degree = mc.getAttr(refCurve+'.degree') spans = mc.getAttr(refCurve+'.spans') mc.rebuildCurve(subCurve,ch=0,rpo=1,rt=0,end=1,kr=0,kcp=0,kep=1,kt=0,s=spans,d=degree,tol=0) # Return result return subCurve
def getPercentOfCurvePoint(curve, curvePoint, curveSteps=1000, tolerance=0.01): percentage = None for i in range(curveSteps + 1): currPercent = (1.0/curveSteps)*i currPoint = cmds.pointOnCurve(curve, ch=False, pr=currPercent, p=True) dist = abs(sqrt((curvePoint[0]-currPoint[0])^2 + (curvePoint[1]-currPoint[1])^2 + (curvePoint[2]-currPoint[2])^2)) if dist <= tolerance: percentage = currPercent break return percentage
def fromRefCurve(curve, refCurve, rebuildToRef=True):
"""
"""
# Get start and end reference points
stRef = cmds.pointOnCurve(refCurve, top=True, pr=0.0, p=True)
enRef = cmds.pointOnCurve(refCurve, top=True, pr=1.0, p=True)
# Get boundary parameters
stParam = glTools.utils.curve.closestPoint(curve, stRef)
enParam = glTools.utils.curve.closestPoint(curve, enRef)
# SubCurve
subCurve = cmds.detachCurve(curve,
p=[stParam, enParam],
replaceOriginal=False,
ch=False)
cmds.delete(subCurve[0], subCurve[2])
subCurve = cmds.rename(subCurve[1], curve + '_subCurve')
if rebuildToRef:
degree = cmds.getAttr(refCurve + '.degree')
spans = cmds.getAttr(refCurve + '.spans')
cmds.rebuildCurve(subCurve,
ch=0,
rpo=1,
rt=0,
end=1,
kr=0,
kcp=0,
kep=1,
kt=0,
s=spans,
d=degree,
tol=0)
# Return result
return subCurve
def eqDistanceCurveDivide(curvename, segmentcurveLength):
uValeStart = 0.0
curveLength = mc.arclen(curvename)
kk = (int(curveLength / segmentcurveLength))
intCL = int(curveLength)
accur = 100 * intCL
uVale = 1.0 / accur
for t in range(kk):
for i in range(accur):
pointA = mc.pointOnCurve(curvename,
top=True,
pr=uValeStart,
p=True)
vecA = om.MVector(pointA[0], pointA[1], pointA[2])
pointB = mc.pointOnCurve(curvename, top=True, pr=uVale, p=True)
vecB = om.MVector(pointB[0], pointB[1], pointB[2])
vecC = om.MVector()
vecC = (vecB - vecA)
distance = vecC.length()
if distance < segmentcurveLength:
uVale += 1.0 / accur
else:
uValeStart = uVale
break
mc.spaceLocator(p=(pointB[0], pointB[1], pointB[2]))
if uValeStart >= 0.99:
break
def movePivot(side, *args):
check = False
sel = cmds.ls(sl=True, exactType="transform")
if sel:
for x in sel:
check = curveCheck(x)
if check:
# get curve info
pos = cmds.pointOnCurve(x, parameter=side, position=True)
cmds.xform(x, ws=True, rp=pos)
else:
cmds.warning(
"{} is not a nurbsCurve object. Skipping!".format(x))
def getNormalizedTangent(crv):
"""
gets normalized tan of selected cv
"""
cvs = cmds.ls("{0}.cv[*]".format(crv), fl=True)
denom = len(cvs)
sel = cmds.ls(sl=True, fl=True)[0]
num = float(sel.partition("[")[2].rpartition("]")[0])
pr = num / denom
tan = cmds.pointOnCurve(crv, pr=pr, nt=True)
return tan
def getNormalizedTangent(pt = ""):
"""
gets normalized tan of selected (or given) list of cvs
"""
if cmds.objectType(pt) != "nurbsCurve":
return
crv = pt.partition(".")[0]
print pt, crv
cvs = cmds.ls("{0}.cv[*]".format(crv), fl=True)
denom = len(cvs)
num = float(pt.partition("[")[2].rpartition("]")[0])
pr = num/denom
tan = cmds.pointOnCurve(crv, pr=pr, nt=True)
return(tan)
def curve_to_joint(spans, *args):
'''main function to create joint chain from NurbsCurve'''
try:
objlist = cmds.ls(sl=True)
curve = objlist[0]
#cmds.objectType(curve, isType='nurbsCurve')):
d_curve = cmds.duplicate()
if not isinstance(spans, int):
spans = int(cmds.intField(spans, q=True, v=True))
print "span is " + str(spans)
cmds.rebuildCurve(d_curve, rt=0, kr=2, s=spans - 1)
for i in range(spans):
position = cmds.pointOnCurve(d_curve, pr=i, p=True)
cmds.joint(p=position)
cmds.delete(d_curve)
except:
print "No curve Selected"
def getCHNormAtT(chI, chJ, tparam):
global csNum
global cs
global chNum
global ch
origN = ch[chI][chJ].nor
origT1 = ch[chI][chJ].tan
origT2 = ch[chJ][chI].tan
targetT = cmds.pointOnCurve(cs[chI].name, pr=tparam, nt=True) # z comp incorrect
targetT[2] = -(origT2[0]*targetT[0]+origT2[1]*targetT[1])/origT2[2] # solve t_z, t2 dot t = 0
crossProd = np.cross(origT1, targetT)
axis = normalize(crossProd)
angle = np.arcsin( np.linalg.norm(crossProd) / (np.linalg.norm(origT1)*np.linalg.norm(targetT)) )
rot = rotation(angle,axis)
return normalize(np.dot(rot, origN))
def orientToCurve(curve,obj,uValue=0.0,useClosestPoint=False,upVector=(0,1,0),tangentAxis='x',upAxis='y'):
'''
Orient object to a specified point on a curve.
@param curve: Curve to orient object to
@type curve: str
@param obj: Object to orient
@type obj: str
@param uValue: Paramater value of the curve to orient to
@type uValue: float
@param useClosestPoint: Use the closest point on the curve instead of the specified uv parameter
@type useClosestPoint: bool
@param upVector: upVector needed to calculate rotation matrix
@type upVector: tuple
@param tangentAxis: Basis axis that will be derived from the tangent of the curve point
@type tangentAxis: str
@param upAxis: Basis axis that will be derived from the upVector
@type upAxis: str
'''
# Check curve
if not isCurve(curve): raise Exception('Object '+curve+' is not a valid curve!!')
# Check uValue
minu = mc.getAttr(curve+'.minValue')
maxu = mc.getAttr(curve+'.maxValue')
# Closest Point
if useClosestPoint:
pos = mc.xform(obj,q=True,ws=True,rp=True)
uValue = closestPoint(curve,pos)
# Verify surface parameter
if uValue < minu or uValue > maxu:
raise Exception('U paramater '+str(uValue)+' is not within the parameter range for '+curve+'!!')
# Check object
if not mc.objExists(obj): raise Exception('Object '+obj+' does not exist!!')
rotateOrder = mc.getAttr(obj+'.ro')
# Get tangent at curve point
tan = mc.pointOnCurve(curve,pr=uValue,nt=True)
# Build rotation matrix
mat = glTools.utils.matrix.buildRotation(tan,upVector,tangentAxis,upAxis)
rot = glTools.utils.matrix.getRotation(mat,rotateOrder)
# Orient object to curve
mc.rotate(rot[0],rot[1],rot[2],obj,a=True,ws=True)
def move_pivot(end, *args):
"""
Args:
end (int): parameter value (0 or 1 from buttons) the point on curve will return, start or end
*args:
"""
check = False
sel = cmds.ls(sl=True, exactType = "transform")
if sel:
for x in sel:
check = rig.isType(x, "nurbsCurve")
if check:
# get curve info
pos = cmds.pointOnCurve(x, parameter = end, position = True)
cmds.xform(x, ws=True, piv=pos)
else:
cmds.warning("{0} is not a nurbsCurve object. Skipping!".format(x))
def AlignVer(verts, crv, axes=[False, False, False]):
numPositions = len(verts) - 1
for i in range(len(verts)):
#top=turnOnPercentage
coord = cmds.pointOnCurve(crv,
top=True,
pr=float(i) / float(numPositions))
print(coord[1])
print(cmds.pointPosition(verts[i], w=True))
cmds.move(coord[0],
coord[1],
coord[2],
verts[i],
absolute=True,
x=axes[0],
y=axes[1],
z=axes[2],
worldSpace=True)
print(cmds.pointPosition(verts[i], w=True))
def __orientControl(self, offset):
# get position
pos = cmds.xform(offset, q=True, ws=True, t=True)
# get closest parameter on curve
parameter, _ = curve.nearestPointOnCurve(self.curveShape, pos)
# get tangent
forward = cmds.pointOnCurve(self.curveShape,
pr=parameter,
normalizedTangent=True)
# get up
forward = OpenMaya.MVector(*forward)
up = OpenMaya.MVector(*self.upVector)
right = up ^ forward
right.normalize()
up = right ^ forward
up.normalize()
orient = up * OpenMaya.MVector(*self.upVector)
if orient <= 0:
up = up * -1
# construct quaternion
quaternion = math.lookRotation(up, forward)
# convert to euler
euler = quaternion.asEulerRotation()
rot = [
math.degrees(euler.x),
math.degrees(euler.y),
math.degrees(euler.z),
]
# set euler
cmds.xform(offset, ws=True, ro=rot)
def postPositions(self):
oldPost = None
XZ = 0, 0
for num in range(self.postNum):
pos = cmds.pointOnCurve(FindPositions.nurbsCurve,
p=True,
pr=float(num) /
(float(self.postNum) / float(self.points)))
post = cmds.duplicate(FindPositions.post)
cmds.move(pos[0], pos[1], pos[2], post)
if num > 0:
yRot = findYRot(XZ, (pos[0], pos[2]))
cmds.rotate(0, yRot, 0, oldPost, relative=True)
if num != self.postNum:
crossBeams = CrossBeams().addBeams(
width=distance(XZ[0], pos[0], XZ[1], pos[2]))
pickets = Pickets().create(
totalSpace=(distance(XZ[0], pos[0], XZ[1], pos[2]) -
findWidth(FindPositions.post)))
cmds.move(XZ[0], 0, XZ[1], crossBeams)
cmds.rotate(0,
yRot,
0,
crossBeams,
relative=True,
p=[XZ[0], 0, XZ[1]])
cmds.move(XZ[0], 0, XZ[1], pickets)
cmds.rotate(0,
yRot,
0,
pickets,
relative=True,
p=[XZ[0], 0, XZ[1]])
oldPost = post
XZ = pos[0], pos[2]
def noiseCurve( curve, start=0.0, end=1.0, freq=1.0, ease=0.5, strength=1.0 ):
""" Adds noise to a given curve by moving each vertex with Perlin
noise based on the normal. This process takes place over the
range defined by "start" and "end" as percentages of arc length.
Noise eases to full strength as determined by the "ease" and
"strength" arguments. """
if(ease > (end-start)*0.5): # ease must be between 0 and 0.5
ease = (end-start)*0.5
if(start < end):
CVs = mc.getAttr( curve+".cv[*]" )
newCVs = findCVsInRange(curve, start, end)
for (I,U,L) in newCVs:
interp = (L-start)/(end-start)
noiz = noise(freq*interp)
scale = pulse(start+ease, end, ease, L)
normal = Vector(0,1,0)**Vector(mc.pointOnCurve(curve, parameter=U, tangent=True))
normal = normal.norm()
pos = Vector(CVs[I])
pos = pos+normal*scale*strength*noiz
CVs[I] = pos.asTuple()
for i,cv in enumerate(CVs):
print(curve+".cv[%d]"%cv[0], cv[0], cv[1], cv[2])
mc.setAttr(curve+".cv[%d]"%i, cv[0], cv[1], cv[2])
def neighbour(vertexList,referenceObject,meshRelax):
'''
'''
# Get meshRelax object and target plug
sel = OpenMaya.MSelectionList()
OpenMaya.MGlobal.getSelectionListByName(meshRelax,sel)
meshRelaxObj = OpenMaya.MObject()
sel.getDependNode(0,meshRelaxObj)
meshRelaxNode = OpenMaya.MFnDependencyNode(meshRelaxObj)
neighbourDataPlug = meshRelaxNode.findPlug('neighbourData')
neighbourDataArrayPlug = neighbourDataPlug.elementByLogicalIndex(0)
# Check reference object
isCurve = True
if not glTools.utils.curve.isCurve(referenceObject):
isCurve = False
elif not glTools.utils.curve.isSurface(referenceObject):
raise UserInputError('Reference object must be a valid nurbs curve or surface!!')
# Create neighbourData object
neighbourData = OpenMaya.MVectorArray()
# Get mesh and vertex list
compUtil = glTools.common.componentUtilities.ComponentUtilities()
mesh = compUtil.getComponentIndexList(vertexList).keys()[0]
# Get vertexIterator for mesh
sel = OpenMaya.MSelectionList()
OpenMaya.MGlobal.getSelectionListByName(mesh,sel)
meshObj = OpenMaya.MObject()
sel.getDependNode(0,meshObj)
meshIt = OpenMaya.MItMeshVertex(meshObj)
# Get neighbour data
for i in range(len(vertexList)):
# Get current point
pnt = mc.pointPosition(vertexList[i])
pntId = compUtil.getComponentIndexList([vertexList[i]])[mesh][0]
# Get closest U tangent
if isCurve:
u = glTools.utils.curve.closestPoint(referenceObject,pnt)
tan = mc.pointOnCurve(referenceObject,pr=u,nt=True)
else:
uv = glTools.utils.surface.closestPoint(referenceObject,pnt)
tan = mc.pointOnSurface(referenceObject,u=uv[0],v=uv[1],ntu=True)
tangent = OpenMaya.MVector(tan[0],tan[1],tan[2])
# Get neighbouring points
n1 = mc.pickWalk(vertexList[i],d='up')[0]
n1Id = compUtil.getComponentIndexList([n1])[mesh][0]
n1Pt = mc.pointPosition(n1)
n1Dist = glTools.utils.mathUtils.distanceBetween(pnt,n1Pt)
n2 = mc.pickWalk(vertexList[i],d='down')[0]
n2Id = compUtil.getComponentIndexList([n2])[mesh][0]
n2Pt = mc.pointPosition(n2)
n2Dist = glTools.utils.mathUtils.distanceBetween(pnt,n2Pt)
# Build neighbour data vector
tDist = n1Dist + n2Dist
neighbourData.append(OpenMaya.MVector(float(pntId),n1Id+(n1Dist/tDist),n2Id+(n2Dist/tDist)))
# Set value
neighbourDataArrayPlug.setMObject(OpenMaya.MFnVectorArrayData().create(neighbourData))
import maya.cmds as mc
import math
wid = 2
dist = 0.1
hig = 1
crv = "curve1"
for i in range(0, 20):
dist = 0 + 0.01 * (i % 2)
while dist < 1:
tan = mc.pointOnCurve(crv, t=1, top=1, pr=dist)
mag = math.sqrt(tan[0] * tan[0] + tan[1] * tan[1] + tan[2] * tan[2])
rot = math.atan2(tan[0], tan[2])
p = mc.pointOnCurve(crv, top=1, pr=dist)
#print(p)
c = mc.polyCube(w=wid, h=hig)
mc.rotate(0, math.degrees(rot) + 90, 0)
mc.move(p[0], i * 1.05 + p[1], p[2])
dist = dist + 0.3 / mag
def create( path,
objectType,
num=0,
parent=False,
useDist=False,
min=0.0,
max=1.0,
prefix='' ):
'''
Create objects along a curve
# INPUTS:
@input path: Input nurbs curve path
@inputType path: str
@input objectType: Type of objects to create and place along path
@inputType objectType: str
@input num: Number of objects to create along path. If num=0, number of edit points will be used.
@inputType num: int
@input parent: Parent each new object to the previously created object. eg. Joint chain
@inputType parent: bool
@input useDist: Use distance along curve instead of parametric length for sample distribution
@inputType useDist: bool
@input min: Percent along the path to start placing objects
@inputType min: float
@input max: Percent along the path to stop placing objects
@inputType max: float
@input prefix: Name prefix for builder created nodes. If left at default ("") prefix will be derived from path name.
@inputType prefix: str
# OUTPUTS:
@output outObjectList: List of objects placed along path
@outputType outObjectList: list
'''
# Check Path
if not glTools.utils.curve.isCurve(path):
raise Exception('Path object '+path+' is not a valid nurbs curve!')
# Check prefix
if not prefix: prefix = glTools.utils.stringUtils.stripSuffix(path)
# Check object count
if not num: num = mc.getAttr(path+'.spans') + 1
# Get curve sample points
paramList = glTools.utils.curve.sampleParam(path,num,useDist,min,max)
# Create object along path
objList = []
for i in range(num):
# Get string index
ind = glTools.utils.stringUtils.stringIndex(i+1)
# Create object
obj = mc.createNode(objectType,n=prefix+ind+'_'+objectType)
if not glTools.utils.base.isTransform(obj): obj = mc.listRelatives(obj,p=True,pa=True)[0]
# Position
pos = mc.pointOnCurve(path,pr=paramList[i])
mc.xform(obj,t=pos,ws=True)
# Parent
if parent and i: obj = mc.parent(obj,objList[-1])[0]
# Orient Joint
if objectType == 'joint' and i: mc.joint(objList[-1],e=True,zso=True,oj='xyz',sao='yup')
# Append result
objList.append( str(obj) )
# Return result
return objList
def Rig(nameSpace):
# - get guides -
guides = ["%s:link_start_gui" % nameSpace, "%s:link_end_gui" % nameSpace, "%s:link_up_gui" % nameSpace]
# - make curve -
pathCurve = buildeCurve(guides[0], guides[1])
# - make up curve -
upvectorCurve = buidleUpCurve(*guides)
# - make Joints and locators-
Joints = []
locators = []
multiNodes = []
counts = mc.getAttr("%s.jointCount" % guides[0])
for i in range(counts):
# - 1 create
Joints.append(mc.createNode("joint"))
locators.append(mc.spaceLocator(p=(0, 0, 0))[0])
# - 2
parameter = (((float(i + 1) - 0) / (counts + 1 - 0)) * (1 - 0)) + 0
# - 3 attact to curve
multiNodes.append(attachToCurve(Joints[-1], pathCurve, parameter))
attachToCurve(locators[-1], upvectorCurve, parameter)
# - 4 connect object up
addUpObject(Joints[-1], locators[-1])
# - add rig Joins -
rigJoints = []
for i in range(4):
rigJoints.append(mc.createNode("joint"))
# - move
position = mc.pointOnCurve(pathCurve, pr=1.0 / 3 * i)
mc.move(position[0], position[1], position[2], rigJoints[-1], a=True)
# - orient
mc.delete(mc.orientConstraint(Joints[0], rigJoints[-1]))
# - bind Curve
mc.skinCluster(rigJoints, pathCurve)
mc.skinCluster(rigJoints, upvectorCurve)
# - rig rigJoints -
controlLst = []
for jnt in rigJoints:
# - make control
controls = [mc.createNode("transform") for i in range(4)]
for i in range(len(controls) - 1):
mc.parent(controls[i], controls[i + 1])
controlLst.append(controls)
# - match positions, parent Joint
mc.delete(mc.parentConstraint(jnt, controls[-1]))
mc.parent(jnt, controls[0])
# -add Shape
circle = mc.circle(nr=(1, 0, 0), ch=0)
mc.parent(mc.listRelatives(circle, s=True, path=True), controls[0], r=True, s=True)
mc.delete(circle)
# - Constraint control
appLocators = []
for controls in controlLst:
appLocators.append(mc.spaceLocator(p=(0, 0, 0))[0])
mc.delete(mc.parentConstraint(controls[0], appLocators[-1]))
mc.parentConstraint(appLocators[-1], controls[-2])
mc.scaleConstraint(appLocators[-1], controls[-2])
# - add def
mc.addAttr(appLocators[-1], sn="IKFKSwitch", min=0, max=1, dv=0, k=True)
mc.addAttr(appLocators[-1], sn="fkRotate", dv=0, k=True)
mc.addAttr(appLocators[-1], sn="ikRotate", dv=0, k=True)
blendNode = mc.createNode("blendTwoAttr")
mc.connectAttr("%s.IKFKSwitch" % appLocators[-1], "%s.ab" % blendNode)
mc.connectAttr("%s.fkRotate" % appLocators[-1], "%s.input[0]" % blendNode)
mc.connectAttr("%s.ikRotate" % appLocators[-1], "%s.input[1]" % blendNode)
for md in multiNodes:
mc.connectAttr("%s.output" % blendNode, "%s.input1" % md)
# -- comp hery --
curveGrp = mc.group(pathCurve, upvectorCurve)
jointGrp = mc.group(Joints)
locatorGrp = mc.group(locators)
controlGrp = mc.group([L[-1] for L in controlLst])
RootGrp = mc.group(curveGrp, jointGrp, locatorGrp, controlGrp)
# -- clean scene --
mc.hide(curveGrp, locatorGrp, rigJoints)
# -* rename *-
# - groups -
curveGrp = mc.rename(curveGrp, "%s_cusg_0" % nameSpace)
jointGrp = mc.rename(jointGrp, "%s_jntg_0" % nameSpace)
locatorGrp = mc.rename(locatorGrp, "%s_locg_0" % nameSpace)
controlGrp = mc.rename(controlGrp, "%s_ctlg_0" % nameSpace)
RootGrp = mc.rename(RootGrp, "%s_setg_0" % nameSpace)
# - joints -
for i, jnt in enumerate(Joints):
Joints[i] = mc.rename(jnt, "%s_bnd%s_0" % (nameSpace, string.uppercase[i]))
# - locators -
for i, loc in enumerate(locators):
locators[i] = mc.rename(loc, "%s_loc%s_0" % (nameSpace, string.uppercase[i]))
# - aooLocators -
for i, loc in enumerate(appLocators):
appLocators[i] = mc.rename(loc, "%s_apploc%s_0" % (nameSpace, string.uppercase[i]))
# - rig Joints -
for i, jnt in enumerate(rigJoints):
rigJoints[i] = mc.rename(jnt, "%s_ctj%s_0" % (nameSpace, string.uppercase[i]))
# - control -
ctlType = ("ctl", "ctu", "cth", "ctg")
for i, ctls in enumerate(controlLst):
for d, ctl in enumerate(ctls):
controlLst[i][d] = mc.rename(ctl, "%s%s_%s_0" % (nameSpace, string.uppercase[i], ctlType[d]))
# - curve -
pathCurve = mc.rename(pathCurve, "%s_TWbaseCus_0" % nameSpace)
upvectorCurve = mc.rename(upvectorCurve, "%s_TWupperCus_0" % nameSpace)
for lx_i in lx_eyeLidPtion :
lx_endPtion = mc.xform (lx_i,q=True ,ws=True ,t=True );
lx_sj = mc.joint (p=(lx_cption[0],lx_cption[1],lx_cption[2]));
lx_ee = mc.joint (p=(lx_endPtion [0],lx_endPtion [1],lx_endPtion [2],));
mc.ikHandle (sj =lx_sj,ee = lx_ee ,sol ="ikSCsolver" );
mc.select (cl=1);
import maya.cmds as mc
lx_curve = mc.ls(sl=1);
import maya.cmds as mc
lx_jnt = mc.ls(sl=1);
lx_node=[];
for lx_temp in lx_jnt :
nd=mc.pointOnCurve (lx_curve,ch=True );
lx_node.insert(1,nd);
mc.rename(nd,"cueNd_"+lx_temp);
mc.group(empty=1,n=("nl_"+lx_temp));
mc.connectAttr(("cueNd_"+lx_temp +".position"),("nl_"+lx_temp+".translate"));
mc.toggle (("nl_"+lx_temp),localAxis=1);
import maya.cmds as mc
infoNd = mc.ls(sl=1)
mc.select(cl=1)
for i in infoNd:
mc.print(i)
grp = mc.group(em =1)
def curveIntersectJoints(curve,
intersectCurveList,
jointAtBase=True,
jointAtTip=True,
useDirection=False,
intersectDirection=(0, 0, 1),
prefix=''):
"""
Create joints along a curve at the points of intersection with a list of secondary curves
@param curve: Curve to create joints along
@type curve: list
@param intersectCurveList: List of intersection curves
@type intersectCurveList: list
@param jointAtBase: Create a joint at the base of the curve
@type jointAtBase: bool
@param jointAtTip: Create a joint at the tip of the curve
@type jointAtTip: bool
@param useDirection: Project the curves in a specified direction before intersecting
@type useDirection: bool
@param intersectDirection: The direction to project the curves before intersecting
@type intersectDirection: tuple or list
@param prefix: Name prefix for newly created nodes
@type prefix: str
"""
# Check curve
if not cmds.objExists(curve):
raise Exception('Curve object ' + curve + ' does not exist!')
# Check intersect curve list
for i in range(len(intersectCurveList)):
if not cmds.objExists(intersectCurveList[i]):
raise Exception('Object ' + intersectCurveList[i] + ' is not a valid curve!')
# Check prefix
if not prefix: prefix = glTools.utils.stringUtils.stripSuffix(curve)
# Get curve Range
minU = cmds.getAttr(curve + '.minValue')
maxU = cmds.getAttr(curve + '.maxValue')
# Initialize return list
cmds.select(cl=True)
jointList = []
# Create Base Joint
if jointAtBase:
# Get curve point position
pos = cmds.pointOnCurve(curve, pr=minU, p=True)
# Create joint
ind = '01'
jnt = prefix + nameUtil.delineator + nameUtil.subPart['joint'] + ind + nameUtil.delineator + nameUtil.node[
'joint']
jnt = cmds.joint(p=pos, n=jnt)
jointList.append(jnt)
# Create joints at curve intersections
for n in range(len(intersectCurveList)):
# Get string index
ind = str(n + 1 + int(jointAtBase))
if i < (9 - int(jointAtBase)): ind = '0' + ind
# Get curve intersections
uList = cmds.curveIntersect(curve, intersectCurveList[n], ud=useDirection, d=intersectDirection)
if not uList: continue
uList = uList.split(' ')
# Create joints
for u in range(len(uList) / 2):
# Get curve point position
pos = cmds.pointOnCurve(curve, pr=float(uList[u * 2]), p=True)
# Create joint
jnt = prefix + nameUtil.delineator + nameUtil.subPart['joint'] + ind + nameUtil.delineator + nameUtil.node[
'joint']
jnt = cmds.joint(p=pos, n=jnt)
jointList.append(jnt)
# Create Tip Joint
if jointAtTip:
# Get string index
ind = str(len(intersectCurveList) + int(jointAtBase) + 1)
if len(intersectCurveList) < (9 - int(jointAtBase)): ind = '0' + ind
# Get curve point position
pos = cmds.pointOnCurve(curve, pr=maxU, p=True)
# Create joint
jnt = prefix + nameUtil.delineator + nameUtil.subPart['joint'] + ind + nameUtil.delineator + nameUtil.node[
'joint']
jnt = cmds.joint(p=pos, n=jnt)
jointList.append(jnt)
# Return result
return jointList
def createCoonsPatch(cpairs):
global csNum
global cs
global chNum
global ch
global vertices
global normals
# square patch dimension T_STEP by T_STEP
T_STEPS = 10
vertices = [[None]*(T_STEPS) for x in range(T_STEPS)]
normals = [[None]*(T_STEPS) for x in range(T_STEPS)]
# ALONG CURVE
# go from each ch to ch
for p in range(4):
cStart = ch[ cpairs[p][1] ][ cpairs[p][0] ]
cEnd = None
if p<3:
cEnd = ch[ cpairs[p+1][0] ][ cpairs[p+1][1] ]
else:
cEnd = ch[ cpairs[0][0] ][ cpairs[0][1] ]
tStep = (cEnd.t-cStart.t)/(T_STEPS-1)
# print "%s to %s : %s" % (cStart.t, cEnd.t, tStep)
# go down curve
t = cStart.t
for step in range(T_STEPS-1):
if step == 0:
pos = cStart.pos
nor = cStart.nor
else:
# get position
pos = np.array(cmds.pointOnCurve(cs[cStart.i].name, pr=t, p=True))
# get normal
nor1 = getCHNormAtT(cStart.i, cStart.j, t)
nor2 = getCHNormAtT(cEnd.i, cEnd.j, t)
blendT = (t-cStart.t) / (cEnd.t-cStart.t)
nor = blendT*nor2+(1-blendT)*nor1
if p == 0:
coord = (step,0)
elif p == 1:
coord = (T_STEPS-1,step)
elif p == 2:
coord = (T_STEPS-1-step,T_STEPS-1)
elif p == 3:
coord = (0, T_STEPS-1-step)
#print "(%s,%s)" % (coord[0], coord[1])
vertices[coord[0]][coord[1]] = pos
normals[coord[0]][coord[1]] = nor
#cmds.spaceLocator( p=(pos+nor).tolist() )
t = t + tStep
# ALONG PATCH
n = T_STEPS-1
for i in range(1, T_STEPS-1):
for j in range(1, T_STEPS-1):
vertices[i][j] = np.array([0.0,0.0,0.0])
normals[i][j] = np.array([0.0,0.0,0.0])
fi = float(i)
fj = float(j)
for k in range(3):
vertices[i][j][k] = (
(1.0-fi/n)*vertices[0][j][k] + fi/n*vertices[n][j][k] +
(1.0-fj/n)*vertices[i][0][k] + fj/n*vertices[i][n][k] -
(
vertices[0][0][k]+(vertices[n][0][k]-vertices[0][0][k])*(fi/n) +
(
(vertices[0][n][k]+(vertices[n][n][k]-vertices[0][n][k])*(fi/n)) -
(vertices[0][0][k]+(vertices[n][0][k]-vertices[0][0][k])*(fi/n))
) * (fj/n)
)
)
normals[i][j][k] = (
(1.0-fi/n)*normals[0][j][k] + fi/n*normals[n][j][k] +
(1.0-fj/n)*normals[i][0][k] + fj/n*normals[i][n][k] -
(
normals[0][0][k]+(normals[n][0][k]-normals[0][0][k])*(fi/n) +
(
(normals[0][n][k]+(normals[n][n][k]-normals[0][n][k])*(fi/n)) -
(normals[0][0][k]+(normals[n][0][k]-normals[0][0][k])*(fi/n))
) * (fj/n)
)
)
# cmds.spaceLocator( p=(vertices[i][j]+normals[i][j]).tolist() )
createPatchMesh(vertices, normals)
def multiCurveAicmdsonstraint(transform, curve1, curve2, toggleAttr, aimAxis='y', tangentAxis='x', prefix=''):
"""
@param transform: Transforms to aim at point on curve
@type transform: list
@param curve1: First curve aim target
@type curve1: str
@param curve2: Second curve aim target
@type curve2: str
@param toggleAttr: Attribute to toggle between the constraint targets
@type toggleAttr: str
@param aimAxis: Transform axis to aim at the point on curve
@type aimAxis: float
@param tangentAxis: Transform axis to align to the curve tangent
@type tangentAxis: str
@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)}
# Check prefix
if not prefix: prefix = glTools.utils.stringUtils.stripSuffix(transform)
# Transform worldSpace position
pmm = prefix + '_pointMatrixMult'
pmm = cmds.createNode('pointMatrixMult', n=pmm)
cmds.connectAttr(transform + '.translate', pmm + '.inPoint', f=True)
cmds.connectAttr(transform + '.parentMatrix[0]', pmm + '.inMatrix', f=True)
cmds.setAttr(pmm + '.vectorMultiply', 1)
# PointOnCurveInfo
poc1 = prefix + '_pc01_pointOnCurveInfo'
poc1 = cmds.createNode('pointOnCurveInfo', n=poc1)
cmds.connectAttr(curve1 + '.worldSpace[0]', poc1 + '.inputCurve', f=True)
poc2 = prefix + '_pc02_pointOnCurveInfo'
poc2 = cmds.createNode('pointOnCurveInfo', n=poc2)
cmds.connectAttr(curve2 + '.worldSpace[0]', poc2 + '.inputCurve', f=True)
pos = cmds.xform(transform, q=True, ws=True, rp=True)
param = glTools.utils.curve.closestPoint(curve1, pos)
cmds.setAttr(poc1 + '.parameter', param)
pos = cmds.pointOnCurve(curve1, pr=param, p=True)
param = glTools.utils.curve.closestPoint(curve2, pos)
cmds.setAttr(poc2 + '.parameter', param)
# Offset
pma1 = prefix + '_pc01_plusMinusAverage'
pma1 = cmds.createNode('plusMinusAverage', n=pma1)
cmds.connectAttr(poc1 + '.position', pma1 + '.input3D[0]', f=True)
cmds.connectAttr(pmm + '.output', pma1 + '.input3D[1]', f=True)
cmds.setAttr(pma1 + '.operation', 2) # Subtract
pma2 = prefix + '_pc02_plusMinusAverage'
pma2 = cmds.createNode('plusMinusAverage', n=pma2)
cmds.connectAttr(poc2 + '.position', pma2 + '.input3D[0]', f=True)
cmds.connectAttr(pmm + '.output', pma2 + '.input3D[1]', f=True)
cmds.setAttr(pma2 + '.operation', 2) # Subtract
# Blend Offset
pos_bcn = prefix + '_ps01_blendColors'
pos_bcn = cmds.createNode('blendColors', n=pos_bcn)
cmds.connectAttr(pma1 + '.output3D', pos_bcn + '.color1', f=True)
cmds.connectAttr(pma2 + '.output3D', pos_bcn + '.color2', f=True)
cmds.connectAttr(toggleAttr, pos_bcn + '.blender', f=True)
# Blend Tangent
tan_bcn = prefix + '_rt01_blendColors'
tan_bcn = cmds.createNode('blendColors', n=tan_bcn)
cmds.connectAttr(poc1 + '.tangent', tan_bcn + '.color1', f=True)
cmds.connectAttr(poc2 + '.tangent', tan_bcn + '.color2', f=True)
cmds.connectAttr(toggleAttr, tan_bcn + '.blender', f=True)
# Aim Constraint
aicmdson = prefix + '_aicmdsonstraint'
aicmdson = cmds.createNode('aicmdsonstraint', n=aicmdson)
cmds.connectAttr(pos_bcn + '.output', aicmdson + '.target[0].targetTranslate', f=True)
cmds.connectAttr(tan_bcn + '.output', aicmdson + '.worldUpVector', f=True)
cmds.setAttr(aicmdson + '.worldUpType', 3) # Vector
cmds.connectAttr(transform + '.parentInverseMatrix[0]', aicmdson + '.constraintParentInverseMatrix', f=True)
cmds.connectAttr(aicmdson + '.constraintRotateX', transform + '.rotateX', f=True)
cmds.connectAttr(aicmdson + '.constraintRotateY', transform + '.rotateY', f=True)
cmds.connectAttr(aicmdson + '.constraintRotateZ', transform + '.rotateZ', f=True)
aimVec = axisDict[aimAxis]
tanVec = axisDict[tangentAxis]
cmds.setAttr(aicmdson + '.aimVector', aimVec[0], aimVec[1], aimVec[2])
cmds.setAttr(aicmdson + '.upVector', tanVec[0], tanVec[1], tanVec[2])
cmds.parent(aicmdson, transform)
# Add parameter attribute
minU = cmds.getAttr(curve1 + '.minValue')
maxU = cmds.getAttr(curve1 + '.maxValue')
if not cmds.objExists(transform + '.param1'):
cmds.addAttr(transform, ln='param1', at='float', min=minU, max=maxU, k=True)
cmds.setAttr(transform + '.param1', cmds.getAttr(poc1 + '.parameter'))
cmds.connectAttr(transform + '.param1', poc1 + '.parameter', f=True)
minU = cmds.getAttr(curve2 + '.minValue')
maxU = cmds.getAttr(curve2 + '.maxValue')
if not cmds.objExists(transform + '.param2'):
cmds.addAttr(transform, ln='param2', at='float', min=minU, max=maxU, k=True)
cmds.setAttr(transform + '.param2', cmds.getAttr(poc2 + '.parameter'))
cmds.connectAttr(transform + '.param2', poc2 + '.parameter', f=True)
# Return result
return (aicmdson, poc1, poc2)
def readCrossSections():
global csNum
global cs
global chNum
global ch
#mel.eval("layerEditorSelectObjects layerCross;")
curveNames = mel.eval("ls -sl -type transform")
# no curve drawn
if not curveNames:
return
# init globals
csNum = len(curveNames)
cs = [None for x in range(csNum)]
for i in range(csNum):
cs[i] = CrossSection(i)
cs[i].name = curveNames[i]
chNum = 0
ch = [[None]*csNum for x in range(csNum)]
# process intersections
for i in range(csNum):
for j in range(i+1, csNum):
rawIntersects = cmds.curveIntersect(cs[i].name, cs[j].name, useDirection=True, direction=(0,0,1))
if rawIntersects:
ch[i][j] = CrossHair(i,j)
ch[j][i] = CrossHair(j,i)
intersects = [float(k) for k in rawIntersects.split()]
ch[i][j].t = intersects[0]
ch[j][i].t = intersects[1]
pi = cmds.pointOnCurve(cs[i].name, pr=ch[i][j].t, p=True)
ch[i][j].pos = np.array(pi) # save
ch[j][i].pos = np.array(pi)
#cmds.spaceLocator(p=pi) # place locator
t_ij = cmds.pointOnCurve(cs[i].name, pr=ch[i][j].t, nt=True)
ch[i][j].tan = np.array(t_ij)
t_ji = cmds.pointOnCurve(cs[j].name, pr=ch[j][i].t, nt=True)
ch[j][i].tan = np.array(t_ji)
print "(%s,%s) processed" % (i, j)
chNum += 1
else:
print "(%s,%s) no intersect" % (i, j)
# clear all selection
mel.eval("select -cl")
# store sorted list of ch for each cs
for i in range(csNum):
for j in range(csNum):
if ch[i][j] is not None:
cs[i].ch.append(ch[i][j])
cs[i].ch = sorted(cs[i].ch, key=lambda ch: ch.t)
import maya.cmds as cmds
import random
#from ObjectScatter import *
import ObjectScatter
reload(ObjectScatter)
import maya.cmds as cmds
import random
points = [ cmds.pointPosition('curve1.cv[%i]'%i) for i in range(cmds.getAttr('curve1.spans') + cmds.getAttr('curve1.degree')) ]
tangent = [ cmds.pointOnCurve('curve1', pr=(1.0/23)*i, t=True) for i in range(23) ]
for pos in points:
cmds.select(cmds.polyCone(r=0.2, h=0.2)[0])
cmds.move(pos[0], pos[1], pos[2])
cmds.select(['curve1', cmds.ls(sl=True)[0]])
cmds.tangentConstraint(aimVector=(0,1,0), upVector=(1,0,1), worldUpType="vector",worldUpVector=(0,1,0))
new = cmds.polyCube()[0]
cmds.rotate(0, random.uniform(0, 360), 0)
cmds.move(random.uniform(0,8), 0, 0, os=True)
# UI
winName = "Object Scatter"
if(cmds.window(winName, exists=True)):
cmds.deleteUI(winName)
window = cmds.window( title=winName, iconName=winName, widthHeight=(512, 512), maximizeButton=False )
def showtimeOnCurve(numFireworks, duration, variation, loop):
selectedCurve = cmds.ls(sl=True)[0]
#if (cmds.objectType(cmds.ls(sl=True)[0], isType = 'nurbsCurve') != 1):
# cmds.error('You didn\'t select a curve yo!')
#Checks for correct naming format for script to work
if cmds.objExists(selectedCurve+'Shape'):
curveLen = cmds.getAttr(selectedCurve+'Shape.max')
else:
cmds.error('Please select/rename your curve cuz')
d = curveLen / duration
locOnCurve = 0
t1 = 0
print "curveLen: " + str(curveLen)
total = numFireworks
initializeProgressWindow('Firworks Along Cuve', total)
while locOnCurve < curveLen:
print "locOnCurve: " + str(locOnCurve)
ifCreate = random.randint(0,1)
if ifCreate == 1 and numFireworks > 0: #you can now create a firework
loc = cmds.pointOnCurve(pr=locOnCurve, p=True)
print "loc: " + str(loc)
cmds.select(cl=True)
newFirework = firework(0, 0)
numFireworks -= 1
fname = "firework"+"%03d"%numFireworks
emname = fname+"EM"
pname = fname+"P"
#create emitters for firework effect and set certain attributes that don't need to be keyed
newFirework.makeMe(emname, pname)
cmds.xform(emname, t=(loc[0] + random.random()*variation - variation/2, loc[1] + random.random()*variation - variation/2, loc[2] + random.random()*variation - variation/2), ro=(newFirework.anglex, 0, newFirework.anglez))
cmds.setAttr(pname+'Shape.startFrame', t1)
#Shade and Key newly created firework.
newFirework.shadeMe(fname, pname)
newFirework.keyMe(emname, pname, t1)
#group emitter and particle together in firework###
cmds.group(emname, pname, n=fname)
#deselect particle so that next iteration's emitters aren't created in each particle
cmds.select(cl=True)
locOnCurve += d
if numFireworks > 0 and locOnCurve >= curveLen:
if loop == True:
t1 = 0
locOnCurve = 0
if numFireworks < 0:
break
t1 +=1
updateProgressWindow(total-numFireworks, total)
cmds.select(selectedCurve)
#selects all fireworks and groups them together
cmds.select([node for node in cmds.ls() if 'firework' in node and 'EM' not in node and 'P' not in node and 'Shape' not in node])
cmds.group(name='fireworkShow')
#kills progress window
killProgressWindow()
def Rig(nameSpace='arm'):
#- get guides -
guides = ['%s:link_start_gui'%nameSpace, '%s:link_end_gui'%nameSpace, '%s:link_up_gui'%nameSpace]
#- make curve -
pathCurve = buildeCurve(guides[0], guides[1])
#- make up curve -
upvectorCurve = buidleUpCurve(*guides)
#- make Joints and locators-
Joints = []
locators = []
counts = mc.getAttr('%s.jointCount'%guides[0])
for i in range(counts):
#- 1 create
Joints.append(mc.createNode('joint'))
locators.append(mc.spaceLocator(p=(0,0,0))[0])
#- 2
parameter = (((float(i + 1) - 0) / (counts + 1 - 0)) * (1 - 0)) + 0
#- 3 attact to curve
attachToCurve(Joints[-1], pathCurve, parameter)
attachToCurve(locators[-1], upvectorCurve, parameter)
#- 4 connect object up
addUpObject(Joints[-1], locators[-1])
#- add rig Joins -
rigJoints = []
for i in range(4):
rigJoints.append(mc.createNode('joint'))
#- move
position = mc.pointOnCurve(pathCurve, pr= 1.0 / 3 * i)
mc.move(position[0], position[1], position[2], rigJoints[-1], a=True)
#- orient
mc.delete(mc.orientConstraint(Joints[0], rigJoints[-1]))
#- bind Curve
mc.skinCluster(rigJoints, pathCurve)
mc.skinCluster(rigJoints, upvectorCurve)
#- rig rigJoints -
controlLst = []
for jnt in rigJoints:
#- make control
controls = [mc.createNode('transform') for i in range(4)]
for i in range(len(controls) - 1):
mc.parent(controls[i], controls[i+1])
controlLst.append(controls)
#- match positions, parent Joint
mc.delete(mc.parentConstraint(jnt, controls[-1]))
mc.parent(jnt, controls[0])
#-add Shape
circle = mc.circle(nr=(1,0,0), ch=0)
mc.parent(mc.listRelatives(circle, s=True, path=True), controls[0], r=True, s=True)
mc.delete(circle)
#-- comp hery --
curveGrp = mc.group(pathCurve, upvectorCurve)
jointGrp = mc.group(Joints)
locatorGrp = mc.group(locators)
controlGrp = mc.group([L[-1] for L in controlLst])
RootGrp = mc.group(curveGrp, jointGrp, locatorGrp, controlGrp)
#-- clean scene --
mc.hide(curveGrp, locatorGrp, rigJoints)
#-* rename *-
#- groups -
curveGrp = mc.rename(curveGrp, '%s_cusg_0'%nameSpace)
jointGrp = mc.rename(jointGrp, '%s_jntg_0'%nameSpace)
locatorGrp = mc.rename(locatorGrp, '%s_locg_0'%nameSpace)
controlGrp = mc.rename(controlGrp, '%s_ctlg_0'%nameSpace)
RootGrp = mc.rename(RootGrp, '%s_setg_0'%nameSpace)
#- joints -
for i,jnt in enumerate(Joints):
Joints[i] = mc.rename(jnt, '%s_bnd%s_0'%(nameSpace, string.uppercase[i]))
#- locators -
for i,loc in enumerate(locators):
locators[i] = mc.rename(loc, '%s_loc%s_0'%(nameSpace, string.uppercase[i]))
#- rig Joints -
for i,jnt in enumerate(rigJoints):
rigJoints[i] = mc.rename(jnt, '%s_ctj%s_0'%(nameSpace, string.uppercase[i]))
#- control -
ctlType = ('ctl', 'ctu', 'cth', 'ctg')
for i, ctls in enumerate(controlLst):
for d, ctl in enumerate(ctls):
controlLst[i][d] = mc.rename(ctl, '%s%s_%s_0'%(nameSpace, string.uppercase[i], ctlType[d]))
#- curve -
pathCurve = mc.rename(pathCurve, '%s_TWbaseCus_0'%nameSpace)
upvectorCurve = mc.rename(upvectorCurve , '%s_TWupperCus_0'%nameSpace)
def setNeighbour(vertexList=[],referenceObject='',dnDirectionalSmoothNode='',direction='u'):
'''
'''
# Flatten vertex list
vertexList = mc.ls(vertexList,fl=True)
# Get dnDirectionalSmoothNode object and target plug
sel = OpenMaya.MSelectionList()
OpenMaya.MGlobal.getSelectionListByName(dnDirectionalSmoothNode,sel)
dnDirectionalSmoothNodeObj = OpenMaya.MObject()
sel.getDependNode(0,dnDirectionalSmoothNodeObj)
dnDirectionalSmoothNodeNode = OpenMaya.MFnDependencyNode(dnDirectionalSmoothNodeObj)
neighbourDataPlug = dnDirectionalSmoothNodeNode.findPlug('neighbourData')
neighbourDataArrayPlug = neighbourDataPlug.elementByLogicalIndex(0)
# Check reference object
isCurve = True
if not glTools.utils.curve.isCurve(referenceObject):
isCurve = False
elif not glTools.utils.curve.isSurface(referenceObject):
raise UserInputError('Reference object must be a valid nurbs curve or surface!!')
# Create neighbourData object
neighbourData = OpenMaya.MVectorArray()
# Get mesh and vertex list
mesh = glTools.utils.component.getComponentIndexList(vertexList).keys()[0]
# Get vertexIterator for mesh
sel = OpenMaya.MSelectionList()
OpenMaya.MGlobal.getSelectionListByName(mesh,sel)
meshObj = OpenMaya.MObject()
sel.getDependNode(0,meshObj)
meshIt = OpenMaya.MItMeshVertex(meshObj)
# Get neighbour data
neighbourIndexList = OpenMaya.MIntArray()
for i in range(len(vertexList)):
# Get current point
pnt = mc.pointPosition(vertexList[i])
pntId = glTools.utils.component.getComponentIndexList([vertexList[i]])[mesh][0]
# Get closest U tangent
if isCurve:
u = glTools.utils.curve.closestPoint(referenceObject,pnt)
tan = mc.pointOnCurve(referenceObject,pr=u,nt=True)
else:
uv = glTools.utils.surface.closestPoint(referenceObject,pnt)
tan = [0,0,0]
if direction == 'u':
tan = mc.pointOnSurface(referenceObject,u=uv[0],v=uv[1],ntu=True)
elif direction == 'v':
tan = mc.pointOnSurface(referenceObject,u=uv[0],v=uv[1],ntv=True)
else:
raise Exception('Invalid direction value!')
tan = glTools.utils.mathUtils.normalizeVector(tan)
# Get neighbouring points
conFaces = mc.ls(mc.polyListComponentConversion(vertexList[i],fv=True,tf=True),fl=True)
conVerts = mc.ls(mc.polyListComponentConversion(conFaces,ff=True,tv=True),fl=True)
conVertList = glTools.utils.component.getComponentIndexList(conVerts)[mesh]
# Determine neighbours
n1Id = -1
n2Id = -1
n1Dist = 0.5
n2Dist = 0.5
minDot = 0.0
maxDot = 0.0
# Iterate through connected verts
for n in range(len(conVertList)):
nPnt = mc.pointPosition(mesh+'.vtx['+str(conVertList[n])+']')
dist = glTools.utils.mathUtils.offsetVector(pnt,nPnt)
nDist = glTools.utils.mathUtils.normalizeVector(dist)
dot = glTools.utils.mathUtils.dotProduct(tan,nDist)
if dot > maxDot:
n1Id = conVertList[n]
n1Dist = glTools.utils.mathUtils.mag(dist)
maxDot = dot
if dot < minDot:
n2Id = conVertList[n]
n2Dist = glTools.utils.mathUtils.mag(dist)
minDot = dot
# Build neighbour data vector
tDist = n1Dist + n2Dist
n1Dist = 1.0 - (n1Dist/tDist)
n2Dist = 1.0 - (n2Dist/tDist)
neighbourData.append(OpenMaya.MVector(float(pntId),n1Id+n1Dist,n2Id+n2Dist))
# Set value
neighbourDataArrayPlug.setMObject(OpenMaya.MFnVectorArrayData().create(neighbourData))
# Return result
return neighbourData