@needle-tools/gltf-build-pipeline 2.2.1-alpha.2 → 2.2.1-alpha.4

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

@@ -1,3 +1,3 @@
-import { Extension } from "@gltf-transform/core";
-export * from "./NEEDLE_opaque.js";
-export declare const ALL_EXTENSIONS: (typeof Extension)[];
+import { Extension } from "@gltf-transform/core";
+export * from "./NEEDLE_opaque.js";
+export declare const ALL_EXTENSIONS: (typeof Extension)[];

package/dist/extensions/NEEDLE_opaque/index.js

@@ -1,28 +1,28 @@
-import { PropertyType } from "@gltf-transform/core";
-import { createOpaqueExtension } from "./NEEDLE_opaque.js";
-export * from "./NEEDLE_opaque.js";
-const opaqueOptions = {
-    debug: process.argv.includes("debug"),
-};
-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, PropertyType.MESH], { ...opaqueOptions }),
-    createOpaqueExtension("EXT_texture_exr", [PropertyType.TEXTURE], { ...opaqueOptions }),
-    createOpaqueExtension("NEEDLE_editor", [PropertyType.NODE, PropertyType.MATERIAL], { ...opaqueOptions }),
-    createOpaqueExtension("NEEDLE_gltf_dependencies", [PropertyType.ROOT], { ...opaqueOptions }),
-    // VRM 0.0
-    createOpaqueExtension("VRM", [PropertyType.ROOT], { ...opaqueOptions }),
-    // VRM 1.0 https://vrm.dev/en/vrm1/changed/
-    createOpaqueExtension("VRMC_vrm", [PropertyType.ROOT], { ...opaqueOptions }),
-    createOpaqueExtension("VRMC_springBone", [PropertyType.ROOT], { ...opaqueOptions }),
-    createOpaqueExtension("VRMC_node_constraint", [PropertyType.NODE], { ...opaqueOptions }),
-    // TODO: mtoon materials don't work yet
-    // createOpaqueExtension("VRMC_materials_mtoon", [PropertyType.MATERIAL], { ...opaqueOptions, debug: true, breakpoint: "pointer:read" },),
-];
+import { PropertyType } from "@gltf-transform/core";
+import { createOpaqueExtension } from "./NEEDLE_opaque.js";
+export * from "./NEEDLE_opaque.js";
+const opaqueOptions = {
+    debug: process.argv.includes("debug"),
+};
+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, PropertyType.MESH], { ...opaqueOptions }),
+    createOpaqueExtension("EXT_texture_exr", [PropertyType.TEXTURE], { ...opaqueOptions }),
+    createOpaqueExtension("NEEDLE_editor", [PropertyType.NODE, PropertyType.MATERIAL], { ...opaqueOptions }),
+    createOpaqueExtension("NEEDLE_gltf_dependencies", [PropertyType.ROOT], { ...opaqueOptions }),
+    // VRM 0.0
+    createOpaqueExtension("VRM", [PropertyType.ROOT], { ...opaqueOptions }),
+    // VRM 1.0 https://vrm.dev/en/vrm1/changed/
+    createOpaqueExtension("VRMC_vrm", [PropertyType.ROOT], { ...opaqueOptions }),
+    createOpaqueExtension("VRMC_springBone", [PropertyType.ROOT], { ...opaqueOptions }),
+    createOpaqueExtension("VRMC_node_constraint", [PropertyType.NODE], { ...opaqueOptions }),
+    // TODO: mtoon materials don't work yet
+    // createOpaqueExtension("VRMC_materials_mtoon", [PropertyType.MATERIAL], { ...opaqueOptions, debug: true, breakpoint: "pointer:read" },),
+];

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

@@ -1,48 +1,48 @@
-import { Extension, ExtensionProperty, PropertyType, ReaderContext, WriterContext } from "@gltf-transform/core";
-export declare const NEEDLE_PROGRESSIVE_EXTENSION_NAME = "NEEDLE_progressive";
-export type ProgressiveLoadingInfo = {
-    /** guid of the asset the LODs belong to */
-    guid: string;
-    /** lod infos and paths */
-    lods?: Array<LodInfo>;
-};
-type LodInfo = {
-    /** Relative path to the LOD file */
-    path: string;
-    /**  Hash of the LOD file. It has been generated using the file content and settings */
-    hash: string;
-};
-export type ProgressiveTextureLodEntry = LodInfo & {
-    width: number;
-    height: number;
-};
-export type ProgressiveTextureModel = ProgressiveLoadingInfo & {
-    lods?: Array<ProgressiveTextureLodEntry>;
-};
-export type ProgressiveMeshModel = ProgressiveLoadingInfo & {
-    /** LOD0 vertex density. TODO: remove this since we now have a LODs array. This is just for supporting older engine versions */
-    density: number;
-    lods?: Array<LodInfo & {
-        /** Mesh vertex density */
-        density: number;
-        vertexCount: number;
-        indexCount: number;
-    }>;
-};
-export declare class NEEDLE_progressive extends Extension {
-    static EXTENSION_NAME: string;
-    extensionName: string;
-    createTexture(data: ProgressiveTextureModel): NEEDLE_progressive_property;
-    createMesh(data: ProgressiveMeshModel): NEEDLE_progressive_property;
-    read(_context: ReaderContext): this;
-    write(context: WriterContext): this;
-}
-export declare class NEEDLE_progressive_property extends ExtensionProperty {
-    static EXTENSION_NAME: string;
-    readonly extensionName: string;
-    parentTypes: PropertyType[];
-    propertyType: string;
-    init(): void;
-    model: ProgressiveLoadingInfo;
-}
-export {};
+import { Extension, ExtensionProperty, PropertyType, ReaderContext, WriterContext } from "@gltf-transform/core";
+export declare const NEEDLE_PROGRESSIVE_EXTENSION_NAME = "NEEDLE_progressive";
+export type ProgressiveLoadingInfo = {
+    /** guid of the asset the LODs belong to */
+    guid: string;
+    /** lod infos and paths */
+    lods?: Array<LodInfo>;
+};
+type LodInfo = {
+    /** Relative path to the LOD file */
+    path: string;
+    /**  Hash of the LOD file. It has been generated using the file content and settings */
+    hash: string;
+};
+export type ProgressiveTextureLodEntry = LodInfo & {
+    width: number;
+    height: number;
+};
+export type ProgressiveTextureModel = ProgressiveLoadingInfo & {
+    lods?: Array<ProgressiveTextureLodEntry>;
+};
+export type ProgressiveMeshModel = ProgressiveLoadingInfo & {
+    /** LOD0 vertex density. TODO: remove this since we now have a LODs array. This is just for supporting older engine versions */
+    density: number;
+    lods?: Array<LodInfo & {
+        /** Mesh vertex density */
+        density: number;
+        vertexCount: number;
+        indexCount: number;
+    }>;
+};
+export declare class NEEDLE_progressive extends Extension {
+    static EXTENSION_NAME: string;
+    extensionName: string;
+    createTexture(data: ProgressiveTextureModel): NEEDLE_progressive_property;
+    createMesh(data: ProgressiveMeshModel): NEEDLE_progressive_property;
+    read(_context: ReaderContext): this;
+    write(context: WriterContext): this;
+}
+export declare class NEEDLE_progressive_property extends ExtensionProperty {
+    static EXTENSION_NAME: string;
+    readonly extensionName: string;
+    parentTypes: PropertyType[];
+    propertyType: string;
+    init(): void;
+    model: ProgressiveLoadingInfo;
+}
+export {};

package/dist/extensions/NEEDLE_progressive/NEEDLE_progressive.js

@@ -1,69 +1,69 @@
-import { Extension, ExtensionProperty, PropertyType } from "@gltf-transform/core";
-// TODO: rename to NEEDLE_progressive_texture
-export const NEEDLE_PROGRESSIVE_EXTENSION_NAME = "NEEDLE_progressive";
-export class NEEDLE_progressive extends Extension {
-    static EXTENSION_NAME = NEEDLE_PROGRESSIVE_EXTENSION_NAME;
-    extensionName = NEEDLE_PROGRESSIVE_EXTENSION_NAME;
-    createTexture(data) {
-        const ext = new NEEDLE_progressive_property(this.document.getGraph());
-        ext.model = data;
-        return ext;
-    }
-    createMesh(data) {
-        const ext = new NEEDLE_progressive_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 root = this.document.getRoot();
-        const textureDefinitions = context.jsonDoc.json.textures;
-        if (textureDefinitions.length) {
-            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_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_EXTENSION_NAME] = prop.model;
-                        }
-                    }
-                }
-            }
-        }
-        const meshDefinitions = context.jsonDoc.json.meshes;
-        if (meshDefinitions?.length) {
-            const meshIndexMap = context.meshIndexMap;
-            const meshes = root.listMeshes();
-            for (let i = 0; i < meshes.length; i++) {
-                const mesh = meshes[i];
-                const meshIndex = meshIndexMap.get(mesh);
-                const meshExt = mesh.getExtension(NEEDLE_PROGRESSIVE_EXTENSION_NAME);
-                if (meshExt && meshExt.model) {
-                    const meshDef = meshDefinitions[meshIndex];
-                    meshDef.extensions = meshDef.extensions || {};
-                    meshDef.extensions[NEEDLE_PROGRESSIVE_EXTENSION_NAME] = meshExt.model;
-                }
-            }
-        }
-        return this;
-    }
-}
-export class NEEDLE_progressive_property extends ExtensionProperty {
-    static EXTENSION_NAME = NEEDLE_PROGRESSIVE_EXTENSION_NAME;
-    extensionName = NEEDLE_PROGRESSIVE_EXTENSION_NAME;
-    parentTypes = [PropertyType.TEXTURE, PropertyType.MESH];
-    propertyType = "progressive_texture";
-    init() { }
-    model;
-}
+import { Extension, ExtensionProperty, PropertyType } from "@gltf-transform/core";
+// TODO: rename to NEEDLE_progressive_texture
+export const NEEDLE_PROGRESSIVE_EXTENSION_NAME = "NEEDLE_progressive";
+export class NEEDLE_progressive extends Extension {
+    static EXTENSION_NAME = NEEDLE_PROGRESSIVE_EXTENSION_NAME;
+    extensionName = NEEDLE_PROGRESSIVE_EXTENSION_NAME;
+    createTexture(data) {
+        const ext = new NEEDLE_progressive_property(this.document.getGraph());
+        ext.model = data;
+        return ext;
+    }
+    createMesh(data) {
+        const ext = new NEEDLE_progressive_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 root = this.document.getRoot();
+        const textureDefinitions = context.jsonDoc.json.textures;
+        if (textureDefinitions.length) {
+            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_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_EXTENSION_NAME] = prop.model;
+                        }
+                    }
+                }
+            }
+        }
+        const meshDefinitions = context.jsonDoc.json.meshes;
+        if (meshDefinitions?.length) {
+            const meshIndexMap = context.meshIndexMap;
+            const meshes = root.listMeshes();
+            for (let i = 0; i < meshes.length; i++) {
+                const mesh = meshes[i];
+                const meshIndex = meshIndexMap.get(mesh);
+                const meshExt = mesh.getExtension(NEEDLE_PROGRESSIVE_EXTENSION_NAME);
+                if (meshExt && meshExt.model) {
+                    const meshDef = meshDefinitions[meshIndex];
+                    meshDef.extensions = meshDef.extensions || {};
+                    meshDef.extensions[NEEDLE_PROGRESSIVE_EXTENSION_NAME] = meshExt.model;
+                }
+            }
+        }
+        return this;
+    }
+}
+export class NEEDLE_progressive_property extends ExtensionProperty {
+    static EXTENSION_NAME = NEEDLE_PROGRESSIVE_EXTENSION_NAME;
+    extensionName = NEEDLE_PROGRESSIVE_EXTENSION_NAME;
+    parentTypes = [PropertyType.TEXTURE, PropertyType.MESH];
+    propertyType = "progressive_texture";
+    init() { }
+    model;
+}

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

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

package/dist/extensions/NEEDLE_progressive/index.js

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

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

@@ -1,23 +1,23 @@
-import { Extension, ExtensionProperty, PropertyType, ReaderContext, WriterContext } from "@gltf-transform/core";
-export declare interface IProgressiveMeshSettings {
-    /**
-     * When false no LODs will be generated for this mesh
-     */
-    generateLods: boolean;
-    guid: string;
-}
-export declare class NEEDLE_progressive_mesh_settings extends Extension {
-    static EXTENSION_NAME: string;
-    extensionName: string;
-    read(context: ReaderContext): this;
-    write(context: WriterContext): this;
-}
-export declare class NEEDLE_progressive_mesh_settings_property extends ExtensionProperty implements IProgressiveMeshSettings {
-    static EXTENSION_NAME: string;
-    readonly extensionName: string;
-    parentTypes: PropertyType[];
-    propertyType: string;
-    init(): void;
-    generateLods: boolean;
-    guid: string;
-}
+import { Extension, ExtensionProperty, PropertyType, ReaderContext, WriterContext } from "@gltf-transform/core";
+export declare interface IProgressiveMeshSettings {
+    /**
+     * When false no LODs will be generated for this mesh
+     */
+    generateLods: boolean;
+    guid: string;
+}
+export declare class NEEDLE_progressive_mesh_settings extends Extension {
+    static EXTENSION_NAME: string;
+    extensionName: string;
+    read(context: ReaderContext): this;
+    write(context: WriterContext): this;
+}
+export declare class NEEDLE_progressive_mesh_settings_property extends ExtensionProperty implements IProgressiveMeshSettings {
+    static EXTENSION_NAME: string;
+    readonly extensionName: string;
+    parentTypes: PropertyType[];
+    propertyType: string;
+    init(): void;
+    generateLods: boolean;
+    guid: string;
+}

package/dist/extensions/NEEDLE_progressive_mesh_settings/index.js

@@ -1,41 +1,41 @@
-import { Extension, ExtensionProperty, PropertyType } from "@gltf-transform/core";
-const EXTENSION_NAME = "NEEDLE_progressive_mesh_settings";
-export class NEEDLE_progressive_mesh_settings extends Extension {
-    static EXTENSION_NAME = EXTENSION_NAME;
-    extensionName = EXTENSION_NAME;
-    read(context) {
-        const definitions = context.jsonDoc.json.meshes;
-        if (!definitions)
-            return this;
-        const root = this.document.getRoot();
-        const meshes = root.listMeshes();
-        for (let i = 0; i < definitions.length; i++) {
-            const def = definitions[i];
-            if (def.extensions && def.extensions[EXTENSION_NAME]) {
-                const ext = def.extensions[EXTENSION_NAME];
-                const prop = new NEEDLE_progressive_mesh_settings_property(this.document.getGraph(), "");
-                Object.assign(prop, ext);
-                let index = i;
-                const mesh = meshes[index];
-                if (mesh)
-                    mesh.setExtension(EXTENSION_NAME, prop);
-                else {
-                    console.warn(`WARN: Progressive mesh at index ${i} was not found in the glTF file. This might result in falsely loaded textures for ${ext.guid} / name \"${def.name}\"`);
-                }
-            }
-        }
-        return this;
-    }
-    write(context) {
-        return this;
-    }
-}
-export class NEEDLE_progressive_mesh_settings_property extends ExtensionProperty {
-    static EXTENSION_NAME = EXTENSION_NAME;
-    extensionName = EXTENSION_NAME;
-    parentTypes = [PropertyType.MESH];
-    propertyType = EXTENSION_NAME;
-    init() { }
-    generateLods;
-    guid;
-}
+import { Extension, ExtensionProperty, PropertyType } from "@gltf-transform/core";
+const EXTENSION_NAME = "NEEDLE_progressive_mesh_settings";
+export class NEEDLE_progressive_mesh_settings extends Extension {
+    static EXTENSION_NAME = EXTENSION_NAME;
+    extensionName = EXTENSION_NAME;
+    read(context) {
+        const definitions = context.jsonDoc.json.meshes;
+        if (!definitions)
+            return this;
+        const root = this.document.getRoot();
+        const meshes = root.listMeshes();
+        for (let i = 0; i < definitions.length; i++) {
+            const def = definitions[i];
+            if (def.extensions && def.extensions[EXTENSION_NAME]) {
+                const ext = def.extensions[EXTENSION_NAME];
+                const prop = new NEEDLE_progressive_mesh_settings_property(this.document.getGraph(), "");
+                Object.assign(prop, ext);
+                let index = i;
+                const mesh = meshes[index];
+                if (mesh)
+                    mesh.setExtension(EXTENSION_NAME, prop);
+                else {
+                    console.warn(`WARN: Progressive mesh at index ${i} was not found in the glTF file. This might result in falsely loaded textures for ${ext.guid} / name \"${def.name}\"`);
+                }
+            }
+        }
+        return this;
+    }
+    write(context) {
+        return this;
+    }
+}
+export class NEEDLE_progressive_mesh_settings_property extends ExtensionProperty {
+    static EXTENSION_NAME = EXTENSION_NAME;
+    extensionName = EXTENSION_NAME;
+    parentTypes = [PropertyType.MESH];
+    propertyType = EXTENSION_NAME;
+    init() { }
+    generateLods;
+    guid;
+}

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

@@ -1,25 +1,25 @@
-import { Extension, ExtensionProperty, PropertyType, ReaderContext, WriterContext } from "@gltf-transform/core";
-export declare interface IProgressiveTextureSettings {
-    /**
-     * When false the texture no progressive texture will be generated
-     */
-    generateLods?: boolean;
-    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;
-}
+import { Extension, ExtensionProperty, PropertyType, ReaderContext, WriterContext } from "@gltf-transform/core";
+export declare interface IProgressiveTextureSettings {
+    /**
+     * When false the texture no progressive texture will be generated
+     */
+    generateLods?: boolean;
+    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

@@ -1,67 +1,67 @@
-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();
-        /**
-         * If a texture is used in multiple slots it only appears once in the gltf-transform list
-         * So we have to store the key and the index of the texture in the list
-         */
-        const textureMap = new Map();
-        let offset = 0;
-        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);
-                let textureIndex = i - offset;
-                const key = ext.guid;
-                if (textureMap.has(key)) {
-                    // we keep a track of the index offset assuming gltf-transform textures order is the same as the texture definition order. This is by no means *not* bullet-proof but I'm not sure how to do it properly right now
-                    // Perhaps we could try to find the texture with the same image source binary array as defined in the texture definition but this would also not be perfect I think...
-                    // TODO: find a better way to handle texture definition count and texture count mismatch due to a texture being used in multiple slots (where gltf-transform optimizes the texture list and removes duplicates) 
-                    offset += 1;
-                    // textureIndex = textureMap.get(key);
-                    console.log(`INFO: Progressive texture extension was ${i} already found...`);
-                    continue;
-                }
-                else {
-                    textureMap.set(key, textureIndex);
-                }
-                const tex = textures[textureIndex];
-                if (tex)
-                    tex.setExtension(EXTENSION_NAME, prop);
-                else {
-                    // console.log(textureDefinitions)
-                    console.warn(`WARN: Progressive texture at index ${i} was not found in the glTF file. This might result in falsely loaded textures for ${ext.guid} / name \"${texDef.name}\"`);
-                    // if(debug)
-                    // throw new Error(`Progressive texture at index ${i} was not found in the glTF file.`)
-                }
-            }
-        }
-        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;
-}
+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();
+        /**
+         * If a texture is used in multiple slots it only appears once in the gltf-transform list
+         * So we have to store the key and the index of the texture in the list
+         */
+        const textureMap = new Map();
+        let offset = 0;
+        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);
+                let textureIndex = i - offset;
+                const key = ext.guid;
+                if (textureMap.has(key)) {
+                    // we keep a track of the index offset assuming gltf-transform textures order is the same as the texture definition order. This is by no means *not* bullet-proof but I'm not sure how to do it properly right now
+                    // Perhaps we could try to find the texture with the same image source binary array as defined in the texture definition but this would also not be perfect I think...
+                    // TODO: find a better way to handle texture definition count and texture count mismatch due to a texture being used in multiple slots (where gltf-transform optimizes the texture list and removes duplicates) 
+                    offset += 1;
+                    // textureIndex = textureMap.get(key);
+                    console.log(`INFO: Progressive texture extension was ${i} already found...`);
+                    continue;
+                }
+                else {
+                    textureMap.set(key, textureIndex);
+                }
+                const tex = textures[textureIndex];
+                if (tex)
+                    tex.setExtension(EXTENSION_NAME, prop);
+                else {
+                    // console.log(textureDefinitions)
+                    console.warn(`WARN: Progressive texture at index ${i} was not found in the glTF file. This might result in falsely loaded textures for ${ext.guid} / name \"${texDef.name}\"`);
+                    // if(debug)
+                    // throw new Error(`Progressive texture at index ${i} was not found in the glTF file.`)
+                }
+            }
+        }
+        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

@@ -1,7 +1,7 @@
-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 * from "./NEEDLE_progressive_mesh_settings/index.js";
-export declare function registerExtensions(node: any): void;
+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 * from "./NEEDLE_progressive_mesh_settings/index.js";
+export declare function registerExtensions(node: any): void;