def sang_poly(chue_nod_poly,
lis_xyz,
lis_index_chut,
lis_n_chut_nai_na,
lis_u,
lis_v,
lis_norm=None):
# 頂点のデータを収めておいたリストをmayaの配列オブジェクトにする
arr_xyz = om.MFloatPointArray(lis_xyz) # 頂点の位置
arr_index_chut = om.MIntArray(lis_index_chut) # 頂点の番号
arr_n_chut_nai_na = om.MIntArray(lis_n_chut_nai_na) # 各面に使う頂点の数
arr_u = om.MFloatArray(lis_u) # 頂点のuv
arr_v = om.MFloatArray(lis_v)
trans_fn = om.MFnTransform()
trans_obj = trans_fn.create()
trans_fn.setName(chue_nod_poly)
chue_nod_poly = trans_fn.name()
# 準備しておいたデータから全てのポリゴンメッシュを作成する
fn_mesh = om.MFnMesh()
fn_mesh.create(arr_xyz, arr_n_chut_nai_na, arr_index_chut, arr_u, arr_v,
trans_obj)
fn_mesh.setName(chue_nod_poly + 'Shape')
fn_mesh.assignUVs(arr_n_chut_nai_na, arr_index_chut)
if (lis_norm):
fn_mesh.setVertexNormals(lis_norm, om.MIntArray(range(len(lis_xyz))))
# 一応MMDからのモデルだという情報をポリゴンのノードに刻んでおく
mc.addAttr(chue_nod_poly,
longName='MMD_model',
niceName='MMDからのモデル',
attributeType='bool')
mc.setAttr(chue_nod_poly + '.MMD_model', True)
mc.setAttr(chue_nod_poly + '.aiOpaque', 0) # arnoldを使う時に不透明度を有効にする
return chue_nod_poly
def buildMesh() : numVertices=4 numFaces=1 outputMesh = OpenMaya.MObject() points = OpenMaya.MFloatPointArray() faceConnects = OpenMaya.MIntArray() faceCounts = OpenMaya.MIntArray() p = OpenMaya.MFloatPoint(-1.0,0.0,-1.0) points.append(p) p = OpenMaya.MFloatPoint(-1.0,0.0,1.0) points.append(p) p = OpenMaya.MFloatPoint(1.0,0.0,1.0) points.append(p) p = OpenMaya.MFloatPoint(1.0,0.0,-1.0) points.append(p) faceConnects.append(0) faceConnects.append(1) faceConnects.append(2) faceConnects.append(3) faceCounts.append(4) meshFN = OpenMaya.MFnMesh() meshFN.create(points, [4],faceConnects) nodeName = meshFN.name() print(nodeName) cmds.sets(nodeName, add='initialShadingGroup') cmds.select(nodeName) meshFN.updateSurface()
def __init__(self):
ompy.MUserData.__init__(self, False)
self.setDeleteAfterUse(False) # don;t delete after draw
self.shapes = [] #vector<int>
self.coords = ompy.MFloatVectorArray() #MFloatVectorArray
self.screenSpaceOffsets = ompy.MFloatVectorArray() #MFloatVectorArray
self.sizes = [] #vector<float>
self.thicknesses = [] #vector<float>
self.colors = ompy.MFloatPointArray() #MFloatPointArray
self.pColors = [] #vector<MFloatPointArray>
self.names = [] #vector<MString>
self.fills = [] #vector<bool>
self.spaces = [] #vector<int>
self.maxMemorys = [] #vector<int>
self.projPlanes = [] #vector<int>
self.drawPlaneMode = 0 #int
self.cameraPath = ompy.MDagPath() #MDagPath
self.attrMatrix = ompy.MFloatMatrix() #MFloatMatrix
self.attrNames = [] #vector<MString>
self.attrValueType = [] #vector<MString>
self.attrValueInt = [] #vector<int>
self.attrValueFloat = [] #vector<float>
self.attrValueDouble = [] #vector<double>
self.attrValueEnum = [] #vector<MString>
def createVoxelMesh(self, pVoxelPositions, pVoxelWidth, pOutMeshData):
''' Create a mesh containing one cubic polygon for each voxel in the pVoxelPositions list. '''
numVoxels = len(pVoxelPositions)
numVerticesPerVoxel = 8 # a cube has eight vertices.
numPolygonsPerVoxel = 6 # a cube has six faces.
numVerticesPerPolygon = 4 # four vertices are required to define a face of a cube.
numPolygonConnectsPerVoxel = numPolygonsPerVoxel * numVerticesPerPolygon # 24
# Initialize the required arrays used to create the mesh in MFnMesh.create()
totalVertices = numVoxels * numVerticesPerVoxel
vertexArray = OpenMaya.MFloatPointArray()
vertexArray.setLength(totalVertices)
vertexIndexOffset = 0
totalPolygons = numVoxels * numPolygonsPerVoxel
polygonCounts = OpenMaya.MIntArray()
polygonCounts.setLength(totalPolygons)
polygonCountsIndexOffset = 0
totalPolygonConnects = numVoxels * numPolygonConnectsPerVoxel
polygonConnects = OpenMaya.MIntArray()
polygonConnects.setLength(totalPolygonConnects)
polygonConnectsIndexOffset = 0
# Populate the required arrays used in MFnMesh.create()
for i in range(0, numVoxels):
voxelPosition = pVoxelPositions[i]
# Add a new cube to the arrays.
self.createCube(voxelPosition, pVoxelWidth, vertexArray,
vertexIndexOffset, numVerticesPerVoxel,
polygonCounts, polygonCountsIndexOffset,
numPolygonsPerVoxel, numVerticesPerPolygon,
polygonConnects, polygonConnectsIndexOffset)
# Increment the respective index offsets.
vertexIndexOffset += numVerticesPerVoxel
polygonCountsIndexOffset += numPolygonsPerVoxel
polygonConnectsIndexOffset += numPolygonConnectsPerVoxel
# Create the mesh now that the arrays have been populated. The mesh is stored in pOutMeshData
meshFn = OpenMaya.MFnMesh()
meshFn.create(vertexArray,
polygonCounts,
polygonConnects,
parent=pOutMeshData)
def inflateMesh(mesh, scale=1):
sel_list = om.MSelectionList()
sel_list.add(str(mesh))
DagPath, Obj = sel_list.getComponent(0)
Mesh = om.MFnMesh(DagPath)
MeshPoints = Mesh.getPoints(om.MSpace.kWorld)
newMeshPoints = om.MFloatPointArray()
for i in range(len(MeshPoints)):
MeshPointNormal = Mesh.getVertexNormal(i, om.MSpace.kWorld)
x = MeshPoints[i].x + MeshPointNormal.x * scale
y = MeshPoints[i].y + MeshPointNormal.y * scale
z = MeshPoints[i].z + MeshPointNormal.z * scale
newMeshPoint = om.MFloatPoint(x, y, z)
newMeshPoints.append(newMeshPoint)
Mesh.setPoints(newMeshPoints, om.MSpace.kWorld)
def create(verts, faces, merge=True):
'''
Given a list of vertices (iterables of floats) and a list of faces (iterable of integer vert indices),
creates and returns a maya Mesh
'''
cmds.select(cl=True)
outputMesh = OpenMaya.MObject()
# point array of mesh vertex local positions
points = OpenMaya.MFloatPointArray()
for eachVt in verts:
p = OpenMaya.MFloatPoint(eachVt[0], eachVt[1], eachVt[2])
points.append(p)
# vertex connections per poly face in one array of indexs into point array given above
faceConnects = OpenMaya.MIntArray()
for eachFace in faces:
for eachCorner in eachFace:
faceConnects.append(int(eachCorner))
# an array to hold the total number of vertices that each face has in this case quads so 4
faceCounts = OpenMaya.MIntArray()
# python lists can be multiplied to duplicate
faceCounts = [4] * len(faces)
# get a mesh function set
meshFN = OpenMaya.MFnMesh()
# create mesh object using arrays above
meshFN.create(points, faceCounts, faceConnects, parent=outputMesh)
# now grab the name of the mesh
nodeName = meshFN.name()
cmds.sets(nodeName, add='initialShadingGroup')
cmds.select(nodeName)
meshFN.updateSurface()
# this is useful because it deletes stray vertices (ie, those not used in any faces)
cmds.polyMergeVertex(nodeName, ch=0)
meshFN.updateSurface()
return nodeName
def _importCtm(self, fileName, importOptions):
verbose = importOptions.get('verbose', False)
context = openctm.ctmNewContext(openctm.CTM_IMPORT)
# Extract file
openctm.ctmLoad(context, fileName)
e = openctm.ctmGetError(context)
if e != 0:
s = openctm.ctmErrorString(e)
print(s)
openctm.ctmFreeContext(context)
raise Exception(s)
# Extract indices
triCount = openctm.ctmGetInteger(context, openctm.CTM_TRIANGLE_COUNT)
ctmIndices = openctm.ctmGetIntegerArray(context, openctm.CTM_INDICES)
polyCount = [3] * triCount
# Extract vertices
vertCount = openctm.ctmGetInteger(context, openctm.CTM_VERTEX_COUNT)
ctmVertices = openctm.ctmGetFloatArray(context, openctm.CTM_VERTICES)
vertices = OpenMaya.MFloatPointArray()
vertices.setLength(vertCount)
# Extract Normals
ctmVertNormals = None
vertNormals = OpenMaya.MFloatPointArray()
hasNormals = openctm.ctmGetInteger(
context, openctm.CTM_HAS_NORMALS) == openctm.CTM_TRUE
if hasNormals:
ctmVertNormals = openctm.ctmGetFloatArray(context,
openctm.CTM_NORMALS)
vertNormals.setLength(vertCount)
# Extract UVs
hasUVs = openctm.ctmGetInteger(context, openctm.CTM_UV_MAP_COUNT) > 0
ctmTexCoords = None
uCoords = OpenMaya.MFloatArray()
vCoords = OpenMaya.MFloatArray()
if hasUVs:
ctmTexCoords = openctm.ctmGetFloatArray(context,
openctm.CTM_UV_MAP_1)
uCoords.setLength(vertCount)
vCoords.setLength(vertCount)
textureFilename = openctm.ctmGetUVMapString(
context, openctm.CTM_UV_MAP_1, openctm.CTM_FILE_NAME)
# TODO: Load texture file
if textureFilename:
pass
# Extract colors
colorAttrib = openctm.ctmGetNamedAttribMap(context, "Color")
hasVertexColors = colorAttrib != openctm.CTM_NONE
ctmColors = None
vertexColors = OpenMaya.MColorArray()
if hasVertexColors:
ctmColors = openctm.ctmGetFloatArray(context, colorAttrib)
vertexColors.setLength(vertCount)
pointToIndex = {}
ctmVertIndexToUniqueIndex = {}
nrSkippedVertices = 0
for i in range(vertCount):
ctmVertIndex = i * 3
p = (float(ctmVertices[ctmVertIndex]),
float(ctmVertices[ctmVertIndex + 1]),
float(ctmVertices[ctmVertIndex + 2]))
if p not in pointToIndex:
index = i - nrSkippedVertices
pointToIndex[p] = index
ctmVertIndexToUniqueIndex[i] = index
vertices[index].x = p[0]
vertices[index].y = p[1]
vertices[index].z = p[2]
if hasNormals:
vertNormals[index].x = float(ctmVertNormals[ctmVertIndex])
vertNormals[index].y = float(ctmVertNormals[ctmVertIndex +
1])
vertNormals[index].z = float(ctmVertNormals[ctmVertIndex +
2])
if hasUVs:
ctmUVIndex = i * 2
uCoords[index] = float(ctmTexCoords[ctmUVIndex])
vCoords[index] = float(ctmTexCoords[ctmUVIndex + 1])
if hasVertexColors:
ctmColIndex = i * 4
vertexColors[index].r = float(ctmColors[ctmColIndex])
vertexColors[index].g = float(ctmColors[ctmColIndex + 1])
vertexColors[index].b = float(ctmColors[ctmColIndex + 2])
vertexColors[index].a = float(ctmColors[ctmColIndex + 3])
else:
ctmVertIndexToUniqueIndex[i] = pointToIndex[p]
nrSkippedVertices += 1
uniqVertCount = len(pointToIndex)
vertices.setLength(uniqVertCount)
vertNormals.setLength(uniqVertCount)
indices = [
ctmVertIndexToUniqueIndex[ctmIndices[i]]
for i in range(3 * triCount)
]
if hasUVs:
uCoords.setLength(uniqVertCount)
vCoords.setLength(uniqVertCount)
if hasVertexColors:
vertexColors.setLength(uniqVertCount)
if verbose:
method = openctm.ctmGetInteger(context,
openctm.CTM_COMPRESSION_METHOD)
if method == openctm.CTM_METHOD_RAW:
methodStr = "RAW"
elif method == openctm.CTM_METHOD_MG1:
methodStr = "MG1"
elif method == openctm.CTM_METHOD_MG2:
methodStr = "MG2"
else:
methodStr = "Unknown"
print("File: %s" % fileName)
print("Comment: %s" %
str(openctm.ctmGetString(context, openctm.CTM_FILE_COMMENT)))
print("Compression Method: %s" % methodStr)
print("Vertices Count : %d" % vertCount)
print("Unique Vertices Count : %d" % uniqVertCount)
print("Triangles Count: %d" % triCount)
print("Has normals: %r" % hasNormals)
print("Has UVs: %r" % hasUVs)
print("Has Vertex Colors: %r" % hasVertexColors)
fnMesh = OpenMaya.MFnMesh()
newMesh = fnMesh.create(vertices, polyCount, indices, uCoords, vCoords)
if hasNormals:
fnMesh.setVertexNormals(vertNormals, range(len(vertices)))
if hasVertexColors:
fnMesh.setVertexColors(vertexColors, range(len(vertices)))
fnMesh.updateSurface()
# Assign initial shading group
slist = OpenMaya.MGlobal.getSelectionListByName("initialShadingGroup")
initialSG = slist.getDependNode(0)
fnSG = OpenMaya.MFnSet(initialSG)
if fnSG.restriction() == OpenMaya.MFnSet.kRenderableOnly:
fnSG.addMember(newMesh)
def read_gmc_data(scale_rate, gmc_path, mesh_name):
# first read, get object section
file = open(gmc_path, "r")
line_num = -1
line_nums = []
line = file.readline()
line_num += 1
while True:
line = file.readline()
line_num += 1
if not line:
break
line = strip_space_line(line)
if line.find("Object") == 0:
line_nums.append(line_num)
print line_nums
file.close()
# second read,read section 1
vertexArray = OpenMaya.MFloatPointArray()
uArray = OpenMaya.MFloatArray()
vArray = OpenMaya.MFloatArray()
polygonCounts = OpenMaya.MIntArray()
polygonConnects = OpenMaya.MIntArray()
material_num = 0
material_sets = []
file = open(gmc_path, "r")
line_num = -1
line = file.readline()
line_num += 1
while True:
line = file.readline()
line_num += 1
if not line:
break
line = strip_space_line(line)
if line_num >= line_nums[0] and line_num < line_nums[1]:
if line.find("Vertices") == 0:
print line
elif line.find("v") == 0:
vertex_line = re.split("v|n|c|t", line)
vertex_data = []
vertex_data.append(parse_mesh_element(vertex_line[1]))
vertex_data.append(parse_mesh_element(vertex_line[4]))
pos = vertex_data[0]
pos[0] *= scale_rate
pos[1] *= scale_rate
pos[2] *= scale_rate
v = OpenMaya.MFloatPoint(pos[0], pos[1], pos[2])
vertexArray.append(v)
uv = vertex_data[1]
uArray.append(uv[0])
vArray.append(uv[1])
elif line.find("f") == 0:
face_line = line[1:]
face_data = []
face_data = parse_mesh_element(face_line)
print face_data
polygonCounts.append(3)
polygonConnects.append(int(face_data[1]))
polygonConnects.append(int(face_data[2]))
polygonConnects.append(int(face_data[3]))
mFn_Mesh = OpenMaya.MFnMesh()
m_DagMod = OpenMaya.MDagModifier()
new_object = m_DagMod.createNode('transform')
mFn_Mesh.create(vertexArray, polygonCounts, polygonConnects, uArray,
vArray, new_object)
mFn_Mesh.setName(mesh_name)
m_DagMod.doIt()
new_mesh = pmc.PyNode(mesh_name)
new_transform = pmc.listRelatives(new_mesh, type='transform',
parent=True)[0]
mFn_Mesh.assignUVs(polygonCounts, polygonConnects, 'map1')
node_name = mesh_name + "_mesh"
pmc.select(new_transform)
pmc.rename(new_transform, node_name)
file.close()
def read_skc_file(scale_rate, skc_path, mesh_name):
file = open(skc_path, "r")
line = file.readline()
vertexArray = OpenMaya.MFloatPointArray()
uArray = OpenMaya.MFloatArray()
vArray = OpenMaya.MFloatArray()
polygonCounts = OpenMaya.MIntArray()
polygonConnects = OpenMaya.MIntArray()
vertexWeights = []
material_num = 0
material_sets = []
while True:
line = file.readline()
if not line:
break
line = strip_space_line(line)
if line.find("Materials") != -1:
line = strip_space_line(line)
material_num = int(line.split(":")[1])
for i in range(0, int(material_num)):
material_sets.append(0)
elif line.find("Vertices") != -1:
print line
elif line[0] == "v":
vertex_data = parse_pos_uv_weight(line)
pos = vertex_data[0]
pos[0] *= scale_rate
pos[1] *= scale_rate
pos[2] *= scale_rate
v = OpenMaya.MFloatPoint(pos[0], pos[1], pos[2])
vertexArray.append(v)
uv = vertex_data[1]
uArray.append(uv[0])
vArray.append(uv[1])
# bone weights
skin_data = vertex_data[2]
weight_num = skin_data[0]
weights = []
for bi in range(0, int(weight_num)):
tmp_bone_idx = skin_data[int(1 + 2 * bi)]
tmp_bone_name = bone_name_list[int(tmp_bone_idx)]
tmp_bone_weight = skin_data[int(2 + 2 * bi)]
key_value = (tmp_bone_name, tmp_bone_weight)
weights.append(key_value)
vertexWeights.append(weights)
elif line.find("Triangles") != -1:
print line
elif line[0] == "f":
face_data = parse_face(line)
polygonCounts.append(3)
polygonConnects.append(int(face_data[2]))
polygonConnects.append(int(face_data[3]))
polygonConnects.append(int(face_data[4]))
# assign material
material_sets[int(face_data[1])] += 1
mFn_Mesh = OpenMaya.MFnMesh()
m_DagMod = OpenMaya.MDagModifier()
new_object = m_DagMod.createNode('transform')
mFn_Mesh.create(vertexArray, polygonCounts, polygonConnects, uArray,
vArray, new_object)
mFn_Mesh.setName(mesh_name)
m_DagMod.doIt()
new_mesh = pmc.PyNode(mesh_name)
new_transform = pmc.listRelatives(new_mesh, type='transform',
parent=True)[0]
mFn_Mesh.assignUVs(polygonCounts, polygonConnects, 'map1')
node_name = mesh_name + "_mesh"
pmc.select(new_transform)
pmc.rename(new_transform, node_name)
# skin cluster
pmc.select(bone_name_list[0], add=True)
skin_cluster = pmc.skinCluster(bindMethod=0,
skinMethod=1,
normalizeWeights=0,
maximumInfluences=4,
obeyMaxInfluences=True)
pmc.select(node_name, r=True)
pmc.skinPercent(skin_cluster, node_name, normalize=False, pruneWeights=100)
for v in range(0, len(vertexWeights)):
pmc.skinPercent(skin_cluster,
"{0}.vtx[{1}]".format(node_name, v),
transformValue=vertexWeights[v],
normalize=True)
#create material
#pCylinder1.f[14:17] _mesh.f[{0}:{1}].format()
material_starts = []
material_ends = []
mesh_selcte_sets = []
material_sets = filter(lambda x: x != 0, material_sets)
print material_sets
material_starts.append(0)
material_ends.append(material_sets[0] - 1)
mesh_selcte_sets.append(
node_name +
".f[{0}:{1}]".format(int(material_starts[0]), int(material_ends[0])))
for i in range(1, len(material_sets)):
material_starts.append(material_ends[int(i - 1)] + 1)
material_ends.append(material_ends[int(i - 1)] + material_sets[i])
mesh_selcte_sets.append(node_name + ".f[{0}:{1}]".format(
int(material_starts[i]), int(material_ends[i])))
print mesh_selcte_sets
# 没有这一句会出错，必须将以前的选择清理掉
pmc.select(clear=True)
for i in range(0, len(mesh_selcte_sets)):
shader_name = "p_shader{0}".format(int(i))
new_shader = pmc.shadingNode("lambert",
asShader=True,
name=shader_name)
new_shadinggroup = pmc.sets(renderable=True,
noSurfaceShader=True,
empty=True,
name='{}_SG'.format(shader_name))
pmc.connectAttr(new_shader.outColor, new_shadinggroup.surfaceShader)
pmc.select(mesh_selcte_sets[i])
pmc.hyperShade(assign=new_shadinggroup)
pmc.select(clear=True)
import pymel.core as pmc import pymel.core.datatypes as pmdt import maya.api.OpenMaya as OpenMaya vertexArray = OpenMaya.MFloatPointArray() v = OpenMaya.MFloatPoint(0.0, 0.0, 0.0) vertexArray.append(v) v = OpenMaya.MFloatPoint(0.0, 1.0, 0.0) vertexArray.append(v) v = OpenMaya.MFloatPoint(1.0, 1.0, 0.0) vertexArray.append(v) v = OpenMaya.MFloatPoint(1.0, 0.0, 0.0) vertexArray.append(v) v = OpenMaya.MFloatPoint(2.0, 1.0, 0.0) vertexArray.append(v) v = OpenMaya.MFloatPoint(2.0, 0.0, 0.0) vertexArray.append(v) polygonCounts = OpenMaya.MIntArray() polygonCounts.append(3) polygonCounts.append(3) polygonCounts.append(3) polygonCounts.append(3) polygonConnects = OpenMaya.MIntArray() polygonConnects.append(0) polygonConnects.append(2) polygonConnects.append(1) polygonConnects.append(0) polygonConnects.append(3) polygonConnects.append(2)
def FLDSMDFR(self, file_gpu, grp):
file_gpu.seek(self.mesh_header.mesh_dataStart, 0)
self.byte_count = self.mesh_header.vertexCount * self.m0.stride
ti_0 = np.fromfile(file_gpu, dtype='B', count=self.byte_count).reshape(
(self.mesh_header.vertexCount, self.m0.stride))
for x in cat_list:
cat(self.m0.data, x)
for p in self.m0.data:
g = self.m0.data[p]
chunc = data_paver(g["start"], g["end"],
self.mesh_header.vertexCount,
g["item_subCount"], g["d_type"], ti_0)
if p == "POSITION0":
self.VA = om2.MFloatPointArray(chunc.tolist())
elif p == "BLENDINDICES":
self.bone_ids = chunc.tolist()
elif p == "BLENDWEIGHTS":
self.weights = chunc.tolist()
chunk2_start = self.mesh_header.mesh_dataStart + self.m1.offset
byteCount2 = self.mesh_header.vertexCount * self.m1.stride
file_gpu.seek(chunk2_start, 0)
ti_1 = np.fromfile(file_gpu, dtype='B', count=byteCount2).reshape(
(self.mesh_header.vertexCount, self.m1.stride))
for j in self.m1.data:
z = self.m1.data[j]
chunc = data_paver(z["start"], z["end"],
self.mesh_header.vertexCount,
z["item_subCount"], z["d_type"], ti_1)
if j == "NORMAL0":
Normal_Array0 = chunc[:, 0:3].reshape(
(self.mesh_header.vertexCount, 3))
Normal_Array = Normal_Array0.tolist()
elif j == "TANGENT0":
pass
elif j == "TEXCOORD0":
chunc[:, 1:2] *= -1
chunc[:, 1:2] += 1
uvData0 = chunc.tolist()
u0 = zip(*uvData0)[0]
v0 = zip(*uvData0)[1]
self.uArray0.copy(u0)
self.vArray0.copy(v0)
elif j == "TEXCOORD1":
uvData1 = chunc.tolist()
u1 = zip(*uvData1)[0]
v1 = zip(*uvData1)[1]
self.uArray1.copy(u1)
self.vArray1.copy(v1)
elif j == "TEXCOORD2":
uvData2 = chunc.tolist()
u2 = zip(*uvData2)[0]
v2 = zip(*uvData2)[1]
self.uArray2.copy(u2)
self.vArray2.copy(v2)
elif j == "TEXCOORD3":
uvData3 = chunc.tolist()
u3 = zip(*uvData3)[0]
v3 = zip(*uvData3)[1]
self.uArray3.copy(u3)
self.vArray3.copy(v3)
elif j == "NORMAL4FACTORS0":
pass
elif j == "NORMAL2FACTORS0":
pass
mesh = om2.MFnMesh()
ShapeMesh = cmds.group(em=True)
parentOwner = get_mobject(ShapeMesh)
meshMObj = mesh.create(self.VA,
self.pCounts,
self.faces,
uValues=self.uArray0,
vValues=self.vArray0,
parent=parentOwner)
cmds.sets(ShapeMesh, e=True, forceElement='initialShadingGroup')
defaultUVSetName = ''
defaultUVSetName = mesh.currentUVSetName(-1)
mesh.setUVs(self.uArray0, self.vArray0, defaultUVSetName)
mesh.assignUVs(self.pCounts, self.faces, defaultUVSetName)
if len(self.uArray1) > 1:
mesh.createUVSet('map2')
mesh.setUVs(self.uArray1, self.vArray1, 'map2')
mesh.assignUVs(self.pCounts, self.faces, 'map2')
if len(self.uArray2) > 1:
mesh.createUVSet('map3')
mesh.setUVs(self.uArray2, self.vArray2, 'map3')
mesh.assignUVs(self.pCounts, self.faces, 'map3')
if len(self.uArray3) > 1:
mesh.createUVSet('map4')
mesh.setUVs(self.uArray3, self.vArray3, 'map4')
mesh.assignUVs(self.pCounts, self.faces, 'map4')
vertexIds = range(self.mesh_header.vertexCount)
self.NA = om2.MVectorArray(Normal_Array)
mesh.setVertexNormals(self.NA, vertexIds, space=om2.MSpace.kWorld)
cmds.rename(self.name)
s1 = cmds.ls(sl=1)
self.s2 = s1[0]
if cmds.objExists(self.file_name):
cmds.parent(self.s2, self.file_name)
else:
cmds.group(em=True, name=self.file_name)
if cmds.objExists(grp): cmds.parent(self.file_name, grp)
cmds.parent(self.s2, self.file_name)
self.shapeName = self.s2.encode('ascii', 'ignore')
def moveVtx(self):
mfnMesh = Om2.MFnMesh(self.mDag)
array = Om2.MFloatPointArray()
for k in sorted(self.vtxPositionsNew):
array.append(Om2.MFloatPoint(self.vtxPositionsNew[k]))
mfnMesh.setPoints(array , space=Om2.MSpace.kWorld)
def readFile(filepath):
files = path_wrangler(filepath)
files.get_files()
md = open(files.data['uexp'], 'rb')
ua = open(files.data['uasset'], 'rb')
meshName = files.data['meshName']
submesh_name = files.data['submesh_name']
arm = False
weightData = {}
Weight_array = []
vertexArray = []
NA = []
normal_array = []
faces = []
U0 = om2.MFloatArray()
V0 = om2.MFloatArray()
U1 = om2.MFloatArray()
V1 = om2.MFloatArray()
U2 = om2.MFloatArray()
V2 = om2.MFloatArray()
U3 = om2.MFloatArray()
V3 = om2.MFloatArray()
U4 = om2.MFloatArray()
V4 = om2.MFloatArray()
U5 = om2.MFloatArray()
V5 = om2.MFloatArray()
t1 = time.time()
names = readUasset(ua)
pattern0 = re.compile(b'\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00........')
for x in xrange(20000):
s1 = struct.unpack("18s", md.read(18))[0]
if pattern0.match(s1):
c0 = struct.unpack("<L", md.read(4))[0]
c1 = struct.unpack("<L", md.read(4))[0]
c2 = struct.unpack("<L", md.read(4))[0]
c3 = struct.unpack("<L", md.read(4))[0]
c4 = struct.unpack("<L", md.read(4))[0]
if (c0 and c1 and c2 and c3 and c4 > 1000000000):
break
else:
md.seek(-20, 1)
md.seek(-17, 1)
materialCount = struct.unpack("<L", md.read(4))[0]
materials = {}
for m in xrange(materialCount):
materials[m] = {}
materials[m]['val0'] = struct.unpack("<l", md.read(4))[0]
stringIndex = struct.unpack("<L", md.read(4))[0]
unk0 = struct.unpack("<L", md.read(4))[0]
unk1 = struct.unpack("<L", md.read(4))[0]
unk2 = struct.unpack("<L", md.read(4))[0]
unk3 = struct.unpack("<f", md.read(4))[0]
unk4 = struct.unpack("<f", md.read(4))[0]
unk5 = struct.unpack("<L", md.read(4))[0]
unk6 = struct.unpack("<L", md.read(4))[0]
materials[m]['name'] = names[stringIndex]
boneCount = struct.unpack("<L", md.read(4))[0]
joint_data = {}
bt = np.empty([1, boneCount], dtype='U32')
for i in xrange(boneCount):
string_index = struct.unpack("<L", md.read(4))[0]
jName = names[string_index]
unk = struct.unpack("<L", md.read(4))[0]
parent = struct.unpack("<l", md.read(4))[0]
joint_data[i] = {"name": jName, "parent": parent}
bt[0, i] = jName
boneCount2 = struct.unpack("<L", md.read(4))[0]
bone_list = []
boneArray = []
for k in xrange(boneCount2):
m1 = struct.unpack("<10f", md.read(40))
boneName = joint_data[k]["name"]
BNparent = joint_data[k]["parent"]
boneArray.append(boneName)
BNps = om.MVector(-m1[5], -m1[6], m1[4])
BNrt = om.MQuaternion(m1[1], m1[2], -m1[0], -m1[3])
BNsc = om.MVector(-m1[8], -m1[9], -m1[7])
if BNparent == -1:
cmds.select(clear=True)
else:
pm.select(bone_list[BNparent])
newBone = pm.joint(p=(0, 0, 0), name=boneName, radius=0.1)
newBone.setTranslation(BNps)
newBone.setOrientation(BNrt)
newBone.setScale(BNsc)
bone_list.append(newBone)
arm = True
boneCount3 = struct.unpack("<L", md.read(4))[0]
md.seek(boneCount3 * 12, 1)
vertexGroups = {}
unk0 = struct.unpack("<L", md.read(4))[0]
unk1 = struct.unpack("B", md.read(1))[0]
unk2 = struct.unpack("B", md.read(1))[0]
groupCount = struct.unpack("<L", md.read(4))[0]
for m in xrange(groupCount):
z1 = struct.unpack("<H", md.read(2))[0]
ID = struct.unpack("<H", md.read(2))[0]
md.seek(24, 1)
vertexGroups[ID] = {'range': 0, 'bones': []}
# pragma region bone palette
start = struct.unpack("<L", md.read(4))[0]
count = struct.unpack("<L", md.read(4))[0]
bt = np.empty([1, count], dtype='U32')
for bn in xrange(count):
bid = struct.unpack("<H", md.read(2))[0]
vertexGroups[ID]['bones'].append(bid)
bt[0, bn] = joint_data[bid]["name"]
# pragma endregion bone palette
size = struct.unpack("<L", md.read(4))[0]
stop = start + size
vertexGroups[ID]['range'] = range(start, stop)
vertexGroups[ID]["start"] = start
vertexGroups[ID]["stop"] = stop
vertexGroups[ID]["size"] = size
vertexGroups[ID]["names"] = bt
md.seek(34, 1)
FFx4 = readHexString(md, 4)
flag = struct.unpack("<L", md.read(4))[0]
if flag: # extra data for this group
count = struct.unpack("<L", md.read(4))[0]
md.seek(count * 16, 1)
else:
null = struct.unpack("<L", md.read(4))[0]
unk = struct.unpack("B", md.read(1))[0]
checkHere = md.tell()
stride = struct.unpack("<L", md.read(4))[0]
fCount = struct.unpack("<L", md.read(4))[0]
faceByteCount = fCount * stride
fi = np.fromfile(md, dtype='B', count=faceByteCount)
if stride == 4:
fi_0 = fi.view(dtype='<L').reshape(fCount // 3, 3)
elif stride == 2:
fi_0 = fi.view(dtype='<H').reshape(fCount // 3, 3)
fi_1 = fi_0.ravel()
faces = tuple(fi_1)
pCounts = [3] * (len(faces) // 3)
gh = pCounts[0]
unkCount = struct.unpack("<L", md.read(4))[0]
md.seek(unkCount * 2, 1)
unk = struct.unpack("<L", md.read(4))[0]
vertexCount = struct.unpack("<L", md.read(4))[0]
boneCount = struct.unpack("<L", md.read(4))[0]
md.seek(boneCount * 2, 1)
null0 = struct.unpack("<L", md.read(4))[0]
null1 = struct.unpack("<L", md.read(4))[0]
uv_count = struct.unpack("<L", md.read(4))[0]
unk0 = struct.unpack("<H", md.read(2))[0]
uv_count2 = struct.unpack("<L", md.read(4))[0]
null2 = struct.unpack("<L", md.read(4))[0]
unk1 = struct.unpack("<f", md.read(4))[0]
unk2 = struct.unpack("<f", md.read(4))[0]
unk3 = struct.unpack("<f", md.read(4))[0]
null3 = struct.unpack("<L", md.read(4))[0]
null4 = struct.unpack("<L", md.read(4))[0]
null5 = struct.unpack("<L", md.read(4))[0]
vStride = struct.unpack("<L", md.read(4))[0]
vCount = struct.unpack("<L", md.read(4))[0]
byteCount = vCount * vStride
vi = np.fromfile(md, dtype='B', count=byteCount).reshape((vCount, vStride))
pos = vi[:, 8:20].ravel().view(dtype='<f').reshape((vCount, 3))
pos[:, [0, 2]] = pos[:, [2, 0]]
pos[:, [0, 1]] = pos[:, [1, 0]]
pos[:, [2]] *= -1
positions = pos.tolist()
VA = om2.MFloatPointArray(positions)
if uv_count > 0:
uvData_ = vi[:, 20:24].ravel().view(dtype='<f2').reshape((vCount, 2))
uvData_[:, 1:2] *= -1
uvData_[:, 1:2] += 1
uvData = tuple(map(tuple, uvData_))
u = zip(*uvData)[0]
v = zip(*uvData)[1]
U0.copy(u)
V0.copy(v)
if uv_count > 1:
uvData_ = vi[:, 24:28].ravel().view(dtype='<f2').reshape((vCount, 2))
uvData_[:, 1:2] *= -1
uvData_[:, 1:2] += 1
uvData = tuple(map(tuple, uvData_))
u = zip(*uvData)[0]
v = zip(*uvData)[1]
U1.copy(u)
V1.copy(v)
if uv_count > 2:
uvData_ = vi[:, 28:32].ravel().view(dtype='<f2').reshape((vCount, 2))
uvData_[:, 1:2] *= -1
uvData_[:, 1:2] += 1
uvData = tuple(map(tuple, uvData_))
u = zip(*uvData)[0]
v = zip(*uvData)[1]
U2.copy(u)
V2.copy(v)
if uv_count > 3:
uvData_ = vi[:, 32:36].ravel().view(dtype='<f2').reshape((vCount, 2))
uvData_[:, 1:2] *= -1
uvData_[:, 1:2] += 1
uvData = tuple(map(tuple, uvData_))
u = zip(*uvData)[0]
v = zip(*uvData)[1]
U3.copy(u)
V3.copy(v)
if uv_count > 4:
uvData_ = vi[:, 36:40].ravel().view(dtype='<f2').reshape((vCount, 2))
uvData_[:, 1:2] *= -1
uvData_[:, 1:2] += 1
uvData = tuple(map(tuple, uvData_))
u = zip(*uvData)[0]
v = zip(*uvData)[1]
U4.copy(u)
V4.copy(v)
mesh = om2.MFnMesh()
ShapeMesh = cmds.group(em=True)
parentOwner = get_mobject(ShapeMesh)
meshMObj = mesh.create(VA,
pCounts,
faces,
uValues=U0,
vValues=V0,
parent=parentOwner)
cmds.sets(ShapeMesh, e=True, forceElement='initialShadingGroup')
cmds.polyUVSet(rename=True,
newUVSet='map_0',
uvSet=mesh.currentUVSetName(-1))
mesh.setUVs(U0, V0, 'map_0')
mesh.assignUVs(pCounts, faces, 'map_0')
cmds.rename(meshName)
s1 = cmds.ls(sl=1)
s2 = s1[0]
shapeName = s2.encode('ascii', 'ignore')
if uv_count > 1:
mesh.createUVSet('map_1')
mesh.setUVs(U1, V1, 'map_1')
mesh.assignUVs(pCounts, faces, 'map_1')
if uv_count > 2:
mesh.createUVSet('map_2')
mesh.setUVs(U2, V2, 'map_2')
mesh.assignUVs(pCounts, faces, 'map_2')
if uv_count > 3:
mesh.createUVSet('map_3')
mesh.setUVs(U3, V3, 'map_3')
mesh.assignUVs(pCounts, faces, 'map_3')
if uv_count > 4:
mesh.createUVSet('map_4')
mesh.setUVs(U4, V4, 'map_4')
mesh.assignUVs(pCounts, faces, 'map_4')
unkS = struct.unpack("<H", md.read(2))[0]
extraBoneWeights = struct.unpack("<L", md.read(4))[0]
wCount = struct.unpack("<L", md.read(4))[0]
stride = struct.unpack("<L", md.read(4))[0]
wCount2 = struct.unpack("<L", md.read(4))[0]
subStride = int(stride / 2)
clusterName = shapeName + '_' + 'skinCluster'
pm.skinCluster(boneArray[:], shapeName, sm=1, mi=8, omi=1, n=clusterName)
skin = mm.eval('findRelatedSkinCluster "' + s2 + '"')
sel = om.MSelectionList()
sel.add(shapeName)
meshMObject = om.MObject()
sel.getDependNode(0, meshMObject)
sel2 = om.MSelectionList()
sel2.add(skin)
skinMObject = om.MObject()
sel2.getDependNode(0, skinMObject)
FnSkin = oma.MFnSkinCluster(skinMObject)
dag_path, skinMObject = get_skin_dag_path_and_mobject(FnSkin)
weights = om.MDoubleArray()
influence_paths = om.MDagPathArray()
influence_count = FnSkin.influenceObjects(influence_paths)
components_per_influence = weights.length() / influence_count
# influences
unused_influences = list()
influences = [
influence_paths[inf_count].partialPathName()
for inf_count in xrange(influence_paths.length())
]
wSize = vCount * influence_count
weights = om.MDoubleArray(wSize, 0.0)
w_byteCount = wCount * stride
wi = np.fromfile(md, dtype='B', count=w_byteCount).reshape(
(wCount, stride))
wi_b = wi[:, :subStride].ravel().view().reshape((wCount, subStride))
wi_w = wi[:, subStride:stride].ravel().view().reshape(
(wCount, subStride)).astype(np.float64)
wi_w /= 255.0
def do_stuff(n):
fg = influences.index(L[n])
idx = fg + (j * influence_count)
weights[idx] = W[n]
for h in xrange(len(vertexGroups)):
crnt_grp = vertexGroups[h]
g_names = crnt_grp["names"]
g_range = crnt_grp["range"]
for j in g_range:
Wt = np.trim_zeros(wi_w[j], 'b')
W = tuple(Wt)
a = Wt.shape[0]
ids = wi_b[j, :a]
L = tuple(g_names[0, ids])
map(do_stuff, range(len(L)))
influence_array = om.MIntArray(influence_count)
m_util.createIntArrayFromList(range(influence_count), influence_array)
FnSkin.setWeights(dag_path, skinMObject, influence_array, weights, False)
createMaterials(files, vertexGroups, materials, shapeName)
pm.select(shapeName)
cmds.viewFit()
elapsed = time.time() - t1
return elapsed
md.close()
ua.close()
def mesh_generator(source_verts, source_polys, source_norms, materials,
source_bones, gen_bones, settings):
vertex_count = len(source_verts)
face_count = len(source_polys)
vertices = OpenMaya.MFloatPointArray()
for i in range(len(source_verts)):
vert = source_verts[i]
vertices.append(OpenMaya.MFloatPoint(vert.x, vert.y, vert.z))
face_vertexes = OpenMaya.MIntArray()
vertex_indexes = OpenMaya.MIntArray()
for i in range(len(source_polys)):
poly = source_polys[i]
face_vertexes.append(poly.numVertex)
vertex_indexes += poly.vertex
mesh_object = OpenMaya.MObject()
mesh = OpenMaya.MFnMesh()
mesh.create(vertices, face_vertexes, vertex_indexes, [], [], mesh_object)
mesh.updateSurface()
py_obj = pm.ls(mesh.name())[0]
if settings.use_palette:
face_list = []
for i in range(len(materials)):
faces = [materials[i]]
for j in range(face_count):
if source_polys[j].colour == materials[i]:
faces.append(j)
if len(faces) > 0:
face_list.append(faces)
for i in range(len(face_list)):
if len(face_list[i]) == 1:
continue
m_faces = []
for j in range(len(face_list[i])):
if j == 0:
continue
m_faces.append(py_obj.f[face_list[i][j]])
sg = "paletteSG" + str(face_list[i][0])
pm.sets(sg, edit=True, forceElement=m_faces)
else:
pm.sets("initialShadingGroup", edit=True, forceElement=py_obj)
space = OpenMaya.MSpace.kObject
for i in range(len(source_norms)):
norm = source_norms[i]
normal = OpenMaya.MVector(norm.x, norm.y, norm.z)
mesh.setVertexNormal(normal, i, space)
if settings.use_rigging:
cluster = pm.skinCluster(gen_bones[0],
py_obj,
tsb=True,
mi=1,
hmf=1.0,
dr=10,
nw=0)
# create vertex groups
vertex_groups = []
for i in range(len(source_bones)):
if i != 0:
pm.skinCluster(cluster,
edit=True,
ai=gen_bones[i],
tsb=True,
hmf=1.0,
dr=10,
wt=0)
group = []
for j in range(vertex_count):
if source_verts[j].bone == i:
group.append(j)
vertex_groups.append(group)
# set influences
transform_zeros = []
for i in range(len(source_bones)):
value = [gen_bones[i], 0]
transform_zeros.append(value)
for i in range(len(vertex_groups)):
group = vertex_groups[i]
pm.select(clear=True)
# select vertices
for j in range(len(group)):
pm.select(py_obj.vtx[group[j]], add=True)
for j in range(len(transform_zeros)):
transform_zeros[j][1] = 1 if i == j else 0
pm.skinPercent(cluster, transformValue=transform_zeros, nrm=True)
return mesh.name()
def addUIDrawables(self, objPath, drawManager, frameContext, data):
DEBUG_C = 1
if (DEBUG_C):
print(
"glDrawDrawOverride________________________________________addUIDrawables - GET DATA"
)
#glDrawData* data = (glDrawData*)dataRaw;
#if (!data) { return; }
cameraFn = ompy.MFnCamera(data.cameraPath)
cameraTrsf = ompy.MFnDagNode(cameraFn.parent(0))
camMatrix = MMatrixToMFloatMatrix(cameraTrsf.transformationMatrix())
camPlaneNearDistance = cameraFn.nearClippingPlane
camPlaneFarDistance = cameraFn.farClippingPlane
if (DEBUG_C):
print(
"glDrawDrawOverride________________________________________addUIDrawables - DRAW"
)
drawManager.beginDrawable()
iCoords = 0
exitDrawing = False
for i in range(0, len(data.shapes)):
#________________________________________GET COORDS FOR BUILDING ONE SHAPE
nbrElementForBuild = self.shapeToNbrElemForBuild[data.shapes[i]]
coordsForBuild = ompy.MFloatPointArray()
ssOffsetsForBuild = ompy.MFloatVectorArray()
for j in range(0, nbrElementForBuild):
if (len(data.coords) <= iCoords):
exitDrawing = True
break
coordsForBuild.append(data.coords[iCoords])
ssOffsetsForBuild.append(data.screenSpaceOffsets[iCoords])
iCoords += 1
if (exitDrawing == True): break
#________________________________________DRAW BUILD CONVERT COORDS
distIncr = 0.001
foregroundDist = camPlaneNearDistance + 0.02
backgroundDist = camPlaneFarDistance - 0.02
coords = ompy.MFloatPointArray()
size = 1.0
thickness = 1.0
if ((data.drawPlaneMode == 1)
and (0 < coordsForBuild.length())): #FOREGROUND
coords = snapCoordsOnCameraPlane(camMatrix, foregroundDist,
coordsForBuild)
size = snapLengthOnCameraPlane(camMatrix, foregroundDist,
coordsForBuild[0],
data.sizes[i])
#thickness = data.thicknesses[i]
foregroundDist += distIncr
elif ((data.drawPlaneMode == 2)
and (0 < coordsForBuild.length())): #sBACKGROUND
coords = snapCoordsOnCameraPlane(camMatrix, backgroundDist,
coordsForBuild)
size = snapLengthOnCameraPlane(camMatrix, backgroundDist,
coordsForBuild[0],
data.sizes[i])
#thickness = data.thicknesses[i]
backgroundDist -= distIncr
else:
coords = coordsForBuild
size = data.sizes[i]
#thickness = data.thicknesses[i]
ssOffsets = ompy.MFloatVectorArray(ssOffsetsForBuild)
#________________________________________DRAW SHAPE
if (self.shapesNames[data.shapes[i]] == "segment"):
glDrawSegments(drawManager, camMatrix, coords, ssOffsets,
data.colors[i], 0, 1.0)
elif (self.shapesNames[data.shapes[i]] == "triangle"):
pass #glDrawTriangles( drawManager, camMatrix, coords, ssOffsets, data.colors[i], data.pColors[i])
elif (self.shapesNames[data.shapes[i]] == "pointTriangle"):
pass #glDrawPointTriangle( drawManager, camMatrix, coords, ssOffsets, data.colors[i], data.fills[i], size, thickness)
elif (self.shapesNames[data.shapes[i]] == "pointSquare"):
pass #glDrawPointSquare( drawManager, camMatrix, coords, ssOffsets, data.colors[i], data.fills[i], size, thickness)
elif (self.shapesNames[data.shapes[i]] == "pointCircle"):
pass #glDrawPointCircle( drawManager, camMatrix, coords, ssOffsets, data.colors[i], data.fills[i], size, thickness)
elif (self.shapesNames[data.shapes[i]] == "pointStar"):
pass #glDrawPointStar( drawManager, camMatrix, coords, ssOffsets, data.colors[i], data.fills[i], size, thickness)
elif (self.shapesNames[data.shapes[i]] == "pointCross"):
pass #glDrawPointCross( drawManager, camMatrix, coords, ssOffsets, data.colors[i], data.fills[i], size, thickness)
elif (self.shapesNames[data.shapes[i]] == "vector"):
pass #glDrawVector( drawManager, camMatrix, coords, ssOffsets, data.colors[i], data.fills[i], size, thickness)
elif (self.shapesNames[data.shapes[i]] == "text"):
glDrawText(drawManager, camMatrix, coords, ssOffsets,
data.names[i], data.colors[i], True, size, 1.0)
drawManager.endDrawable()
