Include only tangent in mesh data and calculate binormal on the fly

[libs/gl.git] / blender / io_mspgl / mesh.py

diff --git a/blender/io_mspgl/mesh.py b/blender/io_mspgl/mesh.py
index 754e6ffc2d35460c0e474e7fc02e70b3e62c9568..9741b8dd916f28495d3e25cde8fd64e767a7d118 100644 (file)
--- a/blender/io_mspgl/mesh.py
+++ b/blender/io_mspgl/mesh.py
@@ -48,11 +48,9 @@ class Vertex:
                if vertex.__class__==Vertex:
                        self.uvs = vertex.uvs[:]
                        self.tan = vertex.tan
-                       self.bino = vertex.bino
                else:
                        self.uvs = []
                        self.tan = None
-                       self.bino = None
                self.index = vertex.index
                self.co = mathutils.Vector(vertex.co)
                self.normal = mathutils.Vector(vertex.normal)
@@ -160,8 +158,8 @@ class Mesh:
                self.winding_test = mesh.winding_test
                self.smoothing = mesh.smoothing
                self.use_uv = mesh.use_uv
-               self.tbn_vecs = mesh.tbn_vecs
-               self.tbn_uvtex = mesh.tbn_uvtex
+               self.tangent_vecs = mesh.tangent_vecs
+               self.tangent_uvtex = mesh.tangent_uvtex
                self.vertex_groups = mesh.vertex_groups
 
                # Clone basic data
@@ -447,31 +445,31 @@ class Mesh:
                prog_count = len(self.uv_layers)
                prog_step = 0
 
-               # Split by the UV layer used for TBN vectors first so connectivity
-               # remains intact for TBN vector computation
-               tbn_layer_index = -1
-               if self.tbn_vecs:
-                       if self.tbn_uvtex:
+               # Split by the UV layer used for tangent vectors first so connectivity
+               # remains intact for tangent vector computation
+               tangent_layer_index = -1
+               if self.tangent_vecs:
+                       if self.tangent_uvtex:
                                uv_names = [u.name for u in self.uv_layers]
-                               if self.tbn_uvtex in uv_names:
-                                       tbn_layer_index = uv_names.index(self.tbn_uvtex)
+                               if self.tangent_uvtex in uv_names:
+                                       tangent_layer_index = uv_names.index(self.tangent_uvtex)
                        elif self.uv_layers[0].unit==0:
-                               tbn_layer_index = 0
+                               tangent_layer_index = 0
 
-                       if tbn_layer_index>=0:
+                       if tangent_layer_index>=0:
                                prog_count += 1
-                               progress.push_task_slice("Computing TBN", 0, prog_count)
-                               self.split_vertices(self.find_uv_group, progress, tbn_layer_index)
-                               progress.set_task_slice(self.tbn_uvtex, 1, prog_count)
-                               self.compute_tbn(tbn_layer_index, progress)
+                               progress.push_task_slice("Computing tangents", 0, prog_count)
+                               self.split_vertices(self.find_uv_group, progress, tangent_layer_index)
+                               progress.set_task_slice(self.tangent_uvtex, 1, prog_count)
+                               self.compute_tangents(tangent_layer_index, progress)
                                progress.pop_task()
                                prog_step = 2
                        else:
-                               raise Exception("TBN UV layer not found")
+                               raise Exception("Tangent UV layer not found")
 
                # Split by the remaining UV layers
                for i, u in enumerate(self.uv_layers):
-                       if i==tbn_layer_index:
+                       if i==tangent_layer_index:
                                continue
 
                        progress.push_task_slice(u.name, prog_step, prog_count)
@@ -620,14 +618,11 @@ class Mesh:
 
                        progress.set_progress(i/len(self.vertices))
 
-       def compute_tbn(self, index, progress):
-               # This function is called at an early stage during UV preparation when
-               # face UVs are not available yet
+       def compute_tangents(self, index, progress):
                layer_uvs = self.uv_layers[index].uvs
 
                for i, v in enumerate(self.vertices):
                        v.tan = mathutils.Vector()
-                       v.bino = mathutils.Vector()
                        for f in v.faces:
                                vi = f.pivot_vertex(v)
                                uv0 = layer_uvs[f.loop_indices[vi[0]]]
@@ -643,12 +638,9 @@ class Mesh:
                                if div:
                                        mul = edge1.angle(edge2)/div
                                        v.tan += (edge1*dv2-edge2*dv1)*mul
-                                       v.bino += (edge2*du1-edge1*du2)*mul
 
                        if v.tan.length:
                                v.tan.normalize()
-                       if v.bino.length:
-                               v.bino.normalize()
 
                        progress.set_progress(i/len(self.vertices))
 
@@ -817,8 +809,8 @@ def create_mesh_from_object(context, obj, progress, *, material_atlas=None):
                bmesh.vertex_groups = o.data.vertex_groups
                bmesh.max_groups_per_vertex = o.data.max_groups_per_vertex
                bmesh.use_uv = o.data.use_uv
-               bmesh.tbn_vecs = o.data.tbn_vecs
-               bmesh.tbn_uvtex = o.data.tbn_uvtex
+               bmesh.tangent_vecs = o.data.tangent_vecs
+               bmesh.tangent_uvtex = o.data.tangent_uvtex
 
                me = Mesh(bmesh)
                me.transform(m)