def sphere(parent=None, name="sphere", width=1, color=[0,0,0], m=dt.Matrix(), pos_offset=None, rot_offset=None):
dlen = width
v0 = dt.Vector(0.75*dlen, 0, 0)
v1 = dt.Vector(0, -.75*dlen, 0)
v2 = dt.Vector(-.75*dlen, 0, 0)
v3 = dt.Vector(0, 0.75*dlen, 0)
v4 = dt.Vector(0.75*dlen, 0, 0)
v5 = dt.Vector(0, 0, -.75*dlen)
v6 = dt.Vector(-.75*dlen, 0, 0)
v7 = dt.Vector(0, 0, 0.75*dlen)
v8 = dt.Vector(0, 0, 0.75*dlen)
v9 = dt.Vector(0, -.75*dlen, 0)
v10 = dt.Vector(0, 0, -.75*dlen)
v11 = dt.Vector(0, 0.75*dlen, 0)
points = getPointArrayWithOffset([v0, v1, v2, v3], pos_offset, rot_offset)
node = cur.addCurve(parent, name, points, True, 3, m)
points = getPointArrayWithOffset([v4, v5, v6, v7], pos_offset, rot_offset)
crv_0 = cur.addCurve(parent, node+"_0crv", points, True, 3, m)
points = getPointArrayWithOffset([v8, v9, v10, v11], pos_offset, rot_offset)
crv_1 = cur.addCurve(parent, node+"_1crv", points, True, 3, m)
for crv in [crv_0, crv_1]:
for shp in crv.listRelatives(shapes=True):
node.addChild(shp, add=True, shape=True)
delete(crv)
setcolor(node, color)
return node
def null(parent=None, name="null", width=1, color=[0,0,0], m=dt.Matrix(), pos_offset=None, rot_offset=None):
dlen = width * .5
v0 = dt.Vector(dlen, 0, 0)
v1 = dt.Vector(-dlen, 0, 0)
v2 = dt.Vector(0,dlen, 0)
v3 = dt.Vector(0, -dlen, 0)
v4 = dt.Vector(0, 0, dlen)
v5 = dt.Vector(0, 0, -dlen)
points = getPointArrayWithOffset([v0, v1], pos_offset, rot_offset)
node = cur.addCurve(parent, name, points, False, 1, m)
points = getPointArrayWithOffset([v2, v3], pos_offset, rot_offset)
crv_0 = cur.addCurve(parent, name, points, False, 1, m)
points = getPointArrayWithOffset([v4, v5], pos_offset, rot_offset)
crv_1 = cur.addCurve(parent, name, points, False, 1, m)
for crv in [crv_0, crv_1]:
for shp in crv.listRelatives(shapes=True):
node.addChild(shp, add=True, shape=True)
delete(crv)
setcolor(node, color)
return node
def sphere(parent=None, name="sphere", width=1, color=[0,0,0], m=dt.Matrix(), pos_offset=None, rot_offset=None):
"""
Create a curve with a SPHERE shape.
Args:
parent (dagNode): The parent object of the newly created curve.
name (str): Name of the curve.
width (float): Width of the shape.
color (int or list of float): The color in index base or RGB.
m (matrix): The global transformation of the curve.
pos_offset (vector): The xyz position offset of the curve from its center.
rot_offset (vector): The xyz rotation offset of the curve from its center. xyz in radians
Returns:
dagNode: The newly created icon.
"""
dlen = width
v0 = dt.Vector(0.75*dlen, 0, 0)
v1 = dt.Vector(0, -.75*dlen, 0)
v2 = dt.Vector(-.75*dlen, 0, 0)
v3 = dt.Vector(0, 0.75*dlen, 0)
v4 = dt.Vector(0.75*dlen, 0, 0)
v5 = dt.Vector(0, 0, -.75*dlen)
v6 = dt.Vector(-.75*dlen, 0, 0)
v7 = dt.Vector(0, 0, 0.75*dlen)
v8 = dt.Vector(0, 0, 0.75*dlen)
v9 = dt.Vector(0, -.75*dlen, 0)
v10 = dt.Vector(0, 0, -.75*dlen)
v11 = dt.Vector(0, 0.75*dlen, 0)
points = getPointArrayWithOffset([v0, v1, v2, v3], pos_offset, rot_offset)
node = cur.addCurve(parent, name, points, True, 3, m)
points = getPointArrayWithOffset([v4, v5, v6, v7], pos_offset, rot_offset)
crv_0 = cur.addCurve(parent, node+"_0crv", points, True, 3, m)
points = getPointArrayWithOffset([v8, v9, v10, v11], pos_offset, rot_offset)
crv_1 = cur.addCurve(parent, node+"_1crv", points, True, 3, m)
for crv in [crv_0, crv_1]:
for shp in crv.listRelatives(shapes=True):
node.addChild(shp, add=True, shape=True)
pm.delete(crv)
setcolor(node, color)
return node
def cross(parent=None, name="cross", width=1, color=[0,0,0], m=dt.Matrix(), pos_offset=None, rot_offset=None):
width = width * 0.35
offset1 = width * .5
offset2 = width * 1.5
v0 = dt.Vector(width,offset2,0)
v1 = dt.Vector(offset2,width,0)
v2 = dt.Vector(offset1,0,0)
v3 = dt.Vector(offset2,-width,0)
v4 = dt.Vector(width,-offset2,0)
v5 = dt.Vector(0,-offset1,0)
v6 = dt.Vector(-width,-offset2,0)
v7 = dt.Vector(-offset2,-width,0)
v8 = dt.Vector(-offset1,0,0)
v9 = dt.Vector(-offset2,width,0)
v10 = dt.Vector(-width,offset2,0)
v11 = dt.Vector(0,offset1,0)
points = getPointArrayWithOffset([v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11], pos_offset, rot_offset)
node = cur.addCurve(parent, name, points, True, 1, m)
setcolor(node, color)
return node
def square(parent=None, name="square", width=1, depth=1, color=[0,0,0], m=dt.Matrix(), pos_offset=None, rot_offset=None):
"""
Create a curve with a SQUARE shape.
Args:
parent (dagNode): The parent object of the newly created curve.
name (str): Name of the curve.
width (float): Width of the shape.
depth (float): Depth of the shape.
color (int or list of float): The color in index base or RGB.
m (matrix): The global transformation of the curve.
pos_offset (vector): The xyz position offset of the curve from its center.
rot_offset (vector): The xyz rotation offset of the curve from its center. xyz in radians
Returns:
dagNode: The newly created icon.
"""
lenX = width * 0.5
lenZ = depth * 0.5
v0 = dt.Vector(lenX , 0, lenZ)
v1 = dt.Vector(lenX , 0, lenZ*-1)
v2 = dt.Vector(lenX*-1, 0, lenZ*-1)
v3 = dt.Vector(lenX*-1, 0, lenZ)
points = getPointArrayWithOffset([v0, v1, v2, v3], pos_offset, rot_offset)
node = cur.addCurve(parent, name, points, True, 1, m)
setcolor(node, color)
return node
def diamond(parent=None, name="diamond", width=1, color=[0,0,0], m=dt.Matrix(), pos_offset=None, rot_offset=None):
"""
Create a curve with a DIAMOND shape.
Args:
parent (dagNode): The parent object of the newly created curve.
name (str): Name of the curve.
width (float): Width of the shape.
height (float): Height of the shape.
depth (float): Depth of the shape.
color (int or list of float): The color in index base or RGB.
m (matrix): The global transformation of the curve.
pos_offset (vector): The xyz position offset of the curve from its center.
rot_offset (vector): The xyz rotation offset of the curve from its center. xyz in radians
Returns:
dagNode: The newly created icon.
"""
dlen = width * 0.5
top = dt.Vector(0,dlen,0)
pp = dt.Vector(dlen,0,dlen)
pN = dt.Vector(dlen,0,dlen*-1)
Np = dt.Vector(dlen*-1,0,dlen)
NN = dt.Vector(dlen*-1,0,dlen*-1)
bottom = (0,-dlen,0)
points = getPointArrayWithOffset([pp,top,pN,pp,Np,top,NN,Np,NN,pN,bottom,NN,bottom,Np,bottom,pp], pos_offset, rot_offset)
node = cur.addCurve(parent, name, points, False, 1, m)
setcolor(node, color)
return node
def arrow(parent=None, name="arrow", width=1, color=[0,0,0], m=dt.Matrix(), pos_offset=None, rot_offset=None):
"""
Create a curve with a ARROW shape.
Args:
parent (dagNode): The parent object of the newly created curve.
name (str): Name of the curve.
width (float): Width of the shape.
color (int or list of float): The color in index base or RGB.
m (matrix): The global transformation of the curve.
pos_offset (vector): The xyz position offset of the curve from its center.
rot_offset (vector): The xyz rotation offset of the curve from its center. xyz in radians
Returns:
dagNode: The newly created icon.
"""
dlen = width * 0.5
v0 = dt.Vector(0, 0.3*dlen, -dlen)
v1 = dt.Vector(0, 0.3*dlen, 0.3*dlen)
v2 = dt.Vector(0, 0.6*dlen, 0.3*dlen)
v3 = dt.Vector(0, 0, dlen)
v4 = dt.Vector(0, -0.6*dlen, 0.3*dlen)
v5 = dt.Vector(0, -0.3*dlen, 0.3*dlen)
v6 = dt.Vector(0, -0.3*dlen, -dlen)
points = getPointArrayWithOffset([v0, v1, v2, v3, v4, v5, v6], pos_offset, rot_offset)
node = cur.addCurve(parent, name, points, True, 1, m)
setcolor(node, color)
return node
def guideBladeIcon(parent=None, name="blade",lenX=1.0, color=[0,0,0], m=dt.Matrix(), pos_offset=None, rot_offset=None):
"""
Create a curve with a BLADE GUIDE shape.
Note:
This icon is specially design for **Shifter** blade guides
Args:
parent (dagNode): The parent object of the newly created curve.
name (str): Name of the curve.
lenX (float): Width of the shape.
color (int or list of float): The color in index base or RGB.
m (matrix): The global transformation of the curve.
pos_offset (vector): The xyz position offset of the curve from its center.
rot_offset (vector): The xyz rotation offset of the curve from its center. xyz in radians
Returns:
dagNode: The newly created icon.
"""
v0 = dt.Vector(0 , 0, 0)
v1 = dt.Vector(lenX , 0, 0)
v2 = dt.Vector(0, lenX/3, 0)
points = getPointArrayWithOffset([v0, v1, v2 ], pos_offset, rot_offset)
bladeIco = cur.addCurve(parent, name, points, True, 1, m)
setcolor(bladeIco, color)
att.setNotKeyableAttributes(bladeIco)
return bladeIco
def axis(parent=None, name="axis", width=1, color=[0,0,0], m=dt.Matrix(), pos_offset=None, rot_offset=None):
"""
Create a curve with a AXIS shape.
Args:
parent (dagNode): The parent object of the newly created curve.
name (str): Name of the curve.
width (float): Width of the shape.
color (int or list of float): The color in index base or RGB.
m (matrix): The global transformation of the curve.
pos_offset (vector): The xyz position offset of the curve from its center.
rot_offset (vector): The xyz rotation offset of the curve from its center. xyz in radians
Returns:
dagNode: The newly created icon.
"""
dlen = width * .5
v0 = dt.Vector(0, 0, 0)
v1 = dt.Vector(dlen, 0, 0)
v2 = dt.Vector(0,dlen, 0)
v3 = dt.Vector(0, 0, dlen)
points = getPointArrayWithOffset([v0, v1], pos_offset, rot_offset)
node = cur.addCurve(parent, name, points, False, 1, m)
setcolor(node, 4)
points = getPointArrayWithOffset([v0, v2], pos_offset, rot_offset)
crv_0 = cur.addCurve(parent, name, points, False, 1, m)
setcolor(crv_0, 14)
points = getPointArrayWithOffset([v0, v3], pos_offset, rot_offset)
crv_1 = cur.addCurve(parent, name, points, False, 1, m)
setcolor(crv_1, 6)
for crv in [crv_0, crv_1]:
for shp in crv.listRelatives(shapes=True):
node.addChild(shp, add=True, shape=True)
pm.delete(crv)
return node
def square(parent=None, name="square", width=1, depth=1, color=[0,0,0], m=dt.Matrix(), pos_offset=None, rot_offset=None):
lenX = width * 0.5
lenZ = depth * 0.5
v0 = dt.Vector(lenX , 0, lenZ)
v1 = dt.Vector(lenX , 0, lenZ*-1)
v2 = dt.Vector(lenX*-1, 0, lenZ*-1)
v3 = dt.Vector(lenX*-1, 0, lenZ)
points = getPointArrayWithOffset([v0, v1, v2, v3], pos_offset, rot_offset)
node = cur.addCurve(parent, name, points, True, 1, m)
setcolor(node, color)
return node
def diamond(parent=None, name="diamond", width=1, color=[0,0,0], m=dt.Matrix(), pos_offset=None, rot_offset=None):
dlen = width * 0.5
top = dt.Vector(0,dlen,0)
pp = dt.Vector(dlen,0,dlen)
pN = dt.Vector(dlen,0,dlen*-1)
Np = dt.Vector(dlen*-1,0,dlen)
NN = dt.Vector(dlen*-1,0,dlen*-1)
bottom = (0,-dlen,0)
points = getPointArrayWithOffset([pp,top,pN,pp,Np,top,NN,Np,NN,pN,bottom,NN,bottom,Np,bottom,pp], pos_offset, rot_offset)
node = cur.addCurve(parent, name, points, False, 1, m)
setcolor(node, color)
return node
def cross(parent=None, name="cross", width=1, color=[0,0,0], m=dt.Matrix(), pos_offset=None, rot_offset=None):
"""
Create a curve with a CROSS shape.
Args:
parent (dagNode): The parent object of the newly created curve.
name (str): Name of the curve.
width (float): Width of the shape.
color (int or list of float): The color in index base or RGB.
m (matrix): The global transformation of the curve.
pos_offset (vector): The xyz position offset of the curve from its center.
rot_offset (vector): The xyz rotation offset of the curve from its center. xyz in radians
Returns:
dagNode: The newly created icon.
"""
width = width * 0.35
offset1 = width * .5
offset2 = width * 1.5
v0 = dt.Vector(width,offset2,0)
v1 = dt.Vector(offset2,width,0)
v2 = dt.Vector(offset1,0,0)
v3 = dt.Vector(offset2,-width,0)
v4 = dt.Vector(width,-offset2,0)
v5 = dt.Vector(0,-offset1,0)
v6 = dt.Vector(-width,-offset2,0)
v7 = dt.Vector(-offset2,-width,0)
v8 = dt.Vector(-offset1,0,0)
v9 = dt.Vector(-offset2,width,0)
v10 = dt.Vector(-width,offset2,0)
v11 = dt.Vector(0,offset1,0)
points = getPointArrayWithOffset([v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11], pos_offset, rot_offset)
node = cur.addCurve(parent, name, points, True, 1, m)
setcolor(node, color)
return node
def arrow(parent=None, name="arrow", width=1, color=[0,0,0], m=dt.Matrix(), pos_offset=None, rot_offset=None):
dlen = width * 0.5
v0 = dt.Vector(0, 0.3*dlen, -dlen)
v1 = dt.Vector(0, 0.3*dlen, 0.3*dlen)
v2 = dt.Vector(0, 0.6*dlen, 0.3*dlen)
v3 = dt.Vector(0, 0, dlen)
v4 = dt.Vector(0, -0.6*dlen, 0.3*dlen)
v5 = dt.Vector(0, -0.3*dlen, 0.3*dlen)
v6 = dt.Vector(0, -0.3*dlen, -dlen)
points = getPointArrayWithOffset([v0, v1, v2, v3, v4, v5, v6], pos_offset, rot_offset)
node = cur.addCurve(parent, name, points, True, 1, m)
setcolor(node, color)
return node
def circle(parent=None, name="circle", width=1, color=[0,0,0], m=dt.Matrix(), pos_offset=None, rot_offset=None):
dlen = width * 0.5
v0 = dt.Vector(0, 0, -dlen * 1.108)
v1 = dt.Vector(dlen * .78 , 0, -dlen * .78)
v2 = dt.Vector(dlen * 1.108, 0, 0)
v3 = dt.Vector(dlen * .78 , 0, dlen * .78)
v4 = dt.Vector(0, 0, dlen * 1.108)
v5 = dt.Vector(-dlen * .78 , 0, dlen * .78)
v6 = dt.Vector(-dlen * 1.108, 0, 0)
v7 = dt.Vector(-dlen * .78 , 0, -dlen * .78)
points = getPointArrayWithOffset([v0, v1, v2, v3, v4, v5, v6, v7], pos_offset, rot_offset)
node = cur.addCurve(parent, name, points, True, 3, m)
setcolor(node, color)
return node
def pyramid(parent=None, name="pyramid", width=1, height=1, depth=1, color=[0,0,0], m=dt.Matrix(), pos_offset=None, rot_offset=None):
lenX = width * 0.5
lenY = height
lenZ = depth * 0.5
# p is positive, N is negative
top = dt.Vector(0,lenY,0)
pp = dt.Vector(lenX, 0, lenZ)
pN = dt.Vector(lenX,0,lenZ*-1)
Np = dt.Vector(lenX*-1,0,lenZ)
NN = dt.Vector(lenX*-1,0,lenZ*-1)
points = getPointArrayWithOffset([pp, top, pN, pp, Np, top, NN, Np, NN, pN], pos_offset, rot_offset)
node = cur.addCurve(parent, name, points, False, 1, m)
setcolor(node, color)
return node
def cubewithpeak(parent=None, name="cubewithpeak", width=1, color=[0,0,0], m=dt.Matrix(), pos_offset=None, rot_offset=None):
dlen = width * 0.5
peak = dt.Vector(0,width,0)
ppp = dt.Vector(dlen,dlen,dlen)
ppN = dt.Vector(dlen,dlen,dlen*-1)
pNp = dt.Vector(dlen,0,dlen)
Npp = dt.Vector(dlen*-1,dlen,dlen)
pNN = dt.Vector(dlen,0,dlen*-1)
NNp = dt.Vector(dlen*-1,0,dlen)
NpN = dt.Vector(dlen*-1,dlen,dlen*-1)
NNN = dt.Vector(dlen*-1,0,dlen*-1)
points = getPointArrayWithOffset([peak,ppp,ppN,peak,NpN,ppN,NpN,peak,Npp,NpN,NNN,NNp,Npp,NpN,Npp,ppp,pNp,NNp,pNp,pNN,ppN,pNN,NNN], pos_offset, rot_offset)
node = cur.addCurve(parent, name, points, False, 1, m)
setcolor(node, color)
return node
def cube(parent=None, name="cube", width=1, height=1, depth=1, color=[0,0,0], m=dt.Matrix(), pos_offset=None, rot_offset=None):
"""
Create a curve with a CUBE shape.
Args:
parent (dagNode): The parent object of the newly created curve.
name (str): Name of the curve.
width (float): Width of the shape.
height (float): Height of the shape.
depth (float): Depth of the shape.
color (int or list of float): The color in index base or RGB.
m (matrix): The global transformation of the curve.
pos_offset (vector): The xyz position offset of the curve from its center.
rot_offset (vector): The xyz rotation offset of the curve from its center. xyz in radians
Returns:
dagNode: The newly created icon.
"""
lenX = width * 0.5
lenY = height * 0.5
lenZ = depth * 0.5
# p is positive, N is negative
ppp = dt.Vector(lenX,lenY,lenZ)
ppN = dt.Vector(lenX,lenY,lenZ*-1)
pNp = dt.Vector(lenX,lenY*-1,lenZ)
Npp = dt.Vector(lenX*-1,lenY,lenZ)
pNN = dt.Vector(lenX,lenY*-1,lenZ*-1)
NNp = dt.Vector(lenX*-1,lenY*-1,lenZ)
NpN = dt.Vector(lenX*-1,lenY,lenZ*-1)
NNN = dt.Vector(lenX*-1,lenY*-1,lenZ*-1)
points = getPointArrayWithOffset([ppp, ppN, NpN, NNN, NNp, Npp, NpN, Npp, ppp, pNp, NNp, pNp, pNN, ppN, pNN, NNN], pos_offset, rot_offset)
node = cur.addCurve(parent, name, points, False, 1, m)
setcolor(node, color)
return node
def compas(parent=None, name="compas", width=1, color=[0,0,0], m=dt.Matrix(), pos_offset=None, rot_offset=None):
"""
Create a curve with a COMPAS shape.
Args:
parent (dagNode): The parent object of the newly created curve.
name (str): Name of the curve.
width (float): Width of the shape.
color (int or list of float): The color in index base or RGB.
m (matrix): The global transformation of the curve.
pos_offset (vector): The xyz position offset of the curve from its center.
rot_offset (vector): The xyz rotation offset of the curve from its center. xyz in radians
Returns:
dagNode: The newly created icon.
"""
dlen = width * 0.5
division = 24
point_pos = []
v = dt.Vector(0, 0, dlen)
for i in range(division):
if i == division/2:
w = dt.Vector(v.x, v.y, v.z-dlen*.4)
else:
w = dt.Vector(v.x, v.y, v.z)
point_pos.append(w)
v = v.rotateBy((0,(2*pmu.math.pi)/(division+0.0),0))
points = getPointArrayWithOffset(point_pos, pos_offset, rot_offset)
node = cur.addCurve(parent, name, points, True, 3, m)
setcolor(node, color)
return node
def compas(parent=None, name="compas", width=1, color=[0,0,0], m=dt.Matrix(), pos_offset=None, rot_offset=None):
dlen = width * 0.5
division = 24
point_pos = []
v = dt.Vector(0, 0, dlen)
for i in range(division):
if i == division/2:
w = dt.Vector(v.x, v.y, v.z-dlen*.4)
else:
w = dt.Vector(v.x, v.y, v.z)
point_pos.append(w)
v = v.rotateBy((0,(2*math.pi)/(division+0.0),0))
points = getPointArrayWithOffset(point_pos, pos_offset, rot_offset)
node = cur.addCurve(parent, name, points, True, 3, m)
setcolor(node, color)
return node
def crossarrow(parent=None, name="crossArrow", width=1, color=[0,0,0], m=dt.Matrix(), pos_offset=None, rot_offset=None):
dlen = width * 0.5
v0 = dt.Vector(0.2*dlen, 0, 0.2*dlen)
v1 = dt.Vector(0.2*dlen, 0, 0.6*dlen)
v2 = dt.Vector(0.4*dlen, 0, 0.6*dlen)
v3 = dt.Vector(0, 0, dlen)
v4 = dt.Vector(-0.4*dlen, 0, 0.6*dlen)
v5 = dt.Vector(-0.2*dlen, 0, 0.6*dlen)
v6 = dt.Vector(-0.2*dlen, 0, 0.2*dlen)
v7 = dt.Vector(-0.6*dlen, 0, 0.2*dlen)
v8 = dt.Vector(-0.6*dlen, 0, 0.4*dlen)
v9 = dt.Vector(-dlen, 0, 0)
v10 = dt.Vector(-0.6*dlen, 0, -0.4*dlen)
v11 = dt.Vector(-0.6*dlen, 0, -0.2*dlen)
v12 = dt.Vector(-0.2*dlen, 0, -0.2*dlen)
v13 = dt.Vector(-0.2*dlen, 0, -0.6*dlen)
v14 = dt.Vector(-0.4*dlen, 0, -0.6*dlen)
v15 = dt.Vector(0, 0, -dlen)
v16 = dt.Vector(0.4*dlen, 0, -0.6*dlen)
v17 = dt.Vector(0.2*dlen, 0, -0.6*dlen)
v18 = dt.Vector(0.2*dlen, 0, -0.2*dlen)
v19 = dt.Vector(0.6*dlen, 0, -0.2*dlen)
v20 = dt.Vector(0.6*dlen, 0, -0.4*dlen)
v21 = dt.Vector(dlen, 0, 0)
v22 = dt.Vector(0.6*dlen, 0, 0.4*dlen)
v23 = dt.Vector(0.6*dlen, 0, 0.2*dlen)
points = getPointArrayWithOffset([v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23], pos_offset, rot_offset)
node = cur.addCurve(parent, name, points, True, 1, m)
setcolor(node, color)
return node
def cubewithpeak(parent=None, name="cubewithpeak", width=1, color=[0,0,0], m=dt.Matrix(), pos_offset=None, rot_offset=None):
"""
Create a curve with a CUBE WITH PEAK shape.
Args:
parent (dagNode): The parent object of the newly created curve.
name (str): Name of the curve.
width (float): Width of the shape.
color (int or list of float): The color in index base or RGB.
m (matrix): The global transformation of the curve.
pos_offset (vector): The xyz position offset of the curve from its center.
rot_offset (vector): The xyz rotation offset of the curve from its center. xyz in radians
Returns:
dagNode: The newly created icon.
"""
dlen = width * 0.5
peak = dt.Vector(0,width,0)
ppp = dt.Vector(dlen,dlen,dlen)
ppN = dt.Vector(dlen,dlen,dlen*-1)
pNp = dt.Vector(dlen,0,dlen)
Npp = dt.Vector(dlen*-1,dlen,dlen)
pNN = dt.Vector(dlen,0,dlen*-1)
NNp = dt.Vector(dlen*-1,0,dlen)
NpN = dt.Vector(dlen*-1,dlen,dlen*-1)
NNN = dt.Vector(dlen*-1,0,dlen*-1)
points = getPointArrayWithOffset([peak,ppp,ppN,peak,NpN,ppN,NpN,peak,Npp,NpN,NNN,NNp,Npp,NpN,Npp,ppp,pNp,NNp,pNp,pNN,ppN,pNN,NNN], pos_offset, rot_offset)
node = cur.addCurve(parent, name, points, False, 1, m)
setcolor(node, color)
return node
def addObjects(self):
# Ik Controlers ------------------------------------
t = tra.getTransformLookingAt(self.guide.pos["tan1"],
self.guide.pos["neck"],
self.guide.blades["blade"].z, "yx",
self.negate)
t = tra.setMatrixPosition(t, self.guide.pos["neck"])
self.ik_cns = pri.addTransform(self.root, self.getName("ik_cns"), t)
self.ik_ctl = self.addCtl(self.ik_cns,
"ik_ctl",
t,
self.color_ik,
"compas",
w=self.size * .5)
att.setKeyableAttributes(self.ik_ctl)
att.setRotOrder(self.ik_ctl, "XZY")
# Tangents -----------------------------------------
t = tra.setMatrixPosition(t, self.guide.pos["tan1"])
self.tan1_loc = pri.addTransform(self.ik_ctl, self.getName("tan1_loc"),
t)
t = tra.getTransformLookingAt(self.guide.pos["root"],
self.guide.pos["tan0"],
self.guide.blades["blade"].z, "yx",
self.negate)
t = tra.setMatrixPosition(t, self.guide.pos["tan0"])
self.tan0_loc = pri.addTransform(self.root, self.getName("tan0_loc"),
t)
# Curves -------------------------------------------
self.mst_crv = cur.addCnsCurve(
self.root, self.getName("mst_crv"),
[self.root, self.tan0_loc, self.tan1_loc, self.ik_ctl], 3)
self.slv_crv = cur.addCurve(self.root, self.getName("slv_crv"),
[dt.Vector()] * 10, False, 3)
self.mst_crv.setAttr("visibility", False)
self.slv_crv.setAttr("visibility", False)
# Division -----------------------------------------
# The user only define how many intermediate division he wants.
# First and last divisions are an obligation.
parentdiv = self.root
parentctl = self.root
self.div_cns = []
self.fk_ctl = []
self.fk_npo = []
self.scl_npo = []
for i in range(self.settings["division"]):
# References
div_cns = pri.addTransform(parentdiv, self.getName("%s_cns" % i))
setAttr(div_cns + ".inheritsTransform", False)
self.div_cns.append(div_cns)
parentdiv = div_cns
scl_npo = pri.addTransform(parentctl,
self.getName("%s_scl_npo" % i),
tra.getTransform(parentctl))
# Controlers (First and last one are fake)
if i in [0, self.settings["division"] - 1]:
fk_ctl = pri.addTransform(scl_npo, self.getName("%s_loc" % i),
tra.getTransform(parentctl))
fk_npo = fk_ctl
else:
fk_npo = pri.addTransform(scl_npo,
self.getName("fk%s_npo" % (i - 1)),
tra.getTransform(parentctl))
fk_ctl = self.addCtl(fk_npo,
"fk%s_ctl" % (i - 1),
tra.getTransform(parentctl),
self.color_fk,
"cube",
w=self.size * .2,
h=self.size * .05,
d=self.size * .2)
att.setKeyableAttributes(self.fk_ctl)
att.setRotOrder(fk_ctl, "XZY")
# setAttr(fk_npo+".inheritsTransform", False)
self.scl_npo.append(scl_npo)
self.fk_npo.append(fk_npo)
self.fk_ctl.append(fk_ctl)
parentctl = fk_ctl
# Deformers (Shadow)
self.addShadow(fk_ctl, i)
# Head ---------------------------------------------
t = tra.getTransformLookingAt(self.guide.pos["head"],
self.guide.pos["eff"],
self.guide.blades["blade"].z, "yx",
self.negate)
self.head_cns = pri.addTransform(self.root, self.getName("head_cns"),
t)
dist = vec.getDistance(self.guide.pos["head"], self.guide.pos["eff"])
self.head_ctl = self.addCtl(self.head_cns,
"head_ctl",
t,
self.color_fk,
"cube",
w=self.size * .5,
h=dist,
d=self.size * .5,
po=dt.Vector(0, dist * .5, 0))
att.setRotOrder(self.head_ctl, "XZY")
self.addShadow(self.head_ctl, "head")
def cylinder(parent=None, name="cylinder", width=1, heigth=1, color=[0,0,0], m=dt.Matrix(), pos_offset=None, rot_offset=None):
"""
Create a curve with a CYLINDER shape.
Args:
parent (dagNode): The parent object of the newly created curve.
name (str): Name of the curve.
width (float): Width of the shape.
height (float): Height of the shape.
color (int or list of float): The color in index base or RGB.
m (matrix): The global transformation of the curve.
pos_offset (vector): The xyz position offset of the curve from its center.
rot_offset (vector): The xyz rotation offset of the curve from its center. xyz in radians
Returns:
dagNode: The newly created icon.
"""
dlen = width * .5
dhei = heigth * .5
# upper circle
v0 = dt.Vector(0, dhei, -dlen * 1.108)
v1 = dt.Vector(dlen * .78 , dhei, -dlen * .78)
v2 = dt.Vector(dlen * 1.108, dhei, 0)
v3 = dt.Vector(dlen * .78 , dhei, dlen * .78)
v4 = dt.Vector(0, dhei, dlen * 1.108)
v5 = dt.Vector(-dlen * .78 , dhei, dlen * .78)
v6 = dt.Vector(-dlen * 1.108, dhei, 0)
v7 = dt.Vector(-dlen * .78 , dhei, -dlen * .78)
# lower circle
v8 = dt.Vector(0, -dhei, -dlen * 1.108)
v9 = dt.Vector(dlen * .78 , -dhei, -dlen * .78)
v10 = dt.Vector(dlen * 1.108, -dhei, 0)
v11 = dt.Vector(dlen * .78 , -dhei, dlen * .78)
v12 = dt.Vector(0, -dhei, dlen * 1.108)
v13 = dt.Vector(-dlen * .78 , -dhei, dlen * .78)
v14 = dt.Vector(-dlen * 1.108, -dhei, 0)
v15 = dt.Vector(-dlen * .78 , -dhei, -dlen * .78)
# curves
v16 = dt.Vector(0, dhei, -dlen)
v17 = dt.Vector(0, -dhei, -dlen)
v18 = dt.Vector(0, -dhei, dlen)
v19 = dt.Vector(0, dhei, dlen)
v20 = dt.Vector(dlen, dhei, 0)
v21 = dt.Vector(dlen, -dhei, 0)
v22 = dt.Vector(-dlen, -dhei, 0)
v23 = dt.Vector(-dlen, dhei, 0)
points = getPointArrayWithOffset([v0, v1, v2, v3, v4, v5, v6, v7], pos_offset, rot_offset)
node = cur.addCurve(parent, name, points, True, 3, m)
points = getPointArrayWithOffset([v8, v9, v10, v11, v12, v13, v14, v15], pos_offset, rot_offset)
crv_0 = cur.addCurve(parent, node+"_0crv", points, True, 3, m)
points = getPointArrayWithOffset([v16, v17], pos_offset, rot_offset)
crv_1 = cur.addCurve(parent, node+"_1crv", points, True, 1, m)
points = getPointArrayWithOffset([v18, v19], pos_offset, rot_offset)
crv_2 = cur.addCurve(parent, node+"_2crv", points, True, 1, m)
points = getPointArrayWithOffset([v20, v21], pos_offset, rot_offset)
crv_3 = cur.addCurve(parent, node+"_3crv", points, True, 1, m)
points = getPointArrayWithOffset([v22, v23], pos_offset, rot_offset)
crv_4 = cur.addCurve(parent, node+"_4crv", points, True, 1, m)
for crv in [crv_0, crv_1, crv_2, crv_3, crv_4]:
for shp in crv.listRelatives(shapes=True):
node.addChild(shp, add=True, shape=True)
pm.delete(crv)
setcolor(node, color)
return node
def cylinder(parent=None, name="cylinder", width=1, heigth=1, color=[0,0,0], m=dt.Matrix(), pos_offset=None, rot_offset=None):
dlen = width * .5
dhei = heigth * .5
# upper circle
v0 = dt.Vector(0, dhei, -dlen * 1.108)
v1 = dt.Vector(dlen * .78 , dhei, -dlen * .78)
v2 = dt.Vector(dlen * 1.108, dhei, 0)
v3 = dt.Vector(dlen * .78 , dhei, dlen * .78)
v4 = dt.Vector(0, dhei, dlen * 1.108)
v5 = dt.Vector(-dlen * .78 , dhei, dlen * .78)
v6 = dt.Vector(-dlen * 1.108, dhei, 0)
v7 = dt.Vector(-dlen * .78 , dhei, -dlen * .78)
# lower circle
v8 = dt.Vector(0, -dhei, -dlen * 1.108)
v9 = dt.Vector(dlen * .78 , -dhei, -dlen * .78)
v10 = dt.Vector(dlen * 1.108, -dhei, 0)
v11 = dt.Vector(dlen * .78 , -dhei, dlen * .78)
v12 = dt.Vector(0, -dhei, dlen * 1.108)
v13 = dt.Vector(-dlen * .78 , -dhei, dlen * .78)
v14 = dt.Vector(-dlen * 1.108, -dhei, 0)
v15 = dt.Vector(-dlen * .78 , -dhei, -dlen * .78)
# curves
v16 = dt.Vector(0, dhei, -dlen)
v17 = dt.Vector(0, -dhei, -dlen)
v18 = dt.Vector(0, -dhei, dlen)
v19 = dt.Vector(0, dhei, dlen)
v20 = dt.Vector(dlen, dhei, 0)
v21 = dt.Vector(dlen, -dhei, 0)
v22 = dt.Vector(-dlen, -dhei, 0)
v23 = dt.Vector(-dlen, dhei, 0)
points = getPointArrayWithOffset([v0, v1, v2, v3, v4, v5, v6, v7], pos_offset, rot_offset)
node = cur.addCurve(parent, name, points, True, 3, m)
points = getPointArrayWithOffset([v8, v9, v10, v11, v12, v13, v14, v15], pos_offset, rot_offset)
crv_0 = cur.addCurve(parent, node+"_0crv", points, True, 3, m)
points = getPointArrayWithOffset([v16, v17], pos_offset, rot_offset)
crv_1 = cur.addCurve(parent, node+"_1crv", points, True, 1, m)
points = getPointArrayWithOffset([v18, v19], pos_offset, rot_offset)
crv_2 = cur.addCurve(parent, node+"_2crv", points, True, 1, m)
points = getPointArrayWithOffset([v20, v21], pos_offset, rot_offset)
crv_3 = cur.addCurve(parent, node+"_3crv", points, True, 1, m)
points = getPointArrayWithOffset([v22, v23], pos_offset, rot_offset)
crv_4 = cur.addCurve(parent, node+"_4crv", points, True, 1, m)
for crv in [crv_0, crv_1, crv_2, crv_3, crv_4]:
for shp in crv.listRelatives(shapes=True):
node.addChild(shp, add=True, shape=True)
delete(crv)
setcolor(node, color)
return node
def addObjects(self):
# Ik Controlers ------------------------------------
t = tra.getTransformLookingAt(self.guide.pos["tan1"], self.guide.pos["neck"], self.guide.blades["blade"].z, "yx", self.negate)
t = tra.setMatrixPosition(t, self.guide.pos["neck"])
self.ik_cns = pri.addTransform(self.root, self.getName("ik_cns"), t)
self.ik_ctl = self.addCtl(self.ik_cns, "ik_ctl", t, self.color_ik, "compas", w=self.size*.5)
att.setKeyableAttributes(self.ik_ctl)
att.setRotOrder(self.ik_ctl, "XZY")
# Tangents -----------------------------------------
t = tra.setMatrixPosition(t, self.guide.pos["tan1"])
self.tan1_loc = pri.addTransform(self.ik_ctl, self.getName("tan1_loc"), t)
t = tra.getTransformLookingAt(self.guide.pos["root"], self.guide.pos["tan0"], self.guide.blades["blade"].z, "yx", self.negate)
t = tra.setMatrixPosition(t, self.guide.pos["tan0"])
self.tan0_loc = pri.addTransform(self.root, self.getName("tan0_loc"), t)
# Curves -------------------------------------------
self.mst_crv = cur.addCnsCurve(self.root, self.getName("mst_crv"), [self.root, self.tan0_loc, self.tan1_loc, self.ik_ctl], 3)
self.slv_crv = cur.addCurve(self.root, self.getName("slv_crv"), [dt.Vector()]*10, False, 3)
self.mst_crv.setAttr("visibility", False)
self.slv_crv.setAttr("visibility", False)
# Division -----------------------------------------
# The user only define how many intermediate division he wants.
# First and last divisions are an obligation.
parentdiv = self.root
parentctl = self.root
self.div_cns = []
self.fk_ctl = []
self.fk_npo = []
self.scl_npo = []
for i in range(self.settings["division"]):
# References
div_cns = pri.addTransform(parentdiv, self.getName("%s_cns"%i))
setAttr(div_cns+".inheritsTransform", False)
self.div_cns.append(div_cns)
parentdiv = div_cns
scl_npo = pri.addTransform(parentctl, self.getName("%s_scl_npo"%i), tra.getTransform(parentctl))
# Controlers (First and last one are fake)
if i in [0, self.settings["division"] - 1]:
fk_ctl = pri.addTransform(scl_npo, self.getName("%s_loc"%i), tra.getTransform(parentctl))
fk_npo = fk_ctl
else:
fk_npo = pri.addTransform(scl_npo, self.getName("fk%s_npo"%(i-1)), tra.getTransform(parentctl))
fk_ctl = self.addCtl(fk_npo, "fk%s_ctl"%(i-1), tra.getTransform(parentctl), self.color_fk, "cube", w=self.size*.2, h=self.size*.05, d=self.size*.2)
att.setKeyableAttributes(self.fk_ctl)
att.setRotOrder(fk_ctl, "XZY")
# setAttr(fk_npo+".inheritsTransform", False)
self.scl_npo.append(scl_npo)
self.fk_npo.append(fk_npo)
self.fk_ctl.append(fk_ctl)
parentctl = fk_ctl
# Deformers (Shadow)
self.addShadow(fk_ctl, i)
# Head ---------------------------------------------
t = tra.getTransformLookingAt(self.guide.pos["head"], self.guide.pos["eff"], self.guide.blades["blade"].z, "yx", self.negate)
self.head_cns = pri.addTransform(self.root, self.getName("head_cns"), t)
dist = vec.getDistance(self.guide.pos["head"], self.guide.pos["eff"])
self.head_ctl = self.addCtl(self.head_cns, "head_ctl", t, self.color_fk, "cube", w=self.size*.5, h=dist, d=self.size*.5, po=dt.Vector(0,dist*.5,0))
att.setRotOrder(self.head_ctl, "XZY")
self.addShadow(self.head_ctl, "head")
def addObjects(self):
# Ik Controlers ------------------------------------
t = tra.getTransformLookingAt(self.guide.apos[0], self.guide.apos[1],
self.guide.blades["blade"].z, "yx",
self.negate)
self.ik0_npo = pri.addTransform(self.root, self.getName("ik0_npo"), t)
self.ik0_ctl = self.addCtl(self.ik0_npo,
"ik0_ctl",
t,
self.color_ik,
"compas",
w=self.size)
att.setKeyableAttributes(self.ik0_ctl)
att.setRotOrder(self.ik0_ctl, "XZY")
t = tra.setMatrixPosition(t, self.guide.apos[1])
self.ik1_npo = pri.addTransform(self.root, self.getName("ik1_npo"), t)
self.ik1_ctl = self.addCtl(self.ik1_npo,
"ik1_ctl",
t,
self.color_ik,
"compas",
w=self.size)
att.setKeyableAttributes(self.ik1_ctl)
att.setRotOrder(self.ik1_ctl, "XZY")
# Tangent controlers -------------------------------
t = tra.setMatrixPosition(
t,
vec.linearlyInterpolate(self.guide.apos[0], self.guide.apos[1],
.33))
self.tan0_npo = pri.addTransform(self.ik0_ctl,
self.getName("tan0_npo"), t)
self.tan0_ctl = self.addCtl(self.tan0_npo,
"tan0_ctl",
t,
self.color_ik,
"sphere",
w=self.size * .2)
att.setKeyableAttributes(self.tan0_ctl, self.t_params)
t = tra.setMatrixPosition(
t,
vec.linearlyInterpolate(self.guide.apos[0], self.guide.apos[1],
.66))
self.tan1_npo = pri.addTransform(self.ik1_ctl,
self.getName("tan1_npo"), t)
self.tan1_ctl = self.addCtl(self.tan1_npo,
"tan1_ctl",
t,
self.color_ik,
"sphere",
w=self.size * .2)
att.setKeyableAttributes(self.tan1_ctl, self.t_params)
# Curves -------------------------------------------
self.mst_crv = cur.addCnsCurve(
self.root, self.getName("mst_crv"),
[self.ik0_ctl, self.tan0_ctl, self.tan1_ctl, self.ik1_ctl], 3)
self.slv_crv = cur.addCurve(self.root, self.getName("slv_crv"),
[dt.Vector()] * 10, False, 3)
self.mst_crv.setAttr("visibility", False)
self.slv_crv.setAttr("visibility", False)
# Division -----------------------------------------
# The user only define how many intermediate division he wants.
# First and last divisions are an obligation.
parentdiv = self.root
parentctl = self.root
self.div_cns = []
self.fk_ctl = []
self.fk_npo = []
self.scl_npo = []
for i in range(self.settings["division"]):
# References
div_cns = pri.addTransform(parentdiv, self.getName("%s_cns" % i))
setAttr(div_cns + ".inheritsTransform", False)
self.div_cns.append(div_cns)
parentdiv = div_cns
scl_npo = pri.addTransform(parentctl,
self.getName("%s_scl_npo" % i),
tra.getTransform(parentctl))
# Controlers (First and last one are fake)
if i in [0, self.settings["division"] - 1]:
fk_ctl = pri.addTransform(scl_npo, self.getName("%s_loc" % i),
tra.getTransform(parentctl))
fk_npo = fk_ctl
else:
fk_npo = pri.addTransform(scl_npo,
self.getName("fk%s_npo" % (i - 1)),
tra.getTransform(parentctl))
fk_ctl = self.addCtl(fk_npo,
"fk%s_ctl" % (i - 1),
tra.getTransform(parentctl),
self.color_fk,
"cube",
w=self.size,
h=self.size * .05,
d=self.size)
att.setKeyableAttributes(self.fk_ctl)
att.setRotOrder(fk_ctl, "XZY")
# setAttr(fk_npo+".inheritsTransform", False)
self.scl_npo.append(scl_npo)
self.fk_npo.append(fk_npo)
self.fk_ctl.append(fk_ctl)
parentctl = fk_ctl
# Deformers (Shadow)
self.addShadow(fk_ctl, i)
# Connections (Hooks) ------------------------------
self.cnx0 = pri.addTransform(self.root, self.getName("0_cnx"))
self.cnx1 = pri.addTransform(self.root, self.getName("1_cnx"))
def addObjects(self):
self.normal = self.guide.blades["blade"].z*-1
# Ik Controlers ------------------------------------
t = tra.getTransformLookingAt(self.guide.pos["tan1"], self.guide.pos["neck"], self.normal, "yx", self.negate)
t = tra.setMatrixPosition(t, self.guide.pos["neck"])
self.ik_cns = pri.addTransform(self.root, self.getName("ik_cns"), t)
self.ik_ctl = self.addCtl(self.ik_cns, "ik_ctl", t, self.color_ik, "compas", w=self.size*.5)
att.setKeyableAttributes(self.ik_ctl)
att.setRotOrder(self.ik_ctl, "ZXY")
# Tangents -----------------------------------------
t = tra.setMatrixPosition(t, self.guide.pos["tan1"])
self.tan1_loc = pri.addTransform(self.ik_ctl, self.getName("tan1_loc"), t)
t = tra.getTransformLookingAt(self.guide.pos["root"], self.guide.pos["tan0"], self.normal, "yx", self.negate)
t = tra.setMatrixPosition(t, self.guide.pos["tan0"])
self.tan0_loc = pri.addTransform(self.root, self.getName("tan0_loc"), t)
# Curves -------------------------------------------
self.mst_crv = cur.addCnsCurve(self.root, self.getName("mst_crv"), [self.root, self.tan0_loc, self.tan1_loc, self.ik_ctl], 3)
self.slv_crv = cur.addCurve(self.root, self.getName("slv_crv"), [dt.Vector()]*10, False, 3)
self.mst_crv.setAttr("visibility", False)
self.slv_crv.setAttr("visibility", False)
# Division -----------------------------------------
# The user only define how many intermediate division he wants.
# First and last divisions are an obligation.
parentdiv = self.root
parentctl = self.root
self.div_cns = []
self.fk_ctl = []
self.fk_npo = []
self.scl_npo = []
self.twister = []
self.ref_twist = []
parent_twistRef = pri.addTransform(self.root, self.getName("reference"), tra.getTransform(self.root))
for i in range(self.settings["division"]):
# References
div_cns = pri.addTransform(parentdiv, self.getName("%s_cns"%i))
pm.setAttr(div_cns+".inheritsTransform", False)
self.div_cns.append(div_cns)
parentdiv = div_cns
scl_npo = pri.addTransform(parentctl, self.getName("%s_scl_npo"%i), tra.getTransform(parentctl))
# Controlers (First and last one are fake)
if i in [ self.settings["division"] - 1]: # 0,
fk_ctl = pri.addTransform(scl_npo, self.getName("%s_loc"%i), tra.getTransform(parentctl))
fk_npo = fk_ctl
else:
fk_npo = pri.addTransform(scl_npo, self.getName("fk%s_npo"%i), tra.getTransform(parentctl))
fk_ctl = self.addCtl(fk_npo, "fk%s_ctl"%i, tra.getTransform(parentctl), self.color_fk, "cube", w=self.size*.2, h=self.size*.05, d=self.size*.2)
att.setKeyableAttributes(self.fk_ctl)
att.setRotOrder(fk_ctl, "ZXY")
self.scl_npo.append(scl_npo)
self.fk_npo.append(fk_npo)
self.fk_ctl.append(fk_ctl)
parentctl = fk_ctl
self.jnt_pos.append([fk_ctl, i])
#Twist references (This objects will replace the spinlookup slerp solver behavior)
twister = pri.addTransform(parent_twistRef, self.getName("%s_rot_ref"%i), tra.getTransform(parent_twistRef))
t = tra.getTransform(self.root)
t[3] = [t[3][0], t[3][1], 1.0, 1.0]
ref_twist = pri.addTransform(parent_twistRef, self.getName("%s_pos_ref"%i), t)
self.twister.append(twister)
self.ref_twist.append(ref_twist)
# Head ---------------------------------------------
t = tra.getTransformLookingAt(self.guide.pos["head"], self.guide.pos["eff"], self.normal, "yx", self.negate)
self.head_cns = pri.addTransform(self.root, self.getName("head_cns"), t)
dist = vec.getDistance(self.guide.pos["head"], self.guide.pos["eff"])
self.head_ctl = self.addCtl(self.head_cns, "head_ctl", t, self.color_fk, "cube", w=self.size*.5, h=dist, d=self.size*.5, po=dt.Vector(0,dist*.5,0))
att.setRotOrder(self.head_ctl, "ZXY")
self.jnt_pos.append([self.head_ctl, "head"])
def addObjects(self):
"""Add all the objects needed to create the component."""
# Auto bend with position controls --------------------
if self.settings["autoBend"]:
self.autoBendChain = primitive.add2DChain(
self.root,
self.getName("autoBend%s_jnt"),
[self.guide.apos[0], self.guide.apos[1]],
self.guide.blades["blade"].z * -1,
False,
True)
for j in self.autoBendChain:
j.drawStyle.set(2)
# Ik Controlers ------------------------------------
t = transform.getTransformLookingAt(self.guide.apos[0],
self.guide.apos[1],
self.guide.blades["blade"].z * -1,
"yx",
self.negate)
self.ik0_npo = primitive.addTransform(
self.root, self.getName("ik0_npo"), t)
self.ik0_ctl = self.addCtl(self.ik0_npo,
"ik0_ctl",
t,
self.color_ik,
"compas",
w=self.size,
tp=self.parentCtlTag)
attribute.setKeyableAttributes(self.ik0_ctl, self.tr_params)
attribute.setRotOrder(self.ik0_ctl, "ZXY")
attribute.setInvertMirror(self.ik0_ctl, ["tx", "ry", "rz"])
t = transform.setMatrixPosition(t, self.guide.apos[1])
if self.settings["autoBend"]:
self.autoBend_npo = primitive.addTransform(
self.root, self.getName("spinePosition_npo"), t)
self.autoBend_ctl = self.addCtl(self.autoBend_npo,
"spinePosition_ctl",
t,
self.color_ik,
"square",
w=self.size,
d=.3 * self.size,
tp=self.parentCtlTag)
attribute.setKeyableAttributes(self.autoBend_ctl,
["tx", "ty", "tz", "ry"])
attribute.setInvertMirror(self.autoBend_ctl, ["tx", "ry"])
self.ik1_npo = primitive.addTransform(
self.autoBendChain[0], self.getName("ik1_npo"), t)
self.ik1autoRot_lvl = primitive.addTransform(
self.ik1_npo, self.getName("ik1autoRot_lvl"), t)
self.ik1_ctl = self.addCtl(self.ik1autoRot_lvl,
"ik1_ctl",
t,
self.color_ik,
"compas",
w=self.size,
tp=self.autoBend_ctl)
else:
t = transform.setMatrixPosition(t, self.guide.apos[1])
self.ik1_npo = primitive.addTransform(
self.root, self.getName("ik1_npo"), t)
self.ik1_ctl = self.addCtl(self.ik1_npo,
"ik1_ctl",
t,
self.color_ik,
"compas",
w=self.size,
tp=self.ik0_ctl)
attribute.setKeyableAttributes(self.ik1_ctl, self.tr_params)
attribute.setRotOrder(self.ik1_ctl, "ZXY")
attribute.setInvertMirror(self.ik1_ctl, ["tx", "ry", "rz"])
# Tangent controllers -------------------------------
if self.settings["centralTangent"]:
vec_pos = vector.linearlyInterpolate(self.guide.apos[0],
self.guide.apos[1],
.33)
t = transform.setMatrixPosition(t, vec_pos)
self.tan0_npo = primitive.addTransform(
self.ik0_ctl, self.getName("tan0_npo"), t)
self.tan0_off = primitive.addTransform(
self.tan0_npo, self.getName("tan0_off"), t)
self.tan0_ctl = self.addCtl(self.tan0_off,
"tan0_ctl",
t,
self.color_ik,
"sphere",
w=self.size * .1,
tp=self.ik0_ctl)
attribute.setKeyableAttributes(self.tan0_ctl, self.t_params)
vec_pos = vector.linearlyInterpolate(self.guide.apos[0],
self.guide.apos[1],
.66)
t = transform.setMatrixPosition(t, vec_pos)
self.tan1_npo = primitive.addTransform(
self.ik1_ctl, self.getName("tan1_npo"), t)
self.tan1_off = primitive.addTransform(
self.tan1_npo, self.getName("tan1_off"), t)
self.tan1_ctl = self.addCtl(self.tan1_off,
"tan1_ctl",
t,
self.color_ik,
"sphere",
w=self.size * .1,
tp=self.ik0_ctl)
attribute.setKeyableAttributes(self.tan1_ctl, self.t_params)
# Tangent mid control
vec_pos = vector.linearlyInterpolate(self.guide.apos[0],
self.guide.apos[1],
.5)
t = transform.setMatrixPosition(t, vec_pos)
self.tan_npo = primitive.addTransform(
self.tan0_npo, self.getName("tan_npo"), t)
self.tan_ctl = self.addCtl(self.tan_npo,
"tan_ctl",
t,
self.color_fk,
"sphere",
w=self.size * .2,
tp=self.ik1_ctl)
attribute.setKeyableAttributes(self.tan_ctl, self.t_params)
attribute.setInvertMirror(self.tan_ctl, ["tx"])
else:
vec_pos = vector.linearlyInterpolate(self.guide.apos[0],
self.guide.apos[1],
.33)
t = transform.setMatrixPosition(t, vec_pos)
self.tan0_npo = primitive.addTransform(
self.ik0_ctl, self.getName("tan0_npo"), t)
self.tan0_ctl = self.addCtl(self.tan0_npo,
"tan0_ctl",
t,
self.color_ik,
"sphere",
w=self.size * .2,
tp=self.ik0_ctl)
attribute.setKeyableAttributes(self.tan0_ctl, self.t_params)
vec_pos = vector.linearlyInterpolate(self.guide.apos[0],
self.guide.apos[1],
.66)
t = transform.setMatrixPosition(t, vec_pos)
self.tan1_npo = primitive.addTransform(
self.ik1_ctl, self.getName("tan1_npo"), t)
self.tan1_ctl = self.addCtl(self.tan1_npo,
"tan1_ctl",
t,
self.color_ik,
"sphere",
w=self.size * .2,
tp=self.ik1_ctl)
attribute.setKeyableAttributes(self.tan1_ctl, self.t_params)
attribute.setInvertMirror(self.tan0_ctl, ["tx"])
attribute.setInvertMirror(self.tan1_ctl, ["tx"])
# Curves -------------------------------------------
self.mst_crv = curve.addCnsCurve(
self.root,
self.getName("mst_crv"),
[self.ik0_ctl, self.tan0_ctl, self.tan1_ctl, self.ik1_ctl],
3)
self.slv_crv = curve.addCurve(self.root, self.getName("slv_crv"),
[datatypes.Vector()] * 10,
False,
3)
self.mst_crv.setAttr("visibility", False)
self.slv_crv.setAttr("visibility", False)
# Division -----------------------------------------
# The user only define how many intermediate division he wants.
# First and last divisions are an obligation.
parentdiv = self.root
parentctl = self.root
self.div_cns = []
self.fk_ctl = []
self.fk_npo = []
self.scl_transforms = []
self.twister = []
self.ref_twist = []
t = transform.getTransformLookingAt(
self.guide.apos[0],
self.guide.apos[1],
self.guide.blades["blade"].z * -1,
"yx",
self.negate)
parent_twistRef = primitive.addTransform(
self.root,
self.getName("reference"),
transform.getTransform(self.root))
self.jointList = []
self.preiviousCtlTag = self.parentCtlTag
for i in range(self.settings["division"]):
# References
div_cns = primitive.addTransform(parentdiv,
self.getName("%s_cns" % i))
pm.setAttr(div_cns + ".inheritsTransform", False)
self.div_cns.append(div_cns)
parentdiv = div_cns
# Controlers (First and last one are fake)
# if i in [0]:
# TODO: add option setting to add or not the first and last
# controller for the fk
# if i in [0, self.settings["division"] - 1] and False:
if i in [0, self.settings["division"] - 1]:
fk_ctl = primitive.addTransform(
parentctl,
self.getName("%s_loc" % i),
transform.getTransform(parentctl))
fk_npo = fk_ctl
if i in [self.settings["division"] - 1]:
self.fk_ctl.append(fk_ctl)
else:
fk_npo = primitive.addTransform(
parentctl,
self.getName("fk%s_npo" % (i - 1)),
transform.getTransform(parentctl))
fk_ctl = self.addCtl(fk_npo,
"fk%s_ctl" % (i - 1),
transform.getTransform(parentctl),
self.color_fk,
"cube",
w=self.size,
h=self.size * .05,
d=self.size,
tp=self.preiviousCtlTag)
attribute.setKeyableAttributes(self.fk_ctl)
attribute.setRotOrder(fk_ctl, "ZXY")
self.fk_ctl.append(fk_ctl)
self.preiviousCtlTag = fk_ctl
# setAttr(fk_npo+".inheritsTransform", False)
self.fk_npo.append(fk_npo)
parentctl = fk_ctl
scl_ref = primitive.addTransform(parentctl,
self.getName("%s_scl_ref" % i),
transform.getTransform(parentctl))
self.scl_transforms.append(scl_ref)
# Deformers (Shadow)
self.jnt_pos.append([scl_ref, i])
# Twist references (This objects will replace the spinlookup slerp
# solver behavior)
t = transform.getTransformLookingAt(
self.guide.apos[0],
self.guide.apos[1],
self.guide.blades["blade"].z * -1,
"yx",
self.negate)
twister = primitive.addTransform(
parent_twistRef, self.getName("%s_rot_ref" % i), t)
ref_twist = primitive.addTransform(
parent_twistRef, self.getName("%s_pos_ref" % i), t)
ref_twist.setTranslation(
datatypes.Vector(1.0, 0, 0), space="preTransform")
self.twister.append(twister)
self.ref_twist.append(ref_twist)
# TODO: update this part with the optiona FK controls update
for x in self.fk_ctl[:-1]:
attribute.setInvertMirror(x, ["tx", "rz", "ry"])
# Connections (Hooks) ------------------------------
self.cnx0 = primitive.addTransform(self.root, self.getName("0_cnx"))
self.cnx1 = primitive.addTransform(self.root, self.getName("1_cnx"))
def addObjects(self):
"""Add all the objects needed to create the component."""
self.normal = self.guide.blades["blade"].z * -1
# Ik Controlers ------------------------------------
t = transform.getTransformLookingAt(self.guide.pos["tan1"],
self.guide.pos["neck"],
self.normal, "yx", self.negate)
t = transform.setMatrixPosition(t, self.guide.pos["neck"])
self.ik_cns = primitive.addTransform(self.root, self.getName("ik_cns"),
t)
self.ik_ctl = self.addCtl(self.ik_cns,
"ik_ctl",
t,
self.color_ik,
"compas",
w=self.size * .5,
tp=self.parentCtlTag)
attribute.setKeyableAttributes(self.ik_ctl, self.tr_params)
attribute.setRotOrder(self.ik_ctl, "ZXY")
attribute.setInvertMirror(self.ik_ctl, ["tx", "ry", "rz"])
# Tangents -----------------------------------------
if self.settings["tangentControls"]:
t = transform.setMatrixPosition(t, self.guide.pos["tan1"])
self.tan1_loc = primitive.addTransform(self.ik_ctl,
self.getName("tan1_loc"), t)
self.tan1_ctl = self.addCtl(self.tan1_loc,
"tan1_ctl",
t,
self.color_ik,
"sphere",
w=self.size * .2,
tp=self.ik_ctl)
attribute.setKeyableAttributes(self.tan1_ctl, self.t_params)
attribute.setInvertMirror(self.tan1_ctl, ["tx"])
t = transform.getTransformLookingAt(self.guide.pos["root"],
self.guide.pos["tan0"],
self.normal, "yx", self.negate)
t = transform.setMatrixPosition(t, self.guide.pos["tan0"])
self.tan0_loc = primitive.addTransform(self.root,
self.getName("tan0_loc"), t)
self.tan0_ctl = self.addCtl(self.tan0_loc,
"tan0_ctl",
t,
self.color_ik,
"sphere",
w=self.size * .2,
tp=self.ik_ctl)
attribute.setKeyableAttributes(self.tan0_ctl, self.t_params)
attribute.setInvertMirror(self.tan0_ctl, ["tx"])
# Curves -------------------------------------------
self.mst_crv = curve.addCnsCurve(
self.root, self.getName("mst_crv"),
[self.root, self.tan0_ctl, self.tan1_ctl, self.ik_ctl], 3)
self.slv_crv = curve.addCurve(self.root, self.getName("slv_crv"),
[datatypes.Vector()] * 10, False, 3)
self.mst_crv.setAttr("visibility", False)
else:
t = transform.setMatrixPosition(t, self.guide.pos["tan1"])
self.tan1_loc = primitive.addTransform(self.ik_ctl,
self.getName("tan1_loc"), t)
t = transform.getTransformLookingAt(self.guide.pos["root"],
self.guide.pos["tan0"],
self.normal, "yx", self.negate)
t = transform.setMatrixPosition(t, self.guide.pos["tan0"])
self.tan0_loc = primitive.addTransform(self.root,
self.getName("tan0_loc"), t)
# Curves -------------------------------------------
self.mst_crv = curve.addCnsCurve(
self.root, self.getName("mst_crv"),
[self.root, self.tan0_loc, self.tan1_loc, self.ik_ctl], 3)
self.slv_crv = curve.addCurve(self.root, self.getName("slv_crv"),
[datatypes.Vector()] * 10, False, 3)
self.mst_crv.setAttr("visibility", False)
self.slv_crv.setAttr("visibility", False)
# Division -----------------------------------------
# The user only define how many intermediate division he wants.
# First and last divisions are an obligation.
parentdiv = self.root
parentctl = self.root
self.div_cns = []
self.fk_ctl = []
self.fk_npo = []
self.scl_npo = []
self.twister = []
self.ref_twist = []
parent_twistRef = primitive.addTransform(
self.root, self.getName("reference"),
transform.getTransform(self.root))
t = transform.getTransformLookingAt(self.guide.pos["root"],
self.guide.pos["neck"],
self.normal, "yx", self.negate)
self.intMRef = primitive.addTransform(self.root,
self.getName("intMRef"), t)
self.previousCtlTag = self.parentCtlTag
for i in range(self.settings["division"]):
# References
div_cns = primitive.addTransform(parentdiv,
self.getName("%s_cns" % i), t)
pm.setAttr(div_cns + ".inheritsTransform", False)
self.div_cns.append(div_cns)
parentdiv = div_cns
scl_npo = primitive.addTransform(parentctl,
self.getName("%s_scl_npo" % i),
transform.getTransform(parentctl))
# Controlers (First and last one are fake)
if i in [self.settings["division"] - 1]: # 0,
fk_ctl = primitive.addTransform(
scl_npo, self.getName("%s_loc" % i),
transform.getTransform(parentctl))
fk_npo = fk_ctl
else:
fk_npo = primitive.addTransform(
scl_npo, self.getName("fk%s_npo" % i),
transform.getTransform(parentctl))
fk_ctl = self.addCtl(fk_npo,
"fk%s_ctl" % i,
transform.getTransform(parentctl),
self.color_fk,
"cube",
w=self.size * .2,
h=self.size * .05,
d=self.size * .2,
tp=self.previousCtlTag)
attribute.setKeyableAttributes(self.fk_ctl)
attribute.setRotOrder(fk_ctl, "ZXY")
self.previousCtlTag = fk_ctl
self.fk_ctl.append(fk_ctl)
self.scl_npo.append(scl_npo)
self.fk_npo.append(fk_npo)
parentctl = fk_ctl
self.jnt_pos.append([fk_ctl, i])
t = transform.getTransformLookingAt(
self.guide.pos["root"], self.guide.pos["neck"],
self.guide.blades["blade"].z * -1, "yx", self.negate)
twister = primitive.addTransform(parent_twistRef,
self.getName("%s_rot_ref" % i), t)
ref_twist = primitive.addTransform(parent_twistRef,
self.getName("%s_pos_ref" % i),
t)
ref_twist.setTranslation(datatypes.Vector(0.0, 0, 1.0),
space="preTransform")
self.twister.append(twister)
self.ref_twist.append(ref_twist)
for x in self.fk_ctl[:-1]:
attribute.setInvertMirror(x, ["tx", "rz", "ry"])
# Head ---------------------------------------------
t = transform.getTransformLookingAt(self.guide.pos["head"],
self.guide.pos["eff"], self.normal,
"yx", self.negate)
self.head_cns = primitive.addTransform(self.root,
self.getName("head_cns"), t)
dist = vector.getDistance(self.guide.pos["head"],
self.guide.pos["eff"])
self.head_ctl = self.addCtl(self.head_cns,
"head_ctl",
t,
self.color_fk,
"cube",
w=self.size * .5,
h=dist,
d=self.size * .5,
po=datatypes.Vector(0, dist * .5, 0),
tp=self.previousCtlTag)
attribute.setRotOrder(self.head_ctl, "ZXY")
attribute.setInvertMirror(self.head_ctl, ["tx", "rz", "ry"])
self.jnt_pos.append([self.head_ctl, "head"])
def addObjects(self):
# Ik Controlers ------------------------------------
t = tra.getTransformLookingAt(self.guide.apos[0], self.guide.apos[1], self.guide.blades["blade"].z, "yx", self.negate)
self.ik0_npo = pri.addTransform(self.root, self.getName("ik0_npo"), t)
self.ik0_ctl = self.addCtl(self.ik0_npo, "ik0_ctl", t, self.color_ik, "compas", w=self.size)
att.setKeyableAttributes(self.ik0_ctl)
att.setRotOrder(self.ik0_ctl, "XZY")
t = tra.setMatrixPosition(t, self.guide.apos[1])
self.ik1_npo = pri.addTransform(self.root, self.getName("ik1_npo"), t)
self.ik1_ctl = self.addCtl(self.ik1_npo, "ik1_ctl", t, self.color_ik, "compas", w=self.size)
att.setKeyableAttributes(self.ik1_ctl)
att.setRotOrder(self.ik1_ctl, "XZY")
# Tangent controlers -------------------------------
t = tra.setMatrixPosition(t, vec.linearlyInterpolate(self.guide.apos[0], self.guide.apos[1], .33))
self.tan0_npo = pri.addTransform(self.ik0_ctl, self.getName("tan0_npo"), t)
self.tan0_ctl = self.addCtl(self.tan0_npo, "tan0_ctl", t, self.color_ik, "sphere", w=self.size*.2)
att.setKeyableAttributes(self.tan0_ctl, self.t_params)
t = tra.setMatrixPosition(t, vec.linearlyInterpolate(self.guide.apos[0], self.guide.apos[1], .66))
self.tan1_npo = pri.addTransform(self.ik1_ctl, self.getName("tan1_npo"), t)
self.tan1_ctl = self.addCtl(self.tan1_npo, "tan1_ctl", t, self.color_ik, "sphere", w=self.size*.2)
att.setKeyableAttributes(self.tan1_ctl, self.t_params)
# Curves -------------------------------------------
self.mst_crv = cur.addCnsCurve(self.root, self.getName("mst_crv"), [self.ik0_ctl, self.tan0_ctl, self.tan1_ctl, self.ik1_ctl], 3)
self.slv_crv = cur.addCurve(self.root, self.getName("slv_crv"), [dt.Vector()]*10, False, 3)
self.mst_crv.setAttr("visibility", False)
self.slv_crv.setAttr("visibility", False)
# Division -----------------------------------------
# The user only define how many intermediate division he wants.
# First and last divisions are an obligation.
parentdiv = self.root
parentctl = self.root
self.div_cns = []
self.fk_ctl = []
self.fk_npo = []
self.scl_npo = []
for i in range(self.settings["division"]):
# References
div_cns = pri.addTransform(parentdiv, self.getName("%s_cns"%i))
setAttr(div_cns+".inheritsTransform", False)
self.div_cns.append(div_cns)
parentdiv = div_cns
scl_npo = pri.addTransform(parentctl, self.getName("%s_scl_npo"%i), tra.getTransform(parentctl))
# Controlers (First and last one are fake)
if i in [0, self.settings["division"] - 1]:
fk_ctl = pri.addTransform(scl_npo, self.getName("%s_loc"%i), tra.getTransform(parentctl))
fk_npo = fk_ctl
else:
fk_npo = pri.addTransform(scl_npo, self.getName("fk%s_npo"%(i-1)), tra.getTransform(parentctl))
fk_ctl = self.addCtl(fk_npo, "fk%s_ctl"%(i-1), tra.getTransform(parentctl), self.color_fk, "cube", w=self.size, h=self.size*.05, d=self.size)
att.setKeyableAttributes(self.fk_ctl)
att.setRotOrder(fk_ctl, "XZY")
# setAttr(fk_npo+".inheritsTransform", False)
self.scl_npo.append(scl_npo)
self.fk_npo.append(fk_npo)
self.fk_ctl.append(fk_ctl)
parentctl = fk_ctl
# Deformers (Shadow)
self.addShadow(fk_ctl, i)
# Connections (Hooks) ------------------------------
self.cnx0 = pri.addTransform(self.root, self.getName("0_cnx"))
self.cnx1 = pri.addTransform(self.root, self.getName("1_cnx"))
