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 __init__(self):
self.uvSetName = 'map1'
self.uArray = openMaya.MFloatArray()
self.vArray = openMaya.MFloatArray()
self.uvCounts = openMaya.MIntArray()
self.uvIds = openMaya.MIntArray()
def reader(self, fileObject, optionString, accessMode):
drc = Draco()
mesh = drc.decode(fileObject.fullName())
# vertices, normals, uvs
vertices = []
normals = []
us = OpenMaya.MFloatArray()
vs = OpenMaya.MFloatArray()
poly_count = [3] * mesh.faces_num
for n in range(mesh.vertices_num):
i = 3 * n
vertices.append(
OpenMaya.MPoint(mesh.vertices[i], mesh.vertices[i + 1],
mesh.vertices[i + 2]))
if mesh.normals:
normals.append(
OpenMaya.MFloatVector(mesh.normals[i], mesh.normals[i + 1],
mesh.normals[i + 2]))
if mesh.uvs:
i = 2 * n
us.append(mesh.uvs[i])
vs.append(mesh.uvs[i + 1])
#create mesh
fnMesh = OpenMaya.MFnMesh()
newMesh = fnMesh.create(vertices, poly_count, mesh.faces)
if mesh.normals:
fnMesh.setVertexNormals(normals, range(len(vertices)))
if mesh.uvs:
uvSetsNames = fnMesh.getUVSetNames()
fnMesh.setUVs(us, vs, uvSetsNames[0])
fnMesh.assignUVs(poly_count, mesh.faces)
fnMesh.updateSurface()
slist = OpenMaya.MGlobal.getSelectionListByName("initialShadingGroup")
initialSG = slist.getDependNode(0)
fnSG = OpenMaya.MFnSet(initialSG)
if fnSG.restriction() == OpenMaya.MFnSet.kRenderableOnly:
fnSG.addMember(newMesh)
def __init__(self, file_gfx):
self.bone_ids = 0
self.weights = 0
self.VA = 0
self.NA = 0
self.uArray0 = om2.MFloatArray()
self.vArray0 = om2.MFloatArray()
self.uArray1 = om2.MFloatArray()
self.vArray1 = om2.MFloatArray()
self.uArray2 = om2.MFloatArray()
self.vArray2 = om2.MFloatArray()
self.uArray3 = om2.MFloatArray()
self.vArray3 = om2.MFloatArray()
self.name = rd_meshBegin(file_gfx)
self.mesh_header = header(file_gfx)
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)
polygonConnects = OpenMaya.MIntArray() polygonConnects.append(0) polygonConnects.append(2) polygonConnects.append(1) polygonConnects.append(0) polygonConnects.append(3) polygonConnects.append(2) polygonConnects.append(3) polygonConnects.append(4) polygonConnects.append(2) polygonConnects.append(3) polygonConnects.append(5) polygonConnects.append(4) uArray = OpenMaya.MFloatArray() vArray = OpenMaya.MFloatArray() uArray.append(0.0) vArray.append(1.0) uArray.append(0.0) vArray.append(0.0) uArray.append(1.0) vArray.append(0.0) uArray.append(1.0) vArray.append(1.0) uArray.append(2.0)
def makeMFloatArray(xmldata):
myFloatArray = om.MFloatArray()
for each in xmldata.attrib['value'].split(' '):
myFloatArray.append(float(each))
return myFloatArray
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()
import maya.api.OpenMaya as mayaApi selList = mayaApi.MSelectionList() selList.add( 'pSphereShape1' ) fnMesh = mayaApi.MFnMesh( selList.getDagPath( 0 ) ) fnMesh.getUVSetNames() uArray = mayaApi.MFloatArray() vArray = mayaApi.MFloatArray() uvCounts = mayaApi.MIntArray() uvIds = mayaApi.MIntArray()
def compute(self, pPlug, pData):
#only compute if output is in out array
if (pPlug.parent() == generalIk.aOutRot):
# descend into coordinated cycles
# inputs
solverDH = pData.inputValue(generalIk.aSolver)
solver = solverDH.asInt()
iterationsDH = pData.inputValue(generalIk.aMaxIter)
maxIter = iterationsDH.asInt()
toleranceDH = pData.inputValue(generalIk.aTolerance)
tolerance = toleranceDH.asFloat()
rootMat = om.MMatrix()
rootMatDH = pData.inputValue(generalIk.aRootMat)
rootMat = rootMatDH.asMatrix()
# target
targetMat = om.MMatrix()
targetMatDH = pData.inputValue(generalIk.aTargetMat)
targetMat = targetMatDH.asMatrix()
endMat = om.MMatrix()
endMatDH = pData.inputValue(generalIk.aEndMat)
endMat = endMatDH.asMatrix()
print "endMat at start is {}".format(endMat)
# get everything in root space
targetRSmat = targetMat.__mul__(rootMat.inverse())
# get reference matrix array from tip to root
# this lets us virtually rebuild the parent-child hierarchy
inJntArrayDH = pData.inputArrayValue(generalIk.aJnts)
inLength = inJntArrayDH.__len__()
# DON'T FORGET our useful arrays are one entry shorter than we have
chainArray = om.MMatrixArray()
jntArray = om.MMatrixArray()
jntWeights = om.MFloatArray()
for i in range(inLength):
inJntArrayDH.jumpToPhysicalElement(i)
childCompDH = inJntArrayDH.inputValue()
childMat = om.MMatrix()
childMatDH = om.MDataHandle(
childCompDH.child(generalIk.aJntMat))
#childUpMatDH = om.MDataHandle(childCompDH.child(generalIk.aJntUpMat))
# not needed atm
childMat = childMatDH.asMatrix()
print "joint{}mat is {}".format(i, childMat)
parentMat = om.MMatrix()
if i != 0:
inJntArrayDH.jumpToPhysicalElement(i - 1)
parentCompDH = inJntArrayDH.inputValue()
parentMatDH = om.MDataHandle(
parentCompDH.child(generalIk.aJntMat))
parentMat = parentMatDH.asMatrix()
else:
# only applies to last in loop (so first in joints)
parentMat = rootMat
chainMat = childMat.__mul__(parentMat.inverse())
chainArray.append(chainMat)
#chainArray is every joint in the space of its parent
#chainArray[i] = jntMat[i] x jntMat[i-1].inverse
jntArray.append(childMat)
#childArray is just the joint matrices
childWeightDH = om.MDataHandle(
childCompDH.child(generalIk.aJntWeight))
childWeight = childWeightDH.asFloat()
print "childWeight is {}".format(childWeight)
jntWeights.append(childWeight)
print ""
#from here applies only to ccd algorithm
gap = 1.0
iter = 0
while (iter < maxIter) and (gap > tolerance):
print "ITERATION {}".format(iter)
print ""
for i in range(inLength):
print "computing joint {} of {}".format(i, inLength)
# welcome to the bone zone
# reconstruct hierarchy with matrices from previous iteration
# currently target is known in rootspace, and end isn't known at all
# backwards to get target and forwards to get end, both in active joint space
#
# +(target)
# .
# .
# O
# / \ X(end)
# / \ /
# / O
# /
#(root)
# this works by getting vector from active joint to end, from active joint to target,
# then aligning one to the other. joints are assumed to have direct parent-child
# hierarchy, so all rotations are inherited rigidly
# ccd operates from tip to root - see reference for actual algorithm
jntMat = om.MMatrix()
jntMat = jntArray.__getitem__(inLength - (i + 1))
print "jntMat is {}".format(jntMat)
chainMult = om.MMatrix()
#backwards
for b in range(inLength - i):
#multiply targetRootSpaceMat by inverse chainMats,
#starting from ROOT
print "chainArray[b] is {}".format(chainArray[b])
if b == 0:
# at first joint, only equals root matrix
chainMult = chainArray[b].inverse()
else:
chainMult.__imul__(chainArray[b].inverse())
print "chainMult at {} is {}".format(b, chainMult)
print "endMat is {}".format(endMat)
print "endMat x chainMult is {}".format(
endMat.__mul__(chainMult))
#forwards
# only need end in joint space
endJSmat = endMat.__mul__(jntMat.inverse())
targetJSmat = targetRSmat * chainMult
# check gap is still important
gapVec = om.MVector(targetJSmat[12] - endJSmat[12],
targetJSmat[13] - endJSmat[13],
targetJSmat[14] - endJSmat[14])
gap = gapVec.length()
if gap > tolerance:
print "gap is {}".format(gap)
print "end JS is {}".format(endJSmat)
print "endMat v2 at {} is {}".format(i, endMat)
print "target JS is {}".format(targetJSmat)
targetJStrans = om.MTransformationMatrix(
targetJSmat).translation(1)
print "targetJStrans at {} is {}".format(
i, targetJStrans)
# we don't just want to aim each joint, we want to
# aim the end, by rotating each joint in turn
# first get the aim matrix from joint to end
endAimMat = om.MMatrix()
endAimMat = lookAt(jntMat, endJSmat)
print "endAimMat is {}".format(endAimMat)
#jntMat.__imul__(endAimMat)
# then from that, aim from end to target
targetAimMat = om.MMatrix()
targetAimMat = lookAt(jntMat, targetJSmat)
# is weighting this simple?
#print "jntWeight is {}".format(jntWeights.__getitem__(i))
targetAimMat.__imul__(jntWeights.__getitem__(i))
print "targetAimMat is {}".format(targetAimMat)
#constraints are going to be fun, but for now
jntMat.__imul__(targetAimMat)
endMat.__imul__(targetAimMat)
print "finalEndMat is {}".format(endMat)
#end of if block and aim procedure
print ""
else:
print ""
print "gap is within tolerance, ending"
break
jntArray.__setitem__(i, jntMat)
#end of single iteration along joint chain
print ""
iter = iter + 1
#end of all iterations, computation has completed
#convert jntArray of matrices to useful rotation values
outArrayDH = pData.outputArrayValue(generalIk.aOutArray)
targetRSTransA = om.MTransformationMatrix(targetRSmat).translation(
4)
print "target in RS world is {}".format(targetRSTransA)
for i in range(0, inLength):
outArrayDH.jumpToPhysicalElement(i)
outCompDH = outArrayDH.outputValue()
outRotDH = outCompDH.child(generalIk.aOutRot)
outRxDH = outRotDH.child(generalIk.aOutRx)
outRyDH = outRotDH.child(generalIk.aOutRy)
outRzDH = outRotDH.child(generalIk.aOutRz)
outRotVals = om.MTransformationMatrix(jntArray[i]).rotation()
# unitConversions bring SHAME on family
xAngle = om.MAngle(outRotVals[0])
yAngle = om.MAngle(outRotVals[1])
zAngle = om.MAngle(outRotVals[2])
outRxDH.setMAngle(xAngle)
outRyDH.setMAngle(yAngle)
outRzDH.setMAngle(zAngle)
outArrayDH.setAllClean()
pData.setClean(pPlug)
