From 84f43a024c0b1da6bc11201fc024e974c7aac806 Mon Sep 17 00:00:00 2001 From: Adam Johnson Date: Sat, 30 Sep 2017 20:52:11 -0400 Subject: [PATCH] Use Blender's convex hull baking for hull bounds This moves convex hull generation from the file serialization stage to the object export stage. No longer are we dependent on spotty library support for proper convex hulls. --- korman/exporter/physics.py | 32 +++++++++++++++++++++++--------- 1 file changed, 23 insertions(+), 9 deletions(-) diff --git a/korman/exporter/physics.py b/korman/exporter/physics.py index a949b22..90fd367 100644 --- a/korman/exporter/physics.py +++ b/korman/exporter/physics.py @@ -37,11 +37,14 @@ class PhysicsConverter: indices += (v[0], v[2], v[3],) return indices - def _convert_mesh_data(self, bo, physical, indices=True): + def _convert_mesh_data(self, bo, physical, indices=True, mesh_func=None): mesh = bo.to_mesh(bpy.context.scene, True, "RENDER", calc_tessface=False) mat = bo.matrix_world - with TemporaryObject(mesh, bpy.data.meshes.remove) as mesh: + with TemporaryObject(mesh, bpy.data.meshes.remove): + if mesh_func is not None: + mesh_func(mesh) + # We can only use the plPhysical xforms if there is a CI... if self._exporter().has_coordiface(bo): mesh.update(calc_tessface=indices) @@ -81,7 +84,7 @@ class PhysicsConverter: physical.sceneNode = self._mgr.get_scene_node(bl=bo) mesh = bo.to_mesh(bpy.context.scene, True, "RENDER", calc_tessface=False) - with TemporaryObject(mesh, bpy.data.meshes.remove) as mesh: + with TemporaryObject(mesh, bpy.data.meshes.remove): # We will apply all xform, seeing as how this is a special case... mesh.transform(bo.matrix_world) mesh.update(calc_tessface=True) @@ -140,12 +143,23 @@ class PhysicsConverter: """Exports convex hull bounds based on the object""" physical.boundsType = plSimDefs.kHullBounds - vertices = self._convert_mesh_data(bo, physical, indices=False) - # --- TODO --- - # Until we have real convex hull processing, simply dump the verts into the physical - # Note that PyPRP has always done this... PhysX will optimize this for us. So, it's not - # the end of the world (but it is evil). - physical.verts = vertices + # Only certain builds of libHSPlasma are able to take artist generated triangle soups and + # bake them to convex hulls. Specifically, Windows 32-bit w/PhysX 2.6. Everything else just + # needs to have us provide some friendlier data... + def _bake_hull(mesh): + # The bmesh API for doing this is trash, so we will link this temporary mesh to an + # even more temporary object so we can use the traditional operator. + # Unless you want to write some code to do this by hand...??? (not me) + bo = bpy.data.objects.new("BMeshSucks", mesh) + bpy.context.scene.objects.link(bo) + with TemporaryObject(bo, bpy.data.objects.remove): + bpy.context.scene.objects.active = bo + bpy.ops.object.mode_set(mode="EDIT") + bpy.ops.mesh.select_all(action="SELECT") + bpy.ops.mesh.convex_hull(use_existing_faces=False) + bpy.ops.object.mode_set(mode="OBJECT") + + physical.verts = self._convert_mesh_data(bo, physical, indices=False, mesh_func=_bake_hull) def _export_sphere(self, bo, physical): """Exports sphere bounds based on the object"""