@needle-tools/gltf-build-pipeline 0.1.0

package/dist/extensions/NEEDLE_opaque/index.d.ts

@@ -0,0 +1,3 @@
+import { IOpaqueExtension } from "./NEEDLE_opaque.js";
+export * from "./NEEDLE_opaque.js";
+export declare const ALL_EXTENSIONS: IOpaqueExtension[];

package/dist/extensions/NEEDLE_opaque/index.js

@@ -0,0 +1,18 @@
+import { PropertyType } from "@gltf-transform/core";
+import { createOpaqueExtension } from "./NEEDLE_opaque.js";
+export * from "./NEEDLE_opaque.js";
+const opaqueOptions = {
+    debug: false,
+};
+export const ALL_EXTENSIONS = [
+    createOpaqueExtension("KHR_animation_pointer", [PropertyType.ANIMATION, PropertyType.ANIMATION_CHANNEL], { ...opaqueOptions }),
+    createOpaqueExtension("NEEDLE_techniques_webgl", [PropertyType.NODE, PropertyType.MATERIAL, PropertyType.ROOT], { ...opaqueOptions }),
+    createOpaqueExtension("NEEDLE_gameobject_data", PropertyType.NODE, { ...opaqueOptions }),
+    createOpaqueExtension("NEEDLE_components", PropertyType.NODE, { ...opaqueOptions }),
+    createOpaqueExtension("NEEDLE_persistent_assets", PropertyType.ROOT, { ...opaqueOptions }),
+    createOpaqueExtension("NEEDLE_lightmaps", PropertyType.ROOT, { ...opaqueOptions }),
+    createOpaqueExtension("NEEDLE_lighting_settings", PropertyType.ROOT, { ...opaqueOptions }),
+    createOpaqueExtension("NEEDLE_render_objects", PropertyType.ROOT, { ...opaqueOptions }),
+    createOpaqueExtension("NEEDLE_progressive", [PropertyType.TEXTURE, PropertyType.MATERIAL], { ...opaqueOptions }),
+    createOpaqueExtension("EXT_texture_exr", [PropertyType.TEXTURE], { ...opaqueOptions }),
+];

package/dist/extensions/NEEDLE_progressive/NEEDLE_progressive.d.ts

@@ -0,0 +1,23 @@
+import { Extension, ExtensionProperty, PropertyType, ReaderContext, WriterContext } from "@gltf-transform/core";
+export declare const NEEDLE_PROGRESSIVE_TEXTURE_EXTENSION_NAME = "NEEDLE_progressive";
+export declare interface IProgressiveTextureInfo {
+    uri?: string;
+    guid: string;
+    level?: number;
+}
+export declare function generateGuid(): string;
+export declare class NEEDLE_progressive extends Extension {
+    static EXTENSION_NAME: string;
+    extensionName: string;
+    create(data: IProgressiveTextureInfo): NEEDLE_progressive_texture_property;
+    read(_context: ReaderContext): this;
+    write(context: WriterContext): this;
+}
+export declare class NEEDLE_progressive_texture_property extends ExtensionProperty {
+    static EXTENSION_NAME: string;
+    readonly extensionName: string;
+    parentTypes: PropertyType[];
+    propertyType: string;
+    init(): void;
+    model: IProgressiveTextureInfo;
+}

package/dist/extensions/NEEDLE_progressive/NEEDLE_progressive.js

@@ -0,0 +1,53 @@
+import { Extension, ExtensionProperty, PropertyType, uuid } from "@gltf-transform/core";
+// TODO: rename to NEEDLE_progressive_texture
+export const NEEDLE_PROGRESSIVE_TEXTURE_EXTENSION_NAME = "NEEDLE_progressive";
+export function generateGuid() {
+    // TODO: replace with same uuid package as in needle engine
+    return uuid();
+}
+export class NEEDLE_progressive extends Extension {
+    static EXTENSION_NAME = NEEDLE_PROGRESSIVE_TEXTURE_EXTENSION_NAME;
+    extensionName = NEEDLE_PROGRESSIVE_TEXTURE_EXTENSION_NAME;
+    create(data) {
+        const ext = new NEEDLE_progressive_texture_property(this.document.getGraph());
+        ext.model = data;
+        return ext;
+    }
+    read(_context) {
+        // console.log("READ " + NEEDLE_PROGRESSIVE_TEXTURE_EXTENSION_NAME);
+        return this;
+    }
+    write(context) {
+        // console.log("WRITE " + NEEDLE_PROGRESSIVE_TEXTURE_EXTENSION_NAME);
+        const textureDefinitions = context.jsonDoc.json.textures;
+        if (!textureDefinitions)
+            return;
+        const root = this.document.getRoot();
+        const textures = root.listTextures();
+        // we use the texture image map to find the texture definition to write the extension to
+        const textureImageIndexMap = context.imageIndexMap;
+        for (const tex of textures) {
+            const prop = tex.getExtension(NEEDLE_PROGRESSIVE_TEXTURE_EXTENSION_NAME);
+            if (prop && prop.model) {
+                // 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) {
+                        def.extensions = def.extensions || {};
+                        def.extensions[NEEDLE_PROGRESSIVE_TEXTURE_EXTENSION_NAME] = prop.model;
+                    }
+                }
+            }
+        }
+        return this;
+    }
+}
+export class NEEDLE_progressive_texture_property extends ExtensionProperty {
+    static EXTENSION_NAME = NEEDLE_PROGRESSIVE_TEXTURE_EXTENSION_NAME;
+    extensionName = NEEDLE_PROGRESSIVE_TEXTURE_EXTENSION_NAME;
+    parentTypes = [PropertyType.TEXTURE];
+    propertyType = "progressive_texture";
+    init() { }
+    model;
+}

package/dist/extensions/NEEDLE_progressive/index.d.ts

@@ -0,0 +1 @@
+export * from "./NEEDLE_progressive.js";

package/dist/extensions/NEEDLE_progressive/index.js

@@ -0,0 +1 @@
+export * from "./NEEDLE_progressive.js";

package/dist/extensions/NEEDLE_progressive_texture_settings/index.d.ts

@@ -0,0 +1,21 @@
+import { Extension, ExtensionProperty, PropertyType, ReaderContext, WriterContext } from "@gltf-transform/core";
+export declare interface IProgressiveTextureSettings {
+    maxSize: number;
+    guid: string;
+}
+export declare class NEEDLE_progressive_texture_settings extends Extension {
+    static EXTENSION_NAME: string;
+    extensionName: string;
+    read(context: ReaderContext): this;
+    write(context: WriterContext): this;
+}
+export declare class NEEDLE_progressive_texture_settings_property extends ExtensionProperty implements IProgressiveTextureSettings {
+    static EXTENSION_NAME: string;
+    readonly extensionName: string;
+    parentTypes: PropertyType[];
+    propertyType: string;
+    init(): void;
+    get isValid(): boolean;
+    maxSize: number;
+    guid: string;
+}

package/dist/extensions/NEEDLE_progressive_texture_settings/index.js

@@ -0,0 +1,39 @@
+import { Extension, ExtensionProperty, PropertyType } from "@gltf-transform/core";
+// TODO: rename to NEEDLE_progressive_texture
+const EXTENSION_NAME = "NEEDLE_progressive_texture_settings";
+export class NEEDLE_progressive_texture_settings extends Extension {
+    static EXTENSION_NAME = EXTENSION_NAME;
+    extensionName = EXTENSION_NAME;
+    read(context) {
+        const textureDefinitions = context.jsonDoc.json.textures;
+        if (!textureDefinitions)
+            return this;
+        const root = this.document.getRoot();
+        const textures = root.listTextures();
+        for (let i = 0; i < textureDefinitions.length; i++) {
+            const texDef = textureDefinitions[i];
+            if (texDef.extensions && texDef.extensions[EXTENSION_NAME]) {
+                const ext = texDef.extensions[EXTENSION_NAME];
+                const prop = new NEEDLE_progressive_texture_settings_property(this.document.getGraph(), "");
+                Object.assign(prop, ext);
+                textures[i].setExtension(EXTENSION_NAME, prop);
+            }
+        }
+        return this;
+    }
+    write(context) {
+        return this;
+    }
+}
+export class NEEDLE_progressive_texture_settings_property extends ExtensionProperty {
+    static EXTENSION_NAME = EXTENSION_NAME;
+    extensionName = EXTENSION_NAME;
+    parentTypes = [PropertyType.TEXTURE];
+    propertyType = EXTENSION_NAME;
+    init() { }
+    get isValid() {
+        return this.maxSize !== undefined && this.maxSize > 0;
+    }
+    maxSize;
+    guid;
+}

package/dist/extensions/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./NEEDLE_opaque/index.js";
+export * from "./NEEDLE_mesh_compression/index.js";
+export * from "./NEEDLE_compression_texture/index.js";
+export * from "./NEEDLE_progressive/index.js";
+export * from "./NEEDLE_progressive_texture_settings/index.js";
+export declare function registerExtensions(node: any): void;

package/dist/extensions/index.js

@@ -0,0 +1,16 @@
+// export * from "./extension.js";
+export * from "./NEEDLE_opaque/index.js";
+export * from "./NEEDLE_mesh_compression/index.js";
+export * from "./NEEDLE_compression_texture/index.js";
+export * from "./NEEDLE_progressive/index.js";
+export * from "./NEEDLE_progressive_texture_settings/index.js";
+import { ALL_EXTENSIONS } from '@gltf-transform/extensions';
+import { ALL_EXTENSIONS as NEEDLE_EXTENSIONS } from "./NEEDLE_opaque/index.js";
+import { NEEDLE_progressive } from './NEEDLE_progressive/index.js';
+export function registerExtensions(node) {
+    node.registerExtensions(ALL_EXTENSIONS);
+    node.registerExtensions(NEEDLE_EXTENSIONS);
+    node.registerExtensions([
+        NEEDLE_progressive
+    ]);
+}

package/dist/extensions/utils.d.ts

@@ -0,0 +1,6 @@
+import { ReaderContext, Texture, WriterContext } from '@gltf-transform/core';
+import { GLTF } from '@gltf-transform/core';
+export declare function tryGetInArray<T>(arr: Array<T> | undefined | null, index: number | undefined): T | null;
+export declare function writeExtension(prop: GLTF.IProperty | null, name: string, ext: any): void;
+export declare function getTexture(context: ReaderContext, tex: GLTF.ITexture): Texture;
+export declare function getTextureDefinition(context: WriterContext | ReaderContext, tex: Texture): GLTF.ITexture | null;

package/dist/extensions/utils.js

@@ -0,0 +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;
+}

package/dist/functions/list-texture-slots.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/functions/list-texture-slots.js

@@ -0,0 +1,35 @@
+export {};
+// TODO: remove once this is resolved: https://github.com/donmccurdy/glTF-Transform/issues/855
+// modified to take a document as a parameter
+// export function listTextureSlots(texture: Texture, document: Document): string[] {
+//     const root = document.getRoot();
+//     const slots = texture
+//         .getGraph()
+//         .listParentEdges(texture)
+//         .filter((edge) => edge.getParent() !== root)
+//         .map((edge) => edge.getName());
+//     return Array.from(new Set(slots));
+// }
+// export function getTextureChannelMask(texture: Texture, document: Document): number {
+//     let mask = 0x0000;
+//     for (const edge of document.getGraph().listParentEdges(texture)) {
+//         const parent = edge.getParent();
+//         let { channels } = edge.getAttributes() as { channels: number | undefined };
+//         if (
+//             channels &&
+//             edge.getName() === 'baseColorTexture' &&
+//             parent instanceof Material &&
+//             parent.getAlphaMode() === Material.AlphaMode.OPAQUE
+//         ) {
+//             channels &= ~TextureChannel.A;
+//         }
+//         if (channels) {
+//             mask |= channels;
+//             continue;
+//         }
+//         if (parent.propertyType !== PropertyType.ROOT) {
+//             document.getLogger().warn(`Missing attribute ".channels" on edge, "${edge.getName()}".`);
+//         }
+//     }
+//     return mask;
+// }

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./utils/index.js";
+export * from "./transforms/index.js";
+export * from "./extensions/index.js";

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from "./utils/index.js";
+export * from "./transforms/index.js";
+export * from "./extensions/index.js";

package/dist/transforms/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./needle_asset.js";
+export * from "./toktx.js";
+export * from "./needle_toktx.js";
+export * from "./needle_progressive.js";
+export * from "./needle_webp.js";
+export * from "./needle_mesh_transform.js";
+export * from "./needle_common.js";
+export * from "./needle_texture_transform.js";
+export * from "./needle_animation_transform.js";

package/dist/transforms/index.js

@@ -0,0 +1,9 @@
+export * from "./needle_asset.js";
+export * from "./toktx.js";
+export * from "./needle_toktx.js";
+export * from "./needle_progressive.js";
+export * from "./needle_webp.js";
+export * from "./needle_mesh_transform.js";
+export * from "./needle_common.js";
+export * from "./needle_texture_transform.js";
+export * from "./needle_animation_transform.js";

package/dist/transforms/needle_animation_transform.d.ts

@@ -0,0 +1,2 @@
+import { Transform } from "@gltf-transform/core";
+export declare const needle_animation_transform: (_options: any) => Transform;

package/dist/transforms/needle_animation_transform.js

@@ -0,0 +1,5 @@
+export const needle_animation_transform = function (_options) {
+    // return resample();
+    return (document, _context) => {
+    };
+};

package/dist/transforms/needle_asset.d.ts

@@ -0,0 +1,2 @@
+import { Transform } from '@gltf-transform/core';
+export declare function needle_asset(): Transform;

package/dist/transforms/needle_asset.js

@@ -0,0 +1,28 @@
+import { createTransform } from '@gltf-transform/functions';
+import { existsSync, readFileSync } from 'fs';
+let version = undefined;
+export function needle_asset() {
+    return createTransform("needle_asset_transform", (document) => {
+        const root = document.getRoot();
+        const asset = root.getAsset();
+        if (asset) {
+            if (version === undefined) {
+                version = null;
+                const path = process.cwd() + "/package.json";
+                if (existsSync(path)) {
+                    const packageJson = readFileSync(path, "utf8");
+                    const packageVersion = JSON.parse(packageJson).version;
+                    version = packageVersion ?? null;
+                }
+                else
+                    console.log("Could not find package.json at " + path);
+            }
+            if (!asset.generator.startsWith("Needle glTF Build Pipeline")) {
+                asset.generator = "Needle glTF Build Pipeline";
+                if (version?.length > 0) {
+                    asset.generator += " " + version;
+                }
+            }
+        }
+    });
+}

package/dist/transforms/needle_common.d.ts

@@ -0,0 +1,11 @@
+import { Document, Texture } from '@gltf-transform/core';
+import { NEEDLE_compression_texture_schema } from '../extensions/index.js';
+export interface NeedleTransformContext {
+    useCache: boolean;
+    noToktx: boolean;
+}
+export interface INeedleTextureTransformContext {
+    prepare(document: Document): Promise<void>;
+    process(index: number, texture: Texture, settings: NEEDLE_compression_texture_schema): Promise<boolean>;
+    finalize(document: Document): Promise<void>;
+}

package/dist/transforms/needle_common.js

@@ -0,0 +1 @@
+export {};

package/dist/transforms/needle_mesh_transform.d.ts

@@ -0,0 +1,3 @@
+import { Transform } from "@gltf-transform/core";
+import { SimplifyOptions } from "@gltf-transform/functions";
+export declare const needle_mesh_transform: (_options: SimplifyOptions) => Transform;

package/dist/transforms/needle_mesh_transform.js

@@ -0,0 +1,83 @@
+import { Primitive } from "@gltf-transform/core";
+import { simplifyPrimitive, SIMPLIFY_DEFAULTS, weldPrimitive, WELD_DEFAULTS } from "@gltf-transform/functions";
+import { MeshoptSimplifier } from "meshoptimizer";
+import { NEEDLE_mesh_compression } from "../extensions/index.js";
+const NAME = 'needle_simplify';
+export const needle_mesh_transform = function (_options) {
+    const simplifier = MeshoptSimplifier;
+    if (!simplifier) {
+        throw new Error(`${NAME}: simplifier dependency required — install "meshoptimizer".`);
+    }
+    return (document, _context) => {
+        const logger = document.getLogger();
+        const options = { ...SIMPLIFY_DEFAULTS, ..._options };
+        const weldOptions = {
+            ...WELD_DEFAULTS,
+            tolerance: 0.00000000001,
+            overwrite: true,
+        };
+        for (const mesh of document.getRoot().listMeshes()) {
+            for (const prim of mesh.listPrimitives()) {
+                // TODO: mesh compression caching
+                // const key = getKey(prim);
+                // const cached = tryGetFromCache(key);
+                // if (cached) {
+                //     logger.debug(`${NAME}: Skipping primitive of mesh "${mesh.getName()}": Already cached.`);
+                //     continue;
+                // }
+                // updatePrimitive(prim, simplifier, null, prim.getIndices());
+                // continue;
+                const ext = prim.getExtension(NEEDLE_mesh_compression.EXTENSION_NAME);
+                const mesh_compression = ext?.model;
+                const simplifyOpts = { ...options };
+                if (!ext) {
+                    // If no extension exists on the primitive dont apply any simplification
+                    continue;
+                }
+                if (mesh_compression) {
+                    // Dont run if useSimplifier is turned off explictly
+                    if (mesh_compression.useSimplifier === false) {
+                        logger.debug(`${NAME}: Skipping primitive of mesh "${mesh.getName()}": useSimplifier is false.`);
+                        continue;
+                    }
+                    if (mesh_compression.error >= 0)
+                        simplifyOpts.error = mesh_compression.error;
+                    if (mesh_compression.ratio >= 0)
+                        simplifyOpts.ratio = mesh_compression.ratio;
+                    simplifyOpts.lockBorder = mesh_compression.lockBorder;
+                }
+                if (prim.getMode() !== Primitive.Mode.TRIANGLES) {
+                    logger.warn(`${NAME}: Skipping primitive of mesh "${mesh.getName()}": Requires TRIANGLES draw mode.`);
+                    continue;
+                }
+                compressPrimitive(document, mesh, prim, weldOptions, simplifyOpts);
+            }
+        }
+    };
+};
+function compressPrimitive(document, mesh, prim, weldOptions, meshOptions) {
+    const logger = document.getLogger();
+    logger.debug(`${NAME}: Welding primitive of mesh "${mesh.getName()}" → tolerance: ${weldOptions.tolerance}`);
+    weldPrimitive(document, prim, weldOptions);
+    logger.debug(`${NAME}: Simplifying primitive of mesh "${mesh.getName()}" → ratio: ${meshOptions.ratio}, error: ${meshOptions.error}, lockBorder: ${meshOptions.lockBorder}`);
+    simplifyPrimitive(document, prim, meshOptions);
+}
+// function updatePrimitive(prim: Primitive, simplifier: any, positionArray, dstIndicesArray) {
+// 	const position = prim.getAttribute('POSITION')!;
+// 	const srcIndices = prim.getIndices()!;
+// 	const srcVertexCount = position.getCount();
+//     const [remap, unique] = simplifier.compactMesh(dstIndicesArray);
+//     // logger.debug(`${NAME}: ${formatDeltaOp(position.getCount(), unique)} vertices, error: ${error.toFixed(4)}.`);
+//     // (3) Write vertex attributes.
+//     for (const srcAttribute of deepListAttributes(prim)) {
+//         const dstAttribute = srcAttribute.clone();
+//         remapAttribute(dstAttribute, remap, unique);
+//         deepSwapAttribute(prim, srcAttribute, dstAttribute);
+//         if (srcAttribute.listParents().length === 1) srcAttribute.dispose();
+//     }
+//     // (4) Write indices.
+//     const dstIndices = srcIndices.clone();
+//     dstIndices.setArray(srcVertexCount <= 65534 ? new Uint16Array(dstIndicesArray) : dstIndicesArray);
+//     prim.setIndices(dstIndices);
+//     if (srcIndices.listParents().length === 1) srcIndices.dispose();
+// }

package/dist/transforms/needle_progressive.d.ts

@@ -0,0 +1,34 @@
+import { ILogger, Texture, Transform, vec2 } from '@gltf-transform/core';
+declare interface ProgressiveOptions {
+    path: string | Array<string>;
+    debug?: boolean;
+    useCache?: boolean;
+}
+export declare function make_progressive(opts: ProgressiveOptions): Promise<void>;
+export declare function createTransform(name: string, fn: Transform): Transform;
+export declare function make_progressive_textures(filePath: string, _options?: TextureResizeOptions, opts?: ProgressiveOptions): Transform;
+/** Options for the {@link textureResize} function. */
+export interface TextureResizeOptions {
+    /**
+     * Maximum width/height to enforce, preserving aspect ratio. For example,
+     * a 4096x8192 texture, resized with limit [2048, 2048] will be reduced
+     * to 1024x2048.
+     */
+    size: vec2;
+    /** Resampling filter method. LANCZOS3 is sharper, LANCZOS2 is smoother. */
+    filter?: TextureResizeFilter;
+    /** Pattern identifying textures to resize, matched to name or URI. */
+    pattern?: RegExp | null;
+    /** Pattern to match slots usage for resizing. */
+    slots?: RegExp | null;
+}
+/** Resampling filter methods. LANCZOS3 is sharper, LANCZOS2 is smoother. */
+export declare enum TextureResizeFilter {
+    /** Lanczos3 (sharp) */
+    LANCZOS3 = "lanczos3",
+    /** Lanczos2 (smooth) */
+    LANCZOS2 = "lanczos2"
+}
+export declare const TEXTURE_RESIZE_DEFAULTS: TextureResizeOptions;
+export declare function resizeTextureToMax(texture: Texture, maxSize: number, logger: ILogger): Promise<void>;
+export {};