def test_can_write_skinnedmesh_identical(self):
vmesh = modmesh.LoadBF2Mesh(self.path_object_skinned)
vmesh.save(self.path_object_skinned_clone)
self.assertTrue(
filecmp.cmp(self.path_object_skinned,
self.path_object_skinned_clone))
def test_can_rename_texture(self):
vmesh = modmesh.LoadBF2Mesh(self.path_object_std)
path_object_clone = os.path.join(*[
'tests', 'generated', 'edit', 'evil_box_rename_texture', 'meshes',
'evil_box_rename_texture.staticmesh'
])
geom = 0
lod = 0
material = 0
map = 0
# ensure we have diffirent texture before test
self.assertTrue(
vmesh.geoms[geom].lods[lod].materials[material].maps[map] ==
b'objects/staticobjects/test/evil_box/textures/evil_box_c.dds')
modmesh.VisMeshTransform(vmesh).rename_texture(
geom, lod, material, map,
'readme/assets/apps/python3/mesher/tests/samples/evil_box/textures/evil_box_c.dds'
)
# save results for manual check
vmesh.save(path_object_clone)
self.assertTrue(
vmesh.geoms[geom].lods[lod].materials[material].maps[map] ==
b'readme/assets/apps/python3/mesher/tests/samples/evil_box/textures/evil_box_c.dds'
)
def main():
vmesh = modmesh.LoadBF2Mesh('ch_kits.skinnedmesh')
order = [0, 1, 2, 3, 4, 5, 6, 7, 9, 8, 10, 11, 12, 13, 14, 15, 16]
modmesh.VisMeshTransform(vmesh).order_geoms_by(order)
vmesh.save('./ch_kits2.skinnedmesh')
def test_can_deserialize_materials_vertices_pavement(self):
path_pavement = os.path.join(*['tests', 'samples', 'pavement', '24m_1', 'meshes', '24m_1.staticmesh'])
path_pavement_clone = os.path.join(*['tests', 'generated', 'edit', 'pavement', '24m_1_clone', 'meshes', '24m_1_clone.staticmesh'])
vmesh = modmesh.LoadBF2Mesh(path_pavement)
vmesh_clone = modmesh.LoadBF2Mesh(path_pavement)
vertex_objects = [vertex for vertex in vmesh.get_vertices()]
vertices = []
for id_geom, geom in enumerate(vmesh.geoms):
for id_lod, lod in enumerate(geom.lods):
for id_mat, material in enumerate(lod.materials):
for vertex in vertex_objects[material.vstart:material.vstart + material.vnum]:
vertices.append(vertex)
vmesh.update_vertices(vertices)
vmesh.save(path_pavement_clone)
self.assertEqual(vmesh.vertices, vmesh_clone.vertices)
def test_can_write_u1_bfp4f_version(self):
vmesh = modmesh.LoadBF2Mesh(self.path_object_static)
vmesh._write_u1_bfp4f_version(self.path_object_static_clone)
with open(self.path_object_static_clone, 'rb') as meshfile:
vmesh2 = modmesh.VisMesh()
vmesh2._read_u1_bfp4f_version(meshfile)
self.assertTrue(vmesh2.u1 == vmesh.u1)
def test_can_write_geomnum_mesh_dest(self):
vmesh = modmesh.LoadBF2Mesh(self.path_object_dest)
vmesh._write_geomnum(self.path_object_static_clone)
with open(self.path_object_static_clone, 'rb') as meshfile:
vmesh2 = modmesh.VisMesh()
vmesh2._read_geomnum(meshfile)
self.assertTrue(vmesh2.geomnum == vmesh.geomnum)
def test_can_write_vertstride(self):
vmesh = modmesh.LoadBF2Mesh(self.path_object_static)
vmesh._write_vertstride(self.path_object_static_clone)
with open(self.path_object_static_clone, 'rb') as meshfile:
vmesh2 = modmesh.VisMesh()
vmesh2._read_vertstride(meshfile)
self.assertTrue(vmesh2.vertstride == vmesh.vertstride)
def test_can_write_index_block(self):
vmesh = modmesh.LoadBF2Mesh(self.path_object_static)
vmesh._write_index_block(self.path_object_static_clone)
with open(self.path_object_static_clone, 'rb') as meshfile:
vmesh2 = modmesh.VisMesh()
vmesh2._read_index_block(meshfile)
self.assertTrue(len(vmesh2.index) == len(vmesh2.index))
def test_can_write_vertex_attribute_table(self):
vmesh = modmesh.LoadBF2Mesh(self.path_object_static)
vmesh._write_vertattrib_table(self.path_object_static_clone)
with open(self.path_object_static_clone, 'rb') as meshfile:
vmesh2 = modmesh.VisMesh()
vmesh2._read_vertattrib_table(meshfile)
for attrib_id, attrib in enumerate(vmesh.vertattrib):
self.assertTrue(attrib == vmesh2.vertattrib[attrib_id])
def test_can_write_geom_table_mesh_std(self):
vmesh = modmesh.LoadBF2Mesh(self.path_object_static)
vmesh._write_geom_table(self.path_object_static_clone)
with open(self.path_object_static_clone, 'rb') as meshfile:
vmesh2 = modmesh.VisMesh()
vmesh2._read_geom_table(meshfile)
self.assertTrue(len(vmesh2.geoms) == len(vmesh.geoms))
self.assertTrue(vmesh2.geoms[0].lodnum == vmesh.geoms[0].lodnum)
def test_can_merge_statics_from_GPO(self):
path_pavement = os.path.join(*[
'tests', 'samples', 'pavement', '24m_1', 'meshes',
'24m_1.staticmesh'
])
path_pavement_clone = os.path.join(*[
'tests', 'generated', 'edit', 'pavement', '24m_1_merge', 'meshes',
'24m_1_merge.staticmesh'
])
# from fallujah
position1 = Vec3(491.567, 24.653, 495.454)
rotation1 = (0.2, 0.0, 0.0)
position2 = Vec3(491.416, 24.653, 443.974)
rotation2 = (0.2, 0.0, 0.0)
diff = position2 - position1
vmesh1 = modmesh.LoadBF2Mesh(path_pavement)
vmesh2 = modmesh.LoadBF2Mesh(path_pavement)
vmesh1.rotate(rotation1)
vmesh2.rotate(rotation2)
vmesh2.translate(diff)
vmesh1.merge(vmesh2)
# translating to center
min = Vec3(*vmesh1.geoms[0].lods[0].min)
max = Vec3(*vmesh1.geoms[0].lods[0].max)
center_offset = (min + max) / 2
#print(min)
#print(max)
#print(center_offset)
#print(position1 + center_offset)
vmesh1.translate(-center_offset)
#vmesh1.geoms[0].lods[0].materials.
vmesh1.save(path_pavement_clone)
def test_can_copy_geom_by_ref(self):
vmesh = modmesh.LoadBF2Mesh(self.path_object_skinned)
vmesh_old = copy.deepcopy(vmesh)
if not vmesh.isSkinnedMesh:
raise
path_object_skinned_clone = os.path.join(*[
'tests', 'generated', 'edit', 'kits', 'mec_geom_copy', 'Meshes',
'mec_kits_geom_copy.skinnedMesh'
])
# example geom
geomToCopy = 0
geomCopyTo = 1
# debugging
#geom = 0
#lod = 0
#mat = 0
#print('vnum = {}'.format(vmesh.geoms[geom].lods[lod].materials[mat].vnum))
#print('vstart = {}'.format(vmesh.geoms[geom].lods[lod].materials[mat].vstart))
#print('inum = {}'.format(vmesh.geoms[geom].lods[lod].materials[mat].inum))
#print('istart = {}'.format(vmesh.geoms[geom].lods[lod].materials[mat].istart))
modmesh.VisMeshTransform(vmesh).copy_geom_id(geomToCopy, geomCopyTo)
vmesh.save(path_object_skinned_clone)
self.assertTrue(vmesh.geomnum == vmesh_old.geomnum + 1)
self.assertTrue(len(vmesh.geoms) == len(vmesh_old.geoms) + 1)
self.assertTrue(vmesh.geoms[geomCopyTo].lodnum ==
vmesh_old.geoms[geomToCopy].lodnum)
for id_lod, lod in enumerate(vmesh.geoms[geomCopyTo].lods):
self.assertTrue(
lod.rignum == vmesh_old.geoms[geomToCopy].lods[id_lod].rignum)
for id_rig, rig in enumerate(lod.rigs):
self.assertTrue(rig.bonenum == vmesh_old.geoms[geomToCopy].
lods[id_lod].rigs[id_rig].bonenum)
for id_bone, bone in enumerate(rig.bones):
self.assertTrue(
bone.id == vmesh_old.geoms[geomToCopy].lods[id_lod].
rigs[id_rig].bones[id_bone].id)
self.assertTrue(
bone.matrix == vmesh_old.geoms[geomToCopy].
lods[id_lod].rigs[id_rig].bones[id_bone].matrix)
for id_mat, material in enumerate(lod.materials):
self.assertTrue(material.vnum == vmesh_old.geoms[geomToCopy].
lods[id_lod].materials[id_mat].vnum)
self.assertTrue(material.vstart == vmesh_old.geoms[geomToCopy].
lods[id_lod].materials[id_mat].vstart)
self.assertTrue(material.inum == vmesh_old.geoms[geomToCopy].
lods[id_lod].materials[id_mat].inum)
self.assertTrue(material.istart == vmesh_old.geoms[geomToCopy].
lods[id_lod].materials[id_mat].istart)
def test_can_write_header(self):
vmesh = modmesh.LoadBF2Mesh(self.path_object_static)
vmesh._write_header(self.path_object_static_clone)
with open(self.path_object_static_clone, 'rb') as meshfile:
vmesh2 = modmesh.VisMesh()
vmesh2._read_head(meshfile)
self.assertTrue(vmesh2.head.u1 == vmesh.head.u1)
self.assertTrue(vmesh2.head.version == vmesh.head.version)
self.assertTrue(vmesh2.head.u3 is vmesh.head.u3)
self.assertTrue(vmesh2.head.u4 is vmesh.head.u4)
self.assertTrue(vmesh2.head.u5 is vmesh.head.u5)
def test_can_rotate_mesh_pavement(self):
path_pavement = os.path.join(*[
'tests', 'samples', 'pavement', '24m_1', 'meshes',
'24m_1.staticmesh'
])
path_pavement_clone = os.path.join(*[
'tests', 'generated', 'edit', 'pavement', '24m_1_rotate', 'meshes',
'24m_1_rotate.staticmesh'
])
vmesh = modmesh.LoadBF2Mesh(path_pavement)
rotation = (45.0, 0.0, 0.0)
vmesh.rotate(rotation)
vmesh.save(path_pavement_clone)
def test_can_read_PR_modmesh_REPO(self):
counter = 0
for dir, dirnames, filenames in os.walk(
os.path.join(bf2.Mod().root, 'objects')):
for filename in filenames:
ext = filename.split('.')[-1].lower()
if ext[-4:] == 'mesh' and ext not in ['collisionmesh'
] and 'test' not in dir:
counter += 1
try:
vmesh = modmesh.LoadBF2Mesh(
os.path.join(bf2.Mod().root, dir, filename))
except struct.error:
print('Failed to load {}'.format(
os.path.join(bf2.Mod().root, dir, filename)))
raise
print(counter)
def test_can_write_nodes(self):
vmesh = modmesh.LoadBF2Mesh(self.path_object_static)
vmesh._write_nodes(self.path_object_static_clone)
with open(self.path_object_static_clone, 'rb') as meshfile:
vmesh2 = modmesh.VisMesh()
vmesh2._read_nodes(meshfile)
self.assertTrue(
vmesh2.geoms[0].lods[0].min == vmesh.geoms[0].lods[0].min)
self.assertTrue(
vmesh2.geoms[0].lods[0].max == vmesh.geoms[0].lods[0].max)
#self.assertTrue(vmesh.geoms[0].lods[0].pivot == (0.5, 1.0, 0.5)) # some old bundleds?
self.assertTrue(
vmesh2.geoms[0].lods[0].nodenum == vmesh.geoms[0].lods[0].nodenum)
self.assertTrue(
vmesh2.geoms[0].lods[0].nodes == vmesh.geoms[0].lods[0].nodes)
def main():
# ############################################################################ #
# box exported from 3dsmax9 have weird additional vertex
# for comparison with blender export data i need to remove it, aswell as
# remove addional UV maps that isn't used
vmesh = modmesh.LoadBF2Mesh(
os.getcwd() +
'\\tests\\samples\\evil_box\\Meshes\\evil_box.staticmesh')
print_vertex_data(vmesh, 24, 'UV1')
remove_vertice_id(vmesh, 24)
replace_index_id(vmesh, 24, 14)
remove_attribute(vmesh, 'UV2')
remove_attribute(vmesh, 'UV3')
remove_attribute(vmesh, 'UV4')
#rename_texture(vmesh, geom=0, lod=0, material=0, map=0, path='readme/assets/apps/python3/mesher/tests/samples/evil_box/textures/evil_box_c.dds')
edit_vertex(vmesh, 14, 'UV1', (0.5, 1.0))
vmesh.save('generated/generated_box/meshes/generated_box_edit.staticmesh')
def test_can_write_materials(self):
vmesh = modmesh.LoadBF2Mesh(self.path_object_static)
vmesh._write_materials(self.path_object_static_clone)
with open(self.path_object_static_clone, 'rb') as meshfile:
vmesh2 = modmesh.VisMesh()
vmesh2._read_materials(meshfile)
for geom_id, geom in enumerate(vmesh.geoms):
for lod_id, lod in enumerate(geom.lods):
self.assertTrue(
lod.matnum == vmesh2.geoms[geom_id].lods[lod_id].matnum)
#for material_id, material in enumerate(lod.materials):
#for key, value in material.__dict__.items():
# print('"{:.10}" : {}'.format(key, value))
#for key, value in vmesh2.geoms[geom_id].lods[lod_id].materials[material_id].__dict__.items():
# print('"{:.10}" : {}'.format(key, value))
#self.assertTrue(material == vmesh2.geoms[geom_id].lods[lod_id].materials[material_id])
self.assertTrue(lod.polycount ==
vmesh2.geoms[geom_id].lods[lod_id].polycount)
def test_can_load_bf2_mesh_with_samples(self):
meshpath = self.path_object_samples.replace('.samples', '.staticmesh')
vmesh = modmesh.LoadBF2Mesh(meshpath, loadSamples=True)
self.assertTrue(
isinstance(vmesh.geoms[0].lods[0].sample, modmesh.StdSample))
print('alphamode = {}'.format(
vmesh.geoms[geom].lods[lod].materials[material].alphamode))
print('fxfile = {}'.format(
vmesh.geoms[geom].lods[lod].materials[material].fxfile))
print('technique = {}'.format(
vmesh.geoms[geom].lods[lod].materials[material].technique))
print('mapnum = {}'.format(
vmesh.geoms[geom].lods[lod].materials[material].mapnum))
for id, map in enumerate(
vmesh.geoms[geom].lods[lod].materials[material].maps):
print('map[{}] = {}'.format(id, map))
print('vnum = {}'.format(
vmesh.geoms[geom].lods[lod].materials[material].vnum))
print('vstart = {}'.format(
vmesh.geoms[geom].lods[lod].materials[material].vstart))
print('inum = {}'.format(
vmesh.geoms[geom].lods[lod].materials[material].inum))
print('istart = {}'.format(
vmesh.geoms[geom].lods[lod].materials[material].istart))
vmesh = modmesh.LoadBF2Mesh(
'tests\\samples\\kits\\Mec\\Meshes\\mec_kits.skinnedMesh')
#vmesh = modmesh.LoadBF2Mesh(os.getcwd() + '/generated/generated_box/meshes/generated_box_edit.staticmesh')
#vmesh = modmesh.LoadBF2Mesh('C:\Program Files\Blender Foundation\Blender\generated\generated_box\meshes\generated_box.staticmesh')
#vmesh = modmesh.LoadBF2Mesh(os.getcwd() + '\\..\\..\\..\\..\\..\\objects\\vehicles\\land\\us_tnk_m1a2\\Meshes\\us_tnk_m1a2.bundledmesh')
#display_mesh_data(vmesh)
display_material_data(vmesh, 17, 0, 0)
display_material_data(vmesh, 18, 0, 0)
def test_can_edit_geoms_order(self):
vmesh = modmesh.LoadBF2Mesh(self.path_object_skinned)
vmesh_old = modmesh.LoadBF2Mesh(
self.path_object_skinned) # faster than deepcopy
if not vmesh.isSkinnedMesh:
self.fail("Source mesh not skinned")
path_object_skinned_clone = os.path.join(*[
'tests', 'generated', 'edit', 'kits', 'mec_geoms_ordered',
'Meshes', 'mec_kits_geoms_ordered.skinnedMesh'
])
# for simplicity we'll just reverse geoms list
order_old = [i for i in range(vmesh.geomnum)]
order_new = list(reversed(order_old))
geoms_old = vmesh_old.geoms
vertices_old = vmesh_old.vertices
indices_old = vmesh_old.index
modmesh.VisMeshTransform(vmesh).order_geoms_by(order_new)
vmesh.save(path_object_skinned_clone)
# verify geomtable reversed properly
for id_geom, geom in enumerate(vmesh.geoms):
id_geom_old = len(
vmesh.geoms) - id_geom - 1 # idk, numering start from 0?
geom_old = geoms_old[id_geom_old]
self.assertTrue(geom.lodnum == geom_old.lodnum)
self.assertTrue(len(geom.lods) == len(geom_old.lods))
for id_lod, lod in enumerate(geom.lods):
lod_old = geom_old.lods[id_lod]
self.assertTrue(lod.rignum == lod_old.rignum)
self.assertTrue(len(lod.rigs) == len(lod_old.rigs))
for id_rig, rig in enumerate(lod.rigs):
rig_old = lod_old.rigs[id_rig]
self.assertTrue(rig.bonenum == rig_old.bonenum)
self.assertTrue(rig.bonenum == rig_old.bonenum)
for id_bone, bone in enumerate(rig.bones):
bone_old = rig_old.bones[id_bone]
self.assertTrue(bone.id == bone_old.id)
self.assertTrue(bone.matrix == bone_old.matrix)
for id_mat, material in enumerate(lod.materials):
material_old = lod_old.materials[id_mat]
self.assertTrue(material.vnum == material_old.vnum)
self.assertTrue(material.inum == material_old.inum)
self.assertTrue(material.vstart == material_old.vstart)
self.assertTrue(material.istart == material_old.istart)
# verify that we have same geom data packed properly
vstart = int(vmesh.vertstride / vmesh.vertformat *
material.vstart)
vstart_old = int(vmesh.vertstride / vmesh.vertformat *
geoms_old[id_geom_old].lods[id_lod].
materials[id_mat].vstart)
vnum = int(vmesh.vertstride / vmesh.vertformat *
material.vnum)
for id_vdata, vdata in enumerate(
vmesh.vertices[vstart:vstart + vnum]):
# Apparently pr skinnedmeshes containing nan data in vertices array
# test fails as nan != nan even through rest of data are same
if math.isnan(vdata) and math.isnan(
vertices_old[vstart_old + id_vdata]):
continue
self.assertEqual(vdata,
vertices_old[vstart_old + id_vdata])
# and proper indices
inum = material.inum
istart = material.istart
istart_old = geoms_old[id_geom_old].lods[id_lod].materials[
id_mat].istart
for id_index, index in enumerate(
vmesh.index[istart:istart + inum]):
self.assertEqual(index,
indices_old[istart_old + id_index])
def test_can_load_bf2_skinned_mesh(self):
vmesh = modmesh.LoadBF2Mesh(self.path_object_skinned)
self.assertTrue(isinstance(vmesh, modmesh.VisMesh))
self.assertTrue(vmesh.isSkinnedMesh)
def test_can_delete_geom(self):
vmesh = modmesh.LoadBF2Mesh(self.path_object_skinned)
vmesh_old = modmesh.LoadBF2Mesh(
self.path_object_skinned) # faster than deepcopy
if not vmesh.isSkinnedMesh:
self.fail("Source mesh not skinned")
path_object_skinned_clone = os.path.join(*[
'tests', 'generated', 'edit', 'kits', 'mec_geom_delete', 'Meshes',
'mec_kits_geom_delete.skinnedMesh'
])
# delete from "middle"
id_geom_delete = 1
vstart_at = vmesh.geoms[id_geom_delete].lods[0].materials[0].vstart
istart_at = vmesh.geoms[id_geom_delete].lods[0].materials[0].istart
vnum_to_delete = sum([
sum([material.vnum for material in lod.materials])
for lod in vmesh.geoms[id_geom_delete].lods
])
inum_to_delete = sum([
sum([material.inum for material in lod.materials])
for lod in vmesh.geoms[id_geom_delete].lods
])
geomnum_before = vmesh.geomnum
geoms_old = vmesh_old.geoms
vertices_old = vmesh_old.vertices
indices_old = vmesh_old.index
vnum_before = vmesh.vertnum
inum_before = vmesh.indexnum
# transforming
modmesh.VisMeshTransform(vmesh).delete_geom_id(id_geom_delete)
vmesh.save(path_object_skinned_clone)
# checking geoms arr
self.assertTrue(vmesh.geomnum == geomnum_before - 1)
self.assertTrue(len(vmesh.geoms) == geomnum_before - 1)
# verify that we cleaned up unnecessary vertex data
self.assertTrue(vmesh.vertnum == vnum_before - vnum_to_delete)
self.assertTrue(
len(vmesh.vertices) == len(vertices_old) - sum([
len(D3DDECLTYPE(attrib.vartype)) for attrib in vmesh.vertattrib
]) * vnum_to_delete)
# and corrected vertex indices
self.assertTrue(vmesh.indexnum == inum_before - inum_to_delete)
self.assertTrue(len(vmesh.index) == inum_before - inum_to_delete)
# verify that geoms adjusted vstart and istart offsets properly
id_geom = id_geom_delete
while id_geom < vmesh.geomnum:
id_geom_old = id_geom + 1
for id_lod, lod in enumerate(vmesh.geoms[id_geom].lods):
rignum_old = geoms_old[id_geom_old].lods[id_lod].rignum
self.assertTrue(lod.rignum == rignum_old)
for id_rig, rig in enumerate(lod.rigs):
bonenum_old = geoms_old[id_geom_old].lods[id_lod].rigs[
id_rig].bonenum
self.assertTrue(rig.bonenum == bonenum_old)
for id_bone, bone in enumerate(rig.bones):
self.assertTrue(
bone.id == geoms_old[id_geom_old].lods[id_lod].
rigs[id_rig].bones[id_bone].id)
self.assertTrue(
bone.matrix == geoms_old[id_geom_old].lods[id_lod].
rigs[id_rig].bones[id_bone].matrix)
for id_mat, material in enumerate(lod.materials):
self.assertTrue(material.vnum == geoms_old[id_geom_old].
lods[id_lod].materials[id_mat].vnum)
self.assertTrue(material.vstart == geoms_old[id_geom_old].
lods[id_lod].materials[id_mat].vstart -
vnum_to_delete)
self.assertTrue(material.inum == geoms_old[id_geom_old].
lods[id_lod].materials[id_mat].inum)
self.assertTrue(material.istart == geoms_old[id_geom_old].
lods[id_lod].materials[id_mat].istart -
inum_to_delete)
# and verify that we deleted vertex and index with correct offset
vstart = int(vmesh.vertstride / vmesh.vertformat *
material.vstart)
vstart_old = int(vmesh.vertstride / vmesh.vertformat *
geoms_old[id_geom_old].lods[id_lod].
materials[id_mat].vstart)
vnum = int(vmesh.vertstride / vmesh.vertformat *
material.vnum)
for id_data, vdata in enumerate(
vmesh.vertices[vstart:vstart + vnum]):
# Apparently pr skinnedmeshes containing nan data in vertices array
# test fails as nan != nan even through rest of data are same
if math.isnan(vdata) and math.isnan(
vertices_old[vstart_old + id_data]):
continue
self.assertEqual(
vdata,
vertices_old[vstart_old + id_data],
msg=
'id {}:{} after {},\nvnum_to_delete = {},\nat geom{} lod{} material{}'
.format(vstart + id_data, vstart_old + id_data,
id_data, vnum_to_delete, id_geom, id_lod,
id_mat))
#'''
inum = material.inum
istart = material.istart
istart_old = geoms_old[id_geom_old].lods[id_lod].materials[
id_mat].istart
for id_index, index in enumerate(
vmesh.index[istart:istart + inum]):
self.assertEqual(index,
indices_old[istart_old + id_index])
id_geom += 1
def test_can_load_bf2_staticmesh(self):
vmesh = modmesh.LoadBF2Mesh(self.path_object_static)
self.assertTrue(isinstance(vmesh, modmesh.VisMesh))
self.assertTrue(vmesh.isStaticMesh)
