@needle-tools/gltf-build-pipeline 2.13.0 → 2.13.1

package/dist/extensions/utils.js

@@ -1,72 +1,72 @@
-import { WriterContext } from '@gltf-transform/core';
-export function tryGetInArray(arr, index) {
-    if (index === undefined)
-        return null;
-    if (Array.isArray(arr) && arr.length > index) {
-        return arr[index];
-    }
-    return null;
-}
-export function writeExtension(prop, name, ext) {
-    if (prop === null)
-        return;
-    if (ext) {
-        if (!prop.extensions) {
-            prop.extensions = {};
-        }
-        prop.extensions[name] = ext;
-    }
-}
-// Texture index in context.textures
-export function getTexture(context, tex) {
-    if (!context.jsonDoc.json.images)
-        return null;
-    if (tex.source !== undefined) {
-        return context.textures[tex.source];
-    }
-    else {
-        for (const key of Object.keys(tex.extensions)) {
-            const ext = tex.extensions[key];
-            if (ext && typeof ext["source"] === "number") {
-                return context.textures[ext["source"]];
-            }
-        }
-    }
-    console.log("Could not fnd texture", tex);
-    return null;
-}
-export function getTextureDefinition(context, tex) {
-    const textureDefinitions = context.jsonDoc.json.textures;
-    if (!textureDefinitions)
-        return null;
-    if (context instanceof WriterContext) {
-        // we use the texture image map to find the texture definition to write the extension to
-        const textureImageIndexMap = context.imageIndexMap;
-        // get the image this texture is using
-        const imageIndex = textureImageIndexMap.get(tex);
-        // find the texture definition that uses this image and add the extension
-        for (const def of textureDefinitions) {
-            if (def.source === imageIndex) {
-                return def;
-            }
-        }
-    }
-    else {
-        const textureIndex = context.textures.indexOf(tex);
-        for (let i = 0; i < textureDefinitions.length; i++) {
-            const textureDef = textureDefinitions[i];
-            if (textureDef.source === textureIndex) {
-                return textureDef;
-            }
-            else if (textureDef.extensions) {
-                for (const key of Object.keys(textureDef.extensions)) {
-                    const ext = textureDef.extensions[key];
-                    if (ext && ext["source"] === textureIndex) {
-                        return textureDef;
-                    }
-                }
-            }
-        }
-    }
-    return null;
-}
+import { WriterContext } from '@gltf-transform/core';
+export function tryGetInArray(arr, index) {
+    if (index === undefined)
+        return null;
+    if (Array.isArray(arr) && arr.length > index) {
+        return arr[index];
+    }
+    return null;
+}
+export function writeExtension(prop, name, ext) {
+    if (prop === null)
+        return;
+    if (ext) {
+        if (!prop.extensions) {
+            prop.extensions = {};
+        }
+        prop.extensions[name] = ext;
+    }
+}
+// Texture index in context.textures
+export function getTexture(context, tex) {
+    if (!context.jsonDoc.json.images)
+        return null;
+    if (tex.source !== undefined) {
+        return context.textures[tex.source];
+    }
+    else {
+        for (const key of Object.keys(tex.extensions)) {
+            const ext = tex.extensions[key];
+            if (ext && typeof ext["source"] === "number") {
+                return context.textures[ext["source"]];
+            }
+        }
+    }
+    console.log("Could not fnd texture", tex);
+    return null;
+}
+export function getTextureDefinition(context, tex) {
+    const textureDefinitions = context.jsonDoc.json.textures;
+    if (!textureDefinitions)
+        return null;
+    if (context instanceof WriterContext) {
+        // we use the texture image map to find the texture definition to write the extension to
+        const textureImageIndexMap = context.imageIndexMap;
+        // get the image this texture is using
+        const imageIndex = textureImageIndexMap.get(tex);
+        // find the texture definition that uses this image and add the extension
+        for (const def of textureDefinitions) {
+            if (def.source === imageIndex) {
+                return def;
+            }
+        }
+    }
+    else {
+        const textureIndex = context.textures.indexOf(tex);
+        for (let i = 0; i < textureDefinitions.length; i++) {
+            const textureDef = textureDefinitions[i];
+            if (textureDef.source === textureIndex) {
+                return textureDef;
+            }
+            else if (textureDef.extensions) {
+                for (const key of Object.keys(textureDef.extensions)) {
+                    const ext = textureDef.extensions[key];
+                    if (ext && ext["source"] === textureIndex) {
+                        return textureDef;
+                    }
+                }
+            }
+        }
+    }
+    return null;
+}

package/dist/functions/weld.3.d.ts

@@ -1,76 +1,76 @@
-import { Document, Primitive, Transform } from '@gltf-transform/core';
-/** @hidden */
-export declare function createIndices(count: number, maxIndex?: number): Uint16Array | Uint32Array;
-export declare function formatLong(x: number): string;
-export declare function formatDelta(a: number, b: number, decimals?: number): string;
-export declare function formatDeltaOp(a: number, b: number): string;
-export declare function cleanPrimitive(prim: Primitive): void;
-/** Options for the {@link weld} function. */
-export interface WeldOptions {
-    /** Tolerance for vertex positions, as a fraction of primitive AABB. */
-    tolerance?: number;
-    /** Tolerance for vertex normals, in radians. */
-    toleranceNormal?: number;
-    /** Whether to overwrite existing indices. */
-    overwrite?: boolean;
-    /** Enables a more thorough, but slower, search for vertices to weld. */
-    exhaustive?: boolean;
-}
-export declare const WELD_DEFAULTS: Required<WeldOptions>;
-/**
- * Index {@link Primitive Primitives} and (optionally) merge similar vertices. When merged
- * and indexed, data is shared more efficiently between vertices. File size can
- * be reduced, and the GPU can sometimes use the vertex cache more efficiently.
- *
- * When welding, the 'tolerance' threshold determines which vertices qualify for
- * welding based on distance between the vertices as a fraction of the primitive's
- * bounding box (AABB). For example, tolerance=0.01 welds vertices within +/-1%
- * of the AABB's longest dimension. Other vertex attributes are also compared
- * during welding, with attribute-specific thresholds. For `tolerance=0`, geometry
- * is indexed in place, without merging.
- *
- * To preserve visual appearance consistently, use low `toleranceNormal` thresholds
- * around 0.1 (±3º). To pre-processing a scene before simplification or LOD creation,
- * use higher thresholds around 0.5 (±30º).
- *
- * Example:
- *
- * ```javascript
- * import { weld } from '@gltf-transform/functions';
- *
- * await document.transform(
- * 	weld({ tolerance: 0.001, toleranceNormal: 0.5 })
- * );
- * ```
- *
- * @category Transforms
- */
-export declare function weld(_options?: WeldOptions): Transform;
-/**
- * Index a {@link Primitive} and (optionally) weld similar vertices. When merged
- * and indexed, data is shared more efficiently between vertices. File size can
- * be reduced, and the GPU can sometimes use the vertex cache more efficiently.
- *
- * When welding, the 'tolerance' threshold determines which vertices qualify for
- * welding based on distance between the vertices as a fraction of the primitive's
- * bounding box (AABB). For example, tolerance=0.01 welds vertices within +/-1%
- * of the AABB's longest dimension. Other vertex attributes are also compared
- * during welding, with attribute-specific thresholds. For tolerance=0, geometry
- * is indexed in place, without merging.
- *
- * Example:
- *
- * ```javascript
- * import { weldPrimitive } from '@gltf-transform/functions';
- *
- * const mesh = document.getRoot().listMeshes()
- * 	.find((mesh) => mesh.getName() === 'Gizmo');
- *
- * for (const prim of mesh.listPrimitives()) {
- *   weldPrimitive(prim, {tolerance: 0.0001});
- * }
- * ```
- *
- * @privateRemarks TODO(v4): Remove the "Document" parameter.
- */
-export declare function weldPrimitive(a: Document | Primitive, b?: Primitive | WeldOptions, c?: Required<WeldOptions>): void;
+import { Document, Primitive, Transform } from '@gltf-transform/core';
+/** @hidden */
+export declare function createIndices(count: number, maxIndex?: number): Uint16Array | Uint32Array;
+export declare function formatLong(x: number): string;
+export declare function formatDelta(a: number, b: number, decimals?: number): string;
+export declare function formatDeltaOp(a: number, b: number): string;
+export declare function cleanPrimitive(prim: Primitive): void;
+/** Options for the {@link weld} function. */
+export interface WeldOptions {
+    /** Tolerance for vertex positions, as a fraction of primitive AABB. */
+    tolerance?: number;
+    /** Tolerance for vertex normals, in radians. */
+    toleranceNormal?: number;
+    /** Whether to overwrite existing indices. */
+    overwrite?: boolean;
+    /** Enables a more thorough, but slower, search for vertices to weld. */
+    exhaustive?: boolean;
+}
+export declare const WELD_DEFAULTS: Required<WeldOptions>;
+/**
+ * Index {@link Primitive Primitives} and (optionally) merge similar vertices. When merged
+ * and indexed, data is shared more efficiently between vertices. File size can
+ * be reduced, and the GPU can sometimes use the vertex cache more efficiently.
+ *
+ * When welding, the 'tolerance' threshold determines which vertices qualify for
+ * welding based on distance between the vertices as a fraction of the primitive's
+ * bounding box (AABB). For example, tolerance=0.01 welds vertices within +/-1%
+ * of the AABB's longest dimension. Other vertex attributes are also compared
+ * during welding, with attribute-specific thresholds. For `tolerance=0`, geometry
+ * is indexed in place, without merging.
+ *
+ * To preserve visual appearance consistently, use low `toleranceNormal` thresholds
+ * around 0.1 (±3º). To pre-processing a scene before simplification or LOD creation,
+ * use higher thresholds around 0.5 (±30º).
+ *
+ * Example:
+ *
+ * ```javascript
+ * import { weld } from '@gltf-transform/functions';
+ *
+ * await document.transform(
+ * 	weld({ tolerance: 0.001, toleranceNormal: 0.5 })
+ * );
+ * ```
+ *
+ * @category Transforms
+ */
+export declare function weld(_options?: WeldOptions): Transform;
+/**
+ * Index a {@link Primitive} and (optionally) weld similar vertices. When merged
+ * and indexed, data is shared more efficiently between vertices. File size can
+ * be reduced, and the GPU can sometimes use the vertex cache more efficiently.
+ *
+ * When welding, the 'tolerance' threshold determines which vertices qualify for
+ * welding based on distance between the vertices as a fraction of the primitive's
+ * bounding box (AABB). For example, tolerance=0.01 welds vertices within +/-1%
+ * of the AABB's longest dimension. Other vertex attributes are also compared
+ * during welding, with attribute-specific thresholds. For tolerance=0, geometry
+ * is indexed in place, without merging.
+ *
+ * Example:
+ *
+ * ```javascript
+ * import { weldPrimitive } from '@gltf-transform/functions';
+ *
+ * const mesh = document.getRoot().listMeshes()
+ * 	.find((mesh) => mesh.getName() === 'Gizmo');
+ *
+ * for (const prim of mesh.listPrimitives()) {
+ *   weldPrimitive(prim, {tolerance: 0.0001});
+ * }
+ * ```
+ *
+ * @privateRemarks TODO(v4): Remove the "Document" parameter.
+ */
+export declare function weldPrimitive(a: Document | Primitive, b?: Primitive | WeldOptions, c?: Required<WeldOptions>): void;