def main():
mesh_list = pm.ls(pm.pickWalk(d="down"), ni=1, type="mesh")
if not mesh_list:
return
csv_path = r"C:\Users\timmyliang\Desktop\file_test\2020-12-1\head.csv"
pm.progressWindow(title=u"设置顶点色", status=u"设置顶点色...", progress=0.0)
with open(csv_path, "r") as f:
reader = csv.DictReader(f)
data_list = {
int(row[" IDX"]): (
float(row[" COLOR.x"]),
float(row[" COLOR.y"]),
float(row[" COLOR.z"]),
float(row[" COLOR.w"]),
)
for row in reader
}
mesh = mesh_list[0]
mfn = mesh.__apimfn__()
itr = OpenMaya.MItMeshFaceVertex(mesh.__apimobject__())
face_list = OpenMaya.MIntArray()
vertex_list = OpenMaya.MIntArray()
colors = OpenMaya.MColorArray()
index = -1
total = len(mesh.vtxFace)
pm.progressWindow(title=u"设置顶点色", status=u"设置顶点色...", progress=0.0)
while not itr.isDone():
index += 1
pm.progressWindow(e=1, progress=index / total * 100)
vert_id = itr.vertId()
face_id = itr.faceId()
vertex_list.append(vert_id)
face_list.append(face_id)
color = data_list.get(vert_id)
if not color:
colors.append(OpenMaya.MColor(0, 0, 0))
itr.next()
continue
r, g, b,a = color
colors.append(OpenMaya.MColor(r, g, b))
itr.next()
mfn.setFaceVertexColors(colors, face_list, vertex_list)
pm.progressWindow(ep=1)
def WriteMeshVertexColor(fileRec, meshPath, prof):
print('write mesh vertex color %s' % meshPath.fullPathName())
itvert = om.MItMeshVertex(meshPath)
print('vertex count: %i' % itvert.count())
nf = itvert.count() * 3
fileRec.write('static const float s%s_%sVertexColors[%i] = {' %
(prof.prefixName, meshPath.partialPathName(), nf))
count = 0
while not itvert.isDone():
col = om.MColor()
itvert.getColor(col, prof.colorName)
fileRec.write("%ff, %ff, %ff, " % (col.r, col.g, col.b))
count += 1
if (count % 32 == 0) or (count == itvert.count() - 1):
fileRec.write("\n")
itvert.next()
fileRec.write('};\n')
def NormaltoColor(VecOriginlist, vTarNorArray, Intensity):
oMeshArray = VecOriginlist[0]
iVertArray = VecOriginlist[1]
iFaceArray = VecOriginlist[2]
vOriNorArray = VecOriginlist[3]
oMeshlist = VecOriginlist[5]
for y in range(oMeshlist.length()):
mMesh = om.MFnMesh(oMeshlist[y])
IntenVec = om.MVector(Intensity, Intensity, Intensity)
cVtxColorArray = om.MColorArray()
CiVertArray = om.MIntArray()
CiFaceArray = om.MIntArray()
samemeshposit = [
i for i in range(oMeshArray.length())
if oMeshArray[i] == oMeshlist[y]
]
for x in range(len(samemeshposit)):
posit = samemeshposit[x]
CiFaceArray.append(iFaceArray[posit])
CiVertArray.append(iVertArray[posit])
OriNor = vOriNorArray[posit]
TarNor = vTarNorArray[posit]
ResultNor = lerpVector(OriNor, TarNor, IntenVec)
cVtxColor = om.MColor((ResultNor.x + 1) / 2, (ResultNor.y + 1) / 2,
(ResultNor.z + 1) / 2, 1.0)
cVtxColorArray.append(cVtxColor)
mMesh.setFaceVertexColors(cVtxColorArray, CiFaceArray, CiVertArray)
def _CopyColorSetToMeshAsDisplayColor(self, srcMesh, colorSetName,
dstMesh):
"""
Copies a color set named colorSetName from the MFnMesh srcMesh to
the MFnMesh dstMesh. All existing color sets on dstMesh will be removed.
"""
testUsdExportColorSets._ClearColorSets(dstMesh)
colorSetData = OpenMaya.MColorArray()
unsetColor = OpenMaya.MColor(-999, -999, -999, -999)
srcMesh.getFaceVertexColors(colorSetData, colorSetName, unsetColor)
colorRep = srcMesh.getColorRepresentation(colorSetName)
colorRepString = 'RGBA'
if colorRep == OpenMaya.MFnMesh.kAlpha:
colorRepString = 'A'
elif colorRep == OpenMaya.MFnMesh.kRGB:
colorRepString = 'RGB'
isClamped = srcMesh.isColorClamped(colorSetName)
cmds.polyColorSet(dstMesh.name(),
create=True,
colorSet='displayColor',
representation=colorRepString,
clamped=isClamped)
dstMesh.setCurrentColorSetName('displayColor')
# XXX: The Maya setFaceVertexColor() API seems to somehow still author
# faceVertex colors we don't want it to, so after setting the ones we
# intend, we also remove the ones we don't.
removeFaces = OpenMaya.MIntArray()
removeVertices = OpenMaya.MIntArray()
itMeshFV = OpenMaya.MItMeshFaceVertex(srcMesh.object())
itMeshFV.reset()
while not itMeshFV.isDone():
faceId = itMeshFV.faceId()
vertId = itMeshFV.vertId()
faceVertId = itMeshFV.faceVertId()
next(itMeshFV)
colorIndexPtr = OpenMaya.intPtr()
srcMesh.getFaceVertexColorIndex(faceId, faceVertId, colorIndexPtr,
colorSetName)
colorSetValue = colorSetData[colorIndexPtr.value()]
if colorSetValue == unsetColor:
removeFaces.append(faceId)
removeVertices.append(vertId)
continue
dstMesh.setFaceVertexColor(colorSetValue, faceId, vertId, None,
colorRep)
if removeFaces.length() > 0 and removeVertices.length() > 0:
dstMesh.removeFaceVertexColors(removeFaces, removeVertices)
def deform(self, dataBlock, geoIter, mtx, multiIndex):
"""This method performs the deformation algorithm.
The geometry iterator passed to this method is in local space and not world space. To convert
points to world space use the matrix that is suppied.
* dataBlock [MDataBlock] is the node's datablock.
* geoIter [MItGeometry] is an iterator for the current geometry being deformed.
* mtx [MMatrix] is the geometry's world space transformation matrix.
* multiIndex [int] is the index corresponding to the requested output geometry.
"""
# pylint: disable=unused-argument
envelope = dataBlock.inputValue(
ompx.cvar.MPxGeometryFilter_envelope).asFloat()
amplitude = dataBlock.inputValue(TestDeformer.inAmplitude).asFloat()
displace = dataBlock.inputValue(TestDeformer.inDisplace).asFloat()
inputArrayHandle = dataBlock.outputArrayValue(
ompx.cvar.MPxGeometryFilter_input)
inputArrayHandle.jumpToElement(multiIndex)
inputElement = inputArrayHandle.outputValue()
inMesh = inputElement.child(
ompx.cvar.MPxGeometryFilter_inputGeom).asMesh()
outMeshArrayHandle = dataBlock.outputArrayValue(
ompx.cvar.MPxGeometryFilter_outputGeom)
outMesh = outMeshArrayHandle.inputValue().asMesh()
mMatrix = dataBlock.inputValue(TestDeformer.inMatrix).asMatrix()
vTrans = om1.MVector(mMatrix(3, 0), mMatrix(3, 1), mMatrix(3, 2))
meshFn = om1.MFnMesh(inMesh)
normalsArray = om1.MFloatVectorArray()
meshFn.getVertexNormals(False, normalsArray, om1.MSpace.kObject)
posArray = om1.MPointArray()
colorsArray = om1.MColorArray()
vertexArray = om1.MIntArray()
while not geoIter.isDone():
index = geoIter.index()
vertexArray.append(index)
pntPos = geoIter.position()
weight = self.weightValue(dataBlock, multiIndex, index)
colorsArray.append(om1.MColor(1, 0, 0, 1))
if weight != 0:
pntPos.x = pntPos.x + math.sin(
index + displace - vTrans[0]
) * amplitude * normalsArray[index].x * weight * envelope
pntPos.y = pntPos.y + math.sin(
index + displace - vTrans[0]
) * amplitude * normalsArray[index].y * weight * envelope
pntPos.z = pntPos.z + math.sin(
index + displace - vTrans[0]
) * amplitude * normalsArray[index].z * weight * envelope
posArray.append(pntPos)
geoIter.next()
meshFn.setObject(outMesh)
meshFn.setVertexColors(colorsArray, vertexArray)
geoIter.setAllPositions(posArray)
def tagMesh(meshDagPath):
"""Tag the points on the supplied mesh with vertex colors to store Maya's point order"""
# clear any extant vertex colors
try: cmds.polyColorSet(meshDagPath.partialPathName(), e=True, delete=True, acs=True)
except: pass
# encode each point index in the red and green channels of each point's color value
meshFn = om.MFnMesh(meshDagPath)
vertexCount = om.MIntArray()
vertexList = om.MIntArray()
meshFn.getVertices(vertexCount, vertexList)
vertexColors = om.MColorArray(meshFn.numVertices(), om.MColor(0.0,0.0,1.0,1.0))
for i in xrange(meshFn.numVertices()):
col = om.MColor(tagIndexToColor(i))
vertexColors[i].r = col.r
vertexColors[i].g = col.g
meshFn.createColorSetWithName('blendShapeIndexMap')
meshFn.setColors(vertexColors, 'blendShapeIndexMap')
meshFn.assignColors(vertexList)
def tagIndexToColor(i):
"""Encode an integer as an MColor value."""
# get 4 complete hex digits to represent i
asHex = hex(i)
digits = asHex[asHex.find('x')+1::][::-1]
while len(digits) < 4: digits += '0'
digits = digits[::-1]
# pack hex digits into the red and green color values
return om.MColor(
int('0x%s'%digits[2:4], 16)*__oneOverTwoFiftyFive,
int('0x%s'%digits[0:2], 16)*__oneOverTwoFiftyFive,
1.0,
1.0)
def create_object_openmaya():
global imported_object
cmds.select(all=True, hierarchy=True)
current_objs = cmds.ls(selection=True)
new_mesh = om.MFnMesh()
merge_vertices = True
point_tolerance = 0.0001
# create polys
for p in range(0, len(imported_object.polys), 1):
poly_list = []
v_count = len(imported_object.polys[p])
poly_list = om.MPointArray()
poly_list.setLength(v_count)
for i in range(v_count):
poly_list.set(
imported_object.omVertices[int(
imported_object.polys[p][i])], i)
new_mesh.addPolygon(poly_list, merge_vertices, point_tolerance)
# create weightmaps
if len(imported_object.weightMap) > 0:
for v in range(0, imported_object.vertexCount, 1):
c = imported_object.weightMap[v]
vColor = om.MColor(c, c, c, c)
new_mesh.setVertexColor(vColor, v)
# Set mesh edits
new_mesh.updateSurface()
cmds.select(all=True, hierarchy=True)
cmds.select(current_objs, deselect=True)
mesh = pm.selected()[0]
# create vertex normal map
if len(imported_object.vertexNormals) > 0:
for v in range(0, imported_object.vertexNormalsCount, 1):
values = imported_object.vertexNormals[v]
vertex_normal_vector = values[0]
polygon_id = int(values[1])
vert_id = int(values[2])
try:
pm.select(mesh.vtxFace[vert_id][polygon_id])
pm.polyNormalPerVertex(xyz=vertex_normal_vector)
except IndexError, e:
print e
def draw(self, view, path, style, status):
OpenMayaMPx.MPxManipContainer.draw(self, view, path, style, status)
if not self.isMouseDown:
return
u = OpenMaya.MPoint()
v = OpenMaya.MPoint()
drawText = ""
am = self.activeManip()
m = self.getTransformMtxFromNode(
self.helices[self.firstHelix].helixTransform)
if am is self.fDistanceFrontManip:
drawText = str(self.deltaFront)
if self.deltaFront > 0:
drawText = "+" + drawText
c = self.canMove(self.deltaFront)
if c[0]:
drawText = "< " + drawText
if c[1]:
drawText = drawText + " >"
u = self.sp * m
v = u + self.frontDir * self.frontDistance
elif am is self.fDistanceBackManip:
drawText = str(self.deltaBack)
if self.deltaBack > 0:
drawText = "+" + drawText
c = self.canMove(self.deltaBack)
if c[0]:
drawText = "< " + drawText
if c[1]:
drawText = drawText + " >"
u = self.ep * m
v = u + self.backDir * self.backDistance
w = OpenMaya.MPoint((u.x + v.x) / 2, (u.y + v.y) / 2, (u.z + v.z) / 2)
view.beginGL()
view.setDrawColor(OpenMaya.MColor(0.9, 0, 0))
view.drawText(drawText, w, OpenMayaUI.M3dView.kCenter)
view.endGL()
def apply_vert_colors(obj, colors, vert_indexes):
"""
Sets vert colors on the supplied mesh.
Args:
obj(string): Object to edit vert colors.
colors(float[]): A list of rgb values.
vert_indexes(int[]): A list of vertex indexes.
This should match the length of colors.
"""
obj_shapes = cmds.listRelatives(obj, f=True, shapes=True) or []
old_pcolor = set(
cmds.ls(cmds.listHistory(obj_shapes), type="polyColorPerVertex"))
color_array = OpenMaya.MColorArray()
int_array = OpenMaya.MIntArray()
for rgb, vert_index in zip(colors, vert_indexes):
color_array.append(OpenMaya.MColor(rgb[0], rgb[1], rgb[2]))
int_array.append(vert_index)
selection_list = OpenMaya.MSelectionList()
dag_path = OpenMaya.MDagPath()
selection_list.add(obj)
selection_list.getDagPath(0, dag_path)
mfn_mesh = OpenMaya.MFnMesh(dag_path)
mfn_mesh.setVertexColors(color_array,
int_array) # This creates polyColorPerVertex
new_pcolor = set(
cmds.ls(cmds.listHistory(obj_shapes), type="polyColorPerVertex"))
dif_pcolor = list(new_pcolor.difference(old_pcolor))
if dif_pcolor:
cmds.addAttr(dif_pcolor[0],
ln=constants.POLY_COLOR_PER_VERT,
dt="string")
cmds.rename(dif_pcolor[0], constants.POLY_COLOR_PER_VERT)
def draw(self, view, path, style, status):
view.beginGL()
# Push the current state
glFuncTable.glPushAttrib(openmayarender.MGL_CURRENT_BIT)
# Enable Blend mode(to enable transparency)
glFuncTable.glEnable(openmayarender.MGL_BLEND)
# Defined Blend function
glFuncTable.glBlendFunc(openmayarender.MGL_SRC_ALPHA,
openmayarender.MGL_ONE_MINUS_SRC_ALPHA)
if status == view.kActive:
glFuncTable.glColor4f(0.2, 0.5, 0.1, 0.3)
elif status == view.kLead:
glFuncTable.glColor4f(0.5, 0.2, 0.1, 0.3)
elif status == view.kDormant:
glFuncTable.glColor4f(0.1, 0.1, 0.1, 0.3)
# Draw Polygon shape
glFuncTable.glBegin(openmayarender.MGL_POLYGON)
glFuncTable.glVertex3f(-0.031, 0, -2.875)
glFuncTable.glVertex3f(-0.939, 0.1, -2.370)
glFuncTable.glVertex3f(-1.175, 0.2, -1.731)
glFuncTable.glVertex3f(-0.603, 0.3, 1.060)
glFuncTable.glVertex3f(0.473, 0.3, 1.026)
glFuncTable.glVertex3f(0.977, 0.2, -1.731)
glFuncTable.glVertex3f(0.809, 0.1, -2.337)
glFuncTable.glVertex3f(0.035, 0, -2.807)
glFuncTable.glEnd()
# Disable blend shape
glFuncTable.glDisable(openmayarender.MGL_BLEND)
# Restore the state
glFuncTable.glPopAttrib()
view.endGL()
view.setDrawColor(openmaya.MColor(0.1, 0.8, 0.7, 1.0))
view.drawText("Left Foot", openmaya.MPoint(0, 0, 0), view.kLeft)
def fn_createObject_openMaya():
global importedObj
cmds.select(all=True, hierarchy=True)
currentObjs = cmds.ls(selection=True)
newMesh = om.MFnMesh()
mergeVertices = True
pointTolerance = 0.0001
for p in range(0, len(importedObj.polys), 1):
polylist = []
vCount = len(importedObj.polys[p])
polylist = om.MPointArray()
polylist.setLength(vCount)
for i in range(vCount):
polylist.set(importedObj.omVertices[int(importedObj.polys[p][i])],
i)
newMesh.addPolygon(polylist, mergeVertices, pointTolerance)
if len(importedObj.weightMap) > 0:
for v in range(0, importedObj.vertexCount, 1):
c = importedObj.weightMap[v]
vColor = om.MColor(c, c, c, c)
newMesh.setVertexColor(vColor, v)
newMesh.updateSurface()
cmds.select(all=True, hierarchy=True)
cmds.select(currentObjs, deselect=True)
newObjs = cmds.ls(selection=True, transforms=True)
cmds.select(newObjs, replace=True)
cmds.sets(newObjs, e=True, forceElement='initialShadingGroup')
cmds.rename(newObjs, importObjectName)
def BuildVecOrigin():
dagPathMeshArray, oCompsArray, oMeshList = _getSelectedComponents()
if not oCompsArray[0].isNull():
oMeshArray = om.MObjectArray()
iVertArray = om.MIntArray()
iFaceArray = om.MIntArray()
vPosArray = om.MVectorArray()
vNormalArray = om.MVectorArray()
cVtxColorArray = om.MColorArray()
for x in range(dagPathMeshArray.length()):
dagPathMesh = dagPathMeshArray[x]
oMesh = dagPathMesh.node()
oComps = oCompsArray[x]
itComponent = om.MItMeshFaceVertex(
dagPathMesh, oComps) # iterate only on selected components
while not itComponent.isDone():
iVertArray.append(itComponent.vertId())
iFaceArray.append(itComponent.faceId())
oMeshArray.append(oMesh)
cVtxColor = om.MColor()
itComponent.getColor(cVtxColor, om.MSpace.kObject)
cVtxColorArray.append(cVtxColor)
#get normals in each vertex
pPos = itComponent.position(om.MSpace.kWorld)
vPosArray.append(om.MVector(pPos.x, pPos.y, pPos.z))
oNormal = om.MVector()
itComponent.getNormal(oNormal, om.MSpace.kObject)
vNormalArray.append(oNormal)
itComponent.next()
return [
oMeshArray, iVertArray, iFaceArray, vNormalArray, vPosArray,
oMeshList, cVtxColorArray
]
else:
print "nothing test"
return [0, 0, 0, 0, 0]
else:
xform = OpenMaya.MMatrix()
xform.setToIdentity()
dagPath.extendToShape()
if (dagPath.apiType() == OpenMaya.MFn.kMesh):
mesh = dagPath.node()
meshFn = OpenMaya.MFnMesh(mesh)
vertIter = OpenMaya.MItMeshVertex(dagPath, component)
print "// ", vertIter.count(), " verts in ", dagPath.partialPathName()
print "ErrorRenderLoop::Vertex_t g_verts_%s[%d] = {" % (
dagPath.partialPathName(), vertIter.count())
while not vertIter.isDone():
vertPos = OpenMaya.MVector(vertIter.position()).rotateBy(rot)
vertColor = OpenMaya.MColor(1, 1, 1, 1)
vertNormal = OpenMaya.MVector()
vertIter.getNormal(vertNormal)
if (vertIter.hasColor()):
vertIter.getColor(vertColor)
vertNormal = vertNormal.rotateBy(rot)
print "{%.3f,%.3f,%.3f, %.3f,%.3f,%.3f, 0x%02X%02X%02X%02X }," % (
vertPos.x, vertPos.y, vertPos.z, vertNormal.x, vertNormal.y,
vertNormal.z, vertColor.r * 255, vertColor.g * 255,
vertColor.b * 255, vertColor.a * 255)
vertIter.next()
print "};"
faceIter = OpenMaya.MItMeshPolygon(dagPath, component)
print "// ", faceIter.count(), " triangles"
print "uint16_t g_tris_%s[%d][3] = {" % (dagPath.partialPathName(),
def exportMesh(self,
mObject,
dagPath,
meshNode,
points,
us,
vs,
normals,
faceVertexColors,
exportOptions,
verbose=False):
if verbose:
print("\texportMesh")
itMeshPoly = OpenMaya.MItMeshPolygon(mObject)
numPerFaceVertices = 0
while not itMeshPoly.isDone():
currentFace = itMeshPoly.currentItem()
numFaceVertices = itMeshPoly.polygonVertexCount()
numPerFaceVertices = numPerFaceVertices + numFaceVertices
itMeshPoly.next()
if verbose:
print("\tPer Faces Vertices : %d" % numPerFaceVertices)
numPoints = points.length()
numNormals = normals.length()
numFaces = meshNode.numPolygons()
numUVs = us.length()
hasColors = faceVertexColors and faceVertexColors.length() > 0
if (numPerFaceVertices == numNormals):
perFacePerVertexNormals = True
mergeNormalsWithFaces = False
mergeNormalsWithVertices = False
elif (numFaces == numNormals):
perFacePerVertexNormals = False
mergeNormalsWithFaces = True
mergeNormalsWithVertices = False
elif (numNormals == numPoints):
perFacePerVertexNormals = False
mergeNormalsWithFaces = False
mergeNormalsWithVertices = True
mergeUVsWithVertices = (numUVs == numPoints)
# PLY Vertex type
vertexDType = [('x', 'f4'), ('y', 'f4'), ('z', 'f4')]
if mergeUVsWithVertices:
if verbose:
print("\tVertices have UVs")
vertexDType.extend([('u', 'f4'), ('v', 'f4')])
if mergeNormalsWithVertices:
if verbose:
print("\tVertices have Normals")
vertexDType.extend([('nx', 'f4'), ('ny', 'f4'), ('nz', 'f4')])
vertices = np.zeros(numPoints, dtype=vertexDType)
# Copy data to PLY vertex list
for i in range(numPoints):
vertex = (points[i].x, points[i].y, points[i].z)
if mergeUVsWithVertices:
vertex = vertex + (us[i], vs[i])
if mergeNormalsWithVertices:
vertex = vertex + (normals[i].x, normals[i].y, normals[i].z)
vertices[i] = vertex
# Copy data to PLY UV list, if necessary
if not mergeUVsWithVertices:
if verbose:
print("\tUVs listed independently")
uvs = np.zeros(numUVs, dtype=[('u', 'f4'), ('v', 'f4')])
for i in range(us.length()):
#print( "UV %d : %s, %s" % (i, us[i], vs[i]))
uvs[i] = (us[i], vs[i])
# Copy data to PLY Normals list, if necessary
if perFacePerVertexNormals:
if verbose:
print("\tNormals listed independently")
normalsNP = np.zeros(numNormals,
dtype=[('nx', 'f4'), ('ny', 'f4'),
('nz', 'f4')])
for i in range(normals.length()):
#print( "Normals %d : %s %s %s" % (i,
# normals[i].x, normals[i].y, normals[i].z))
normalsNP[i] = (normals[i].x, normals[i].y, normals[i].z)
if hasColors:
if verbose:
print("\tColors listed independently")
colorsNP = np.zeros(faceVertexColors.length(),
dtype=[('r', 'f4'), ('g', 'f4'), ('b', 'f4')])
# Use this later
faceColorDict = {}
faceColorCount = 0
for i in range(faceVertexColors.length()):
#if verbose:
# print( "Colors %d : %s %s %s" % (i,
# faceVertexColors[i].r, faceVertexColors[i].g, faceVertexColors[i].b))
color = (faceVertexColors[i].r, faceVertexColors[i].g,
faceVertexColors[i].b)
colorsNP[i] = color
faceColorDict[color] = i
# Create face data
rawFaces = []
rawFaceUVs = []
rawFaceNormals = []
rawFaceNormalValues = []
rawFaceColors = []
colorIdxPx = OpenMaya.MScriptUtil()
colorIdxPx.createFromInt(0)
colorIdxPtr = colorIdxPx.asIntPtr()
# object-relative vert indices in a face
polygonVertices = OpenMaya.MIntArray()
itMeshPoly = OpenMaya.MItMeshPolygon(mObject)
while not itMeshPoly.isDone():
currentFace = itMeshPoly.currentItem()
numFaceVertices = itMeshPoly.polygonVertexCount()
faceVertices = []
faceVertexUVIndices = []
faceVertexNormalIndices = []
faceNormal = ()
faceVertexColorIndices = []
# Step through 'local' vertex indices
# vertexIndex, getUVIndex, normalIndex and getColorIndex expect
# local vertex indices
for v in range(numFaceVertices):
vertIndex = itMeshPoly.vertexIndex(v)
faceVertices.append(vertIndex)
if not mergeUVsWithVertices and us.length() > 0:
util = OpenMaya.MScriptUtil()
util.createFromInt(0)
uv_pInt = util.asIntPtr()
uv_index = OpenMaya.MScriptUtil()
uv_index.createFromInt(0)
itMeshPoly.getUVIndex(v, uv_pInt)
vertexUVIndex = uv_index.getInt(uv_pInt)
faceVertexUVIndices.append(vertexUVIndex)
if not mergeNormalsWithVertices and normals.length() > 0:
vertexNormalIndex = itMeshPoly.normalIndex(v)
if perFacePerVertexNormals:
faceVertexNormalIndices.append(vertexNormalIndex)
else:
faceNormal = (normals[vertexNormalIndex].x,
normals[vertexNormalIndex].y,
normals[vertexNormalIndex].z)
if hasColors:
itMeshPoly.getColorIndex(v, colorIdxPtr)
# Going to override this as the values seem to be off
vertColorIndex = OpenMaya.MScriptUtil(colorIdxPtr).asInt()
vertColorIndex0 = vertColorIndex
color = OpenMaya.MColor()
itMeshPoly.getColor(color, v)
colorTuple = (color.r, color.g, color.b)
if colorTuple in faceColorDict:
vertColorIndex = faceColorDict[colorTuple]
faceVertexColorIndices.append(vertColorIndex)
rawFaces.append(faceVertices)
rawFaceUVs.append(faceVertexUVIndices)
rawFaceNormals.append(faceVertexNormalIndices)
rawFaceColors.append(faceVertexColorIndices)
rawFaceNormalValues.append(faceNormal)
#if verbose:
# print( "Face %d Vertices : %s" % (i, faceVertices) )
# print( "Face %d UVs : %s" % (i, faceVertexUVIndices) )
# print( "Face %d Normals : %s" % (i, faceVertexNormalIndices) )
# print( "Face %d Normal : %s" % (i, faceNormal) )
# print( "Face %d Colors : %s" % (i, faceVertexColorIndices) )
itMeshPoly.next()
# Using 'object' instead of something like
# ('vertex_indices', 'i4', (maxVertices,))
# allows for faces with varying numbers of vertices
dtype = []
dtype.append(('vertex_indices', object))
if not mergeUVsWithVertices:
if verbose:
print("\tFaces have Per-Vertex UVs")
dtype.append(('uv_indices', object))
if mergeNormalsWithFaces:
if verbose:
print("\tFaces have single Normals")
dtype.extend([('nx', 'f4'), ('ny', 'f4'), ('nz', 'f4')])
elif perFacePerVertexNormals:
if verbose:
print("\tFaces have Per-Vertex Normals")
dtype.append(('normals_indices', object))
if hasColors:
if verbose:
print("\tFaces have Per-Vertex Colors")
dtype.append(('colors_indices', object))
#print( "Face D Type : %s" % str(dtype) )
faces = np.zeros(numFaces, dtype=dtype)
for i in range(numFaces):
#print( "Face %d" % i )
faceEntryIndex = 0
faces[i][faceEntryIndex] = rawFaces[i]
faceEntryIndex = faceEntryIndex + 1
if not mergeUVsWithVertices:
faces[i][faceEntryIndex] = rawFaceUVs[i]
faceEntryIndex = faceEntryIndex + 1
if mergeNormalsWithFaces:
#print( "Normal : %3.3f, %3.3f, %3.3f" % (rawFaceNormalValues[i][0],
# rawFaceNormalValues[i][1], rawFaceNormalValues[i][2]) )
faces[i][faceEntryIndex + 0] = float(rawFaceNormalValues[i][0])
faces[i][faceEntryIndex + 1] = float(rawFaceNormalValues[i][1])
faces[i][faceEntryIndex + 2] = float(rawFaceNormalValues[i][2])
faceEntryIndex = faceEntryIndex + 3
elif perFacePerVertexNormals:
faces[i][2] = rawFaceNormals[i]
faceEntryIndex = faceEntryIndex + 1
if hasColors:
faces[i][faceEntryIndex] = rawFaceColors[i]
faceEntryIndex = faceEntryIndex + 1
# Build PLY data structures
text = False
byte_order = '='
if exportOptions:
if 'format' in exportOptions and exportOptions['format'] == 'text':
text = True
plyElements = [
ply.PlyElement.describe(vertices, 'vertex'),
ply.PlyElement.describe(faces, 'face')
]
if not mergeUVsWithVertices:
plyElements.insert(-1, ply.PlyElement.describe(uvs, 'uvs'))
if perFacePerVertexNormals:
plyElements.insert(-1,
ply.PlyElement.describe(normalsNP, 'normals'))
if hasColors:
plyElements.insert(-1, ply.PlyElement.describe(colorsNP, 'colors'))
plyData = ply.PlyData(plyElements,
text=text,
byte_order=byte_order,
comments=[dagPath])
return plyData
def importPly(self, plyPath, importOptions):
verbose = False
if importOptions:
if 'verbose' in importOptions and importOptions[
'verbose'] == 'true':
verbose = True
plydata = ply.PlyData.read(str(plyPath))
#if verbose:
# print( plydata )
#
# Process vertices
#
vertexElement = plydata['vertex']
numVertices = vertexElement.count
vertexAttributes = map(lambda x: x[0], vertexElement.dtype())
if verbose:
print("Vertices : %d" % numVertices)
print("Vertex Attributes : %s" % vertexAttributes)
vertexProperties = vertexElement.properties
(x, y, z) = (vertexElement[t] for t in ('x', 'y', 'z'))
vertices = OpenMaya.MFloatPointArray(numVertices)
for i in range(numVertices):
vertices.set(i, float(x[i]), float(y[i]), float(z[i]))
vertexNormalsPresent = ('nx' in vertexAttributes
and 'ny' in vertexAttributes
and 'nz' in vertexAttributes)
if vertexNormalsPresent:
if verbose:
print("Vertex Normals present")
(nx, ny, nz) = (vertexElement[t] for t in ('nx', 'ny', 'nz'))
vertexNormals = OpenMaya.MVectorArray()
vertexNormalsIndices = OpenMaya.MIntArray()
vertexNormalsIndices.setLength(numVertices)
for i in range(numVertices):
vertexNormals.append(
OpenMaya.MVector(float(nx[i]), float(ny[i]), float(nz[i])))
vertexNormalsIndices.set(i, i)
vertexUVsPresent = ('u' in vertexAttributes
and 'v' in vertexAttributes)
if vertexUVsPresent:
if verbose:
print("Vertex UVs present")
(u, v) = (vertexElement[t] for t in ('u', 'v'))
uArray = OpenMaya.MFloatArray()
uArray.setLength(numVertices)
vArray = OpenMaya.MFloatArray()
vArray.setLength(numVertices)
for i in range(numVertices):
uArray.set(float(u[i]), i)
vArray.set(float(v[i]), i)
vertexColorsPresent = ('r' in vertexAttributes
and 'g' in vertexAttributes
and 'b' in vertexAttributes)
if vertexColorsPresent:
if verbose:
print("Vertex Colors present")
(r, g, b) = (vertexElement[t] for t in ('r', 'g', 'b'))
vertexColors = OpenMaya.MColorArray()
vertexColorsIndices = OpenMaya.MIntArray()
vertexColorsIndices.setLength(numVertices)
for i in range(numVertices):
vertexColors.append(
OpenMaya.MColor(float(r[i]), float(g[i]), float(b[i])))
vertexColorsIndices.set(i, i)
#
# Process faces
#
faceElement = plydata['face']
numFaces = faceElement.count
faceAttributes = map(lambda x: x[0], faceElement.dtype())
if verbose:
print("Faces : %d" % numFaces)
print("Face Attributes : %s" % faceAttributes)
vertex_indices = faceElement['vertex_indices']
faceCounts = OpenMaya.MIntArray()
faceCounts.setLength(numFaces)
faceIndicesCount = 0
for i in range(numFaces):
indices = vertex_indices[i]
faceCounts.set(int(len(indices)), i)
faceIndicesCount += int(len(indices))
faceIndicesArray = OpenMaya.MIntArray()
faceIndicesArray.setLength(faceIndicesCount)
n = 0
for i in range(numFaces):
indices = vertex_indices[i]
for j in range(len(indices)):
faceIndicesArray.set(int(indices[j]), int(n))
n = n + 1
faceNormalsPresent = ('nx' in faceAttributes and 'ny' in faceAttributes
and 'nz' in faceAttributes)
if faceNormalsPresent:
if verbose:
print("Per Face Normals present")
(nx, ny, nz) = (faceElement[t] for t in ('nx', 'ny', 'nz'))
faceNormals = OpenMaya.MVectorArray()
faceNormalsIndices = OpenMaya.MIntArray()
faceNormalsVertexIndices = OpenMaya.MIntArray()
faceNormalsIndices.setLength(faceIndicesCount)
faceNormalsVertexIndices.setLength(faceIndicesCount)
n = 0
for i in range(numFaces):
indices = vertex_indices[i]
for j in range(len(indices)):
faceNormals.append(
OpenMaya.MVector(float(nx[i]), float(ny[i]),
float(nz[i])))
faceNormalsIndices.set(i, n)
faceNormalsVertexIndices.set(int(indices[j]), int(n))
n = n + 1
normalsElement = None
if 'normals' in plydata:
normalsElement = plydata['normals']
facePerVertexNormalsPresent = ('normals_indices'
in faceAttributes) and normalsElement
if facePerVertexNormalsPresent:
if verbose:
print("Per Face Per Vertex Normals present")
(nx, ny, nz) = (normalsElement[t] for t in ('nx', 'ny', 'nz'))
normals_indices = faceElement['normals_indices']
faceNormals = OpenMaya.MVectorArray()
faceNormalsIndices = OpenMaya.MIntArray()
faceNormalsVertexIndices = OpenMaya.MIntArray()
faceNormalsIndices.setLength(faceIndicesCount)
faceNormalsVertexIndices.setLength(faceIndicesCount)
n = 0
for i in range(numFaces):
indices = normals_indices[i]
for j in range(len(indices)):
normalIndex = indices[j]
faceNormals.append(
OpenMaya.MVector(float(nx[normalIndex]),
float(ny[normalIndex]),
float(nz[normalIndex])))
faceNormalsIndices.set(i, n)
faceNormalsVertexIndices.set(int(normalIndex), int(n))
n = n + 1
#if verbose:
# print( "Face %d : Vertex %d : Normal %3.3f, %3.3f, %3.3f" % (
# i, j, float(nx[normalIndex]), float(ny[normalIndex]), float(nz[normalIndex])))
uvElement = None
if 'uvs' in plydata:
uvElement = plydata['uvs']
faceUVsPresent = ('uv_indices' in faceAttributes) and uvElement
if faceUVsPresent:
if verbose:
print("Per Face Per Vertex UVs present")
(u, v) = (uvElement[t] for t in ('u', 'v'))
uv_indices = faceElement['uv_indices']
uArray = OpenMaya.MFloatArray()
uArray.setLength(len(u))
vArray = OpenMaya.MFloatArray()
vArray.setLength(len(v))
for i in range(len(u)):
uArray.set(float(u[i]), i)
vArray.set(float(v[i]), i)
colorsElement = None
if 'colors' in plydata:
colorsElement = plydata['colors']
facePerVertexColorsPresent = ('colors_indices'
in faceAttributes) and colorsElement
if facePerVertexColorsPresent:
if verbose:
print("Per Face Per Vertex Colors present")
(r, g, b) = (colorsElement[t] for t in ('r', 'g', 'b'))
colors_indices = faceElement['colors_indices']
faceColors = OpenMaya.MColorArray()
faceColorsIndices = OpenMaya.MIntArray()
faceColorsVertexIndices = OpenMaya.MIntArray()
faceColorsIndices.setLength(faceIndicesCount)
faceColorsVertexIndices.setLength(faceIndicesCount)
n = 0
for i in range(numFaces):
indices = colors_indices[i]
for j in range(len(indices)):
colorIndex = indices[j]
faceColors.append(
OpenMaya.MColor(float(r[colorIndex]),
float(g[colorIndex]),
float(b[colorIndex])))
faceColorsIndices.set(i, n)
faceColorsVertexIndices.set(int(colorIndex), int(n))
n = n + 1
#
# Build Maya mesh
#
outputMesh = OpenMaya.MObject()
meshFS = OpenMaya.MFnMesh()
newMesh = meshFS.create(numVertices, numFaces, vertices, faceCounts,
faceIndicesArray, outputMesh)
if vertexNormalsPresent:
meshFS.setVertexNormals(vertexNormals, vertexNormalsIndices)
if vertexColorsPresent:
meshFS.setVertexColors(vertexColors, vertexColorsIndices)
if facePerVertexNormalsPresent:
status = meshFS.setFaceVertexNormals(faceNormals,
faceNormalsIndices,
faceIndicesArray)
if faceNormalsPresent:
status = meshFS.setFaceVertexNormals(faceNormals,
faceNormalsIndices,
faceIndicesArray)
if facePerVertexColorsPresent:
meshFS.setFaceVertexColors(faceColors, faceColorsIndices,
faceIndicesArray)
if vertexUVsPresent:
if verbose:
print("Vertex UVs present")
meshFS.setUVs(uArray, vArray)
uvCounts = OpenMaya.MIntArray()
uvCounts.setLength(numFaces)
uvIds = OpenMaya.MIntArray()
uvIds.setLength(faceIndicesCount)
uvCountsIndex = 0
uvIndex = 0
for i in range(numFaces):
numPolygonVertices = meshFS.polygonVertexCount(i)
uvCounts.set(numPolygonVertices, int(uvCountsIndex))
uvCountsIndex = uvCountsIndex + 1
if numPolygonVertices == 0:
continue
indices = vertex_indices[i]
for vertexIndex in range(numPolygonVertices):
uvIds.set(int(indices[vertexIndex]), int(uvIndex))
uvIndex = uvIndex + 1
meshFS.assignUVs(uvCounts, uvIds)
if faceUVsPresent:
if verbose:
print("Face UVs present")
meshFS.setUVs(uArray, vArray)
uvCounts = OpenMaya.MIntArray()
uvCounts.setLength(numFaces)
uvIds = OpenMaya.MIntArray()
uvIds.setLength(faceIndicesCount)
uvCountsIndex = 0
uvIndex = 0
for i in range(numFaces):
numPolygonVertices = meshFS.polygonVertexCount(i)
uvCounts.set(numPolygonVertices, int(uvCountsIndex))
uvCountsIndex = uvCountsIndex + 1
if numPolygonVertices == 0:
continue
indices = uv_indices[i]
for vertexIndex in range(numPolygonVertices):
uvIds.set(int(indices[vertexIndex]), int(uvIndex))
uvIndex = uvIndex + 1
meshFS.assignUVs(uvCounts, uvIds)
meshFS.updateSurface()
# Assign initial shading group
initialSG = OpenMaya.MObject()
slist = OpenMaya.MSelectionList()
OpenMaya.MGlobal.getSelectionListByName("initialShadingGroup", slist)
slist.getDependNode(0, initialSG)
fnSG = OpenMaya.MFnSet(initialSG)
if fnSG.restriction() == OpenMaya.MFnSet.kRenderableOnly:
fnSG.addMember(newMesh)
def createVoxelMesh(self, voxelCenterPosition, uvArray, texNodeName,
cubeWidth, voxelWeights, voxelBlendWeights):
numVoxels = len(voxelCenterPosition)
numVertices = 8 #number of vertices
numPolygons = 6 #number of polygons
numVerticesPerPolygon = 4 #number of vertices per polygon
numNormalsPerVoxel = numVerticesPerPolygon * numPolygons #24 number of vertex normals
numPolygonConnectsPerVoxel = numPolygons * numVerticesPerPolygon #24 number of polygon connects
cubeHalfWidth = cubeWidth / 2.0
#initialize all the params in the MFnMesh.create()
#vertexArray: point array, This should include all the vertices in the mesh and no eatras
totalVertices = numVertices * numVoxels
vertexArray = OpenMaya.MFloatPointArray()
#polygonCounts array of vertex counts for each polygon
#for the cube would have 6 faces, each of which had 4 verts, so the polygonCounts would be [4,4,4,4,4,4]
totalPolygons = numPolygons * numVoxels
polygonCounts = OpenMaya.MIntArray()
#polygonConnects
#array of vertex connections for each polygon
polygonConnects = OpenMaya.MIntArray()
#set shared Normals for these vertices
vertexNormals = OpenMaya.MVectorArray()
#vertexColorArray
vertexColorArray = OpenMaya.MColorArray()
#vertexColorIndexArray
vertexIndexArray = OpenMaya.MIntArray()
#PolygonIDArray
faceList = OpenMaya.MIntArray()
#vertexWeightArray
vertexWeightArray = OpenMaya.MDoubleArray()
#vertexBlendWeightArray
vertexBlendWeightArray = OpenMaya.MDoubleArray()
for i in range(numVoxels):
pVoxelCenterPosition = voxelCenterPosition[i]
#Update VertexArray for VoxelMesh
vertexList = [
OpenMaya.MFloatPoint(pVoxelCenterPosition.x - cubeHalfWidth,
pVoxelCenterPosition.y - cubeHalfWidth,
pVoxelCenterPosition.z -
cubeHalfWidth), #vertex 0
OpenMaya.MFloatPoint(pVoxelCenterPosition.x - cubeHalfWidth,
pVoxelCenterPosition.y - cubeHalfWidth,
pVoxelCenterPosition.z +
cubeHalfWidth), #vertex 1
OpenMaya.MFloatPoint(pVoxelCenterPosition.x - cubeHalfWidth,
pVoxelCenterPosition.y + cubeHalfWidth,
pVoxelCenterPosition.z -
cubeHalfWidth), #vertex 2
OpenMaya.MFloatPoint(pVoxelCenterPosition.x - cubeHalfWidth,
pVoxelCenterPosition.y + cubeHalfWidth,
pVoxelCenterPosition.z +
cubeHalfWidth), #vertex 3
OpenMaya.MFloatPoint(pVoxelCenterPosition.x + cubeHalfWidth,
pVoxelCenterPosition.y - cubeHalfWidth,
pVoxelCenterPosition.z -
cubeHalfWidth), #vertex 4
OpenMaya.MFloatPoint(pVoxelCenterPosition.x + cubeHalfWidth,
pVoxelCenterPosition.y - cubeHalfWidth,
pVoxelCenterPosition.z +
cubeHalfWidth), #vertex 5
OpenMaya.MFloatPoint(pVoxelCenterPosition.x + cubeHalfWidth,
pVoxelCenterPosition.y + cubeHalfWidth,
pVoxelCenterPosition.z -
cubeHalfWidth), #vertex 6
OpenMaya.MFloatPoint(pVoxelCenterPosition.x + cubeHalfWidth,
pVoxelCenterPosition.y + cubeHalfWidth,
pVoxelCenterPosition.z +
cubeHalfWidth), #vertex 7
]
for j in range(numVertices):
vertexArray.append(vertexList[j])
#here need to assign vertexWeight
if self.skinCluster:
for item in voxelWeights[i]:
vertexWeightArray.append(item)
vertexBlendWeightArray.append(voxelBlendWeights[i])
#print [item for sublist in voxelWeights[i] for item in sublist]
#here need to assign vertex color
if texNodeName:
vertexColor = cmds.colorAtPoint(texNodeName,
o='RGB',
u=uvArray[i][0],
v=uvArray[i][1])
mColor = OpenMaya.MColor(vertexColor[0], vertexColor[1],
vertexColor[2])
vertexColorArray.append(mColor)
vertexIndexArray.append(i * numVertices + j)
#print vertexColor
#Update polygonCounts for VoxelMesh
for j in range(numPolygons):
polygonCounts.append(numVerticesPerPolygon)
faceList.append(i * numPolygons + j)
#Update polygonConnects for VoxelMesh
#Update vertexNormals for VoxelMesh
polygonConnectsList = [
0, 1, 3, 2, 1, 5, 7, 3, 4, 6, 7, 5, 2, 6, 4, 0, 0, 4, 5, 1, 2,
3, 7, 6
]
vertexNormalsList = [
OpenMaya.MVector(-1.0, 0.0,
0.0), #vertex normal on face (0,1,3,2) #0
OpenMaya.MVector(-1.0, 0.0,
0.0), #vertex normal on face (0,1,3,2) #1
OpenMaya.MVector(-1.0, 0.0,
0.0), #vertex normal on face (0,1,3,2) #7
OpenMaya.MVector(-1.0, 0.0,
0.0), #vertex normal on face (0,1,3,2) #3
OpenMaya.MVector(0.0, 0.0,
1.0), #vertex normal on face (1,5,7,3) #1
OpenMaya.MVector(0.0, 0.0,
1.0), #vertex normal on face (1,5,7,3) #5
OpenMaya.MVector(0.0, 0.0,
1.0), #vertex normal on face (1,5,7,3) #7
OpenMaya.MVector(0.0, 0.0,
1.0), #vertex normal on face (1,5,7,3) #3
OpenMaya.MVector(1.0, 0.0,
0.0), #vertex normal on face (4,6,7,5) #4
OpenMaya.MVector(1.0, 0.0,
0.0), #vertex normal on face (4,6,7,5) #6
OpenMaya.MVector(1.0, 0.0,
0.0), #vertex normal on face (4,6,7,5) #7
OpenMaya.MVector(1.0, 0.0,
0.0), #vertex normal on face (4,6,7,5) #5
OpenMaya.MVector(0.0, 0.0,
-1.0), #vertex normal on face (2,6,4,0) #2
OpenMaya.MVector(0.0, 0.0,
-1.0), #vertex normal on face (2,6,4,0) #6
OpenMaya.MVector(0.0, 0.0,
-1.0), #vertex normal on face (2,6,4,0) #4
OpenMaya.MVector(0.0, 0.0,
-1.0), #vertex normal on face (2,6,4,0) #0
OpenMaya.MVector(0.0, -1.0,
0.0), #vertex normal on face (0,4,5,1) #0
OpenMaya.MVector(0.0, -1.0,
0.0), #vertex normal on face (0,4,5,1) #4
OpenMaya.MVector(0.0, -1.0,
0.0), #vertex normal on face (0,4,5,1) #5
OpenMaya.MVector(0.0, -1.0,
0.0), #vertex normal on face (0,4,5,1) #1
OpenMaya.MVector(0.0, 1.0,
0.0), #vertex normal on face (2,3,7,6) #2
OpenMaya.MVector(0.0, 1.0,
0.0), #vertex normal on face (2,3,7,6) #3
OpenMaya.MVector(0.0, 1.0,
0.0), #vertex normal on face (2,3,7,6) #7
OpenMaya.MVector(0.0, 1.0,
0.0) #vertex normal on face (2,3,7,6) #6
]
for j in range(numNormalsPerVoxel):
vertexNormals.append(vertexNormalsList[j])
polygonConnects.append(polygonConnectsList[j] +
i * numVertices)
mFnMesh = OpenMaya.MFnMesh()
#shapeNode
mMeshShape = mFnMesh.create(totalVertices, totalPolygons, vertexArray,
polygonCounts, polygonConnects)
mDagNode = OpenMaya.MFnDagNode(mMeshShape)
mDagNode.setName('voxelGeom')
#in case name existing:
name = mDagNode.name()
#print mDagNode.name()
mDagPath = OpenMaya.MDagPath()
mDagNode = OpenMaya.MFnDagNode(mDagNode.child(0))
#print mDagNode.name()
mDagNode.getPath(mDagPath)
mCubeMesh = OpenMaya.MFnMesh(mDagPath)
'''
#assign Normal to the Cubes:
#confused how to use setFaceVertexNormals
#rewrite the function for setFaceVertexNormals based on setFaceVertexNormal
#by query the facelist
#support hard edge!
for i in range (faceList.length()):
for j in range (numVerticesPerPolygon):
index = numVerticesPerPolygon * i + j
mCubeMesh.setFaceVertexNormal(vertexNormals[index], i, polygonConnects[index])
'''
#'''
#setVertexColor
if texNodeName:
mCubeMesh.createColorSetWithName('vertexColorSet')
mCubeMesh.setIsColorClamped('vertexClorSet', True)
mCubeMesh.setVertexColors(vertexColorArray, vertexIndexArray, None,
OpenMaya.MFnMesh.kRGB)
#'''
#create skincluster and remap weightData and blendWeight Data
if self.skinCluster:
influenceObj = cmds.skinCluster(q=True, inf=True)
voxelSkinCluster = cmds.skinCluster(influenceObj,
name,
tsb=2,
nw=2)
mSelectionlist = OpenMaya.MSelectionList()
mSelectionlist.add(voxelSkinCluster[0])
mObj_voxelSkinCluster = OpenMaya.MObject()
mSelectionlist.getDependNode(0, mObj_voxelSkinCluster)
mfnSkinCluster = OpenMayaAnim.MFnSkinCluster(mObj_voxelSkinCluster)
mDagPath, component = self.getSkinClusterData(mfnSkinCluster)
influenceIndices = OpenMaya.MIntArray()
for i in xrange(len(influenceObj)):
influenceIndices.append(i)
#print voxelWeights
mfnSkinCluster.setWeights(mDagPath, component, influenceIndices,
vertexWeightArray, False)
mfnSkinCluster.setBlendWeights(mDagPath, component,
vertexBlendWeightArray)
#'''
#--[retrive initialShadingGroup]--#
mSelectionList = OpenMaya.MSelectionList()
mSelectionList.add("initialShadingGroup")
mObject_initShdGrp = OpenMaya.MObject()
mSelectionList.getDependNode(0, mObject_initShdGrp)
mFnDependencyNode_initialShadingGroup = OpenMaya.MFnDependencyNode(
mObject_initShdGrp)
#mFnDependencyNode_initialShadingGroup.setObject(mObject_initShdGrp)
#name = mFnDependencyNode_initialShadingGroup.name() # Result: initialShadingGroup, so it ok so far
fnSet = OpenMaya.MFnSet(mObject_initShdGrp)
fnSet.addMember(mMeshShape)
def compute(self, plug, dataBlock):
# Always update the whole array at once - we shouldn't be connecting to
# only a single element in the output arrays anyway (ie, what happens
# if the number of verts changes, and we're connected to an output
# index whose vert no longer exists?)
#print plug
#print self.multiAttrs.values()
if plug in self.multiAttrs.values():
meshDataHandle = dataBlock.inputValue(self.meshAttr)
meshObj = meshDataHandle.asMesh()
handles = {}
for comp, attr in self.multiAttrs.iteritems():
handles[comp] = dataBlock.outputArrayValue(attr)
builders = {}
for comp, handle in handles.iteritems():
builders[comp] = handle.builder()
vertIter = om.MItMeshVertex(meshObj)
while not vertIter.isDone():
index = vertIter.index()
# Retrieve the component color info
color = om.MColor()
if vertIter.hasColor():
vertIter.getColor(color)
r = color.r
g = color.g
b = color.b
a = color.a
hUtil = om.MScriptUtil()
hUtil.createFromDouble(0.0)
hPtr = hUtil.asFloatPtr()
sUtil = om.MScriptUtil()
sUtil.createFromDouble(0.0)
sPtr = hUtil.asFloatPtr()
vUtil = om.MScriptUtil()
vUtil.createFromDouble(0.0)
vPtr = hUtil.asFloatPtr()
color.get(color.kHSV, hPtr, sPtr, vPtr)
h = hUtil.getFloat(hPtr)
s = sUtil.getFloat(sPtr)
v = vUtil.getFloat(vPtr)
#print "rgba %3d: %s, %s, %s, %s" % (index, r, g, b, a)
#print "hsv %3d: %s, %s, %s" % (index, h, s, v)
# Add the elements to the array, and set them
indexHandles = {}
for comp, builder in builders.iteritems():
indexHandles[comp] = builder.addElement(index)
indexHandles['red'].setFloat(r)
indexHandles['green'].setFloat(g)
indexHandles['blue'].setFloat(b)
indexHandles['alpha'].setFloat(a)
indexHandles['hue'].setFloat(h)
indexHandles['saturation'].setFloat(s)
indexHandles['value'].setFloat(v)
# done!
vertIter.next()
# Set the array plugs to the builders
for comp, handle in handles.iteritems():
handle.set(builders[comp])
# mark all array plugs clean
for handle in handles.itervalues():
handle.setAllClean()
dataBlock.setClean(plug)
return om.kUnknownParameter
def draw(self, view, mdag_path, display_style, display_status):
use_box = OpenMaya.MPlug(self.thisMObject(), Point.input_box).asInt()
use_cross = OpenMaya.MPlug(self.thisMObject(),
Point.input_cross).asInt()
use_tick = OpenMaya.MPlug(self.thisMObject(), Point.input_tick).asInt()
use_axis = OpenMaya.MPlug(self.thisMObject(), Point.input_axis).asInt()
color_index = OpenMaya.MPlug(self.thisMObject(),
Point.input_color).asInt()
local_position = OpenMaya.MFnDependencyNode(
self.thisMObject()).findPlug("localPosition")
tx = local_position.child(0).asFloat()
ty = local_position.child(1).asFloat()
tz = local_position.child(2).asFloat()
local_scale = OpenMaya.MFnDependencyNode(
self.thisMObject()).findPlug("localScale")
sx = local_scale.child(0).asFloat()
sy = local_scale.child(1).asFloat()
sz = local_scale.child(2).asFloat()
if display_status == OpenMayaUI.M3dView.kActive:
color = OpenMaya.MColor(1.0, 1.0, 1.0)
elif display_status == OpenMayaUI.M3dView.kLead:
color = OpenMaya.MColor(0.26, 1.0, 0.64)
elif display_status == OpenMayaUI.M3dView.kActiveAffected:
color = OpenMaya.MColor(0.783999979496, 0, 0.783999979496)
elif display_status == OpenMayaUI.M3dView.kTemplate:
color = OpenMaya.MColor(0.469999998808, 0.469999998808,
0.469999998808)
elif display_status == OpenMayaUI.M3dView.kActiveTemplate:
color = OpenMaya.MColor(1.0, 0.689999997616, 0.689999997616)
else:
color = OpenMaya.MColor(self._colors[color_index][0],
self._colors[color_index][1],
self._colors[color_index][2])
view.beginGL()
if use_axis == 1:
view.setDrawColor(OpenMaya.MColor(1.0, 0, 0))
view.drawText("x", OpenMaya.MPoint(sx + tx, ty, tz),
OpenMayaUI.M3dView.kCenter)
view.setDrawColor(OpenMaya.MColor(0, 1.0, 0))
view.drawText("y", OpenMaya.MPoint(tx, sy + ty, tz),
OpenMayaUI.M3dView.kCenter)
view.setDrawColor(OpenMaya.MColor(0, 0, 1.0))
view.drawText("z", OpenMaya.MPoint(tx, ty, sz + tz),
OpenMayaUI.M3dView.kCenter)
gl_FT.glPushAttrib(OpenMayaRender.MGL_CURRENT_BIT)
gl_FT.glPushAttrib(OpenMayaRender.MGL_ALL_ATTRIB_BITS)
gl_FT.glEnable(OpenMayaRender.MGL_BLEND)
gl_FT.glBegin(OpenMayaRender.MGL_LINES)
if use_box == 1:
gl_FT.glColor3f(color.r, color.g, color.b)
# Top
gl_FT.glVertex3f(-sx + tx, sy + ty, -sz + tz)
gl_FT.glVertex3f(sx + tx, sy + ty, -sz + tz)
gl_FT.glVertex3f(sx + tx, sy + ty, -sz + tz)
gl_FT.glVertex3f(sx + tx, sy + ty, sz + tz)
gl_FT.glVertex3f(sx + tx, sy + ty, sz + tz)
gl_FT.glVertex3f(-sx + tx, sy + ty, sz + tz)
gl_FT.glVertex3f(-sx + tx, sy + ty, sz + tz)
gl_FT.glVertex3f(-sx + tx, sy + ty, -sz + tz)
# Bottom
gl_FT.glVertex3f(-sx + tx, -sy + ty, -sz + tz)
gl_FT.glVertex3f(sx + tx, -sy + ty, -sz + tz)
gl_FT.glVertex3f(sx + tx, -sy + ty, -sz + tz)
gl_FT.glVertex3f(sx + tx, -sy + ty, sz + tz)
gl_FT.glVertex3f(sx + tx, -sy + ty, sz + tz)
gl_FT.glVertex3f(-sx + tx, -sy + ty, sz + tz)
gl_FT.glVertex3f(-sx + tx, -sy + ty, sz + tz)
gl_FT.glVertex3f(-sx + tx, -sy + ty, -sz + tz)
# Left
gl_FT.glVertex3f(-sx + tx, -sy + ty, -sz + tz)
gl_FT.glVertex3f(-sx + tx, sy + ty, -sz + tz)
gl_FT.glVertex3f(-sx + tx, sy + ty, -sz + tz)
gl_FT.glVertex3f(-sx + tx, sy + ty, sz + tz)
gl_FT.glVertex3f(-sx + tx, sy + ty, sz + tz)
gl_FT.glVertex3f(-sx + tx, -sy + ty, sz + tz)
gl_FT.glVertex3f(-sx + tx, -sy + ty, sz + tz)
gl_FT.glVertex3f(-sx + tx, -sy + ty, -sz + tz)
# Right
gl_FT.glVertex3f(sx + tx, -sy + ty, -sz + tz)
gl_FT.glVertex3f(sx + tx, sy + ty, -sz + tz)
gl_FT.glVertex3f(sx + tx, sy + ty, -sz + tz)
gl_FT.glVertex3f(sx + tx, sy + ty, sz + tz)
gl_FT.glVertex3f(sx + tx, sy + ty, sz + tz)
gl_FT.glVertex3f(sx + tx, -sy + ty, sz + tz)
gl_FT.glVertex3f(sx + tx, -sy + ty, sz + tz)
gl_FT.glVertex3f(sx + tx, -sy + ty, -sz + tz)
if use_cross == 1:
gl_FT.glColor3f(color.r, color.g, color.b)
gl_FT.glVertex3f(tx, -sy + ty, tz)
gl_FT.glVertex3f(tx, sy + ty, tz)
gl_FT.glVertex3f(-sx + tx, ty, tz)
gl_FT.glVertex3f(sx + tx, ty, tz)
gl_FT.glVertex3f(tx, ty, -sz + tz)
gl_FT.glVertex3f(tx, ty, sz + tz)
if use_tick == 1:
gl_FT.glColor3f(color.r, color.g, color.b)
gl_FT.glVertex3f((-sx * 0.05) + tx, (sy * 0.05) + ty, tz)
gl_FT.glVertex3f((sx * 0.05) + tx, (-sy * 0.05) + ty, tz)
gl_FT.glVertex3f((sx * 0.05) + tx, (sy * 0.05) + ty, tz)
gl_FT.glVertex3f((-sx * 0.05) + tx, (-sy * 0.05) + ty, tz)
gl_FT.glVertex3f(tx, (sy * 0.05) + ty, (-sz * 0.05) + tz)
gl_FT.glVertex3f(tx, (-sy * 0.05) + ty, (sz * 0.05) + tz)
gl_FT.glVertex3f(tx, (sy * 0.05) + ty, (sz * 0.05) + tz)
gl_FT.glVertex3f(tx, (-sy * 0.05) + ty, (-sz * 0.05) + tz)
gl_FT.glVertex3f((sx * 0.05) + tx, ty, (-sz * 0.05) + tz)
gl_FT.glVertex3f((-sx * 0.05) + tx, ty, (sz * 0.05) + tz)
gl_FT.glVertex3f((sx * 0.05) + tx, ty, (sz * 0.05) + tz)
gl_FT.glVertex3f((-sx * 0.05) + tx, ty, (-sz * 0.05) + tz)
if use_axis == 1:
gl_FT.glColor3f(color.r, color.g, color.b)
if display_status == OpenMayaUI.M3dView.kDormant:
gl_FT.glColor3f(1.0, 0, 0)
gl_FT.glVertex3f(tx, ty, tz)
gl_FT.glVertex3f(sx + tx, ty, tz)
if display_status == OpenMayaUI.M3dView.kDormant:
gl_FT.glColor3f(0, 1.0, 0)
gl_FT.glVertex3f(tx, ty, tz)
gl_FT.glVertex3f(tx, sy + ty, tz)
if display_status == OpenMayaUI.M3dView.kDormant:
gl_FT.glColor3f(0, 0, 1.0)
gl_FT.glVertex3f(tx, ty, tz)
gl_FT.glVertex3f(tx, ty, sz + tz)
gl_FT.glEnd()
gl_FT.glDisable(OpenMayaRender.MGL_BLEND)
gl_FT.glPopAttrib()
gl_FT.glPopAttrib()
view.endGL()
def exportGeometry(self, msh, shp):
# api calls
dag = shp.__apiobject__()
mshfn = om.MFnMesh(dag)
# export materials
pm.progressWindow( edit=True, status='mesh %s/%s (%s): writing materials...'%(self._prg_count,self._prg_msh,msh) )
sgs = []
sgf = []
def faces(x):
f = []
for fs in x:
if fs.startswith('f'):
fs = fs.split('[')[1].split(']')[0]
if ':' in fs:
a, b = fs.split(':')
a, b = int(a), int(b)
f.extend(range(a, b + 1))
else:
f.append(int(fs))
return f
_o = shp.instObjGroups[0].objectGroups.outputs(type='shadingEngine')
if _o:
# multi mat
for _id in shp.instObjGroups[0].objectGroups.getArrayIndices():
og = shp.instObjGroups[0].objectGroups[_id]
f = faces( og.objectGrpCompList.get() )
_sg = og.outputs()
if _sg and f:
sgs.append(_sg[0])
sgf.append(f)
else:
# single mat
_o = shp.instObjGroups[0].outputs(type='shadingEngine')
sgs += _o
doColors = shp.displayColors.get()
sgi = []
for sg in sgs:
mat = sg.surfaceShader.inputs()[0]
if str(mat) in self.materials:
if doColors:
for m in self.db['materials']:
if m['name'] == str(mat):
m['vertexColors'] = True
break
else:
i = len(self.materials)
self.materials.append(str(mat))
m = {
'id' : i,
'name' : str(mat),
'DbgColor' : 0xFFFFFF,
'DbgIndex' : i,
'DbgName' : str(mat),
}
self.db['materials'].append(m)
_nt = pm.nodeType(mat)
if _nt in ('lambert', 'phong', 'blinn', 'anisotropic'):
m['shading'] = 'Phong'
m['colorDiffuse'] = roundList( mat.color.get(), DECIMALS_COLOR )
_c = pm.dt.Vector(mat.ambientColor.get()) + mat.incandescence.get()
m['colorAmbient'] = roundList( _c, DECIMALS_COLOR )
#m['colorEmissive'] = mat.incandescence.get()
m['colorSpecular'] = [0,0,0]
self.setTextureInfo(i, 'mapDiffuse', mat.color )
self.setTextureInfo(i, 'mapLight', mat.ambientColor )
self.setTextureInfo(i, 'mapBump', mat.normalCamera )
_t = mat.transparency.get()
_t = 1 - (_t[0]+_t[1]+_t[2]) / 3
if _t < 1:
m['transparency'] = _t
m['transparent'] = True
if _nt in ('phong', 'blinn', 'anisotropic'):
m['colorSpecular'] = roundList( mat.specularColor.get(), DECIMALS_COLOR )
m['specularCoef'] = 10
if _nt == 'blinn':
m['specularCoef'] = 4 / mat.eccentricity.get()
elif _nt == 'phong':
m['specularCoef'] = mat.cosinePower.get() * 2
if _nt == 'anisotropic':
m['specularCoef'] = 4 / mat.roughness.get()
self.setTextureInfo(i, 'mapSpecular', mat.specularColor )
if _nt == 'surfaceShader':
m['shading'] = 'Basic'
m['colorDiffuse'] = roundList( mat.outColor.get(), DECIMALS_COLOR )
if shp.doubleSided.get():
m['doubleSided'] = True
elif shp.opposite.get():
m['flipSided'] = True
if doColors:
m['vertexColors'] = True
sgi.append( self.materials.index(str(mat)) )
# export vertices
_v = mshfn.numVertices()
_voffset = self.db['metadata']['vertices']
self.db['metadata']['vertices'] += _v
self.vertices.append(_v)
pm.progressWindow( edit=True, status='mesh %s/%s (%s): writing vertices...'%(self._prg_count,self._prg_msh,msh) )
_pts = om.MPointArray()
mshfn.getPoints(_pts, om.MSpace.kWorld)
for i in xrange(_v):
_p = [ _pts[i][0], _pts[i][1], _pts[i][2] ]
self.db['vertices'] += roundList( _p, DECIMALS_VERTICES )
# export faces
_f = mshfn.numPolygons()
self.db['metadata']['faces'] += _f
self.faces.append(_f)
pm.progressWindow( edit=True, status='mesh %s/%s (%s): writing faces...'%(self._prg_count,self._prg_msh,msh) )
uvs = {}
_noffset = len(self.db['normals'])/3
_normals = om.MFloatVectorArray()
mshfn.getNormals(_normals,om.MSpace.kWorld)
for i in xrange(_normals.length()):
_n = [ _normals[i][0], _normals[i][1], _normals[i][2] ]
self.db['normals'] += roundList( _n, DECIMALS_NORMALS )
_npf = om.MIntArray()
_nid = om.MIntArray()
mshfn.getNormalIds(_npf, _nid)
_coffset = len(self.db['colors'])
_vfoffset = 0
it = om.MItMeshPolygon(dag)
while not it.isDone():
f = it.index()
# vertices
_vtx = om.MIntArray()
it.getVertices( _vtx )
vtx = [x+_voffset for x in _vtx]
if len(vtx)>4:
self.db['metadata']['faces'] -= 1
self.faces[-1] -= 1
it.next()
_vfoffset += len(vtx)
continue
else:
dbf = [0]
dbf += vtx
if len(vtx)==4:
dbf[0] += FACE_QUAD
# material
dbf[0] += FACE_MATERIAL
if len(sgs)==1:
dbf.append(sgi[0])
else:
for i,fset in enumerate(sgf):
if f in fset:
dbf.append(sgi[i])
break
# uvs
_u = om.MFloatArray()
_v = om.MFloatArray()
try:
it.getUVs( _u, _v )
dbf[0] += FACE_VERTEX_UV
for v,uv in zip( vtx, zip(_u,_v) ):
uv = roundList(uv, DECIMALS_UVS)
if not uvs.get(v):
uvs[v] = []
exported = False
for _i,_uv in uvs[v]:
if _uv == uv:
dbf.append(_i)
exported = True
break
if not exported:
i = len(self.db['uvs'][0])/2
self.db['uvs'][0] += uv
uvs[v].append((i,uv))
dbf.append(i)
except:
pass
#print '# warning: %s.f[%s] has no uv' % (shp, f)
# normals
dbf[0] += FACE_VERTEX_NORMAL
for i in xrange( len(vtx) ):
_n = _nid[i+_vfoffset]
dbf.append(_n+_noffset)
# colors
if doColors:
dbf[0] += FACE_VERTEX_COLOR
for i in xrange( len(vtx) ):
if it.hasColor( i ):
color = om.MColor()
it.getColor( color, i )
c = (int(color[0]*255)<<16) + (int(color[1]*255)<<8) + int(color[2]*255)
self.db['colors'].append(c)
dbf.append(i+_vfoffset+_coffset)
else:
# white for colorless vertex
dbf.append(0)
_coffset -= 1
_vfoffset += len(vtx)
# add face
self.db['faces'] += dbf
it.next()
self._prg_count += 1
pm.progressWindow( edit=True, step=1 )
def deform(self, block, iter, mat, multiIndex):
# ###################################
# get attributes
# ###################################
# envelope
envelope = block.inputValue(
OpenMayaMPx.cvar.MPxDeformerNode_envelope).asFloat()
if (envelope == 0.0):
return
# ==================================
# aOrigMesh
oOrig = block.inputValue(self.aOrigMesh).asMesh()
if oOrig.isNull():
return
fnOrig = om.MFnMesh(oOrig)
# ==================================
# input[multiIndex].inputGeometry
hInput = block.outputArrayValue(self.input)
hInput.jumpToElement(multiIndex)
hInputGeom = hInput.outputValue().child(self.inputGeom)
oInputGeom = hInputGeom.asMesh()
fnCurrent = om.MFnMesh(oInputGeom)
# ==================================
# aDisplayColors
displayColors = block.inputValue(self.aDisplayColors).asBool()
if (displayColors):
colorBase = block.inputValue(self.aColorBase).asFloatVector()
colorStretch = block.inputValue(self.aColorStretch).asFloatVector()
colorSquash = block.inputValue(self.aColorSquash).asFloatVector()
# ==================================
# aMeasureTypeHeat
measureTypeHeat = block.inputValue(self.aMeasureTypeHeat).asShort()
# aMultiplyHeat aSquashMultiplyHeat aStretchMultiplyHeat
multHeat = block.inputValue(self.aMultiplyHeat).asFloat()
squashMultHeat = block.inputValue(self.aSquashMultiplyHeat).asFloat()
stretchMultHeat = block.inputValue(self.aStretchMultiplyHeat).asFloat()
if (multHeat == 0.0
or squashMultHeat == 0.0 and stretchMultHeat == 0.0):
return
# aMaxHeat aSquashMaxHeat aStretchMaxHeat
maxHeat = block.inputValue(self.aMaxHeat).asBool()
squashMaxHeat = block.inputValue(self.aSquashMaxHeat).asFloat() * -1
stretchMaxHeat = block.inputValue(self.aStretchMaxHeat).asFloat()
if (squashMaxHeat == 0.0 and stretchMaxHeat == 0.0):
return
# aGrowHeat aSquashGrowHeat aStretchGrowHeat
growHeat = block.inputValue(self.aGrowHeat).asInt()
squashGrowHeat = block.inputValue(self.aSquashGrowHeat).asInt()
stretchGrowHeat = block.inputValue(self.aStretchGrowHeat).asInt()
# aIterationsSmoothHeat
iterationsSmoothHeat = block.inputValue(
self.aIterationsSmoothHeat).asInt()
# aStrengthSmoothHeat
strengthSmoothHeat = block.inputValue(
self.aStrengthSmoothHeat).asFloat()
# ==================================
# aDeformationType
deformationType = block.inputValue(self.aDeformationType).asShort()
if (deformationType == 0):
return
# aIterationsSmoothDeformation
iterationsSmoothDeformation = block.inputValue(
self.aIterationsSmoothDeformation).asInt()
# aStrengthSmoothDeformation
strengthSmoothDeformation = block.inputValue(
self.aStrengthSmoothDeformation).asFloat()
# aTangentSpace
tangentSpace = False
if (deformationType == 2):
tangentSpace = block.inputValue(self.aTangentSpace).asShort()
# ==================================
# aStretchMesh aSquashMesh
if (deformationType == 2):
# aStretchMesh
oStretch = block.inputValue(self.aStretchMesh).asMesh()
if oStretch.isNull():
return
fnStretch = om.MFnMesh(oStretch)
stretchPoints = om.MPointArray()
fnStretch.getPoints(stretchPoints)
# aSquashMesh
oSquash = block.inputValue(self.aSquashMesh).asMesh()
if oSquash.isNull():
return
fnSquash = om.MFnMesh(oSquash)
squashPoints = om.MPointArray()
fnSquash.getPoints(squashPoints)
# orig points
origPoints = om.MPointArray()
fnOrig.getPoints(origPoints)
# ###################################
# Gather information TODO: STORE in node (refresh button)
# ###################################
d_util = om.MScriptUtil()
doublePtr = d_util.asDoublePtr()
# orig edge lengths
itEdgeOrig = om.MItMeshEdge(oOrig)
edgeLengthsOrig = []
lengthSum = 0.0
while not itEdgeOrig.isDone():
itEdgeOrig.getLength(doublePtr)
eachLength = d_util.getDouble(doublePtr)
lengthSum += eachLength
edgeLengthsOrig.append(eachLength)
itEdgeOrig.next()
edgeLengthAvrg = lengthSum / itEdgeOrig.count()
# orig face area
itPolyOrig = om.MItMeshPolygon(oOrig)
polyAreasOrig = []
while not itPolyOrig.isDone():
itPolyOrig.getArea(doublePtr)
eachArea = d_util.getDouble(doublePtr)
polyAreasOrig.append(eachArea)
itPolyOrig.next()
# connected edges and vertices (and faces)
connectedEdges = []
connectedPoints = []
connectedFaces = []
itPointCurrent = om.MItMeshVertex(oOrig)
iaConnectedObjects = om.MIntArray()
while not itPointCurrent.isDone():
# edges
itPointCurrent.getConnectedEdges(iaConnectedObjects)
connectedEdges.append(list(iaConnectedObjects))
# vertices
itPointCurrent.getConnectedVertices(iaConnectedObjects)
connectedPoints.append(list(iaConnectedObjects))
# faces
itPointCurrent.getConnectedFaces(iaConnectedObjects)
connectedFaces.append(list(iaConnectedObjects))
# finish
itPointCurrent.next()
# ###################################
# Gather information per call
# ###################################
d_util = om.MScriptUtil()
doublePtr = d_util.asDoublePtr()
# current polygon area
if (measureTypeHeat == 0):
itPolyCurrent = om.MItMeshPolygon(oInputGeom)
polyAreasCurrent = []
while not itPolyCurrent.isDone():
itPolyCurrent.getArea(doublePtr)
eachArea = d_util.getDouble(doublePtr)
polyAreasCurrent.append(eachArea)
itPolyCurrent.next()
# current edge length
elif (measureTypeHeat == 1):
edgeLengthsCurrent = []
itEdgeCurrent = om.MItMeshEdge(oInputGeom)
while not itEdgeCurrent.isDone():
itEdgeCurrent.getLength(doublePtr)
edgeLengthsCurrent.append(d_util.getDouble(doublePtr))
itEdgeCurrent.next()
# current normals
if (deformationType == 1):
currentNormals = om.MFloatVectorArray()
fnCurrent.getVertexNormals(False, currentNormals,
om.MSpace.kObject)
# find relevant points
paPoints = om.MPointArray()
ptIndices = []
ptWeights = []
while not iter.isDone():
iterIndex = iter.index()
pt = iter.position()
# get painted weight
wPt = self.weightValue(block, multiIndex, iterIndex)
if (wPt == 0.0):
iter.next()
continue
# only store points with weights
paPoints.append(pt)
ptIndices.append(iterIndex)
ptWeights.append(wPt)
iter.next()
iter.reset()
# ###################################
# Heat Calculation
# ###################################
# input: relevant points, default lengths, current lengths, edgeLengthAvrg
# output: arHeat
#
# eachHeat =-1.0 // origLength*0 // squashed
# eachHeat = 0.0 // origLength*1 // default
# eachHeat = 1.0 // origLength*2 // stretched
arHeat = []
for x, eachId in enumerate(ptIndices):
# measure difference between orig and current
currentMeasure = 0.0
origMeasure = 0.0
# faces
if (measureTypeHeat == 0):
for eachFace in connectedFaces[eachId]:
currentMeasure += polyAreasCurrent[eachFace]
origMeasure += polyAreasOrig[eachFace]
eachHeat = ((currentMeasure - origMeasure) / origMeasure)
# edges
elif (measureTypeHeat == 1):
for eachEdge in connectedEdges[eachId]:
currentMeasure += edgeLengthsCurrent[eachEdge]
origMeasure += edgeLengthsOrig[eachEdge]
# to have similar behavior as face area multiply
eachHeat = ((currentMeasure - origMeasure) / origMeasure) * 2
#
# stretch and squash specific modification
if (eachHeat < 0.0):
eachHeat *= squashMultHeat * multHeat
if (eachHeat < squashMaxHeat and maxHeat):
eachHeat = squashMaxHeat
elif (eachHeat > 0.0):
eachHeat *= stretchMultHeat * multHeat
if (eachHeat > stretchMaxHeat and maxHeat):
eachHeat = stretchMaxHeat
# store
arHeat.append(eachHeat)
# ###################################
# Heat Grow
# ###################################
squashGrowHeat += growHeat
stretchGrowHeat += growHeat
if (squashGrowHeat or stretchGrowHeat):
# find iteration count
growIterations = squashGrowHeat
if (stretchGrowHeat > growIterations):
growIterations = stretchGrowHeat
for y in range(growIterations):
arHeatNew = list(arHeat)
# loop through effected points
for x, eachId in enumerate(ptIndices):
strongestSquash = arHeatNew[x]
strongestStretch = arHeatNew[x]
# loop over neighbors
for eachNeighborId in connectedPoints[eachId]:
if (eachNeighborId in ptIndices):
eachNeighborHeat = arHeat[ptIndices.index(
eachNeighborId)]
if (eachNeighborHeat < strongestSquash):
strongestSquash = eachNeighborHeat
if (eachNeighborHeat > strongestStretch):
strongestStretch = eachNeighborHeat
# set proper value
if (squashGrowHeat > y and stretchGrowHeat > y):
newValue = 0.0
if (strongestSquash < 0.0):
newValue = strongestSquash
if (strongestStretch > 0.0):
newValue += strongestStretch
if (newValue):
arHeatNew[x] = newValue
elif (squashGrowHeat > y and strongestSquash < 0.0):
if (arHeatNew[x] > 0.0):
arHeatNew[x] += strongestSquash
else:
arHeatNew[x] = strongestSquash
elif (stretchGrowHeat > y and strongestStretch > 0.0):
if (arHeatNew[x] < 0.0):
arHeatNew[x] += strongestStretch
else:
arHeatNew[x] = strongestStretch
arHeat = arHeatNew
#
# ###################################
# Heat Smooth
# ###################################
# input: arHeat
# output: arHeat
for y in range(iterationsSmoothHeat):
arHeatNew = list(arHeat)
for x, eachId in enumerate(ptIndices):
neighborIds = connectedPoints[eachId]
neighborAvrg = 0.0
validNeighbor = False
for eachNeighborId in neighborIds:
if (eachNeighborId in ptIndices):
validNeighbor = True
neighborAvrg += arHeat[ptIndices.index(eachNeighborId)]
if (validNeighbor):
neighborAvrg /= len(neighborIds)
arHeatNew[x] = arHeatNew[x] * (
1.0 -
strengthSmoothHeat) + neighborAvrg * strengthSmoothHeat
arHeat = arHeatNew
# ###################################
# Heat Display
# ###################################
# input: arHeat
# result: vertexColors
if (displayColors):
colorList = om.MColorArray()
indexList = om.MIntArray()
for x, eachId in enumerate(ptIndices):
# colorBase colorStretch colorSquash
eachColor = om.MFloatVector(colorBase)
if (arHeat[x] > 0.0):
eachColor += (colorStretch - eachColor) * (arHeat[x])
elif (arHeat[x] < 0.0):
eachColor += (colorSquash - eachColor) * (arHeat[x] * -1)
colorList.append(
om.MColor(eachColor.x, eachColor.y, eachColor.z, 1.0))
indexList.append(eachId)
#fnCurrent.setVertexColor( om.MColor(eachColor.x, eachColor.y, eachColor.z), eachId )# (setting all at once is faster)
fnCurrent.setVertexColors(colorList, indexList)
# ###################################
# Deformation Calculation
# ###################################
# input: heatArray
# output: motionVectorArray
arVectors = []
for x, eachId in enumerate(ptIndices):
eachHeat = arHeat[x]
vecMove = om.MVector()
# skip calculation for 0.0 heat
if (eachHeat == 0.0):
arVectors.append(vecMove)
continue
# ###################################
# Normal
# ###################################
if (deformationType == 1):
# normal deformation
vecMove += om.MVector(
currentNormals[eachId]) * (eachHeat * -1) * edgeLengthAvrg
# ###################################
# BlendShape
# ###################################
if (deformationType == 2):
if (eachHeat < 0.0):
targetPt = squashPoints[eachId]
vecMove += (targetPt - origPoints[eachId]) * (eachHeat *
-1)
elif (eachHeat > 0.0):
targetPt = stretchPoints[eachId]
vecMove += (targetPt - origPoints[eachId]) * (eachHeat)
# tangent spaces
if (tangentSpace):
matTangentOrig = getTangentSpace(tangentSpace, fnOrig,
eachId,
connectedFaces[eachId])
matTangentCurrent = getTangentSpace(
tangentSpace, fnCurrent, eachId,
connectedFaces[eachId])
vecMove *= matTangentOrig.inverse() * matTangentCurrent
#
# save vector
arVectors.append(vecMove)
# ###################################
# Deformation Smooth
# ###################################
# input: motionVectorArray
# result: motionVectorArray
for x in range(iterationsSmoothDeformation):
arVectorsNew = list(arVectors)
for x, eachId in enumerate(ptIndices):
neighborIds = connectedPoints[eachId]
neighborAvrg = om.MVector()
validNeighbor = False
for eachNeighborId in neighborIds:
if (eachNeighborId in ptIndices):
validNeighbor = True
neighborAvrg += arVectors[ptIndices.index(
eachNeighborId)]
if (validNeighbor):
neighborAvrg /= len(neighborIds)
arVectorsNew[x] = arVectorsNew[x] * (
1.0 - strengthSmoothDeformation
) + neighborAvrg * strengthSmoothDeformation
arVectors = arVectorsNew
# ###################################
# Deformation
# ###################################
# input: motionVectorArray, weights
# result: deformed mesh
counter = 0
while not iter.isDone():
if (iter.index() in ptIndices):
iter.setPosition(paPoints[counter] + arVectors[counter] *
ptWeights[counter] * envelope)
counter += 1
iter.next()
def createVoxelMesh(self, voxelCenterPosition, uvArray, texNodeName,
cubeWidth, outputMeshData):
numVoxels = len(voxelCenterPosition)
numVertices = 8 #number of vertices
numPolygons = 6 #number of polygons
numVerticesPerPolygon = 4 #number of vertices per polygon
numNormalsPerVoxel = numVerticesPerPolygon * numPolygons #24 number of vertex normals
numPolygonConnectsPerVoxel = numPolygons * numVerticesPerPolygon #24 number of polygon connects
cubeHalfWidth = cubeWidth / 2
#initialize all the params in the MFnMesh.create()
#vertexArray: point array, This should include all the vertices in the mesh and no eatras
totalVertices = numVertices * numVoxels
vertexArray = OpenMaya.MFloatPointArray()
#polygonCounts array of vertex counts for each polygon
#for the cube would have 6 faces, each of which had 4 verts, so the polygonCounts would be [4,4,4,4,4,4]
totalPolygons = numPolygons * numVoxels
polygonCounts = OpenMaya.MIntArray()
#polygonConnects
#array of vertex connections for each polygon
polygonConnects = OpenMaya.MIntArray()
#set shared Normals for these vertices
vertexNormals = OpenMaya.MVectorArray()
#vertexColorArray
vertexColorArray = OpenMaya.MColorArray()
#vertexColorIndexArray
vertexIndexArray = OpenMaya.MIntArray()
#PolygonIDArray
faceList = OpenMaya.MIntArray()
for i in range(numVoxels):
pVoxelCenterPosition = voxelCenterPosition[i]
#Update VertexArray for VoxelMesh
vertexList = [
OpenMaya.MFloatPoint(pVoxelCenterPosition.x - cubeHalfWidth,
pVoxelCenterPosition.y - cubeHalfWidth,
pVoxelCenterPosition.z -
cubeHalfWidth), #vertex 0
OpenMaya.MFloatPoint(pVoxelCenterPosition.x - cubeHalfWidth,
pVoxelCenterPosition.y - cubeHalfWidth,
pVoxelCenterPosition.z +
cubeHalfWidth), #vertex 1
OpenMaya.MFloatPoint(pVoxelCenterPosition.x - cubeHalfWidth,
pVoxelCenterPosition.y + cubeHalfWidth,
pVoxelCenterPosition.z -
cubeHalfWidth), #vertex 2
OpenMaya.MFloatPoint(pVoxelCenterPosition.x - cubeHalfWidth,
pVoxelCenterPosition.y + cubeHalfWidth,
pVoxelCenterPosition.z +
cubeHalfWidth), #vertex 3
OpenMaya.MFloatPoint(pVoxelCenterPosition.x + cubeHalfWidth,
pVoxelCenterPosition.y - cubeHalfWidth,
pVoxelCenterPosition.z -
cubeHalfWidth), #vertex 4
OpenMaya.MFloatPoint(pVoxelCenterPosition.x + cubeHalfWidth,
pVoxelCenterPosition.y - cubeHalfWidth,
pVoxelCenterPosition.z +
cubeHalfWidth), #vertex 5
OpenMaya.MFloatPoint(pVoxelCenterPosition.x + cubeHalfWidth,
pVoxelCenterPosition.y + cubeHalfWidth,
pVoxelCenterPosition.z -
cubeHalfWidth), #vertex 6
OpenMaya.MFloatPoint(pVoxelCenterPosition.x + cubeHalfWidth,
pVoxelCenterPosition.y + cubeHalfWidth,
pVoxelCenterPosition.z +
cubeHalfWidth), #vertex 7
]
for j in range(numVertices):
vertexArray.append(vertexList[j])
#here need to assign vertex color
if texNodeName:
vertexColor = cmds.colorAtPoint(texNodeName,
o='RGB',
u=uvArray[i][0],
v=uvArray[i][1])
mColor = OpenMaya.MColor(vertexColor[0], vertexColor[1],
vertexColor[2], 1.0)
vertexColorArray.append(mColor)
vertexIndexArray.append(i * numVertices + j)
#print vertexColor
#Update polygonCounts for VoxelMesh
for j in range(numPolygons):
polygonCounts.append(numVerticesPerPolygon)
faceList.append(i * numPolygons + j)
#Update polygonConnects for VoxelMesh
#Update vertexNormals for VoxelMesh
polygonConnectsList = [
0, 1, 3, 2, 1, 5, 7, 3, 4, 6, 7, 5, 2, 6, 4, 0, 0, 4, 5, 1, 2,
3, 7, 6
]
vertexNormalsList = [
OpenMaya.MVector(-1.0, 0.0,
0.0), #vertex normal on face (0,1,3,2) #0
OpenMaya.MVector(-1.0, 0.0,
0.0), #vertex normal on face (0,1,3,2) #1
OpenMaya.MVector(-1.0, 0.0,
0.0), #vertex normal on face (0,1,3,2) #7
OpenMaya.MVector(-1.0, 0.0,
0.0), #vertex normal on face (0,1,3,2) #3
OpenMaya.MVector(0.0, 0.0,
1.0), #vertex normal on face (1,5,7,3) #1
OpenMaya.MVector(0.0, 0.0,
1.0), #vertex normal on face (1,5,7,3) #5
OpenMaya.MVector(0.0, 0.0,
1.0), #vertex normal on face (1,5,7,3) #7
OpenMaya.MVector(0.0, 0.0,
1.0), #vertex normal on face (1,5,7,3) #3
OpenMaya.MVector(1.0, 0.0,
0.0), #vertex normal on face (4,6,7,5) #4
OpenMaya.MVector(1.0, 0.0,
0.0), #vertex normal on face (4,6,7,5) #6
OpenMaya.MVector(1.0, 0.0,
0.0), #vertex normal on face (4,6,7,5) #7
OpenMaya.MVector(1.0, 0.0,
0.0), #vertex normal on face (4,6,7,5) #5
OpenMaya.MVector(0.0, 0.0,
-1.0), #vertex normal on face (2,6,4,0) #2
OpenMaya.MVector(0.0, 0.0,
-1.0), #vertex normal on face (2,6,4,0) #6
OpenMaya.MVector(0.0, 0.0,
-1.0), #vertex normal on face (2,6,4,0) #4
OpenMaya.MVector(0.0, 0.0,
-1.0), #vertex normal on face (2,6,4,0) #0
OpenMaya.MVector(0.0, -1.0,
0.0), #vertex normal on face (0,4,5,1) #0
OpenMaya.MVector(0.0, -1.0,
0.0), #vertex normal on face (0,4,5,1) #4
OpenMaya.MVector(0.0, -1.0,
0.0), #vertex normal on face (0,4,5,1) #5
OpenMaya.MVector(0.0, -1.0,
0.0), #vertex normal on face (0,4,5,1) #1
OpenMaya.MVector(0.0, 1.0,
0.0), #vertex normal on face (2,3,7,6) #2
OpenMaya.MVector(0.0, 1.0,
0.0), #vertex normal on face (2,3,7,6) #3
OpenMaya.MVector(0.0, 1.0,
0.0), #vertex normal on face (2,3,7,6) #7
OpenMaya.MVector(0.0, 1.0,
0.0) #vertex normal on face (2,3,7,6) #6
]
for j in range(numNormalsPerVoxel):
vertexNormals.append(vertexNormalsList[j])
polygonConnects.append(polygonConnectsList[j] +
i * numVertices)
#for j in range (numPolygonConnectsPerVoxel):
mFnMesh = OpenMaya.MFnMesh()
#shapeNode
mMeshShape = mFnMesh.create(totalVertices, totalPolygons, vertexArray,
polygonCounts, polygonConnects,
outputMeshData)
#mMeshShape --> kMeshGeom
mCubeMesh = OpenMaya.MFnMesh(mMeshShape)
'''
#assign Normal to the Cubes:
#confused how to use setFaceVertexNormals
#rewrite the function for setFaceVertexNormals based on setFaceVertexNormal
#by query the facelist
#support hard edge!
for i in range (faceList.length()):
for j in range (numVerticesPerPolygon):
index = numVerticesPerPolygon * i + j
mCubeMesh.setFaceVertexNormal(vertexNormals[index], i, polygonConnects[index])
'''
#'''
#setVertexColor
if texNodeName:
mCubeMesh.createColorSetDataMesh('vertexColorSet')
mCubeMesh.setVertexColors(vertexColorArray, vertexIndexArray, None,
OpenMaya.MFnMesh.kRGBA)
#'''
return outputMeshData
def test_array_creation(self):
def assert_matches(ar, items):
assert len(ar) == len(items)
for i in xrange(len(ar)):
assert ar[i] == items[i]
# END assert array entry matches item entry
# END assert items
# test all random access types
def assert_creation(cls, items):
# from multiple
ar = cls.mfromMultiple(*items)
assert_matches(ar, items)
# from iter
ar = cls.mfromIter(iter(items))
assert_matches(ar, items)
# from list
ar = cls.mfromList(items)
assert_matches(ar, items)
# test iteration
ne = 0
for elm in ar:
ne += 1
assert len(ar) == ne
# END assert items
col1 = api.MColor(1.0, 1.0)
col2 = api.MColor(1.0, 2.0)
col3 = api.MColor(1.0, 3.0)
p1 = api.MPoint(1.0, 1.0)
p2 = api.MPoint(1.0, 2.0)
p3 = api.MPoint(1.0, 3.0)
fp1 = api.MFloatPoint(1.0, 1.0)
fp2 = api.MFloatPoint(1.0, 2.0)
fp3 = api.MFloatPoint(1.0, 3.0)
fv1 = api.MFloatVector(1.0, 1.0)
fv2 = api.MFloatVector(1.0, 2.0)
fv3 = api.MFloatVector(1.0, 3.0)
v1 = api.MVector(1.0, 1.0)
v2 = api.MVector(1.0, 2.0)
v3 = api.MVector(1.0, 3.0)
for cls, items in ((api.MIntArray, (4, 6, 7)), (api.MDoubleArray,
(4.0, 6.0, 7.0)),
(api.MFloatArray, (4.0, 6.0, 7.0)),
(api.MColorArray, (col1, col2, col3)),
(api.MPointArray, (p1, p2, p3)),
(api.MFloatPointArray, (fp1, fp2, fp3)),
(api.MFloatVectorArray,
(fv1, fv2, fv3)), (api.MVectorArray, (v1, v2,
v3))):
assert_creation(cls, items)
#Get points.
source_MfnMesh = OpenMaya.MFnMesh(source_mDagPath)
source_Pnts = OpenMaya.MFloatPointArray()
source_MfnMesh.getPoints(source_Pnts, OpenMaya.MSpace.kWorld)
#Defining used variables.
checkCollision = 0
maxDeformation = 0.0
dummyFloatArray = OpenMaya.MFloatArray()
source_pntNormal = OpenMaya.MVector()
#Get Vertex color.
vertexColorList = OpenMaya.MColorArray()
source_MfnMesh.getVertexColors(vertexColorList)
collideColor = OpenMaya.MColor(1.0, 0.0, 0.0, 1.0)
lenVertexList = vertexColorList.length()
#Get Vert list.
fnComponent = OpenMaya.MFnSingleIndexedComponent()
fullComponent = fnComponent.create(OpenMaya.MFn.kMeshVertComponent)
fnComponent.setCompleteData(lenVertexList)
vertexIndexList = OpenMaya.MIntArray()
fnComponent.getElements(vertexIndexList)
# direct collision deformation:
for k in xrange(source_Pnts.length()):
source_MfnMesh.getVertexNormal(k, source_pntNormal,
OpenMaya.MSpace.kWorld)
# define an intersection ray from the mesh that should be deformed
def deform(self, dataBlock, geoIterator, matrix, geometryIndex):
input = OpenMayaMPx.cvar.MPxDeformerNode_input
# attach a handle to input Array Attribute
# prevent recomputation
dataHandleInputArray = dataBlock.outputArrayValue(input)
#jump to particular element
dataHandleInputArray.jumpToElement(geometryIndex)
#attach a handle to specific data block
dataHandleInputElement = dataHandleInputArray.outputValue()
#reach to the child
inputGeom = OpenMayaMPx.cvar.MPxDeformerNode_inputGeom
dataHandleInputGeom = dataHandleInputElement.child(inputGeom)
inMesh = dataHandleInputGeom.asMesh()
#envelope
envolope = OpenMayaMPx.cvar.MPxDeformerNode_envelope
dataHandleEnvelope = dataBlock.inputValue(envolope)
envolopeValue = dataHandleEnvelope.asFloat()
#amplitude
dataHandleAmplitude = dataBlock.inputValue(rippleDeformer.amplitude)
amplitudeValue = dataHandleAmplitude.asFloat()
#displace
dataHandleDisplace = dataBlock.inputValue(rippleDeformer.displacement)
displaceValue = dataHandleDisplace.asFloat()
#matrix
dataHandleMatrix = dataBlock.inputValue(rippleDeformer.matrix)
MatrixValue = dataHandleMatrix.asMatrix()
#read translation from Matrix
mTransMatrix = OpenMaya.MTransformationMatrix(MatrixValue)
translationValue = mTransMatrix.getTranslation(OpenMaya.MSpace.kObject)
#mEulerRot = OpenMaya.MVector()
#mEulerRot = mTransMatrix.eulerRotation().asVector()
mFloatVectorArray_Normal = OpenMaya.MFloatVectorArray()
inMeshMfn = OpenMaya.MFnMesh(inMesh)
inMeshMfn.getVertexNormals(False, mFloatVectorArray_Normal,
OpenMaya.MSpace.kObject)
#create colorSet
inMeshMfn.createColorSetDataMesh('vertexColorSet')
inMeshMfn.setIsColorClamped('vertexColorSet', True)
mPointArray_meshVert = OpenMaya.MPointArray()
mColorArray_meshVert = OpenMaya.MColorArray()
mVertexArray_meshVert = OpenMaya.MIntArray()
while (not geoIterator.isDone()):
pointPosition = geoIterator.position()
weight = self.weightValue(dataBlock, geometryIndex,
geoIterator.index())
#inMeshMfn.setVertexColor(pointColor, geoIterator.index(),None,OpenMaya.MFnMesh.kRGBA)
pointPosition.x = pointPosition.x + math.sin(
geoIterator.index() + displaceValue + translationValue[0]
) * amplitudeValue * envolopeValue * mFloatVectorArray_Normal[
geoIterator.index()].x * weight
pointPosition.y = pointPosition.y + math.sin(
geoIterator.index() + displaceValue + translationValue[0]
) * amplitudeValue * envolopeValue * mFloatVectorArray_Normal[
geoIterator.index()].y * weight
pointPosition.z = pointPosition.z + math.sin(
geoIterator.index() + displaceValue + translationValue[0]
) * amplitudeValue * envolopeValue * mFloatVectorArray_Normal[
geoIterator.index()].z * weight
mPointArray_meshVert.append(pointPosition)
#paint vertex color
Color_R = math.sin(geoIterator.index() +
displaceValue) * amplitudeValue
Color_G = math.cos(geoIterator.index() +
displaceValue) * amplitudeValue
Color_B = math.sin(geoIterator.index() -
displaceValue) * amplitudeValue
pointColor = OpenMaya.MColor(Color_R, Color_G, Color_B, 1.0)
mColorArray_meshVert.append(pointColor)
mVertexArray_meshVert.append(geoIterator.index())
geoIterator.next()
#optimize performance
geoIterator.setAllPositions(mPointArray_meshVert)
inMeshMfn.setVertexColors(mColorArray_meshVert, mVertexArray_meshVert,
None, OpenMaya.MFnMesh.kRGBA)
#set current colorset
#inMeshMfn.setCurrentColorSetDataMesh('vertexColorSet')
if (not cmds.polyColorSet(ccs=True, q=True) == 'vertexColorSet'):
cmds.polyColorSet(ccs=True, cs='vertexColorSet')
