@woosh/meep-engine 2.40.1 → 2.42.0

package/engine/graphics/geometry/MikkT/MikkTSpace.js

@@ -2,30 +2,36 @@ import { assert } from "../../../../core/assert.js";
 import { EPSILON } from "../../../../core/math/MathUtils.js";
 import { array_copy } from "../../../../core/collection/array/copyArray.js";
 import { fabsf } from "../../../../core/math/fabsf.js";
-
-// To avoid visual errors (distortions/unwanted hard edges in lighting), when using sampled normal maps, the
-// normal map sampler must use the exact inverse of the pixel shader transformation.
-// The most efficient transformation we can possibly do in the pixel shader is
-// achieved by using, directly, the "unnormalized" interpolated tangent, bitangent and vertex normal: vT, vB and vN.
-// pixel shader (fast transform out)
-// vNout = normalize( vNt.x * vT + vNt.y * vB + vNt.z * vN );
-// where vNt is the tangent space normal. The normal map sampler must likewise use the
-// interpolated and "unnormalized" tangent, bitangent and vertex normal to be compliant with the pixel shader.
-// sampler does (exact inverse of pixel shader):
-// float3 row0 = cross(vB, vN);
-// float3 row1 = cross(vN, vT);
-// float3 row2 = cross(vT, vB);
-// float fSign = dot(vT, row0)<0 ? -1 : 1;
-// vNt = normalize( fSign * float3(dot(vNout,row0), dot(vNout,row1), dot(vNout,row2)) );
-// where vNout is the sampled normal in some chosen 3D space.
-//
-// Should you choose to reconstruct the bitangent in the pixel shader instead
-// of the vertex shader, as explained earlier, then be sure to do this in the normal map sampler also.
-// Finally, beware of quad triangulations. If the normal map sampler doesn't use the same triangulation of
-// quads as your renderer then problems will occur since the interpolated tangent spaces will differ
-// eventhough the vertex level tangent spaces match. This can be solved either by triangulating before
-// sampling/exporting or by using the order-independent choice of diagonal for splitting quads suggested earlier.
-// However, this must be used both by the sampler and your tools/rendering pipeline.
+import { v3_distance_sqr } from "../../../../core/geom/v3_distance_sqr.js";
+
+
+/*
+ To avoid visual errors (distortions/unwanted hard edges in lighting), when using sampled normal maps, the
+ normal map sampler must use the exact inverse of the pixel shader transformation.
+ The most efficient transformation we can possibly do in the pixel shader is
+ achieved by using, directly, the "unnormalized" interpolated tangent, bitangent and vertex normal: vT, vB and vN.
+ pixel shader (fast transform out)
+ vNout = normalize( vNt.x * vT + vNt.y * vB + vNt.z * vN );
+ where vNt is the tangent space normal. The normal map sampler must likewise use the
+ interpolated and "unnormalized" tangent, bitangent and vertex normal to be compliant with the pixel shader.
+ sampler does (exact inverse of pixel shader):
+ float3 row0 = cross(vB, vN);
+ float3 row1 = cross(vN, vT);
+ float3 row2 = cross(vT, vB);
+ float fSign = dot(vT, row0)<0 ? -1 : 1;
+ vNt = normalize( fSign * float3(dot(vNout,row0), dot(vNout,row1), dot(vNout,row2)) );
+ where vNout is the sampled normal in some chosen 3D space.
+
+ Should you choose to reconstruct the bitangent in the pixel shader instead
+ of the vertex shader, as explained earlier, then be sure to do this in the normal map sampler also.
+ Finally, beware of quad triangulations. If the normal map sampler doesn't use the same triangulation of
+ quads as your renderer then problems will occur since the interpolated tangent spaces will differ
+ eventhough the vertex level tangent spaces match. This can be solved either by triangulating before
+ sampling/exporting or by using the order-independent choice of diagonal for splitting quads suggested earlier.
+ However, this must be used both by the sampler and your tools/rendering pipeline.
+
+ @see https://github.com/mmikk/MikkTSpace/blob/master/mikktspace.c
+*/
 
 
 /**
@@ -63,6 +69,12 @@ class SVec3 {
         this.z = v;
     }
 
+    copy(other) {
+        this.x = other.x;
+        this.y = other.y;
+        this.z = other.z;
+    }
+
 }
 
 class SEdge {
@@ -124,9 +136,9 @@ class STSpace {
      * @param {STSpace} other
      */
     copy(other) {
-        this.vOs = other.vOs;
+        this.vOs.copy(other.vOs);
         this.fMagS = other.fMagS;
-        this.vOt = other.vOt;
+        this.vOt.copy(other.vOt);
         this.fMagT = other.fMagT;
         this.iCounter = other.iCounter;
         this.bOrient = other.bOrient;
@@ -143,7 +155,7 @@ class SSubGroup {
 
         /**
          * *int
-         * @type {null}
+         * @type {Int32Array|null}
          */
         this.pTriMembers = null;
     }
@@ -210,130 +222,6 @@ class STriInfo {
     }
 }
 
-class SMikkTSpaceInterface {
-    constructor() {
-
-    }
-
-    /**
-     * Returns the number of faces (triangles/quads) on the mesh to be processed.
-     * @param {SMikkTSpaceContext} pContext
-     * @returns {number}
-     */
-    m_getNumFaces(pContext) {
-        return pContext.geometry_buffer_index.length / 3;
-    }
-
-    /**
-     * Returns the number of vertices on face number iFace
-     * iFace is a number in the range {0, 1, ..., getNumFaces()-1}
-     * @param {SMikkTSpaceContext} pContext
-     * @param {number} iFace
-     * @returns {number}
-     */
-    m_getNumVerticesOfFace(pContext, iFace) {
-        // only support triangles
-        return 3;
-    }
-
-    // returns the position/normal/texcoord of the referenced face of vertex number iVert.
-    // iVert is in the range {0,1,2} for triangles and {0,1,2,3} for quads.
-
-    /**
-     *
-     * @param {SMikkTSpaceContext} pContext
-     * @param {number[]|{0:number,1:number,2:number}} fvPosOut
-     * @param {number} iFace
-     * @param {number} iVert
-     * @returns {void}
-     */
-    m_getPosition(pContext, fvPosOut, iFace, iVert) {
-        // figure out which vertex it is
-        const vertex_index = pContext.geometry_buffer_index[iFace * 3 + iVert];
-
-        array_copy(pContext.geometry_buffer_vertex_position, vertex_index * 3, fvPosOut, 0, 3);
-    }
-
-    /**
-     *
-     * @param {SMikkTSpaceContext} pContext
-     * @param {number[]|{0:number,1:number,2:number}} fvNormOut
-     * @param {number} iFace
-     * @param {number} iVert
-     * @returns {void}
-     */
-    m_getNormal(pContext, fvNormOut, iFace, iVert) {
-        // figure out which vertex it is
-        const vertex_index = pContext.geometry_buffer_index[iFace * 3 + iVert];
-
-        array_copy(pContext.geometry_buffer_vertex_normal, vertex_index * 3, fvNormOut, 0, 3);
-    }
-
-    /**
-     *
-     * @param {SMikkTSpaceContext} pContext
-     * @param {number[]|{0:number,1:number}} fvTexcOut
-     * @param {number} iFace
-     * @param {number} iVert
-     * @returns {void}
-     */
-    m_getTexCoord(pContext, fvTexcOut, iFace, iVert) {
-        // figure out which vertex it is
-        const vertex_index = pContext.geometry_buffer_index[iFace * 3 + iVert];
-
-        array_copy(pContext.geometry_buffer_vertex_uv, vertex_index * 2, fvTexcOut, 0, 3);
-    }
-
-    /**
-     * either (or both) of the two setTSpace callbacks can be set.
-     * The call-back m_setTSpaceBasic() is sufficient for basic normal mapping.
-     *
-     * This function is used to return the tangent and fSign to the application.
-     * fvTangent is a unit length vector.
-     * For normal maps it is sufficient to use the following simplified version of the bitangent which is generated at pixel/vertex level.
-     * bitangent = fSign * cross(vN, tangent);
-     * Note that the results are returned unindexed. It is possible to generate a new index list
-     * But averaging/overwriting tangent spaces by using an already existing index list WILL produce INCRORRECT results.
-     * DO NOT! use an already existing index list.
-     *
-     * @param {SMikkTSpaceContext} pContext
-     * @param {number[]} fvTangent
-     * @param {number} fSign
-     * @param {number} iFace
-     * @param {number} iVert
-     * @returns {void}
-     */
-    m_setTSpaceBasic(pContext, fvTangent, fSign, iFace, iVert) {
-        throw new Error('Not supported');
-    }
-
-    /**
-     *
-     * @param {SMikkTSpaceContext} pContext
-     * @param {number[]} fvTangent
-     * @param {number[]} fvBiTangent
-     * @param {number} fMagS
-     * @param {number} fMagT
-     * @param {boolean} bIsOrientationPreserving
-     * @param {number} iFace
-     * @param {number} iVert
-     * @returns {void}
-     */
-    m_setTSpace(pContext, fvTangent, fvBiTangent, fMagS, fMagT, bIsOrientationPreserving, iFace, iVert) {
-        // figure out which vertex it is
-        const vertex_index = pContext.geometry_buffer_index[iFace * 3 + iVert];
-
-        const tangent_destination = pContext.geometry_buffer_vertex_tangent;
-        const tangent_address = vertex_index * 4;
-
-        // for logic explanation, see https://github.com/gltf-rs/mikktspace/blob/6275cc4f15cff8be29819fb34ae8be3b9129dae1/src/lib.rs#L33
-        tangent_destination[tangent_address] = fvTangent[0];
-        tangent_destination[tangent_address + 1] = fvTangent[1];
-        tangent_destination[tangent_address + 2] = fvTangent[2];
-        tangent_destination[tangent_address + 3] = bIsOrientationPreserving ? 1 : -1;
-    }
-}
-
 export class SMikkTSpaceContext {
     constructor() {
         /**
@@ -367,15 +255,127 @@ export class SMikkTSpaceContext {
          * @type {number[]}
          */
         this.geometry_buffer_vertex_bitangent = [];
-
-        /**
-         *
-         * @type {SMikkTSpaceInterface|null}
-         */
-        this.m_pInterface = new SMikkTSpaceInterface();
     }
 }
 
+/**
+ * Returns the number of faces (triangles/quads) on the mesh to be processed.
+ * @param {SMikkTSpaceContext} pContext
+ * @returns {number}
+ */
+function m_getNumFaces(pContext) {
+    return pContext.geometry_buffer_index.length / 3;
+}
+
+/**
+ * Returns the number of vertices on face number iFace
+ * iFace is a number in the range {0, 1, ..., getNumFaces()-1}
+ * @param {SMikkTSpaceContext} pContext
+ * @param {number} iFace
+ * @returns {number}
+ */
+function m_getNumVerticesOfFace(pContext, iFace) {
+    // only support triangles
+    return 3;
+}
+
+// returns the position/normal/texcoord of the referenced face of vertex number iVert.
+// iVert is in the range {0,1,2} for triangles and {0,1,2,3} for quads.
+
+/**
+ *
+ * @param {SMikkTSpaceContext} pContext
+ * @param {number[]|{0:number,1:number,2:number}} fvPosOut
+ * @param {number} iFace
+ * @param {number} iVert
+ * @returns {void}
+ */
+function m_getPosition(pContext, fvPosOut, iFace, iVert) {
+    // figure out which vertex it is
+    const vertex_index = pContext.geometry_buffer_index[iFace * 3 + iVert];
+
+    array_copy(pContext.geometry_buffer_vertex_position, vertex_index * 3, fvPosOut, 0, 3);
+}
+
+/**
+ *
+ * @param {SMikkTSpaceContext} pContext
+ * @param {number[]|{0:number,1:number,2:number}} fvNormOut
+ * @param {number} iFace
+ * @param {number} iVert
+ * @returns {void}
+ */
+function m_getNormal(pContext, fvNormOut, iFace, iVert) {
+    // figure out which vertex it is
+    const vertex_index = pContext.geometry_buffer_index[iFace * 3 + iVert];
+
+    array_copy(pContext.geometry_buffer_vertex_normal, vertex_index * 3, fvNormOut, 0, 3);
+}
+
+/**
+ *
+ * @param {SMikkTSpaceContext} pContext
+ * @param {number[]|{0:number,1:number}} fvTexcOut
+ * @param {number} iFace
+ * @param {number} iVert
+ * @returns {void}
+ */
+function m_getTexCoord(pContext, fvTexcOut, iFace, iVert) {
+    // figure out which vertex it is
+    const vertex_index = pContext.geometry_buffer_index[iFace * 3 + iVert];
+
+    array_copy(pContext.geometry_buffer_vertex_uv, vertex_index * 2, fvTexcOut, 0, 3);
+}
+
+/**
+ * either (or both) of the two setTSpace callbacks can be set.
+ * The call-back m_setTSpaceBasic() is sufficient for basic normal mapping.
+ *
+ * This function is used to return the tangent and fSign to the application.
+ * fvTangent is a unit length vector.
+ * For normal maps it is sufficient to use the following simplified version of the bitangent which is generated at pixel/vertex level.
+ * bitangent = fSign * cross(vN, tangent);
+ * Note that the results are returned unindexed. It is possible to generate a new index list
+ * But averaging/overwriting tangent spaces by using an already existing index list WILL produce INCRORRECT results.
+ * DO NOT! use an already existing index list.
+ *
+ * @param {SMikkTSpaceContext} pContext
+ * @param {number[]} fvTangent
+ * @param {number} fSign
+ * @param {number} iFace
+ * @param {number} iVert
+ * @returns {void}
+ */
+function m_setTSpaceBasic(pContext, fvTangent, fSign, iFace, iVert) {
+    throw new Error('Not supported');
+}
+
+/**
+ *
+ * @param {SMikkTSpaceContext} pContext
+ * @param {number[]} fvTangent
+ * @param {number[]} fvBiTangent
+ * @param {number} fMagS
+ * @param {number} fMagT
+ * @param {boolean} bIsOrientationPreserving
+ * @param {number} iFace
+ * @param {number} iVert
+ * @returns {void}
+ */
+function m_setTSpace(pContext, fvTangent, fvBiTangent, fMagS, fMagT, bIsOrientationPreserving, iFace, iVert) {
+    // figure out which vertex it is
+    const vertex_index = pContext.geometry_buffer_index[iFace * 3 + iVert];
+
+    const tangent_destination = pContext.geometry_buffer_vertex_tangent;
+    const tangent_address = vertex_index * 4;
+
+    // for logic explanation, see https://github.com/gltf-rs/mikktspace/blob/6275cc4f15cff8be29819fb34ae8be3b9129dae1/src/lib.rs#L33
+    tangent_destination[tangent_address] = fvTangent[0];
+    tangent_destination[tangent_address + 1] = fvTangent[1];
+    tangent_destination[tangent_address + 2] = fvTangent[2];
+    tangent_destination[tangent_address + 3] = bIsOrientationPreserving ? 1 : -1;
+}
+
 const MARK_DEGENERATE = 1;
 const QUAD_ONE_DEGEN_TRI = 2;
 const GROUP_WITH_ANY = 4;
@@ -395,34 +395,38 @@ function veq(v1, v2) {
 
 /**
  *
+ * @param {SVec3} res
  * @param {SVec3} v1
  * @param {SVec3} v2
- * @returns {SVec3}
  */
-function vadd(v1, v2) {
-    const res = new SVec3();
+function vadd(res, v1, v2) {
 
-    res.x = v1.x + v2.x;
-    res.y = v1.y + v2.y;
-    res.z = v1.z + v2.z;
+    const x = v1.x + v2.x;
+    const y = v1.y + v2.y;
+    const z = v1.z + v2.z;
+
+    res.x = x;
+    res.y = y;
+    res.z = z;
 
-    return res;
 }
 
 /**
  *
+ * @param {SVec3} res
  * @param {SVec3} v1
  * @param {SVec3} v2
- * @returns {SVec3}
  */
-function vsub(v1, v2) {
-    const res = new SVec3();
+function vsub(res, v1, v2) {
 
-    res.x = v1.x - v2.x;
-    res.y = v1.y - v2.y;
-    res.z = v1.z - v2.z;
+    const x = v1.x - v2.x;
+    const y = v1.y - v2.y;
+    const z = v1.z - v2.z;
+
+    res.x = x;
+    res.y = y;
+    res.z = z;
 
-    return res;
 }
 
 /**
@@ -450,6 +454,16 @@ function LengthSquared(v) {
     return v.x * v.x + v.y * v.y + v.z * v.z;
 }
 
+/**
+ *
+ * @param {SVec3} v0
+ * @param {SVec3} v1
+ * @returns {number}
+ */
+function DistanceSquared(v0, v1) {
+    return v3_distance_sqr(v0.x, v0.y, v0.z, v1.x, v1.y, v1.z);
+}
+
 /**
  *
  * @param {SVec3} v
@@ -462,11 +476,22 @@ function Length(v) {
 
 /**
  *
- * @param {SVec3} v
- * @returns {SVec3}
+ * @param {SVec3} out
+ * @param {SVec3} input
  */
-function Normalize(v) {
-    return vscale(1 / Length(v), v);
+function NormalizeSafe(out, input) {
+
+    const len = Length(input);
+
+    if (len !== 0) {
+        const m = 1 / len;
+
+        out.x = input.x * m;
+        out.y = input.y * m;
+        out.z = input.z * m;
+    } else {
+        out.copy(input);
+    }
 }
 
 /**
@@ -481,11 +506,11 @@ function vdot(v1, v2) {
 
 /**
  *
- * @param {number} fX
+ * @param {number} v
  * @returns {boolean}
  */
-function NotZero(fX) {
-    return Math.abs(fX) > EPSILON;
+function NotZero(v) {
+    return Math.abs(v) > EPSILON;
 }
 
 /**
@@ -519,19 +544,25 @@ function AvgTSpace(ts_res, pTS0, pTS1) {
     // this if is important. Due to floating point precision
     // averaging when ts0==ts1 will cause a slight difference
     // which results in tangent space splits later on
-    if (pTS0.fMagS === pTS1.fMagS && pTS0.fMagT === pTS1.fMagT &&
-        veq(pTS0.vOs, pTS1.vOs) && veq(pTS0.vOt, pTS1.vOt)) {
+    if (
+        pTS0.fMagS === pTS1.fMagS && pTS0.fMagT === pTS1.fMagT &&
+        veq(pTS0.vOs, pTS1.vOs) && veq(pTS0.vOt, pTS1.vOt)
+    ) {
+
         ts_res.fMagS = pTS0.fMagS;
         ts_res.fMagT = pTS0.fMagT;
         ts_res.vOs = pTS0.vOs;
         ts_res.vOt = pTS0.vOt;
+
     } else {
         ts_res.fMagS = 0.5 * (pTS0.fMagS + pTS1.fMagS);
         ts_res.fMagT = 0.5 * (pTS0.fMagT + pTS1.fMagT);
-        ts_res.vOs = vadd(pTS0.vOs, pTS1.vOs);
-        ts_res.vOt = vadd(pTS0.vOt, pTS1.vOt);
-        if (VNotZero(ts_res.vOs)) ts_res.vOs = Normalize(ts_res.vOs);
-        if (VNotZero(ts_res.vOt)) ts_res.vOt = Normalize(ts_res.vOt);
+
+        vadd(ts_res.vOs, pTS0.vOs, pTS1.vOs);
+        vadd(ts_res.vOt, pTS0.vOt, pTS1.vOt);
+
+        NormalizeSafe(ts_res.vOs, ts_res.vOs);
+        NormalizeSafe(ts_res.vOt, ts_res.vOt);
     }
 
 }
@@ -550,7 +581,7 @@ function GetPosition(pContext, index) {
     const iF = index & 0x3;
     const iI = index >> 2;
 
-    pContext.m_pInterface.m_getPosition(pContext, res, iF, iI);
+    m_getPosition(pContext, res, iF, iI);
 
     return res;
 }
@@ -568,26 +599,25 @@ function GetNormal(pContext, index) {
     const iF = index & 0x3;
     const iI = index >> 2;
 
-    pContext.m_pInterface.m_getNormal(pContext, res, iF, iI);
+    m_getNormal(pContext, res, iF, iI);
 
     return res;
 }
 
 /**
  * TODO doesn't need to be V3, can save memory
+ * @param {SVec3} res
  * @param {SMikkTSpaceContext} pContext
  * @param {number} index
  * @returns {SVec3}
  */
-function GetTexCoord(pContext, index) {
-
-    const res = new SVec3();
+function GetTexCoord(res, pContext, index) {
 
     // inlined : IndexToData(&iF, &iI, index);
     const iF = index & 0x3;
     const iI = index >> 2;
 
-    pContext.m_pInterface.m_getTexCoord(pContext, res, iF, iI);
+    m_getTexCoord(pContext, res, iF, iI);
 
     res.z = 1;
 
@@ -702,9 +732,13 @@ function GetEdge(out, indices, indices_offset, i0_in, i1_in) {
  */
 function CalcTexArea(pContext, indices, indices_offset) {
 
-    const t1 = GetTexCoord(pContext, indices[indices_offset + 0]);
-    const t2 = GetTexCoord(pContext, indices[indices_offset + 1]);
-    const t3 = GetTexCoord(pContext, indices[indices_offset + 2]);
+    const t1 = new SVec3();
+    const t2 = new SVec3();
+    const t3 = new SVec3();
+
+    GetTexCoord(t1, pContext, indices[indices_offset + 0]);
+    GetTexCoord(t2, pContext, indices[indices_offset + 1]);
+    GetTexCoord(t3, pContext, indices[indices_offset + 2]);
 
     const t21x = t2.x - t1.x;
     const t21y = t2.y - t1.y;
@@ -745,71 +779,94 @@ function malloc(Klass, count) {
  */
 function EvalTspace(face_indices, iFaces, piTriListIn, pTriInfos, pContext, iVertexRepresentitive) {
     const res = new STSpace();
+
     let fAngleSum = 0;
     let face = 0;
+
     res.vOs.x = 0.0;
     res.vOs.y = 0.0;
     res.vOs.z = 0.0;
+
     res.vOt.x = 0.0;
     res.vOt.y = 0.0;
     res.vOt.z = 0.0;
+
     res.fMagS = 0;
     res.fMagT = 0;
 
+    const vOs = new SVec3();
+    const vOt = new SVec3();
+
     for (face = 0; face < iFaces; face++) {
         const f = face_indices[face];
+        const tri_info = pTriInfos[f];
 
         // only valid triangles get to add their contribution
-        if ((pTriInfos[f].iFlag & GROUP_WITH_ANY) === 0) {
+        if ((tri_info.iFlag & GROUP_WITH_ANY) === 0) {
             /**
              * @type {SVec3}
              */
-            let n, vOs, vOt, p0, p1, p2, v1, v2;
+            let n, p0, p1, p2, v1, v2;
             /**
              * @type {number}
              */
             let fCos, fAngle, fMagS, fMagT;
             let i = -1, index = -1, i0 = -1, i1 = -1, i2 = -1;
 
-            if (piTriListIn[3 * f + 0] === iVertexRepresentitive) i = 0;
-            else if (piTriListIn[3 * f + 1] === iVertexRepresentitive) i = 1;
-            else if (piTriListIn[3 * f + 2] === iVertexRepresentitive) i = 2;
+            const f3 = 3 * f;
+
+            if (piTriListIn[f3] === iVertexRepresentitive) {
+                i = 0;
+            } else if (piTriListIn[f3 + 1] === iVertexRepresentitive) {
+                i = 1;
+            } else if (piTriListIn[f3 + 2] === iVertexRepresentitive) {
+                i = 2;
+            }
+
             assert(i >= 0 && i < 3);
 
             // project
-            index = piTriListIn[3 * f + i];
+            index = piTriListIn[f3 + i];
             n = GetNormal(pContext, index);
-            vOs = vsub(pTriInfos[f].vOs, vscale(vdot(n, pTriInfos[f].vOs), n));
-            vOt = vsub(pTriInfos[f].vOt, vscale(vdot(n, pTriInfos[f].vOt), n));
-            if (VNotZero(vOs)) vOs = Normalize(vOs);
-            if (VNotZero(vOt)) vOt = Normalize(vOt);
 
-            i2 = piTriListIn[3 * f + (i < 2 ? (i + 1) : 0)];
-            i1 = piTriListIn[3 * f + i];
-            i0 = piTriListIn[3 * f + (i > 0 ? (i - 1) : 2)];
+            vsub(vOs, tri_info.vOs, vscale(vdot(n, tri_info.vOs), n));
+
+            vsub(vOt, tri_info.vOt, vscale(vdot(n, tri_info.vOt), n));
+
+            NormalizeSafe(vOs, vOs);
+            NormalizeSafe(vOt, vOt);
+
+            i2 = piTriListIn[f3 + (i < 2 ? (i + 1) : 0)];
+            i1 = piTriListIn[f3 + i];
+            i0 = piTriListIn[f3 + (i > 0 ? (i - 1) : 2)];
 
             p0 = GetPosition(pContext, i0);
             p1 = GetPosition(pContext, i1);
             p2 = GetPosition(pContext, i2);
-            v1 = vsub(p0, p1);
-            v2 = vsub(p2, p1);
+
+            v1 = new SVec3();
+            vsub(v1, p0, p1);
+            v2 = new SVec3();
+            vsub(v2, p2, p1);
 
             // project
-            v1 = vsub(v1, vscale(vdot(n, v1), n));
-            if (VNotZero(v1)) v1 = Normalize(v1);
-            v2 = vsub(v2, vscale(vdot(n, v2), n));
-            if (VNotZero(v2)) v2 = Normalize(v2);
+            vsub(v1, v1, vscale(vdot(n, v1), n));
+            NormalizeSafe(v1, v1);
+
+            vsub(v2, v2, vscale(vdot(n, v2), n));
+            NormalizeSafe(v2, v2);
 
             // weight contribution by the angle
             // between the two edge vectors
             fCos = vdot(v1, v2);
             fCos = fCos > 1 ? 1 : (fCos < (-1) ? (-1) : fCos);
             fAngle = Math.acos(fCos);
-            fMagS = pTriInfos[f].fMagS;
-            fMagT = pTriInfos[f].fMagT;
+            fMagS = tri_info.fMagS;
+            fMagT = tri_info.fMagT;
+
+            vadd(res.vOs, res.vOs, vscale(fAngle, vOs));
+            vadd(res.vOt, res.vOt, vscale(fAngle, vOt));
 
-            res.vOs = vadd(res.vOs, vscale(fAngle, vOs));
-            res.vOt = vadd(res.vOt, vscale(fAngle, vOt));
             res.fMagS += (fAngle * fMagS);
             res.fMagT += (fAngle * fMagT);
             fAngleSum += fAngle;
@@ -817,8 +874,9 @@ function EvalTspace(face_indices, iFaces, piTriListIn, pTriInfos, pContext, iVer
     }
 
     // normalize
-    if (VNotZero(res.vOs)) res.vOs = Normalize(res.vOs);
-    if (VNotZero(res.vOt)) res.vOt = Normalize(res.vOt);
+    NormalizeSafe(res.vOs, res.vOs);
+    NormalizeSafe(res.vOt, res.vOt);
+
     if (fAngleSum > 0) {
         res.fMagS /= fAngleSum;
         res.fMagT /= fAngleSum;
@@ -836,11 +894,21 @@ function EvalTspace(face_indices, iFaces, piTriListIn, pTriInfos, pContext, iVer
 function CompareSubGroups(pg1, pg2) {
     let bStillSame = true;
     let i = 0;
-    if (pg1.iNrFaces !== pg2.iNrFaces) return false;
+
+    if (pg1.iNrFaces !== pg2.iNrFaces) {
+        return false;
+    }
+
     while (i < pg1.iNrFaces && bStillSame) {
+
         bStillSame = pg1.pTriMembers[i] === pg2.pTriMembers[i];
-        if (bStillSame) ++i;
+
+        if (bStillSame) {
+            ++i;
+        }
+
     }
+
     return bStillSame;
 }
 
@@ -906,13 +974,18 @@ function BuildNeighborsFast(pTriInfos, pEdges, piTriListIn, iNrTrianglesIn) {
     // build array of edges
     const uSeed = INTERNAL_RND_SORT_SEED;				// could replace with a random seed?
     let iEntries = 0, iCurStartIndex = -1, f = 0, i = 0;
+
     for (f = 0; f < iNrTrianglesIn; f++)
+
         for (i = 0; i < 3; i++) {
             const i0 = piTriListIn[f * 3 + i];
             const i1 = piTriListIn[f * 3 + (i < 2 ? (i + 1) : 0)];
-            pEdges[f * 3 + i].i0 = i0 < i1 ? i0 : i1;			// put minimum index in i0
-            pEdges[f * 3 + i].i1 = !(i0 < i1) ? i0 : i1;		// put maximum index in i1
-            pEdges[f * 3 + i].f = f;							// record face number
+
+            const edge = pEdges[f * 3 + i];
+
+            edge.i0 = i0 < i1 ? i0 : i1;			// put minimum index in i0
+            edge.i1 = !(i0 < i1) ? i0 : i1;		// put maximum index in i1
+            edge.f = f;							// record face number
         }
 
     // sort over all edges by i0, this is the pricy one.
@@ -923,6 +996,7 @@ function BuildNeighborsFast(pTriInfos, pEdges, piTriListIn, iNrTrianglesIn) {
     // with i0 as msb in the quicksort call above.
     iEntries = iNrTrianglesIn * 3;
     iCurStartIndex = 0;
+
     for (i = 1; i < iEntries; i++) {
         if (pEdges[iCurStartIndex].i0 !== pEdges[i].i0) {
             const iL = iCurStartIndex;
@@ -1061,45 +1135,66 @@ function InitTriInfo(pTriInfos, piTriListIn, pContext, iNrTrianglesIn) {
     // pTriInfos[f].iFlag is cleared in GenerateInitialVerticesIndexList() which is called before this function.
 
     // generate neighbor info list
-    for (f = 0; f < iNrTrianglesIn; f++)
+    for (f = 0; f < iNrTrianglesIn; f++) {
         for (i = 0; i < 3; i++) {
-            pTriInfos[f].FaceNeighbors[i] = -1;
-            pTriInfos[f].AssignedGroup[i] = null;
-
-            pTriInfos[f].vOs.x = 0.0;
-            pTriInfos[f].vOs.y = 0.0;
-            pTriInfos[f].vOs.z = 0.0;
-            pTriInfos[f].vOt.x = 0.0;
-            pTriInfos[f].vOt.y = 0.0;
-            pTriInfos[f].vOt.z = 0.0;
-            pTriInfos[f].fMagS = 0;
-            pTriInfos[f].fMagT = 0;
+            const tri = pTriInfos[f];
+
+            tri.FaceNeighbors[i] = -1;
+            tri.AssignedGroup[i] = null;
+
+            tri.vOs.x = 0.0;
+            tri.vOs.y = 0.0;
+            tri.vOs.z = 0.0;
+
+            tri.vOt.x = 0.0;
+            tri.vOt.y = 0.0;
+            tri.vOt.z = 0.0;
+
+            tri.fMagS = 0;
+            tri.fMagT = 0;
 
             // assumed bad
-            pTriInfos[f].iFlag |= GROUP_WITH_ANY;
+            tri.iFlag |= GROUP_WITH_ANY;
         }
+    }
+
+    const t1 = new SVec3();
+    const t2 = new SVec3();
+    const t3 = new SVec3();
+
+    const d1 = new SVec3();
+    const d2 = new SVec3();
+
+    const vOs = new SVec3();
+    const vOt = new SVec3();
 
     // evaluate first order derivatives
     for (f = 0; f < iNrTrianglesIn; f++) {
         // initial values
-        const v1 = GetPosition(pContext, piTriListIn[f * 3 + 0]);
-        const v2 = GetPosition(pContext, piTriListIn[f * 3 + 1]);
-        const v3 = GetPosition(pContext, piTriListIn[f * 3 + 2]);
-        const t1 = GetTexCoord(pContext, piTriListIn[f * 3 + 0]);
-        const t2 = GetTexCoord(pContext, piTriListIn[f * 3 + 1]);
-        const t3 = GetTexCoord(pContext, piTriListIn[f * 3 + 2]);
+        const f3 = f * 3;
+
+        const v1 = GetPosition(pContext, piTriListIn[f3 + 0]);
+        const v2 = GetPosition(pContext, piTriListIn[f3 + 1]);
+        const v3 = GetPosition(pContext, piTriListIn[f3 + 2]);
+
+        GetTexCoord(t1, pContext, piTriListIn[f3 + 0]);
+        GetTexCoord(t2, pContext, piTriListIn[f3 + 1]);
+        GetTexCoord(t3, pContext, piTriListIn[f3 + 2]);
 
         const t21x = t2.x - t1.x;
         const t21y = t2.y - t1.y;
+
         const t31x = t3.x - t1.x;
         const t31y = t3.y - t1.y;
-        const d1 = vsub(v2, v1);
-        const d2 = vsub(v3, v1);
+
+        vsub(d1, v2, v1);
+        vsub(d2, v3, v1);
 
         const fSignedAreaSTx2 = t21x * t31y - t21y * t31x;
         //assert(fSignedAreaSTx2!=0);
-        let vOs = vsub(vscale(t31y, d1), vscale(t21y, d2));	// eq 18
-        let vOt = vadd(vscale(-t31x, d1), vscale(t21x, d2)); // eq 19
+        vsub(vOs, vscale(t31y, d1), vscale(t21y, d2));	// eq 18
+
+        vadd(vOt, vscale(-t31x, d1), vscale(t21x, d2)); // eq 19
 
         pTriInfos[f].iFlag |= (fSignedAreaSTx2 > 0 ? ORIENT_PRESERVING : 0);
 
@@ -1108,16 +1203,21 @@ function InitTriInfo(pTriInfos, piTriListIn, pContext, iNrTrianglesIn) {
             const fLenOs = Length(vOs);
             const fLenOt = Length(vOt);
             const fS = (pTriInfos[f].iFlag & ORIENT_PRESERVING) === 0 ? (-1.0) : 1.0;
-            if (NotZero(fLenOs)) pTriInfos[f].vOs = vscale(fS / fLenOs, vOs);
-            if (NotZero(fLenOt)) pTriInfos[f].vOt = vscale(fS / fLenOt, vOt);
+            if (NotZero(fLenOs)) {
+                pTriInfos[f].vOs = vscale(fS / fLenOs, vOs);
+            }
+            if (NotZero(fLenOt)) {
+                pTriInfos[f].vOt = vscale(fS / fLenOt, vOt);
+            }
 
             // evaluate magnitudes prior to normalization of vOs and vOt
             pTriInfos[f].fMagS = fLenOs / fAbsArea;
             pTriInfos[f].fMagT = fLenOt / fAbsArea;
 
             // if this is a good triangle
-            if (NotZero(pTriInfos[f].fMagS) && NotZero(pTriInfos[f].fMagT))
+            if (NotZero(pTriInfos[f].fMagS) && NotZero(pTriInfos[f].fMagT)) {
                 pTriInfos[f].iFlag &= (~GROUP_WITH_ANY);
+            }
         }
     }
 
@@ -1140,7 +1240,7 @@ function InitTriInfo(pTriInfos, piTriListIn, pContext, iNrTrianglesIn) {
                     //printf("found quad with bad mapping\n");
                     let bChooseOrientFirstTri = false;
                     if ((pTriInfos[t + 1].iFlag & GROUP_WITH_ANY) !== 0) bChooseOrientFirstTri = true;
-                    else if (CalcTexArea(pContext, piTriListIn, t * 3 + 0) >= CalcTexArea(pContext, piTriListIn, (t + 1) * 3 + 0))
+                    else if (CalcTexArea(pContext, piTriListIn, t * 3) >= CalcTexArea(pContext, piTriListIn, (t + 1) * 3 + 0))
                         bChooseOrientFirstTri = true;
 
                     // force match
@@ -1176,21 +1276,14 @@ export function genTangSpace(pContext, fAngularThreshold = 180) {
     let iNrTrianglesIn = 0, f = 0, t = 0, i = 0;
     let iNrTSPaces = 0, iTotTris = 0, iDegenTriangles = 0, iNrMaxGroups = 0;
     let iNrActiveGroups = 0, index = 0;
-    const iNrFaces = pContext.m_pInterface.m_getNumFaces(pContext);
+    const iNrFaces = m_getNumFaces(pContext);
     let bRes = false;
     const fThresCos = Math.cos((fAngularThreshold * Math.PI) / 180.0);
 
-    // verify all call-backs have been set
-    if (pContext.m_pInterface.m_getNumFaces === null ||
-        pContext.m_pInterface.m_getNumVerticesOfFace === null ||
-        pContext.m_pInterface.m_getPosition === null ||
-        pContext.m_pInterface.m_getNormal === null ||
-        pContext.m_pInterface.m_getTexCoord === null)
-        return false;
 
     // count triangles on supported faces
     for (f = 0; f < iNrFaces; f++) {
-        const verts = pContext.m_pInterface.m_getNumVerticesOfFace(pContext, f);
+        const verts = m_getNumVerticesOfFace(pContext, f);
         if (verts === 3) ++iNrTrianglesIn;
         else if (verts === 4) iNrTrianglesIn += 2;
     }
@@ -1294,7 +1387,7 @@ export function genTangSpace(pContext, fAngularThreshold = 180) {
 
     index = 0;
     for (f = 0; f < iNrFaces; f++) {
-        const verts = pContext.m_pInterface.m_getNumVerticesOfFace(pContext, f);
+        const verts = m_getNumVerticesOfFace(pContext, f);
         if (verts !== 3 && verts !== 4) continue;
 
 
@@ -1325,7 +1418,7 @@ export function genTangSpace(pContext, fAngularThreshold = 180) {
             const tang = [pTSpace.vOs.x, pTSpace.vOs.y, pTSpace.vOs.z];
             const bitang = [pTSpace.vOt.x, pTSpace.vOt.y, pTSpace.vOt.z];
 
-            pContext.m_pInterface.m_setTSpace(pContext, tang, bitang, pTSpace.fMagS, pTSpace.fMagT, pTSpace.bOrient, f, i);
+            m_setTSpace(pContext, tang, bitang, pTSpace.fMagS, pTSpace.fMagT, pTSpace.bOrient, f, i);
 
             ++index;
         }
@@ -1390,7 +1483,10 @@ function GenerateSharedVerticesIndexList(piTriList_in_and_out, pContext, iNrTria
         else if (vMax.z < vP.z) vMax.z = vP.z;
     }
 
-    vDim = vsub(vMax, vMin);
+    vDim = new SVec3();
+
+    vsub(vDim, vMax, vMin);
+
     iChannel = 0;
     fMin = vMin.x;
     fMax = vMax.x;
@@ -1485,14 +1581,25 @@ function MergeVertsFast(piTriList_in_and_out, pTmpVert, pContext, iL_in, iR_in)
     let c = 0, l = 0, channel = 0;
     let fvMin = [], fvMax = [];
     let dx = 0, dy = 0, dz = 0, fSep = 0;
+
     for (c = 0; c < 3; c++) {
         fvMin[c] = pTmpVert[iL_in].vert[c];
         fvMax[c] = fvMin[c];
     }
+
     for (l = (iL_in + 1); l <= iR_in; l++) {
+        const temp_vert = pTmpVert[l];
+
         for (c = 0; c < 3; c++) {
-            if (fvMin[c] > pTmpVert[l].vert[c]) fvMin[c] = pTmpVert[l].vert[c];
-            if (fvMax[c] < pTmpVert[l].vert[c]) fvMax[c] = pTmpVert[l].vert[c];
+            const coordinate = temp_vert.vert[c];
+
+            if (fvMin[c] > coordinate) {
+                fvMin[c] = coordinate;
+            }
+
+            if (fvMax[c] < coordinate) {
+                fvMax[c] = coordinate;
+            }
         }
     }
 
@@ -1507,8 +1614,9 @@ function MergeVertsFast(piTriList_in_and_out, pTmpVert, pContext, iL_in, iR_in)
     fSep = 0.5 * (fvMax[channel] + fvMin[channel]);
 
     // stop if all vertices are NaNs
-    if (!Number.isFinite(fSep))
+    if (!Number.isFinite(fSep)) {
         return;
+    }
 
     // terminate recursion when the separation/average value
     // is no longer strictly between fMin and fMax values.
@@ -1519,7 +1627,8 @@ function MergeVertsFast(piTriList_in_and_out, pTmpVert, pContext, iL_in, iR_in)
             const index = piTriList_in_and_out[i];
             const vP = GetPosition(pContext, index);
             const vN = GetNormal(pContext, index);
-            const vT = GetTexCoord(pContext, index);
+            const vT = new SVec3();
+            GetTexCoord(vT, pContext, index);
 
             let bNotFound = true;
             let l2 = iL_in, i2rec = -1;
@@ -1528,16 +1637,22 @@ function MergeVertsFast(piTriList_in_and_out, pTmpVert, pContext, iL_in, iR_in)
                 const index2 = piTriList_in_and_out[i2];
                 const vP2 = GetPosition(pContext, index2);
                 const vN2 = GetNormal(pContext, index2);
-                const vT2 = GetTexCoord(pContext, index2);
+
+                const vT2 = new SVec3();
+                GetTexCoord(vT2, pContext, index2);
+
                 i2rec = i2;
 
                 //if (vP==vP2 && vN==vN2 && vT==vT2)
-                if (vP.x === vP2.x && vP.y === vP2.y && vP.z == vP2.z &&
+                if (
+                    vP.x === vP2.x && vP.y === vP2.y && vP.z === vP2.z &&
                     vN.x === vN2.x && vN.y === vN2.y && vN.z === vN2.z &&
-                    vT.x === vT2.x && vT.y === vT2.y && vT.z === vT2.z)
+                    vT.x === vT2.x && vT.y === vT2.y && vT.z === vT2.z
+                ) {
                     bNotFound = false;
-                else
+                } else {
                     ++l2;
+                }
             }
 
             // merge if previously found
@@ -1599,8 +1714,8 @@ function MergeVertsFast(piTriList_in_and_out, pTmpVert, pContext, iL_in, iR_in)
 function GenerateInitialVerticesIndexList(pTriInfos, piTriList_out, pContext, iNrTrianglesIn) {
     let iTSpacesOffs = 0, f = 0, t = 0;
     let iDstTriIndex = 0;
-    for (f = 0; f < pContext.m_pInterface.m_getNumFaces(pContext); f++) {
-        const verts = pContext.m_pInterface.m_getNumVerticesOfFace(pContext, f);
+    for (f = 0; f < m_getNumFaces(pContext); f++) {
+        const verts = m_getNumVerticesOfFace(pContext, f);
         if (verts !== 3 && verts !== 4) continue;
 
         pTriInfos[iDstTriIndex].iOrgFaceNumber = f;
@@ -1629,12 +1744,19 @@ function GenerateInitialVerticesIndexList(pTriInfos, piTriList_out, pContext, iN
                 const i1 = MakeIndex(f, 1);
                 const i2 = MakeIndex(f, 2);
                 const i3 = MakeIndex(f, 3);
-                const T0 = GetTexCoord(pContext, i0);
-                const T1 = GetTexCoord(pContext, i1);
-                const T2 = GetTexCoord(pContext, i2);
-                const T3 = GetTexCoord(pContext, i3);
-                const distSQ_02 = LengthSquared(vsub(T2, T0));
-                const distSQ_13 = LengthSquared(vsub(T3, T1));
+
+                const T0 = new SVec3();
+                GetTexCoord(T0, pContext, i0);
+                const T1 = new SVec3();
+                GetTexCoord(T1, pContext, i1);
+                const T2 = new SVec3();
+                GetTexCoord(T2, pContext, i2);
+                const T3 = new SVec3();
+                GetTexCoord(T3, pContext, i3);
+
+
+                const distSQ_02 = DistanceSquared(T2, T0);
+                const distSQ_13 = DistanceSquared(T3, T1);
                 let bQuadDiagIs_02 = false;
                 if (distSQ_02 < distSQ_13)
                     bQuadDiagIs_02 = true;
@@ -1645,8 +1767,8 @@ function GenerateInitialVerticesIndexList(pTriInfos, piTriList_out, pContext, iN
                     const P1 = GetPosition(pContext, i1);
                     const P2 = GetPosition(pContext, i2);
                     const P3 = GetPosition(pContext, i3);
-                    const distSQ_02 = LengthSquared(vsub(P2, P0));
-                    const distSQ_13 = LengthSquared(vsub(P3, P1));
+                    const distSQ_02 = DistanceSquared(P2, P0);
+                    const distSQ_13 = DistanceSquared(P3, P1);
 
                     bQuadDiagIs_02 = distSQ_13 >= distSQ_02;
                 }
@@ -1909,6 +2031,9 @@ function GenerateTSpaces(psTspace, pTriInfos, pGroups, iNrActiveGroups, piTriLis
 
     iUniqueTspaces = 0;
 
+    const vOs = new SVec3();
+    const vOt = new SVec3();
+
     for (g = 0; g < iNrActiveGroups; g++) {
         const pGroup = pGroups[g];
         let iUniqueSubGroups = 0, s = 0;
@@ -1925,7 +2050,7 @@ function GenerateTSpaces(psTspace, pTriInfos, pGroups, iNrActiveGroups, piTriLis
             /**
              * @type {SVec3}
              */
-            let n, vOs, vOt;
+            let n;
 
             if (pTriInfos[f].AssignedGroup[0] === pGroup) index = 0;
             else if (pTriInfos[f].AssignedGroup[1] === pGroup) index = 1;
@@ -1939,10 +2064,12 @@ function GenerateTSpaces(psTspace, pTriInfos, pGroups, iNrActiveGroups, piTriLis
             n = GetNormal(pContext, iVertIndex);
 
             // project
-            vOs = vsub(pTriInfos[f].vOs, vscale(vdot(n, pTriInfos[f].vOs), n));
-            vOt = vsub(pTriInfos[f].vOt, vscale(vdot(n, pTriInfos[f].vOt), n));
-            if (VNotZero(vOs)) vOs = Normalize(vOs);
-            if (VNotZero(vOt)) vOt = Normalize(vOt);
+
+            vsub(vOs, pTriInfos[f].vOs, vscale(vdot(n, pTriInfos[f].vOs), n));
+            vsub(vOt, pTriInfos[f].vOt, vscale(vdot(n, pTriInfos[f].vOt), n));
+
+            NormalizeSafe(vOs, vOs);
+            NormalizeSafe(vOt, vOt);
 
             // original face number
             iOF_1 = pTriInfos[f].iOrgFaceNumber;
@@ -1953,10 +2080,14 @@ function GenerateTSpaces(psTspace, pTriInfos, pGroups, iNrActiveGroups, piTriLis
                 const iOF_2 = pTriInfos[t].iOrgFaceNumber;
 
                 // project
-                let vOs2 = vsub(pTriInfos[t].vOs, vscale(vdot(n, pTriInfos[t].vOs), n));
-                let vOt2 = vsub(pTriInfos[t].vOt, vscale(vdot(n, pTriInfos[t].vOt), n));
-                if (VNotZero(vOs2)) vOs2 = Normalize(vOs2);
-                if (VNotZero(vOt2)) vOt2 = Normalize(vOt2);
+                let vOs2 = new SVec3();
+                vsub(vOs2, pTriInfos[t].vOs, vscale(vdot(n, pTriInfos[t].vOs), n));
+
+                let vOt2 = new SVec3();
+                vsub(vOt2, pTriInfos[t].vOt, vscale(vdot(n, pTriInfos[t].vOt), n));
+
+                NormalizeSafe(vOs2, vOs2);
+                NormalizeSafe(vOt2, vOt2);
 
                 {
                     const bAny = ((pTriInfos[f].iFlag | pTriInfos[t].iFlag) & GROUP_WITH_ANY) !== 0;
@@ -1975,6 +2106,7 @@ function GenerateTSpaces(psTspace, pTriInfos, pGroups, iNrActiveGroups, piTriLis
             // sort pTmpMembers
             tmp_group.iNrFaces = iMembers;
             tmp_group.pTriMembers = pTmpMembers;
+
             if (iMembers > 1) {
                 const uSeed = INTERNAL_RND_SORT_SEED;	// could replace with a random seed?
                 QuickSort(pTmpMembers, 0, iMembers - 1, uSeed);
@@ -2140,30 +2272,43 @@ function DegenEpilogue(psTspace, pTriInfos, piTriListIn, pContext, iNrTrianglesI
 
     // deal with degenerate triangles
     // punishment for degenerate triangles is O(N^2)
+
     for (t = iNrTrianglesIn; t < iTotTris; t++) {
+        const tri0 = pTriInfos[t];
+
         // degenerate triangles on a quad with one good triangle are skipped
         // here but processed in the next loop
-        const bSkip = (pTriInfos[t].iFlag & QUAD_ONE_DEGEN_TRI) !== 0;
+        const bSkip = (tri0.iFlag & QUAD_ONE_DEGEN_TRI) !== 0;
 
         if (!bSkip) {
             for (i = 0; i < 3; i++) {
+
                 const index1 = piTriListIn[t * 3 + i];
                 // search through the good triangles
                 let bNotFound = true;
                 let j = 0;
+
                 while (bNotFound && j < (3 * iNrTrianglesIn)) {
                     const index2 = piTriListIn[j];
-                    if (index1 === index2) bNotFound = false;
-                    else ++j;
+
+                    if (index1 === index2) {
+                        bNotFound = false;
+                    } else {
+                        ++j;
+                    }
                 }
 
                 if (!bNotFound) {
                     const iTri = j / 3;
                     const iVert = j % 3;
-                    const iSrcVert = pTriInfos[iTri].vert_num[iVert];
-                    const iSrcOffs = pTriInfos[iTri].iTSpacesOffs;
-                    const iDstVert = pTriInfos[t].vert_num[i];
-                    const iDstOffs = pTriInfos[t].iTSpacesOffs;
+
+                    const tri1 = pTriInfos[iTri];
+
+                    const iSrcVert = tri1.vert_num[iVert];
+                    const iSrcOffs = tri1.iTSpacesOffs;
+
+                    const iDstVert = tri0.vert_num[i];
+                    const iDstOffs = tri0.iTSpacesOffs;
 
                     // copy tspace
                     psTspace[iDstOffs + iDstVert] = psTspace[iSrcOffs + iSrcVert];
@@ -2176,33 +2321,49 @@ function DegenEpilogue(psTspace, pTriInfos, piTriListIn, pContext, iNrTrianglesI
     for (t = 0; t < iNrTrianglesIn; t++) {
         // this triangle belongs to a quad where the
         // other triangle is degenerate
-        if ((pTriInfos[t].iFlag & QUAD_ONE_DEGEN_TRI) !== 0) {
+        const tri = pTriInfos[t];
+
+        if ((tri.iFlag & QUAD_ONE_DEGEN_TRI) !== 0) {
+
             /**
              * @type {SVec3}
              */
             let vDstP;
             let iOrgF = -1, i = 0;
             let bNotFound;
-            const pV = pTriInfos[t].vert_num;
+
+            const pV = tri.vert_num;
             const iFlag = (1 << pV[0]) | (1 << pV[1]) | (1 << pV[2]);
+
             let iMissingIndex = 0;
-            if ((iFlag & 2) === 0) iMissingIndex = 1;
-            else if ((iFlag & 4) === 0) iMissingIndex = 2;
-            else if ((iFlag & 8) === 0) iMissingIndex = 3;
 
-            iOrgF = pTriInfos[t].iOrgFaceNumber;
+            if ((iFlag & 2) === 0) {
+                iMissingIndex = 1;
+            } else if ((iFlag & 4) === 0) {
+                iMissingIndex = 2;
+            } else if ((iFlag & 8) === 0) {
+                iMissingIndex = 3;
+            }
+
+            iOrgF = tri.iOrgFaceNumber;
             vDstP = GetPosition(pContext, MakeIndex(iOrgF, iMissingIndex));
             bNotFound = true;
+
             i = 0;
+
             while (bNotFound && i < 3) {
+
                 const iVert = pV[i];
                 const vSrcP = GetPosition(pContext, MakeIndex(iOrgF, iVert));
-                if (veq(vSrcP, vDstP) === true) {
-                    const iOffs = pTriInfos[t].iTSpacesOffs;
+
+                if (veq(vSrcP, vDstP)) {
+                    const iOffs = tri.iTSpacesOffs;
                     psTspace[iOffs + iMissingIndex] = psTspace[iOffs + iVert];
                     bNotFound = false;
-                } else
+                } else {
                     ++i;
+                }
+
             }
             assert(!bNotFound);
         }