@woosh/meep-engine 2.41.0 → 2.42.1

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

@@ -1,153 +1,51 @@
-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.
-
-
-/**
- * @extends {number[]}
- */
-class SVec3 {
-    constructor() {
-        this.x = 0;
-        this.y = 0;
-        this.z = 0;
-    }
-
-    get 0() {
-        return this.x;
-    }
-
-    set 0(v) {
-        this.x = v;
-    }
-
-    get 1() {
-        return this.y;
-    }
-
-
-    set 1(v) {
-        this.y = v;
-    }
-
-    get 2() {
-        return this.z;
-    }
-
-    set 2(v) {
-        this.z = v;
-    }
-
-}
-
-class SEdge {
-    constructor() {
-        /**
-         * int
-         * @type {number}
-         */
-        this.i0 = 0;
-        /**
-         * int
-         * @type {number}
-         */
-        this.i1 = 0;
-        /**
-         * int
-         * @type {number}
-         */
-        this.f = 0;
-    }
-
-    get 0() {
-        return this.i0;
-    }
-
-    set 0(v) {
-        this.i0 = v;
-    }
-
-    get 1() {
-        return this.i1;
-    }
-
-    set 1(v) {
-        this.i1 = v;
-    }
-
-    get 2() {
-        return this.f;
-    }
-
-    set 2(v) {
-        this.f = v;
-    }
-}
-
-class STSpace {
-    constructor() {
-        this.vOs = new SVec3();
-        this.fMagS = 0;
-        this.vOt = new SVec3();
-        this.fMagT = 0;
-        this.iCounter = 0;	// this is to average back into quads.
-        this.bOrient = false;
-    }
-
-    /**
-     *
-     * @param {STSpace} other
-     */
-    copy(other) {
-        this.vOs = other.vOs;
-        this.fMagS = other.fMagS;
-        this.vOt = other.vOt;
-        this.fMagT = other.fMagT;
-        this.iCounter = other.iCounter;
-        this.bOrient = other.bOrient;
-    }
-}
-
-class SSubGroup {
-    constructor() {
-        /**
-         *
-         * @type {number}
-         */
-        this.iNrFaces = 0;
-
-        /**
-         * *int
-         * @type {null}
-         */
-        this.pTriMembers = null;
-    }
-}
+import { vec3 } from "gl-matrix";
+import { m_setTSpace } from "./m_setTSpace.js";
+import { GetPosition } from "./GetPosition.js";
+import { malloc } from "./malloc.js";
+import { STSpace } from "./STSpace.js";
+import { MARK_DEGENERATE } from "./constants/MARK_DEGENERATE.js";
+import { InitTriInfo } from "./InitTriInfo.js";
+import { GenerateTSpaces } from "./GenerateTSpaces.js";
+import { DegenEpilogue } from "./DegenEpilogue.js";
+import { Build4RuleGroups } from "./Build4RuleGroups.js";
+import { allocate_v3 } from "../../ecs/mesh-v2/allocate_v3.js";
+import { m_getNumFaces } from "./m_getNumFaces.js";
+import { GenerateInitialVerticesIndexList } from "./GenerateInitialVerticesIndexList.js";
+import { DegenPrologue } from "./DegenPrologue.js";
+import { GenerateSharedVerticesIndexList } from "./GenerateSharedVerticesIndexList.js";
+import { DEG_TO_RAD } from "../../../../core/math/DEG_TO_RAD.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 (the original)
+ @see https://github.com/blender/blender/blob/594f47ecd2d5367ca936cf6fc6ec8168c2b360d0/intern/mikktspace/mikktspace.c (looks like best-optimized version)
+ @see https://github.com/undefinist/mikktspacehx/blob/master/src/mikktspace/Mikktspace.hx (Haxe port)
+ @see https://github.com/gltf-rs/mikktspace/blob/6275cc4f15cff8be29819fb34ae8be3b9129dae1/src/generated.rs (Rust port)
+*/
 
 class SGroup {
     constructor() {
@@ -177,8 +75,15 @@ class STriInfo {
         this.AssignedGroup = [];
 
         // normalized first order face derivatives
-        this.vOs = new SVec3();
-        this.vOt = new SVec3();
+
+        /**
+         * @type {vec3|Float32Array}
+         */
+        this.vOs = allocate_v3();
+        /**
+         * @type {vec3|Float32Array}
+         */
+        this.vOt = allocate_v3();
 
         // original magnitudes
         this.fMagS = 0;
@@ -200,7 +105,7 @@ class STriInfo {
          * int[4]
          * @type {number[]}
          */
-        this.vert_num = [];
+        this.vert_num = new Uint8Array(4);
 
         /**
          *
@@ -210,130 +115,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,1844 +148,192 @@ export class SMikkTSpaceContext {
          * @type {number[]}
          */
         this.geometry_buffer_vertex_bitangent = [];
-
-        /**
-         *
-         * @type {SMikkTSpaceInterface|null}
-         */
-        this.m_pInterface = new SMikkTSpaceInterface();
     }
 }
 
-const MARK_DEGENERATE = 1;
-const QUAD_ONE_DEGEN_TRI = 2;
-const GROUP_WITH_ANY = 4;
-const ORIENT_PRESERVING = 8;
+// 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.
 
-const INTERNAL_RND_SORT_SEED = 39871946;
-
-/**
- *
- * @param {SVec3} v1
- * @param {SVec3} v2
- * @returns {boolean}
- */
-function veq(v1, v2) {
-    return (v1.x === v2.x) && (v1.y === v2.y) && (v1.z === v2.z);
-}
 
 /**
  *
- * @param {SVec3} v1
- * @param {SVec3} v2
- * @returns {SVec3}
+ * @param {SMikkTSpaceContext} pContext
+ * @param {number} fAngularThreshold
+ * @return {boolean}
  */
-function vadd(v1, v2) {
-    const res = new SVec3();
+export function genTangSpace(pContext, fAngularThreshold = 180) {
+    // count nr_triangles
+    let iNrTSPaces = 0, iNrMaxGroups = 0;
+    let iNrActiveGroups = 0;
 
-    res.x = v1.x + v2.x;
-    res.y = v1.y + v2.y;
-    res.z = v1.z + v2.z;
+    const iNrFaces = m_getNumFaces(pContext);
+    const fThresCos = Math.cos(fAngularThreshold * DEG_TO_RAD);
 
-    return res;
-}
 
-/**
- *
- * @param {SVec3} v1
- * @param {SVec3} v2
- * @returns {SVec3}
- */
-function vsub(v1, v2) {
-    const res = new SVec3();
+    // count triangles on supported faces
+    // AlexGoldring: since we only support triangles, the number of triangles is going to equal number of faces
+    let iNrTrianglesIn = iNrFaces;
 
-    res.x = v1.x - v2.x;
-    res.y = v1.y - v2.y;
-    res.z = v1.z - v2.z;
+    if (iNrTrianglesIn <= 0) {
+        return false;
+    }
 
-    return res;
-}
+    // allocate memory for an index list
+    const piTriListIn = new Int32Array(3 * iNrTrianglesIn);
+    const pTriInfos = malloc(STriInfo, iNrTrianglesIn);
 
-/**
- *
- * @param {number} fS
- * @param {SVec3} v
- * @returns {SVec3}
- */
-function vscale(fS, v) {
-    const res = new SVec3();
+    // make an initial triangle --> face index list
+    iNrTSPaces = GenerateInitialVerticesIndexList(pTriInfos, piTriListIn, pContext, iNrTrianglesIn);
 
-    res.x = v.x * fS;
-    res.y = v.y * fS;
-    res.z = v.z * fS;
+    // make a welded index list of identical positions and attributes (pos, norm, texc)
+    //printf("gen welded index list begin\n");
+    GenerateSharedVerticesIndexList(piTriListIn, pContext, iNrTrianglesIn);
+    //printf("gen welded index list end\n");
 
-    return res;
-}
+    // Mark all degenerate triangles
+    const iTotTris = iNrTrianglesIn;
+    let iDegenTriangles = 0;
 
-/**
- *
- * @param {SVec3} v
- * @returns {number}
- */
-function LengthSquared(v) {
-    return v.x * v.x + v.y * v.y + v.z * v.z;
-}
+    const p0 = vec3.create();
+    const p1 = vec3.create();
+    const p2 = vec3.create();
 
-/**
- *
- * @param {SVec3} v
- * @returns {number}
- */
-function Length(v) {
-    return Math.sqrt(LengthSquared(v));
-}
+    for (let t = 0; t < iTotTris; t++) {
 
+        const t3 = t * 3;
 
-/**
- *
- * @param {SVec3} v
- * @returns {SVec3}
- */
-function Normalize(v) {
-    return vscale(1 / Length(v), v);
-}
+        const i0 = piTriListIn[t3 ];
+        const i1 = piTriListIn[t3 + 1];
+        const i2 = piTriListIn[t3 + 2];
 
-/**
- *
- * @param {SVec3} v1
- * @param {SVec3} v2
- * @returns {number}
- */
-function vdot(v1, v2) {
-    return v1.x * v2.x + v1.y * v2.y + v1.z * v2.z;
-}
+        GetPosition(p0, 0, pContext, i0);
+        GetPosition(p1, 0, pContext, i1);
+        GetPosition(p2, 0, pContext, i2);
 
-/**
- *
- * @param {number} fX
- * @returns {boolean}
- */
-function NotZero(fX) {
-    return Math.abs(fX) > EPSILON;
-}
+        if (
+            vec3.exactEquals(p0, p1) ||
+            vec3.exactEquals(p0, p2) ||
+            vec3.exactEquals(p1, p2)
+        ) {
+            // degenerate
+            pTriInfos[t].iFlag |= MARK_DEGENERATE;
+            ++iDegenTriangles;
+        }
+    }
 
-/**
- *
- * @param {SVec3} v
- * @returns {boolean}
- */
-function VNotZero(v) {
-    return NotZero(v.x) || NotZero(v.y) || NotZero(v.z);
-}
+    iNrTrianglesIn = iTotTris - iDegenTriangles;
 
-/**
- *
- * @param {number} iFace
- * @param {number} iVert
- * @returns {number}
- */
-function MakeIndex(iFace, iVert) {
-    return (iFace << 2) | (iVert & 0x3);
-}
+    // mark all triangle pairs that belong to a quad with only one
+    // good triangle. These need special treatment in DegenEpilogue().
+    // Additionally, move all good triangles to the start of
+    // pTriInfos[] and piTriListIn[] without changing order and
+    // put the degenerate triangles last.
+    DegenPrologue(pTriInfos, piTriListIn, iNrTrianglesIn, iTotTris);
 
-/**
- *
- * @param {STSpace} ts_res
- * @param {STSpace} pTS0
- * @param {STSpace} pTS1
- * @returns {void}
- */
-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)) {
-        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);
-    }
+    // evaluate triangle level attributes and neighbor list
+    //printf("gen neighbors list begin\n");
+    InitTriInfo(pTriInfos, piTriListIn, pContext, iNrTrianglesIn);
+    //printf("gen neighbors list end\n");
 
-}
 
+    // based on the 4 rules, identify groups based on connectivity
+    iNrMaxGroups = iNrTrianglesIn * 3;
+    const pGroups = malloc(SGroup, iNrMaxGroups);
+    const piGroupTrianglesBuffer = new Int32Array(iNrTrianglesIn * 3);
 
-/**
- *
- * @param {SMikkTSpaceContext} pContext
- * @param {number} index
- * @returns {SVec3}
- */
-function GetPosition(pContext, index) {
-    const res = new SVec3();
+    //printf("gen 4rule groups begin\n");
+    iNrActiveGroups = Build4RuleGroups(
+        pTriInfos,
+        pGroups,
+        piGroupTrianglesBuffer,
+        piTriListIn,
+        iNrTrianglesIn
+    );
+    //printf("gen 4rule groups end\n");
 
-    // inlined : IndexToData(&iF, &iI, index);
-    const iF = index & 0x3;
-    const iI = index >> 2;
+    //
 
-    pContext.m_pInterface.m_getPosition(pContext, res, iF, iI);
+    /**
+     *
+     * @type {STSpace[]}
+     */
+    const psTspace = malloc(STSpace, iNrTSPaces);
 
-    return res;
-}
+    // memset not requried in JS
+    // memset(psTspace, 0, sizeof(STSpace)*iNrTSPaces);
 
-/**
- *
- * @param {SMikkTSpaceContext} pContext
- * @param {number} index
- * @returns {SVec3}
- */
-function GetNormal(pContext, index) {
-    const res = new SVec3();
+    for (let t = 0; t < iNrTSPaces; t++) {
+        const stSpace = psTspace[t];
 
-    // inlined : IndexToData(&iF, &iI, index);
-    const iF = index & 0x3;
-    const iI = index >> 2;
+        stSpace.vOs[0] = 1.0;
+        stSpace.vOs[1] = 0.0;
+        stSpace.vOs[2] = 0.0;
 
-    pContext.m_pInterface.m_getNormal(pContext, res, iF, iI);
+        stSpace.fMagS = 1.0;
 
-    return res;
-}
+        stSpace.vOt[0] = 0.0;
+        stSpace.vOt[1] = 1.0;
+        stSpace.vOt[2] = 0.0;
 
-/**
- * TODO doesn't need to be V3, can save memory
- * @param {SMikkTSpaceContext} pContext
- * @param {number} index
- * @returns {SVec3}
- */
-function GetTexCoord(pContext, index) {
+        stSpace.fMagT = 1.0;
+    }
 
-    const res = new SVec3();
+    // make tspaces, each group is split up into subgroups if necessary
+    // based on fAngularThreshold. Finally, a tangent space is made for
+    // every resulting subgroup
+    //printf("gen tspaces begin\n");
+    GenerateTSpaces(
+        psTspace,
+        pTriInfos,
+        pGroups,
+        iNrActiveGroups,
+        piTriListIn,
+        fThresCos,
+        pContext
+    );
+    //printf("gen tspaces end\n");
 
-    // inlined : IndexToData(&iF, &iI, index);
-    const iF = index & 0x3;
-    const iI = index >> 2;
 
-    pContext.m_pInterface.m_getTexCoord(pContext, res, iF, iI);
+    // degenerate quads with one good triangle will be fixed by copying a space from
+    // the good triangle to the coinciding vertex.
+    // all other degenerate triangles will just copy a space from any good triangle
+    // with the same welded index in piTriListIn[].
+    DegenEpilogue(
+        psTspace,
+        pTriInfos,
+        piTriListIn,
+        pContext,
+        iNrTrianglesIn,
+        iTotTris
+    );
 
-    res.z = 1;
 
-    return res;
-}
+    for (let f = 0; f < iNrFaces; f++) {
 
-/**
- *
- * @param {SEdge[]} pSortBuffer
- * @param {number} iLeft
- * @param {number} iRight
- * @param {number} channel
- * @param {number} uSeed
- * @returns {void}
- */
-function QuickSortEdges(pSortBuffer, iLeft, iRight, channel, uSeed) {
-    let t;
-    let iL, iR, n, index, iMid;
+        // set data
+        for (let i = 0; i < 3; i++) {
+            const index = f * 3 + i
+            const pTSpace = psTspace[index];
 
-    // early out
-    let sTmp;
-    const iElems = iRight - iLeft + 1;
-    if (iElems < 2) return;
-    else if (iElems === 2) {
-        if (pSortBuffer[iLeft][channel] > pSortBuffer[iRight][channel]) {
-            sTmp = pSortBuffer[iLeft];
-            pSortBuffer[iLeft] = pSortBuffer[iRight];
-            pSortBuffer[iRight] = sTmp;
+            const tangent = pTSpace.vOs;
+            const bitangent = pTSpace.vOt;
+
+            m_setTSpace(
+                pContext,
+                tangent,
+                bitangent,
+                pTSpace.fMagS,
+                pTSpace.fMagT,
+                pTSpace.bOrient,
+                f,
+                i
+            );
         }
-        return;
     }
 
-    // Random
-    t = uSeed & 31;
-    t = (uSeed << t) | (uSeed >> (32 - t));
-    uSeed = uSeed + t + 3;
-
-    uSeed = uSeed >>> 0; // make unsigned
-    // Random end
-
-    iL = iLeft;
-    iR = iRight;
-    n = (iR - iL) + 1;
-    assert(n >= 0);
-    index = (uSeed % n);
 
-    iMid = pSortBuffer[index + iL][channel];
+    return true;
+}
 
-    do {
-        while (pSortBuffer[iL][channel] < iMid)
-            ++iL;
-        while (pSortBuffer[iR][channel] > iMid)
-            --iR;
 
-        if (iL <= iR) {
-            sTmp = pSortBuffer[iL];
-            pSortBuffer[iL] = pSortBuffer[iR];
-            pSortBuffer[iR] = sTmp;
-            ++iL;
-            --iR;
-        }
-    }
-    while (iL <= iR);
-
-    if (iLeft < iR)
-        QuickSortEdges(pSortBuffer, iLeft, iR, channel, uSeed);
-    if (iL < iRight)
-        QuickSortEdges(pSortBuffer, iL, iRight, channel, uSeed);
-}
-
-/**
- * resolve ordering and edge number
- * @param {SEdge} out
- * @param {number[]} indices
- * @param {number} indices_offset
- * @param {number} i0_in
- * @param {number} i1_in
- * @returns {void}
- */
-function GetEdge(out, indices, indices_offset, i0_in, i1_in) {
-
-    // test if first index is on the edge
-    const index_0 = indices[indices_offset + 0];
-    const index_1 = indices[indices_offset + 1];
-    const index_2 = indices[indices_offset + 2];
-
-    if (index_0 === i0_in || index_0 === i1_in) {
-        // test if second index is on the edge
-        if (index_1 === i0_in || index_1 === i1_in) {
-            out.f = 0; // first edge
-            out.i0 = index_0;
-            out.i1 = index_1;
-        } else {
-            out.f = 2; // third edge
-            out.i0 = index_2;
-            out.i1 = index_0;
-        }
-    } else {
-        // only second and third index is on the edge
-        out.f = 1; // second edge
-        out.i0 = index_1;
-        out.i1 = index_2;
-    }
-}
-
-/**
- * returns the texture area times 2
- * @param {SMikkTSpaceContext } pContext
- * @param {number[]} indices
- * @param {number} indices_offset
- * @returns {number}
- */
-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 t21x = t2.x - t1.x;
-    const t21y = t2.y - t1.y;
-    const t31x = t3.x - t1.x;
-    const t31y = t3.y - t1.y;
-
-    const fSignedAreaSTx2 = t21x * t31y - t21y * t31x;
-
-    return fSignedAreaSTx2 < 0 ? (-fSignedAreaSTx2) : fSignedAreaSTx2;
-}
-
-/**
- * Mimics C malloc somewhat, allocates an array of class instances of fixed size
- * @template T
- * @param {constructor<T>} Klass
- * @param {number} count
- * @returns {T[]}
- */
-function malloc(Klass, count) {
-    const r = new Array(count);
-
-    for (let i = 0; i < count; i++) {
-        r[i] = new Klass();
-    }
-
-    return r;
-}
-
-/**
- *
- * @param {number[]} face_indices
- * @param {number} iFaces
- * @param {number[]} piTriListIn
- * @param {STriInfo[]} pTriInfos
- * @param {SMikkTSpaceContext} pContext
- * @param {number} iVertexRepresentitive
- * @returns {STSpace}
- */
-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;
-
-    for (face = 0; face < iFaces; face++) {
-        const f = face_indices[face];
-
-        // only valid triangles get to add their contribution
-        if ((pTriInfos[f].iFlag & GROUP_WITH_ANY) === 0) {
-            /**
-             * @type {SVec3}
-             */
-            let n, vOs, vOt, 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;
-            assert(i >= 0 && i < 3);
-
-            // project
-            index = piTriListIn[3 * f + 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)];
-
-            p0 = GetPosition(pContext, i0);
-            p1 = GetPosition(pContext, i1);
-            p2 = GetPosition(pContext, i2);
-            v1 = vsub(p0, p1);
-            v2 = vsub(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);
-
-            // 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;
-
-            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;
-        }
-    }
-
-    // normalize
-    if (VNotZero(res.vOs)) res.vOs = Normalize(res.vOs);
-    if (VNotZero(res.vOt)) res.vOt = Normalize(res.vOt);
-    if (fAngleSum > 0) {
-        res.fMagS /= fAngleSum;
-        res.fMagT /= fAngleSum;
-    }
-
-    return res;
-}
-
-/**
- *
- * @param {SSubGroup} pg1
- * @param {SSubGroup } pg2
- * @returns {boolean}
- */
-function CompareSubGroups(pg1, pg2) {
-    let bStillSame = true;
-    let i = 0;
-    if (pg1.iNrFaces !== pg2.iNrFaces) return false;
-    while (i < pg1.iNrFaces && bStillSame) {
-        bStillSame = pg1.pTriMembers[i] === pg2.pTriMembers[i];
-        if (bStillSame) ++i;
-    }
-    return bStillSame;
-}
-
-
-/**
- *
- * @param {number[]|ArrayLike<number>|Uint32Array|Int32Array} pSortBuffer
- * @param {number} iLeft
- * @param {number} iRight
- * @param {number} uSeed
- * @returns {void}
- */
-function QuickSort(pSortBuffer, iLeft, iRight, uSeed) {
-    let iL, iR, n, index, iMid, iTmp;
-
-    // Random
-    let t = uSeed & 31;
-    t = (uSeed << t) | (uSeed >> (32 - t));
-    uSeed = uSeed + t + 3;
-    uSeed = uSeed >>> 0; // make unsigned
-    // Random end
-
-    iL = iLeft;
-    iR = iRight;
-    n = (iR - iL) + 1;
-    assert(n >= 0);
-    index = (uSeed % n);
-
-    iMid = pSortBuffer[index + iL];
-
-
-    do {
-        while (pSortBuffer[iL] < iMid)
-            ++iL;
-        while (pSortBuffer[iR] > iMid)
-            --iR;
-
-        if (iL <= iR) {
-            iTmp = pSortBuffer[iL];
-            pSortBuffer[iL] = pSortBuffer[iR];
-            pSortBuffer[iR] = iTmp;
-            ++iL;
-            --iR;
-        }
-    }
-    while (iL <= iR);
-
-    if (iLeft < iR)
-        QuickSort(pSortBuffer, iLeft, iR, uSeed);
-    if (iL < iRight)
-        QuickSort(pSortBuffer, iL, iRight, uSeed);
-}
-
-/**
- *
- * @param {STriInfo[]} pTriInfos
- * @param {SEdge[]} pEdges
- * @param {number[]} piTriListIn
- * @param {number} iNrTrianglesIn
- * @returns {void}
- */
-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
-        }
-
-    // sort over all edges by i0, this is the pricy one.
-    QuickSortEdges(pEdges, 0, iNrTrianglesIn * 3 - 1, 0, uSeed);	// sort channel 0 which is i0
-
-    // sub sort over i1, should be fast.
-    // could replace this with a 64 bit int sort over (i0,i1)
-    // 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;
-            const iR = i - 1;
-            //const int iElems = i-iL;
-            iCurStartIndex = i;
-            QuickSortEdges(pEdges, iL, iR, 1, uSeed);	// sort channel 1 which is i1
-        }
-    }
-
-    // sub sort over f, which should be fast.
-    // this step is to remain compliant with BuildNeighborsSlow() when
-    // more than 2 triangles use the same edge (such as a butterfly topology).
-    iCurStartIndex = 0;
-    for (i = 1; i < iEntries; i++) {
-        if (pEdges[iCurStartIndex].i0 !== pEdges[i].i0 || pEdges[iCurStartIndex].i1 !== pEdges[i].i1) {
-            const iL = iCurStartIndex;
-            const iR = i - 1;
-            //const int iElems = i-iL;
-            iCurStartIndex = i;
-            QuickSortEdges(pEdges, iL, iR, 2, uSeed);	// sort channel 2 which is f
-        }
-    }
-
-    const temp_edge_A = new SEdge();
-    const temp_edge_B = new SEdge();
-
-    // pair up, adjacent triangles
-    for (i = 0; i < iEntries; i++) {
-        const i0 = pEdges[i].i0;
-        const i1 = pEdges[i].i1;
-        const f = pEdges[i].f;
-        let bUnassigned_A = false;
-
-        let i0_A, i1_A;
-        let edgenum_A, edgenum_B = 0;	// 0,1 or 2
-
-        GetEdge(temp_edge_A, piTriListIn, f * 3, i0, i1);	// resolve index ordering and edge_num
-        i0_A = temp_edge_A.i0;
-        i1_A = temp_edge_A.i1;
-        edgenum_A = temp_edge_A.f;
-
-        bUnassigned_A = pTriInfos[f].FaceNeighbors[edgenum_A] === -1;
-
-        if (bUnassigned_A) {
-            // get true index ordering
-            let j = i + 1, t;
-            let bNotFound = true;
-            while (j < iEntries && i0 === pEdges[j].i0 && i1 === pEdges[j].i1 && bNotFound) {
-                let bUnassigned_B = false;
-                let i0_B, i1_B;
-                t = pEdges[j].f;
-                // flip i0_B and i1_B
-                GetEdge(temp_edge_B, piTriListIn, t * 3, pEdges[j].i0, pEdges[j].i1);	// resolve index ordering and edge_num
-
-                i0_B = temp_edge_B.i0;
-                i1_B = temp_edge_B.i1;
-                edgenum_B = temp_edge_B.f;
-
-                //assert(!(i0_A==i1_B && i1_A==i0_B));
-                bUnassigned_B = pTriInfos[t].FaceNeighbors[edgenum_B] === -1;
-                if (i0_A === i0_B && i1_A === i1_B && bUnassigned_B)
-                    bNotFound = false;
-                else
-                    ++j;
-            }
-
-            if (!bNotFound) {
-                let t = pEdges[j].f;
-                pTriInfos[f].FaceNeighbors[edgenum_A] = t;
-                //assert(pTriInfos[t].FaceNeighbors[edgenum_B]==-1);
-                pTriInfos[t].FaceNeighbors[edgenum_B] = f;
-            }
-        }
-    }
-}
-
-/**
- *
- * @param {STriInfo[]} pTriInfos
- * @param {number} piTriListIn
- * @param {number} iNrTrianglesIn
- * @returns {void}
- */
-function BuildNeighborsSlow(pTriInfos, piTriListIn, iNrTrianglesIn) {
-    let f = 0, i = 0;
-    for (f = 0; f < iNrTrianglesIn; f++) {
-        for (i = 0; i < 3; i++) {
-            // if unassigned
-            if (pTriInfos[f].FaceNeighbors[i] === -1) {
-                const i0_A = piTriListIn[f * 3 + i];
-                const i1_A = piTriListIn[f * 3 + (i < 2 ? (i + 1) : 0)];
-
-                // search for a neighbor
-                let bFound = false;
-                let t = 0, j = 0;
-                while (!bFound && t < iNrTrianglesIn) {
-                    if (t !== f) {
-                        j = 0;
-                        while (!bFound && j < 3) {
-                            // in rev order
-                            const i1_B = piTriListIn[t * 3 + j];
-                            const i0_B = piTriListIn[t * 3 + (j < 2 ? (j + 1) : 0)];
-                            //assert(!(i0_A==i1_B && i1_A==i0_B));
-                            if (i0_A === i0_B && i1_A === i1_B)
-                                bFound = true;
-                            else
-                                ++j;
-                        }
-                    }
-
-                    if (!bFound) ++t;
-                }
-
-                // assign neighbors
-                if (bFound) {
-                    pTriInfos[f].FaceNeighbors[i] = t;
-                    //assert(pTriInfos[t].FaceNeighbors[j]==-1);
-                    pTriInfos[t].FaceNeighbors[j] = f;
-                }
-            }
-        }
-    }
-}
-
-/**
- *
- * @param {STriInfo[]} pTriInfos
- * @param {number[]|Int32Array} piTriListIn
- * @param {SMikkTSpaceContext} pContext
- * @param {number} iNrTrianglesIn
- * @returns {void}
- */
-function InitTriInfo(pTriInfos, piTriListIn, pContext, iNrTrianglesIn) {
-    let f = 0, i = 0, t = 0;
-    // pTriInfos[f].iFlag is cleared in GenerateInitialVerticesIndexList() which is called before this function.
-
-    // generate neighbor info list
-    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;
-
-            // assumed bad
-            pTriInfos[f].iFlag |= GROUP_WITH_ANY;
-        }
-
-    // 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 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);
-
-        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
-
-        pTriInfos[f].iFlag |= (fSignedAreaSTx2 > 0 ? ORIENT_PRESERVING : 0);
-
-        if (NotZero(fSignedAreaSTx2)) {
-            const fAbsArea = fabsf(fSignedAreaSTx2);
-            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);
-
-            // 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))
-                pTriInfos[f].iFlag &= (~GROUP_WITH_ANY);
-        }
-    }
-
-    // force otherwise healthy quads to a fixed orientation
-    while (t < (iNrTrianglesIn - 1)) {
-        const iFO_a = pTriInfos[t].iOrgFaceNumber;
-        const iFO_b = pTriInfos[t + 1].iOrgFaceNumber;
-        if (iFO_a === iFO_b)	// this is a quad
-        {
-            const bIsDeg_a = (pTriInfos[t].iFlag & MARK_DEGENERATE) !== 0;
-            const bIsDeg_b = (pTriInfos[t + 1].iFlag & MARK_DEGENERATE) !== 0;
-
-            // bad triangles should already have been removed by
-            // DegenPrologue(), but just in case check bIsDeg_a and bIsDeg_a are false
-            if ((bIsDeg_a || bIsDeg_b) === false) {
-                const bOrientA = (pTriInfos[t].iFlag & ORIENT_PRESERVING) !== 0;
-                const bOrientB = (pTriInfos[t + 1].iFlag & ORIENT_PRESERVING) !== 0;
-                // if this happens the quad has extremely bad mapping!!
-                if (bOrientA !== bOrientB) {
-                    //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))
-                        bChooseOrientFirstTri = true;
-
-                    // force match
-                    {
-                        const t0 = bChooseOrientFirstTri ? t : (t + 1);
-                        const t1 = bChooseOrientFirstTri ? (t + 1) : t;
-                        pTriInfos[t1].iFlag &= (~ORIENT_PRESERVING);	// clear first
-                        pTriInfos[t1].iFlag |= (pTriInfos[t0].iFlag & ORIENT_PRESERVING);	// copy bit
-                    }
-                }
-            }
-            t += 2;
-        } else
-            ++t;
-    }
-
-    // match up edge pairs
-    {
-        const pEdges = malloc(SEdge, iNrTrianglesIn * 3);
-        BuildNeighborsFast(pTriInfos, pEdges, piTriListIn, iNrTrianglesIn);
-    }
-}
-
-
-/**
- *
- * @param {SMikkTSpaceContext} pContext
- * @param {number} fAngularThreshold
- * @return {boolean}
- */
-export function genTangSpace(pContext, fAngularThreshold = 180) {
-    // count nr_triangles
-    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);
-    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);
-        if (verts === 3) ++iNrTrianglesIn;
-        else if (verts === 4) iNrTrianglesIn += 2;
-    }
-    if (iNrTrianglesIn <= 0) return false;
-
-    // allocate memory for an index list
-    const piTriListIn = new Int32Array(3 * iNrTrianglesIn);
-    const pTriInfos = malloc(STriInfo, iNrTrianglesIn);
-
-    // make an initial triangle -. face index list
-    iNrTSPaces = GenerateInitialVerticesIndexList(pTriInfos, piTriListIn, pContext, iNrTrianglesIn);
-
-    // make a welded index list of identical positions and attributes (pos, norm, texc)
-    //printf("gen welded index list begin\n");
-    GenerateSharedVerticesIndexList(piTriListIn, pContext, iNrTrianglesIn);
-    //printf("gen welded index list end\n");
-
-    // Mark all degenerate triangles
-    iTotTris = iNrTrianglesIn;
-    iDegenTriangles = 0;
-    for (t = 0; t < iTotTris; t++) {
-        const i0 = piTriListIn[t * 3 + 0];
-        const i1 = piTriListIn[t * 3 + 1];
-        const i2 = piTriListIn[t * 3 + 2];
-        const p0 = GetPosition(pContext, i0);
-        const p1 = GetPosition(pContext, i1);
-        const p2 = GetPosition(pContext, i2);
-        if (veq(p0, p1) || veq(p0, p2) || veq(p1, p2))	// degenerate
-        {
-            pTriInfos[t].iFlag |= MARK_DEGENERATE;
-            ++iDegenTriangles;
-        }
-    }
-    iNrTrianglesIn = iTotTris - iDegenTriangles;
-
-    // mark all triangle pairs that belong to a quad with only one
-    // good triangle. These need special treatment in DegenEpilogue().
-    // Additionally, move all good triangles to the start of
-    // pTriInfos[] and piTriListIn[] without changing order and
-    // put the degenerate triangles last.
-    DegenPrologue(pTriInfos, piTriListIn, iNrTrianglesIn, iTotTris);
-
-
-    // evaluate triangle level attributes and neighbor list
-    //printf("gen neighbors list begin\n");
-    InitTriInfo(pTriInfos, piTriListIn, pContext, iNrTrianglesIn);
-    //printf("gen neighbors list end\n");
-
-
-    // based on the 4 rules, identify groups based on connectivity
-    iNrMaxGroups = iNrTrianglesIn * 3;
-    const pGroups = malloc(SGroup, iNrMaxGroups);
-    const piGroupTrianglesBuffer = new Int32Array(iNrTrianglesIn * 3);
-
-    //printf("gen 4rule groups begin\n");
-    iNrActiveGroups =
-        Build4RuleGroups(pTriInfos, pGroups, piGroupTrianglesBuffer, piTriListIn, iNrTrianglesIn);
-    //printf("gen 4rule groups end\n");
-
-    //
-
-    /**
-     *
-     * @type {STSpace[]}
-     */
-    const psTspace = malloc(STSpace, iNrTSPaces);
-
-    // memset not requried in JS
-    // memset(psTspace, 0, sizeof(STSpace)*iNrTSPaces);
-
-    for (t = 0; t < iNrTSPaces; t++) {
-        psTspace[t].vOs.x = 1.0;
-        psTspace[t].vOs.y = 0.0;
-        psTspace[t].vOs.z = 0.0;
-        psTspace[t].fMagS = 1.0;
-        psTspace[t].vOt.x = 0.0;
-        psTspace[t].vOt.y = 1.0;
-        psTspace[t].vOt.z = 0.0;
-        psTspace[t].fMagT = 1.0;
-    }
-
-    // make tspaces, each group is split up into subgroups if necessary
-    // based on fAngularThreshold. Finally a tangent space is made for
-    // every resulting subgroup
-    //printf("gen tspaces begin\n");
-    bRes = GenerateTSpaces(psTspace, pTriInfos, pGroups, iNrActiveGroups, piTriListIn, fThresCos, pContext);
-    //printf("gen tspaces end\n");
-
-    if (!bRes)	// if an allocation in GenerateTSpaces() failed
-    {
-        // clean up and return false
-        return false;
-    }
-
-
-    // degenerate quads with one good triangle will be fixed by copying a space from
-    // the good triangle to the coinciding vertex.
-    // all other degenerate triangles will just copy a space from any good triangle
-    // with the same welded index in piTriListIn[].
-    DegenEpilogue(psTspace, pTriInfos, piTriListIn, pContext, iNrTrianglesIn, iTotTris);
-
-    index = 0;
-    for (f = 0; f < iNrFaces; f++) {
-        const verts = pContext.m_pInterface.m_getNumVerticesOfFace(pContext, f);
-        if (verts !== 3 && verts !== 4) continue;
-
-
-        // I've decided to let degenerate triangles and group-with-anythings
-        // vary between left/right hand coordinate systems at the vertices.
-        // All healthy triangles on the other hand are built to always be either or.
-
-        /*// force the coordinate system orientation to be uniform for every face.
-        // (this is already the case for good triangles but not for
-        // degenerate ones and those with bGroupWithAnything==true)
-        bool bOrient = psTspace[index].bOrient;
-        if (psTspace[index].iCounter == 0)	// tspace was not derived from a group
-        {
-            // look for a space created in GenerateTSpaces() by iCounter>0
-            bool bNotFound = true;
-            int i=1;
-            while (i<verts && bNotFound)
-            {
-                if (psTspace[index+i].iCounter > 0) bNotFound=false;
-                else ++i;
-            }
-            if (!bNotFound) bOrient = psTspace[index+i].bOrient;
-        }*/
-
-        // set data
-        for (i = 0; i < verts; i++) {
-            const pTSpace = psTspace[index];
-            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);
-
-            ++index;
-        }
-    }
-
-
-    return true;
-}
-
-class STmpVert {
-    constructor() {
-        this.vert = [0, 0, 0];
-        this.index = 0;
-    }
-}
-
-/**
- *
- * @type {number}
- */
-const g_iCells = 2048;
-
-
-/**
- *
- * @param {number} fMin
- * @param {number} fMax
- * @param {number} fVal
- * @return {number}
- */
-function FindGridCell(fMin, fMax, fVal) {
-    const fIndex = g_iCells * ((fVal - fMin) / (fMax - fMin));
-    const iIndex = fIndex >> 0;
-    return iIndex < g_iCells ? (iIndex >= 0 ? iIndex : 0) : (g_iCells - 1);
-}
-
-/**
- *
- * @param {number[]|Int32Array} piTriList_in_and_out
- * @param {SMikkTSpaceContext} pContext
- * @param {number} iNrTrianglesIn
- * @returns {void}
- */
-function GenerateSharedVerticesIndexList(piTriList_in_and_out, pContext, iNrTrianglesIn) {
-
-    // Generate bounding box
-    let piHashCount = null, piHashOffsets = null, piHashCount2 = null;
-    let pTmpVert = null;
-    let i = 0, iChannel = 0, k = 0, e = 0;
-    let iMaxCount = 0;
-    let vMin = GetPosition(pContext, 0), vMax = vMin, vDim;
-    let fMin, fMax;
-    for (i = 1; i < (iNrTrianglesIn * 3); i++) {
-        const index = piTriList_in_and_out[i];
-
-        const vP = GetPosition(pContext, index);
-        if (vMin.x > vP.x) vMin.x = vP.x;
-        else if (vMax.x < vP.x) vMax.x = vP.x;
-        if (vMin.y > vP.y) vMin.y = vP.y;
-        else if (vMax.y < vP.y) vMax.y = vP.y;
-        if (vMin.z > vP.z) vMin.z = vP.z;
-        else if (vMax.z < vP.z) vMax.z = vP.z;
-    }
-
-    vDim = vsub(vMax, vMin);
-    iChannel = 0;
-    fMin = vMin.x;
-    fMax = vMax.x;
-    if (vDim.y > vDim.x && vDim.y > vDim.z) {
-        iChannel = 1;
-        fMin = vMin.y;
-        fMax = vMax.y;
-    } else if (vDim.z > vDim.x) {
-        iChannel = 2;
-        fMin = vMin.z;
-        fMax = vMax.z;
-    }
-
-    // make allocations
-    const piHashTable = new Int32Array(iNrTrianglesIn * 3);
-    piHashCount = new Int32Array(g_iCells);
-    piHashOffsets = new Int32Array(g_iCells);
-    piHashCount2 = new Int32Array(g_iCells);
-
-    // memset is not needed in JS, as arrays are initialized with 0 per spec
-    // memset(piHashCount, 0, sizeof(int)*g_iCells);
-    // memset(piHashCount2, 0, sizeof(int)*g_iCells);
-
-    // count amount of elements in each cell unit
-    for (i = 0; i < (iNrTrianglesIn * 3); i++) {
-        const index = piTriList_in_and_out[i];
-        const vP = GetPosition(pContext, index);
-        const fVal = iChannel === 0 ? vP.x : (iChannel === 1 ? vP.y : vP.z);
-        const iCell = FindGridCell(fMin, fMax, fVal);
-        ++piHashCount[iCell];
-    }
-
-    // evaluate start index of each cell.
-    piHashOffsets[0] = 0;
-    for (k = 1; k < g_iCells; k++)
-        piHashOffsets[k] = piHashOffsets[k - 1] + piHashCount[k - 1];
-
-    // insert vertices
-    for (i = 0; i < (iNrTrianglesIn * 3); i++) {
-        const index = piTriList_in_and_out[i];
-        const vP = GetPosition(pContext, index);
-        const fVal = iChannel === 0 ? vP.x : (iChannel === 1 ? vP.y : vP.z);
-        const iCell = FindGridCell(fMin, fMax, fVal);
-
-        assert(piHashCount2[iCell] < piHashCount[iCell]);
-        const table_offset = piHashOffsets[iCell] + piHashCount2[iCell];
-        piHashTable[table_offset] = i;	// vertex i has been inserted.
-        ++piHashCount2[iCell];
-    }
-    for (k = 0; k < g_iCells; k++)
-        assert(piHashCount2[k] === piHashCount[k]);	// verify the count
-
-    // find maximum amount of entries in any hash entry
-    iMaxCount = piHashCount[0];
-    for (k = 1; k < g_iCells; k++)
-        if (iMaxCount < piHashCount[k])
-            iMaxCount = piHashCount[k];
-    pTmpVert = malloc(STmpVert, iMaxCount);
-
-
-    // complete the merge
-    for (k = 0; k < g_iCells; k++) {
-        // extract table of cell k and amount of entries in it
-        const pTable = piHashTable[piHashOffsets[k]];
-        const iEntries = piHashCount[k];
-        if (iEntries < 2) continue;
-
-        for (e = 0; e < iEntries; e++) {
-            const i = pTable[e];
-            const vP = GetPosition(pContext, piTriList_in_and_out[i]);
-            pTmpVert[e].vert[0] = vP.x;
-            pTmpVert[e].vert[1] = vP.y;
-            pTmpVert[e].vert[2] = vP.z;
-            pTmpVert[e].index = i;
-        }
-        MergeVertsFast(piTriList_in_and_out, pTmpVert, pContext, 0, iEntries - 1);
-    }
-
-}
-
-/**
- *
- * @param {number[]} piTriList_in_and_out
- * @param {STmpVert[]} pTmpVert
- * @param {SMikkTSpaceContext} pContext
- * @param {number} iL_in
- * @param {number} iR_in
- * @returns {void}
- */
-function MergeVertsFast(piTriList_in_and_out, pTmpVert, pContext, iL_in, iR_in) {
-    // make bbox
-    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++) {
-        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];
-        }
-    }
-
-    dx = fvMax[0] - fvMin[0];
-    dy = fvMax[1] - fvMin[1];
-    dz = fvMax[2] - fvMin[2];
-
-    channel = 0;
-    if (dy > dx && dy > dz) channel = 1;
-    else if (dz > dx) channel = 2;
-
-    fSep = 0.5 * (fvMax[channel] + fvMin[channel]);
-
-    // stop if all vertices are NaNs
-    if (!Number.isFinite(fSep))
-        return;
-
-    // terminate recursion when the separation/average value
-    // is no longer strictly between fMin and fMax values.
-    if (fSep >= fvMax[channel] || fSep <= fvMin[channel]) {
-        // complete the weld
-        for (l = iL_in; l <= iR_in; l++) {
-            let i = pTmpVert[l].index;
-            const index = piTriList_in_and_out[i];
-            const vP = GetPosition(pContext, index);
-            const vN = GetNormal(pContext, index);
-            const vT = GetTexCoord(pContext, index);
-
-            let bNotFound = true;
-            let l2 = iL_in, i2rec = -1;
-            while (l2 < l && bNotFound) {
-                const i2 = pTmpVert[l2].index;
-                const index2 = piTriList_in_and_out[i2];
-                const vP2 = GetPosition(pContext, index2);
-                const vN2 = GetNormal(pContext, index2);
-                const vT2 = GetTexCoord(pContext, index2);
-                i2rec = i2;
-
-                //if (vP==vP2 && vN==vN2 && vT==vT2)
-                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)
-                    bNotFound = false;
-                else
-                    ++l2;
-            }
-
-            // merge if previously found
-            if (!bNotFound)
-                piTriList_in_and_out[i] = piTriList_in_and_out[i2rec];
-        }
-    } else {
-        let iL = iL_in, iR = iR_in;
-        assert((iR_in - iL_in) > 0);	// at least 2 entries
-
-        // separate (by fSep) all points between iL_in and iR_in in pTmpVert[]
-        while (iL < iR) {
-            let bReadyLeftSwap = false, bReadyRightSwap = false;
-            while ((!bReadyLeftSwap) && iL < iR) {
-                assert(iL >= iL_in && iL <= iR_in);
-                bReadyLeftSwap = !(pTmpVert[iL].vert[channel] < fSep);
-                if (!bReadyLeftSwap) ++iL;
-            }
-            while ((!bReadyRightSwap) && iL < iR) {
-                assert(iR >= iL_in && iR <= iR_in);
-                bReadyRightSwap = pTmpVert[iR].vert[channel] < fSep;
-                if (!bReadyRightSwap) --iR;
-            }
-            assert((iL < iR) || !(bReadyLeftSwap && bReadyRightSwap));
-
-            if (bReadyLeftSwap && bReadyRightSwap) {
-                const sTmp = pTmpVert[iL];
-                assert(iL < iR);
-                pTmpVert[iL] = pTmpVert[iR];
-                pTmpVert[iR] = sTmp;
-                ++iL;
-                --iR;
-            }
-        }
-
-        assert(iL === (iR + 1) || (iL === iR));
-        if (iL === iR) {
-            const bReadyRightSwap = pTmpVert[iR].vert[channel] < fSep;
-            if (bReadyRightSwap) ++iL;
-            else --iR;
-        }
-
-        // only need to weld when there is more than 1 instance of the (x,y,z)
-        if (iL_in < iR)
-            MergeVertsFast(piTriList_in_and_out, pTmpVert, pContext, iL_in, iR);	// weld all left of fSep
-        if (iL < iR_in)
-            MergeVertsFast(piTriList_in_and_out, pTmpVert, pContext, iL, iR_in);	// weld all right of (or equal to) fSep
-    }
-}
-
-/**
- *
- * @param {STriInfo[]} pTriInfos
- * @param {number[]|Int32Array} piTriList_out
- * @param {SMikkTSpaceContext } pContext
- * @param {number} iNrTrianglesIn
- * @return {number}
- */
-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);
-        if (verts !== 3 && verts !== 4) continue;
-
-        pTriInfos[iDstTriIndex].iOrgFaceNumber = f;
-        pTriInfos[iDstTriIndex].iTSpacesOffs = iTSpacesOffs;
-
-        if (verts === 3) {
-            const pVerts = pTriInfos[iDstTriIndex].vert_num;
-            pVerts[0] = 0;
-            pVerts[1] = 1;
-            pVerts[2] = 2;
-            piTriList_out[iDstTriIndex * 3 + 0] = MakeIndex(f, 0);
-            piTriList_out[iDstTriIndex * 3 + 1] = MakeIndex(f, 1);
-            piTriList_out[iDstTriIndex * 3 + 2] = MakeIndex(f, 2);
-            ++iDstTriIndex;	// next
-        } else {
-            {
-                pTriInfos[iDstTriIndex + 1].iOrgFaceNumber = f;
-                pTriInfos[iDstTriIndex + 1].iTSpacesOffs = iTSpacesOffs;
-            }
-
-            {
-                // need an order independent way to evaluate
-                // tspace on quads. This is done by splitting
-                // along the shortest diagonal.
-                const i0 = MakeIndex(f, 0);
-                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));
-                let bQuadDiagIs_02 = false;
-                if (distSQ_02 < distSQ_13)
-                    bQuadDiagIs_02 = true;
-                else if (distSQ_13 < distSQ_02)
-                    bQuadDiagIs_02 = false;
-                else {
-                    const P0 = GetPosition(pContext, i0);
-                    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));
-
-                    bQuadDiagIs_02 = distSQ_13 >= distSQ_02;
-                }
-
-                if (bQuadDiagIs_02) {
-                    {
-                        const pVerts_A = pTriInfos[iDstTriIndex].vert_num;
-                        pVerts_A[0] = 0;
-                        pVerts_A[1] = 1;
-                        pVerts_A[2] = 2;
-                    }
-                    piTriList_out[iDstTriIndex * 3 + 0] = i0;
-                    piTriList_out[iDstTriIndex * 3 + 1] = i1;
-                    piTriList_out[iDstTriIndex * 3 + 2] = i2;
-                    ++iDstTriIndex;	// next
-                    {
-                        const pVerts_B = pTriInfos[iDstTriIndex].vert_num;
-                        pVerts_B[0] = 0;
-                        pVerts_B[1] = 2;
-                        pVerts_B[2] = 3;
-                    }
-                    piTriList_out[iDstTriIndex * 3 + 0] = i0;
-                    piTriList_out[iDstTriIndex * 3 + 1] = i2;
-                    piTriList_out[iDstTriIndex * 3 + 2] = i3;
-                    ++iDstTriIndex;	// next
-                } else {
-                    {
-                        const pVerts_A = pTriInfos[iDstTriIndex].vert_num;
-                        pVerts_A[0] = 0;
-                        pVerts_A[1] = 1;
-                        pVerts_A[2] = 3;
-                    }
-                    piTriList_out[iDstTriIndex * 3 + 0] = i0;
-                    piTriList_out[iDstTriIndex * 3 + 1] = i1;
-                    piTriList_out[iDstTriIndex * 3 + 2] = i3;
-                    ++iDstTriIndex;	// next
-                    {
-                        const pVerts_B = pTriInfos[iDstTriIndex].vert_num;
-                        pVerts_B[0] = 1;
-                        pVerts_B[1] = 2;
-                        pVerts_B[2] = 3;
-                    }
-                    piTriList_out[iDstTriIndex * 3 + 0] = i1;
-                    piTriList_out[iDstTriIndex * 3 + 1] = i2;
-                    piTriList_out[iDstTriIndex * 3 + 2] = i3;
-                    ++iDstTriIndex;	// next
-                }
-            }
-        }
-
-        iTSpacesOffs += verts;
-        assert(iDstTriIndex <= iNrTrianglesIn);
-    }
-
-    for (t = 0; t < iNrTrianglesIn; t++)
-        pTriInfos[t].iFlag = 0;
-
-    // return total amount of tspaces
-    return iTSpacesOffs;
-}
-
-/**
- *
- * @param {STriInfo[]} pTriInfos
- * @param {SGroup[]} pGroups
- * @param {number[]|Int32Array} piGroupTrianglesBuffer
- * @param {number[]|Int32Array} piTriListIn
- * @param {number} iNrTrianglesIn
- * @return {number}
- */
-function Build4RuleGroups(pTriInfos, pGroups, piGroupTrianglesBuffer, piTriListIn, iNrTrianglesIn) {
-    const iNrMaxGroups = iNrTrianglesIn * 3;
-    let iNrActiveGroups = 0;
-    let iOffset = 0, f = 0, i = 0;
-
-    for (; f < iNrTrianglesIn; f++) {
-        const tri_info_f = pTriInfos[f];
-
-        for (i = 0; i < 3; i++) {
-            // if not assigned to a group
-            if ((tri_info_f.iFlag & GROUP_WITH_ANY) === 0 && tri_info_f.AssignedGroup[i] == null) {
-                let neigh_indexL, neigh_indexR;
-                const vert_index = piTriListIn[f * 3 + i];
-
-                assert(iNrActiveGroups < iNrMaxGroups);
-
-                const assigned_group = pGroups[iNrActiveGroups];
-                tri_info_f.AssignedGroup[i] = assigned_group;
-
-                assigned_group.iVertexRepresentitive = vert_index;
-
-                const bOrPre = (tri_info_f.iFlag & ORIENT_PRESERVING) !== 0;
-
-                assigned_group.bOrientPreservering = bOrPre;
-                assigned_group.iNrFaces = 0;
-                assigned_group.pFaceIndices = new Int32Array(piGroupTrianglesBuffer.buffer, iOffset * 4);
-                ++iNrActiveGroups;
-
-                AddTriToGroup(assigned_group, f);
-
-                neigh_indexL = tri_info_f.FaceNeighbors[i];
-                neigh_indexR = tri_info_f.FaceNeighbors[i > 0 ? (i - 1) : 2];
-
-                if (neigh_indexL >= 0) // neighbor
-                {
-                    const bAnswer = AssignRecur(
-                        piTriListIn,
-                        pTriInfos,
-                        neigh_indexL,
-                        assigned_group
-                    );
-
-                    const bOrPre2 = (pTriInfos[neigh_indexL].iFlag & ORIENT_PRESERVING) !== 0;
-                    const bDiff = bOrPre !== bOrPre2;
-                    assert(bAnswer || bDiff);
-                }
-                if (neigh_indexR >= 0) // neighbor
-                {
-                    const bAnswer = AssignRecur(
-                        piTriListIn,
-                        pTriInfos,
-                        neigh_indexR,
-                        assigned_group
-                    );
-
-                    const bOrPre2 = (pTriInfos[neigh_indexR].iFlag & ORIENT_PRESERVING) !== 0;
-                    const bDiff = bOrPre !== bOrPre2;
-                    assert(bAnswer || bDiff);
-                }
-
-                // update offset
-                iOffset += assigned_group.iNrFaces;
-                // since the groups are disjoint a triangle can never
-                // belong to more than 3 groups. Subsequently something
-                // is completely screwed if this assertion ever hits.
-                assert(iOffset <= iNrMaxGroups);
-            }
-        }
-    }
-
-    return iNrActiveGroups;
-}
-
-/**
- *
- * @param {SGroup} pGroup
- * @param {number} iTriIndex
- * @returns {void}
- */
-function AddTriToGroup(pGroup, iTriIndex) {
-    pGroup.pFaceIndices[pGroup.iNrFaces] = iTriIndex;
-    pGroup.iNrFaces++;
-}
-
-/**
- *
- * @param {number[]} piTriListIn
- * @param {STriInfo[]} psTriInfos
- * @param {number} iMyTriIndex
- * @param {SGroup} pGroup
- * @return {boolean}
- */
-function AssignRecur(piTriListIn, psTriInfos, iMyTriIndex, pGroup) {
-
-    // track down vertex
-    const iVertRep = pGroup.iVertexRepresentitive;
-    const pVerts = piTriListIn[iMyTriIndex * 3];
-
-    let i = -1;
-    if (pVerts[0] === iVertRep) i = 0;
-    else if (pVerts[1] === iVertRep) i = 1;
-    else if (pVerts[2] === iVertRep) i = 2;
-
-    assert(i >= 0 && i < 3);
-
-    const pMyTriInfo = psTriInfos[iMyTriIndex];
-
-    // early out
-    if (pMyTriInfo.AssignedGroup[i] === pGroup) {
-        return true;
-    } else if (pMyTriInfo.AssignedGroup[i] !== null) {
-        return false;
-    }
-
-    if ((pMyTriInfo.iFlag & GROUP_WITH_ANY) !== 0) {
-        // first to group with a group-with-anything triangle
-        // determines it's orientation.
-        // This is the only existing order dependency in the code!!
-        if (
-            pMyTriInfo.AssignedGroup[0] === null &&
-            pMyTriInfo.AssignedGroup[1] === null &&
-            pMyTriInfo.AssignedGroup[2] === null
-        ) {
-            pMyTriInfo.iFlag &= (~ORIENT_PRESERVING);
-            pMyTriInfo.iFlag |= (pGroup.bOrientPreservering ? ORIENT_PRESERVING : 0);
-        }
-    }
-    {
-        const bOrient = (pMyTriInfo.iFlag & ORIENT_PRESERVING) !== 0;
-        if (bOrient !== pGroup.bOrientPreservering) return false;
-    }
-
-    AddTriToGroup(pGroup, iMyTriIndex);
-    pMyTriInfo.AssignedGroup[i] = pGroup;
-
-    {
-        const neigh_indexL = pMyTriInfo.FaceNeighbors[i];
-        const neigh_indexR = pMyTriInfo.FaceNeighbors[i > 0 ? (i - 1) : 2];
-        if (neigh_indexL >= 0)
-            AssignRecur(piTriListIn, psTriInfos, neigh_indexL, pGroup);
-        if (neigh_indexR >= 0)
-            AssignRecur(piTriListIn, psTriInfos, neigh_indexR, pGroup);
-    }
-
-
-    return true;
-}
-
-/**
- *
- * @param {STSpace[]} psTspace
- * @param {STriInfo[]} pTriInfos
- * @param {SGroup[]} pGroups
- * @param {number} iNrActiveGroups
- * @param {number[]|Int32Array} piTriListIn
- * @param {number} fThresCos
- * @param {SMikkTSpaceContext} pContext
- * @returns {boolean}
- */
-function GenerateTSpaces(psTspace, pTriInfos, pGroups, iNrActiveGroups, piTriListIn, fThresCos, pContext) {
-
-    let iMaxNrFaces = 0, iUniqueTspaces = 0, g = 0, i = 0;
-
-    for (g = 0; g < iNrActiveGroups; g++) {
-        if (iMaxNrFaces < pGroups[g].iNrFaces) {
-            iMaxNrFaces = pGroups[g].iNrFaces;
-        }
-    }
-
-    if (iMaxNrFaces === 0) {
-        return true;
-    }
-
-
-    // make initial allocations
-    /**
-     * @type {STSpace[]}
-     */
-    let pSubGroupTspace = malloc(STSpace, iMaxNrFaces);
-    /**
-     *
-     * @type {SSubGroup[]}
-     */
-    let pUniSubGroups = malloc(SSubGroup, iMaxNrFaces);
-    /**
-     *
-     * @type {Int32Array|null}
-     */
-    let pTmpMembers = new Int32Array(iMaxNrFaces);
-
-    iUniqueTspaces = 0;
-
-    for (g = 0; g < iNrActiveGroups; g++) {
-        const pGroup = pGroups[g];
-        let iUniqueSubGroups = 0, s = 0;
-
-        for (i = 0; i < pGroup.iNrFaces; i++)	// triangles
-        {
-            const f = pGroup.pFaceIndices[i];	// triangle number
-            let index = -1, iVertIndex = -1, iOF_1 = -1, iMembers = 0, j = 0, l = 0;
-            /**
-             * @type {SSubGroup}
-             */
-            const tmp_group = new SSubGroup();
-            let bFound = false;
-            /**
-             * @type {SVec3}
-             */
-            let n, vOs, vOt;
-
-            if (pTriInfos[f].AssignedGroup[0] === pGroup) index = 0;
-            else if (pTriInfos[f].AssignedGroup[1] === pGroup) index = 1;
-            else if (pTriInfos[f].AssignedGroup[2] === pGroup) index = 2;
-            assert(index >= 0 && index < 3);
-
-            iVertIndex = piTriListIn[f * 3 + index];
-            assert(iVertIndex === pGroup.iVertexRepresentitive);
-
-            // is normalized already
-            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);
-
-            // original face number
-            iOF_1 = pTriInfos[f].iOrgFaceNumber;
-
-            iMembers = 0;
-            for (j = 0; j < pGroup.iNrFaces; j++) {
-                const t = pGroup.pFaceIndices[j];	// triangle number
-                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);
-
-                {
-                    const bAny = ((pTriInfos[f].iFlag | pTriInfos[t].iFlag) & GROUP_WITH_ANY) !== 0;
-                    // make sure triangles which belong to the same quad are joined.
-                    const bSameOrgFace = iOF_1 === iOF_2;
-
-                    const fCosS = vdot(vOs, vOs2);
-                    const fCosT = vdot(vOt, vOt2);
-
-                    assert(f !== t || bSameOrgFace);	// sanity check
-                    if (bAny || bSameOrgFace || (fCosS > fThresCos && fCosT > fThresCos))
-                        pTmpMembers[iMembers++] = t;
-                }
-            }
-
-            // 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);
-            }
-
-            // look for an existing match
-            bFound = false;
-            l = 0;
-            while (l < iUniqueSubGroups && !bFound) {
-                bFound = CompareSubGroups(tmp_group, pUniSubGroups[l]);
-                if (!bFound) ++l;
-            }
-
-            // assign tangent space index
-            assert(bFound || l === iUniqueSubGroups);
-            //piTempTangIndices[f*3+index] = iUniqueTspaces+l;
-
-            // if no match was found we allocate a new subgroup
-            if (!bFound) {
-                // insert new subgroup
-                const pIndices = new Int32Array(iMembers);
-
-                pUniSubGroups[iUniqueSubGroups].iNrFaces = iMembers;
-                pUniSubGroups[iUniqueSubGroups].pTriMembers = pIndices;
-
-                array_copy(tmp_group.pTriMembers, 0, pIndices, 0, iMembers);
-
-                pSubGroupTspace[iUniqueSubGroups] = EvalTspace(
-                    tmp_group.pTriMembers,
-                    iMembers,
-                    piTriListIn,
-                    pTriInfos,
-                    pContext,
-                    pGroup.iVertexRepresentitive
-                );
-
-                ++iUniqueSubGroups;
-            }
-
-            // output tspace
-            {
-                const iOffs = pTriInfos[f].iTSpacesOffs;
-                const iVert = pTriInfos[f].vert_num[index];
-                /**
-                 * @type {STSpace}
-                 */
-                const pTS_out = psTspace[iOffs + iVert];
-                assert(pTS_out.iCounter < 2);
-                assert(((pTriInfos[f].iFlag & ORIENT_PRESERVING) !== 0) === pGroup.bOrientPreservering);
-                if (pTS_out.iCounter === 1) {
-                    AvgTSpace(pTS_out, pTS_out, pSubGroupTspace[l]);
-                    pTS_out.iCounter = 2;	// update counter
-                    pTS_out.bOrient = pGroup.bOrientPreservering;
-                } else {
-                    assert(pTS_out.iCounter === 0);
-                    pTS_out.copy(pSubGroupTspace[l]);
-                    pTS_out.iCounter = 1;	// update counter
-                    pTS_out.bOrient = pGroup.bOrientPreservering;
-                }
-            }
-        }
-
-        // clean up and offset iUniqueTspaces
-
-        iUniqueTspaces += iUniqueSubGroups;
-    }
-
-    return true;
-}
-
-
-/**
- *
- * @param {STriInfo[]} pTriInfos
- * @param {number[]|Int32Array} piTriList_out
- * @param {number} iNrTrianglesIn
- * @param {number} iTotTris
- * @returns {void}
- */
-function DegenPrologue(pTriInfos, piTriList_out, iNrTrianglesIn, iTotTris) {
-    let iNextGoodTriangleSearchIndex = -1;
-    let bStillFindingGoodOnes = false;
-
-    // locate quads with only one good triangle
-    let t = 0;
-    while (t < (iTotTris - 1)) {
-        const iFO_a = pTriInfos[t].iOrgFaceNumber;
-        const iFO_b = pTriInfos[t + 1].iOrgFaceNumber;
-        if (iFO_a === iFO_b)	// this is a quad
-        {
-            const bIsDeg_a = (pTriInfos[t].iFlag & MARK_DEGENERATE) !== 0;
-            const bIsDeg_b = (pTriInfos[t + 1].iFlag & MARK_DEGENERATE) !== 0;
-            if ((bIsDeg_a ^ bIsDeg_b) !== 0) {
-                pTriInfos[t].iFlag |= QUAD_ONE_DEGEN_TRI;
-                pTriInfos[t + 1].iFlag |= QUAD_ONE_DEGEN_TRI;
-            }
-            t += 2;
-        } else
-            ++t;
-    }
-
-    // reorder list so all degen triangles are moved to the back
-    // without reordering the good triangles
-    iNextGoodTriangleSearchIndex = 1;
-    t = 0;
-    bStillFindingGoodOnes = true;
-    while (t < iNrTrianglesIn && bStillFindingGoodOnes) {
-        const bIsGood = (pTriInfos[t].iFlag & MARK_DEGENERATE) === 0;
-        if (bIsGood) {
-            if (iNextGoodTriangleSearchIndex < (t + 2))
-                iNextGoodTriangleSearchIndex = t + 2;
-        } else {
-            let t0, t1;
-            // search for the first good triangle.
-            let bJustADegenerate = true;
-            while (bJustADegenerate && iNextGoodTriangleSearchIndex < iTotTris) {
-                const bIsGood = (pTriInfos[iNextGoodTriangleSearchIndex].iFlag & MARK_DEGENERATE) === 0;
-                if (bIsGood) bJustADegenerate = false;
-                else ++iNextGoodTriangleSearchIndex;
-            }
-
-            t0 = t;
-            t1 = iNextGoodTriangleSearchIndex;
-            ++iNextGoodTriangleSearchIndex;
-            assert(iNextGoodTriangleSearchIndex > (t + 1));
-
-            // swap triangle t0 and t1
-            if (!bJustADegenerate) {
-                let i = 0;
-                for (; i < 3; i++) {
-                    const index = piTriList_out[t0 * 3 + i];
-                    piTriList_out[t0 * 3 + i] = piTriList_out[t1 * 3 + i];
-                    piTriList_out[t1 * 3 + i] = index;
-                }
-                {
-                    const tri_info = pTriInfos[t0];
-                    pTriInfos[t0] = pTriInfos[t1];
-                    pTriInfos[t1] = tri_info;
-                }
-            } else
-                bStillFindingGoodOnes = false;	// this is not supposed to happen
-        }
-
-        if (bStillFindingGoodOnes) ++t;
-    }
-
-    assert(bStillFindingGoodOnes);	// code will still work.
-    assert(iNrTrianglesIn === t);
-}
-
-/**
- *
- * @param {STSpace[]} psTspace
- * @param {STriInfo[]} pTriInfos
- * @param {number[]|Int32Array} piTriListIn
- * @param {SMikkTSpaceContext} pContext
- * @param {number} iNrTrianglesIn
- * @param {number} iTotTris
- * @returns {void}
- */
-function DegenEpilogue(psTspace, pTriInfos, piTriListIn, pContext, iNrTrianglesIn, iTotTris) {
-    let t = 0, i = 0;
-
-    // deal with degenerate triangles
-    // punishment for degenerate triangles is O(N^2)
-    for (t = iNrTrianglesIn; t < iTotTris; 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;
-
-        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 (!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;
-
-                    // copy tspace
-                    psTspace[iDstOffs + iDstVert] = psTspace[iSrcOffs + iSrcVert];
-                }
-            }
-        }
-    }
-
-    // deal with degenerate quads with one good triangle
-    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) {
-            /**
-             * @type {SVec3}
-             */
-            let vDstP;
-            let iOrgF = -1, i = 0;
-            let bNotFound;
-            const pV = pTriInfos[t].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;
-            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;
-                    psTspace[iOffs + iMissingIndex] = psTspace[iOffs + iVert];
-                    bNotFound = false;
-                } else
-                    ++i;
-            }
-            assert(!bNotFound);
-        }
-    }
-}