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

package/dist/transforms/needle_progressive.js

@@ -1,921 +1,921 @@
-import { BufferUtils, Document, NodeIO, PropertyType, TextureChannel, Verbosity } from '@gltf-transform/core';
-import { SIMPLIFY_DEFAULTS, WELD_DEFAULTS, listTextureChannels, listTextureSlots, sparse } from '@gltf-transform/functions';
-import draco3d from 'draco3dgltf';
-import { NEEDLE_PROGRESSIVE_EXTENSION_NAME, NEEDLE_progressive } from "../extensions/NEEDLE_progressive/index.js";
-import { createOpaqueExtension, currentGenerator, NEEDLE_compression_texture, NEEDLE_mesh_compression, NEEDLE_progressive_mesh_settings, NEEDLE_progressive_texture_settings, registerExtensions as registerDefaultExtensions } from '../extensions/index.js';
-import path, { basename, resolve } from 'path';
-import { existsSync, readFileSync, rmSync, statSync, writeFileSync } from 'fs';
-import { addMetaToCache, addToCache, getHash, getKey, tryGetFromCache, tryGetMetaFromCache } from '../cache/index.js';
-import sharp from "sharp";
-import { detectTextureCompressionMode, foreachGLTF, generateGuid, writeNodeIO } from '../utils/index.js';
-import { needle_asset, writeNeedleAsset } from './needle_asset.js';
-import { MeshoptDecoder, MeshoptSimplifier } from 'meshoptimizer';
-import { compressPrimitive } from './needle_mesh_transform.js';
-import { calculateMeshDensity, getMeshInformation } from "../utils/mesh.js";
-export async function make_progressive(opts) {
-    const file = opts.path;
-    let success = true;
-    await foreachGLTF(file, async (f) => {
-        // Should we stop if one file fails?
-        if (!success) {
-            return;
-        }
-        // Don't re-process files that are already LODs
-        if (isMeshLOD(f) || isImageLOD(f)) {
-            console.log(`Progressive Transform: Ignore existing LOD file at ${f}`);
-            return;
-        }
-        const res = await onProcess(f, opts);
-        if (!res)
-            success = false;
-    });
-    return success;
-}
-function registerExtensions(io) {
-    registerDefaultExtensions(io);
-    io.registerExtensions([
-        NEEDLE_progressive,
-        NEEDLE_progressive_texture_settings,
-        NEEDLE_progressive_mesh_settings,
-        NEEDLE_mesh_compression,
-        //@ts-ignore
-        createOpaqueExtension(NEEDLE_compression_texture.EXTENSION_NAME, PropertyType.TEXTURE),
-        //@ts-ignore
-        // createOpaqueExtension(NEEDLE_mesh_compression.EXTENSION_NAME, [PropertyType.ROOT, PropertyType.MESH, PropertyType.PRIMITIVE]),
-    ]);
-}
-async function onProcess(file, opts) {
-    if (!file.endsWith(".glb") && !file.endsWith(".gltf") && !file.endsWith(".vrm")) {
-        console.log("ERR: file is not gltf/glb");
-        return false;
-    }
-    if (!existsSync(file)) {
-        console.log("ERR: file does not exist: " + file);
-        return false;
-    }
-    try {
-        const io = new NodeIO();
-        registerExtensions(io);
-        io.registerDependencies({
-            'meshopt.decoder': MeshoptDecoder,
-            'draco3d.decoder': await draco3d.createDecoderModule(),
-            'draco3d.encoder': await draco3d.createEncoderModule(),
-        });
-        let document = await io.read(file);
-        if (document) {
-            const logger = document.getLogger();
-            //@ts-ignore
-            logger.verbosity = opts.debug || opts.verbose ? Verbosity.DEBUG : Verbosity.WARN;
-            let smallesTextureSize = 128;
-            if (opts.config.usecase === "product") {
-                smallesTextureSize = 512;
-            }
-            const transforms = [
-                needle_asset(),
-            ];
-            if (opts.config?.textures?.lods !== false) {
-                transforms.push(make_progressive_textures(file, { size: [smallesTextureSize, smallesTextureSize] }, opts));
-            }
-            // TODO: progressive meshes aren't supported yet for VRMs
-            const isVRM = file.endsWith(".vrm");
-            if (!isVRM && opts.config?.meshes?.lods !== false) {
-                transforms.push(make_progressive_meshes(file, {}, opts));
-            }
-            else if (isVRM)
-                logger.warn("WARN: Progressive meshes are not supported for VRM files yet");
-            transforms.push(sparse());
-            logger.info("→ Transforming: " + file);
-            await document.transform(...transforms);
-            const filename = file;
-            await writeNodeIO(io, filename, document);
-            opts.results.push(filename);
-            logger.info("← Transforming done: " + filename);
-        }
-    }
-    catch (err) {
-        console.log("ERR: failed to process file \"" + file + "\", Reason: " + err.message, "\nStack:\n" + err.stack);
-        return false;
-    }
-    return true;
-}
-// basic idea:
-// 1. iterate all images that have an extension marking them to be progressively loaded
-// 2. for each image, create a new image that is a downsampled version of the original and create a new gltf that contains the high res texture
-// 3. add extension to low res image containing info about where to find the high res texture
-export function createTransform(name, fn) {
-    Object.defineProperty(fn, 'name', { value: name });
-    return fn;
-}
-const NAME = 'NEEDLE_progressive';
-export function make_progressive_textures(filePath, _options = TEXTURE_RESIZE_DEFAULTS, opts) {
-    const startTime = Date.now();
-    const filename = basename(filePath);
-    const options = { ...TEXTURE_RESIZE_DEFAULTS, ..._options };
-    const directory = path.dirname(filePath);
-    // const fileNameWithoutExtension = path.basename(filePath, path.extname(filePath));
-    const textureLodBasePath = directory + "/";
-    return createTransform(NAME, async (doc) => {
-        const logger = doc.getLogger();
-        if (isLOD(filePath)) {
-            logger.info("Progressive Image Transform: skip lod at " + filePath);
-            return Promise.resolve();
-        }
-        let index = 0;
-        for (const texture of doc.getRoot().listTextures()) {
-            const textureIndex = index++;
-            const name = texture.getName();
-            const uri = texture.getURI();
-            const match = !options.pattern || options.pattern.test(name) || options.pattern.test(uri);
-            if (!match) {
-                logger.debug(`[${NAME}] Skipping, excluded by "pattern" parameter. ${textureIndex}`);
-                continue;
-            }
-            if (texture.getMimeType() !== 'image/png' && texture.getMimeType() !== 'image/jpeg') {
-                logger.warn(`[${NAME}] Skipping, unsupported texture type "${texture.getMimeType()} at ${textureIndex}".`);
-                continue;
-            }
-            const slots = listTextureSlots(texture);
-            if (options.slots && !slots.some((slot) => options.slots?.test(slot))) {
-                logger.debug(`[${NAME}] Skipping, [${slots.join(', ')}] excluded by "slots" parameter. ${textureIndex}`);
-                continue;
-            }
-            let settings = texture.getExtension(NEEDLE_progressive_texture_settings.EXTENSION_NAME);
-            if (!settings) {
-                const size = texture.getSize();
-                if (size?.length >= 2 && size[0] <= options.size[0] && size[1] <= options.size[1]) {
-                    logger.warn(`[${NAME}] Skipping texture[${textureIndex}], no settings found and the texture is already <= ${size[0]}x${size[1]}`);
-                    continue;
-                }
-                else {
-                    settings = {
-                        guid: generateGuid(filename + "_texture_" + index.toString()),
-                        maxSize: _options.size[0],
-                    };
-                    logger.debug(`[${NAME}] No settings found for texture[${index}] - will use default settings (maxSize: ${settings.maxSize}, guid: ${settings.guid})`);
-                }
-            }
-            else if (settings.generateLods === false) {
-                logger.debug(`[${NAME}] Skipping texture[${textureIndex}]: progressive texture disabled`);
-                continue;
-            }
-            if (settings.maxSize == undefined || settings.maxSize <= 0) {
-                logger.warn(`[${NAME}] Skipping texture[${textureIndex}], settings are invalid (maxSize: ${settings.maxSize})`);
-                continue;
-            }
-            const existingExtension = texture.getExtension(NEEDLE_PROGRESSIVE_EXTENSION_NAME);
-            if (existingExtension !== undefined && existingExtension !== null) {
-                logger.debug(`[${NAME}] Skipping, texture is already progressive ${textureIndex}`);
-                continue;
-            }
-            const progressiveExt = doc.createExtension(NEEDLE_progressive);
-            if (!progressiveExt || !progressiveExt.createTexture) {
-                logger.debug(`[${NAME}] Skipping because progressive extension is not available. ${textureIndex}`);
-                continue;
-            }
-            /** This is the current texture's size  */
-            const currentSize = Math.min(...texture.getSize());
-            if (currentSize <= settings.maxSize) {
-                logger.debug(`[${NAME}] Skipping, texture[${textureIndex}] is already smaller than the requested size: ${currentSize}px <= ${settings.maxSize}px`);
-                continue;
-            }
-            const textureGuid = settings.guid?.length ? settings.guid : generateGuid(filename + "_texture_" + index.toString());
-            /** This is the size of the texture that is embedded in the glTF. No LOD should be smaller than this */
-            const maxSize = settings.maxSize;
-            const LOD_LEVEL = new Array();
-            LOD_LEVEL.push({ size: currentSize });
-            let generateLods = true; //opts.config?.usecase === "world";
-            // If lods are enabled in the config
-            // generateLods ||= opts.config?.textures?.lods === true;
-            // // Ensure that texture lods are not disabled by { textures: { lods: false } }
-            // generateLods &&= opts.config?.textures?.lods !== false;
-            if (generateLods) {
-                const LEVEL = 6;
-                let lastSize = currentSize;
-                for (let i = 1; i < LEVEL; i++) {
-                    const size = lastSize * .5;
-                    if (size <= maxSize)
-                        break;
-                    lastSize = size;
-                    LOD_LEVEL.push({ size: size });
-                }
-            }
-            const results = new Array();
-            for (let i = 0; i < LOD_LEVEL.length; i++) {
-                const level = LOD_LEVEL[i];
-                const lodResult = await createTextureLod({
-                    doc,
-                    file: filePath,
-                    basePath: textureLodBasePath,
-                    level: i,
-                    texture,
-                    slots,
-                    guid: textureGuid,
-                    textureIndex,
-                    maxSize: level.size
-                }, opts);
-                if (!lodResult) {
-                    continue;
-                }
-                const { 0: width, 1: height } = lodResult.texture.getSize();
-                const outpath = lodResult?.outpath;
-                const relName = path.relative(directory, outpath);
-                results.push({
-                    path: relName,
-                    hash: lodResult.hash,
-                    width,
-                    height,
-                });
-                opts.results.push(outpath);
-            }
-            const key = getKey(texture);
-            // TODO: this path should be added to the NEEDLE dependencies extension
-            const model = {
-                guid: textureGuid,
-                lods: results,
-            };
-            texture.setExtension(NEEDLE_PROGRESSIVE_EXTENSION_NAME, progressiveExt.createTexture(model));
-            if (opts.useCache) {
-                const cached = tryGetFromCache(key);
-                if (cached) {
-                    logger.debug(`Progressive image ${index}: using cached preview version (size: ${options.size}))`);
-                    texture.setImage(cached);
-                    continue;
-                }
-            }
-            options.size[0] = settings.maxSize;
-            options.size[1] = settings.maxSize;
-            logger.debug(`[${NAME}] Resizing embedded texture[${index}] to ${options.size[0]}x${options.size[1]}`);
-            await resizeTexture(options, texture, logger, uri || name, slots);
-            if (opts?.useCache === false) {
-            }
-            else
-                addToCache(key, texture.getImage());
-        }
-        logger.debug(`Progressive transform finished in ${((Date.now() - startTime) / 1000).toFixed(1)} sec.`);
-    });
-}
-async function createTextureLod(args, opts) {
-    const { doc, file, basePath, level, texture, guid, textureIndex } = args;
-    let slots = args.slots;
-    const logger = doc.getLogger();
-    const newDoc = new Document();
-    writeNeedleAsset(newDoc);
-    const scene = newDoc.createScene();
-    const buffer = newDoc.createBuffer();
-    // add texture
-    const newTexture = newDoc.createTexture();
-    const img = texture.getImage();
-    newTexture.setImage(img);
-    newTexture.setURI(texture.getURI());
-    newTexture.setMimeType(texture.getMimeType());
-    if (args.maxSize && args.maxSize >= 16) {
-        const currentSize = newTexture.getSize();
-        if (currentSize[0] > args.maxSize && currentSize[1] > args.maxSize) {
-            await resizeTexture({ size: [args.maxSize, args.maxSize] }, newTexture, logger, texture.getURI(), slots);
-        }
-    }
-    if (!slots?.length) {
-        logger.warn(`WARN: No material slots found for texture at index ${textureIndex} (name: \"${texture.getName()}\") → will assume slot \"baseColorTexture\"`);
-        slots = ["baseColorTexture"];
-    }
-    let slot_index = 0;
-    // create material adding the texture to the same slot
-    for (const slot of slots) {
-        const newMaterial = newDoc.createMaterial(newTexture.getName());
-        const channels = listTextureChannels(texture);
-        // Ensure that we use the alpha channel if it is present
-        if (channels.includes(TextureChannel.A)) {
-            newMaterial.setAlphaMode("BLEND");
-        }
-        switch (slot) {
-            case "baseColorTexture":
-                newMaterial.setBaseColorTexture(newTexture);
-                break;
-            case "metallicRoughnessTexture":
-                newMaterial.setMetallicRoughnessTexture(newTexture);
-                break;
-            case "normalTexture":
-                newMaterial.setNormalTexture(newTexture);
-                break;
-            case "occlusionTexture":
-                newMaterial.setOcclusionTexture(newTexture);
-                break;
-            case "emissiveTexture":
-                newMaterial.setEmissiveTexture(newTexture);
-                break;
-            default:
-                if (slot.startsWith("/textures/")) {
-                    // Ensure the texture is using the alpha channel since we don't know what slots the original texture was used for
-                    // see https://linear.app/needle/issue/NE-4985
-                    newMaterial.setAlphaMode("BLEND");
-                    newMaterial.setBaseColorTexture(newTexture);
-                    continue;
-                }
-                logger.warn(`WARN: Unknown texture slot: ${slot} for texture ${textureIndex} → can not load progressively`);
-                return null;
-        }
-        // Make sure the material is used
-        createMeshForMaterial(newDoc, newMaterial, slot_index++);
-    }
-    const compressionSettingsExt = texture.getExtension(NEEDLE_compression_texture.EXTENSION_NAME);
-    if (compressionSettingsExt !== undefined && compressionSettingsExt !== null && compressionSettingsExt.getExtensionDefinition) {
-        logger.info("> Pass compression extension to new texture");
-        const newExt = newDoc.createExtension(NEEDLE_compression_texture);
-        const compressionSettings = compressionSettingsExt.getExtensionDefinition();
-        if (compressionSettings?.mode === "none") {
-            // if the mode is set to None then we keep that setting for the new texture
-        }
-        else {
-            switch (opts.config.usecase) {
-                // For world scenarios we use ETC1S
-                case "world":
-                    compressionSettings.mode = "ETC1S";
-                    break;
-                case "product":
-                    compressionSettings.mode = detectTextureCompressionMode(slots);
-                    compressionSettings.quality = 100;
-                    break;
-                default:
-                    compressionSettings.mode = detectTextureCompressionMode(slots);
-                    break;
-            }
-        }
-        compressionSettings.slot = slots[0];
-        const newCompressionSettings = newExt.create(compressionSettings);
-        newTexture.setExtension(NEEDLE_compression_texture.EXTENSION_NAME, newCompressionSettings);
-    }
-    // add progressive texture extension
-    const progressiveExt = newDoc.createExtension(NEEDLE_progressive);
-    newTexture.setExtension(NEEDLE_PROGRESSIVE_EXTENSION_NAME, progressiveExt.createTexture({
-        guid: guid,
-    }));
-    const newIo = new NodeIO();
-    registerExtensions(newIo);
-    const ext = ".glb";
-    const imageName = "image_" + level + "_" + guid;
-    const filename = imageName + ext;
-    const outName = basePath + filename;
-    logger.info(`Write texture LOD ${level} to \"${filename}\"`);
-    newIo.write(outName, newDoc);
-    return {
-        outpath: outName,
-        texture: newTexture,
-        hash: getHash(newTexture).toString(),
-    };
-}
-function createMeshForMaterial(doc, mat, i) {
-    const buffer = doc.getRoot().listBuffers()[0];
-    const scene = doc.getRoot().listScenes()[0];
-    const node = doc.createNode();
-    const mesh = doc.createMesh();
-    const prim = doc.createPrimitive();
-    const accessor = doc.createAccessor();
-    accessor.setType('VEC3');
-    // create quad mesh
-    accessor.setArray(new Float32Array([
-        -.5, -.5, 0,
-        .5, -.5, 0,
-        -.5, .5, 0,
-        .5, .5, 0,
-    ]));
-    accessor.setBuffer(buffer);
-    prim.setAttribute('POSITION', accessor);
-    const indices = doc.createAccessor();
-    indices.setType('SCALAR');
-    indices.setArray(new Uint32Array([0, 1, 2, 2, 1, 3]));
-    indices.setBuffer(buffer);
-    prim.setIndices(indices);
-    const uv = doc.createAccessor();
-    uv.setType('VEC2');
-    uv.setArray(new Float32Array([
-        0, 0,
-        1, 0,
-        0, 1,
-        1, 1,
-    ]));
-    uv.setBuffer(buffer);
-    prim.setAttribute('TEXCOORD_0', uv);
-    prim.setMaterial(mat);
-    mesh.addPrimitive(prim);
-    node.setMesh(mesh);
-    scene.addChild(node);
-    node.setName(`Quad_${i}`);
-    const pos = [i, 0, 0];
-    node.setTranslation(pos);
-    return { node, mesh, prim };
-}
-/** Resampling filter methods. LANCZOS3 is sharper, LANCZOS2 is smoother. */
-export var TextureResizeFilter;
-(function (TextureResizeFilter) {
-    /** Lanczos3 (sharp) */
-    TextureResizeFilter["LANCZOS3"] = "lanczos3";
-    /** Lanczos2 (smooth) */
-    TextureResizeFilter["LANCZOS2"] = "lanczos2";
-})(TextureResizeFilter = TextureResizeFilter || (TextureResizeFilter = {}));
-export const TEXTURE_RESIZE_DEFAULTS = {
-    size: [2048, 2048],
-    filter: TextureResizeFilter.LANCZOS3,
-    pattern: null,
-    slots: null,
-};
-export async function resizeTextureToMax(texture, maxSize, logger) {
-    const options = { ...TEXTURE_RESIZE_DEFAULTS };
-    options.size = [maxSize, maxSize];
-    await resizeTexture(options, texture, logger);
-}
-async function resizeTexture(options, texture, logger, uri, slots) {
-    const [maxWidth, maxHeight] = options.size;
-    const [srcWidth, srcHeight] = texture.getSize();
-    if (srcWidth <= maxWidth && srcHeight <= maxHeight) {
-        logger.debug(`[${NAME}] Skipping, the texture is already smaller than the requested size ${maxWidth}x${maxHeight}}`);
-        return;
-    }
-    if (maxWidth <= 0 || maxHeight <= 0) {
-        logger.debug(`${uri}: Skipping, invalid size range: ${maxWidth}x${maxHeight}`);
-        return;
-    }
-    let dstWidth = srcWidth;
-    let dstHeight = srcHeight;
-    if (dstWidth > maxWidth) {
-        dstHeight = Math.floor(dstHeight * (maxWidth / dstWidth));
-        dstWidth = maxWidth;
-    }
-    if (dstHeight > maxHeight) {
-        dstWidth = Math.floor(dstWidth * (maxHeight / dstHeight));
-        dstHeight = maxHeight;
-    }
-    logger.info("> Resize texture to " + dstWidth + "x" + dstHeight + " (from " + srcWidth + "x" + srcHeight + ")");
-    // https://sharp.pixelplumbing.com/api-resize
-    const buffer = await sharp(texture.getImage())
-        .resize(dstWidth, dstHeight, {
-        fit: 'inside',
-        kernel: "lanczos3",
-        withoutEnlargement: true,
-    })
-        .toBuffer();
-    texture.setImage(BufferUtils.toView(buffer));
-    return {
-        width: dstWidth,
-        height: dstHeight,
-    };
-}
-export function make_progressive_meshes(filePath, _options, opts) {
-    const directory = path.dirname(filePath);
-    // const fileNameWithoutExtension = path.basename(filePath, path.extname(filePath));
-    const outputDirectory = directory + "/";
-    return createTransform("PROGRESSIVE_MESHES", async (doc, _context) => {
-        const logger = doc.getLogger();
-        // this is to ensure we're not creating progressive meshes for engine versions that don't support loading them yet
-        // the generator should include the version or the app that produced the GLB too (needle engine repo: 2c00d0e304e205cf9d4ac0499faabb92a706a5c4)
-        if (currentGenerator == "Needle Engine") {
-            logger.warn("WARN: Skip creating mesh LODs - Unsupported generator found... Please update your editor integration");
-            return;
-        }
-        if (isLOD(filePath)) {
-            logger.info("Progressive Mesh Transform: skip lod at " + filePath);
-            return Promise.resolve();
-        }
-        await MeshoptSimplifier.ready;
-        const filename = path.basename(filePath);
-        logger.info(`[${NAME}]: Begin generating progressive meshes for \"${filename}\"`);
-        let index = 0;
-        // the lowest LOD (last entry) will be saved in the original file
-        let MAX_LODS = 6;
-        if (opts.config.usecase === "product") {
-            MAX_LODS = 3;
-        }
-        const LODS = [
-            {
-                ratio: 1,
-                error: 0,
-                lockBorder: true
-            },
-        ];
-        for (let l = 0; l < MAX_LODS; l++) {
-            // const t = l / MAX_LODS;
-            const latest = LODS[LODS.length - 1];
-            const ratio = latest.ratio * .5;
-            let error = Math.min(.013 * (l + 1), 0.05);
-            if (opts.config.usecase === "product") {
-                error *= .5;
-            }
-            LODS.push({
-                ratio: ratio,
-                error,
-                lockBorder: true,
-                // toleranceNormal: 0.1 + t * 0.1,
-            });
-        }
-        /** Map of visited GUID -> extension */
-        const visited = new Map();
-        const root = doc.getRoot();
-        const meshes = root.listMeshes();
-        for (const mesh of meshes) {
-            await processMesh(mesh, { filename });
-        }
-        logger.info(`[${NAME}]: Finished generating progressive meshes for \"${filename}\"`);
-        async function processMesh(mesh, args) {
-            /** The size and vertex count of the original mesh */
-            const originalMeshInformation = getMeshInformation(mesh);
-            const { totalVertexCount: originalTotalVertexCount, maxVertexCount: originalMaxVertexCount } = originalMeshInformation;
-            let settings = mesh.getExtension(NEEDLE_progressive_mesh_settings.EXTENSION_NAME);
-            if (!settings) {
-                if (originalMaxVertexCount < 32) {
-                    logger.debug(`[${NAME}] Skipping, no settings found and no primitive with more than 32 vertices. mesh[${index}] has ${originalTotalVertexCount} vertices (max: ${originalMaxVertexCount})`);
-                    return;
-                }
-                else {
-                    settings = {
-                        guid: generateGuid(args.filename + "_mesh_" + index.toString()),
-                        generateLods: true,
-                    };
-                    logger.debug(`[${NAME}] No settings found for mesh[${index}] with ${originalTotalVertexCount} vertices (max: ${originalMaxVertexCount}) - will use default settings (guid: ${settings.guid})`);
-                }
-            }
-            else if (settings.generateLods === false) {
-                logger.debug(`[${NAME}] progressive mesh disabled for mesh at index ${index++}`);
-                return;
-            }
-            const progressiveExt = doc.createExtension(NEEDLE_progressive);
-            if (!progressiveExt || !progressiveExt.createMesh) {
-                logger.debug(`[${NAME}] Skipping because progressive extension is not available. ${index++}`);
-                return;
-            }
-            // check if we have already produced LODs for this mesh
-            let needsToGenerateLODs = true;
-            const generatedLODInfos = new Array();
-            if (visited.has(settings.guid)) {
-                // we can not just set the extension here...
-                logger.debug(`[${NAME}] Mesh has already been processed ${index} - will use previously generated LODs`);
-                needsToGenerateLODs = false;
-                const existingPaths = visited.get(settings.guid);
-                generatedLODInfos.push(...existingPaths.infos);
-            }
-            /** async simplification tasks... */
-            const tasks = new Array();
-            if (needsToGenerateLODs) {
-                logger.info(`[${NAME}] Begin generating mesh LODs for \"${mesh.getName()}\"`);
-                // produce LODS, skip the last level because it will be saved in the original file
-                for (let level = 0; level < LODS.length - 1; level++) {
-                    const lod = LODS[level];
-                    const guid = settings.guid;
-                    // TODO: check if the LOD level did actually change the mesh - otherwise we can just skip generating lower resolutions
-                    const lodTask = createMeshLod(doc, outputDirectory, level, mesh, originalMeshInformation, guid, lod, opts);
-                    lodTask.then(res => {
-                        if (res?.success) {
-                            generatedLODInfos[level] = res;
-                        }
-                    });
-                    tasks.push(lodTask);
-                }
-                // wait for all LODs to be generated
-                await Promise.all(tasks);
-                tasks.length = 0;
-            }
-            // compare LOD results and ignore if the mesh did not change
-            // TODO: this should actually check mesh semantics (perhaps hash the mesh using the caching system?)
-            let prevSize = -Infinity;
-            for (let i = 0; i < generatedLODInfos.length; i++) {
-                const lodInfo = generatedLODInfos[i];
-                if (!lodInfo) {
-                    console.log(`[${NAME}] LOD ${i} doesnt exist`);
-                    continue;
-                }
-                const fullPath = outputDirectory + lodInfo.path;
-                if (existsSync(fullPath)) {
-                    const lastSize = prevSize;
-                    const sizeOnDisc = statSync(fullPath).size;
-                    const diff = lastSize - sizeOnDisc;
-                    const level = lodInfo.level;
-                    let shouldOmitLevel = false;
-                    // if the mesh size on disc is identical to the last level, we can omit this level
-                    if (sizeOnDisc <= 0) {
-                        logger.info(`[${NAME}] Flag mesh LOD ${level}: size on disc is 0 → level will be omitted (if this mesh is is taken from cache it can mean that the LOD level was omitted before). \"${mesh.getName()}\" at \"${lodInfo.path}\"`);
-                        shouldOmitLevel = true;
-                    }
-                    else if (diff == 0) {
-                        logger.info(`[${NAME}] Flag mesh LOD ${level}: size on disc did not change compared to previous level → level will be omitted. \"${mesh.getName()}\" at \"${lodInfo.path}\"`);
-                        shouldOmitLevel = true;
-                    }
-                    else if (!shouldOmitLevel) {
-                        // if the mesh vertex count difference to the last valid level is less than 32 vertices or less than 5% of the last level, we can omit this level
-                        const meshInfo = lodInfo.lodMeshInfo;
-                        const lastMeshInfo = generatedLODInfos[i - 1]?.lodMeshInfo;
-                        if (meshInfo && lastMeshInfo) {
-                            const vertexDifference = lastMeshInfo.totalVertexCount - meshInfo.totalVertexCount;
-                            const diff01 = vertexDifference / lastMeshInfo.totalVertexCount;
-                            if (vertexDifference < 0) {
-                                console.log(`WARN: ❌ [${NAME}] Flag mesh LOD ${level}: vertex count did increase (${-vertexDifference.toFixed(0)} vertices, ${(-diff01 * 100).toFixed(4)}%) → LOD ${level} will be omitted. \"${mesh.getName()}\" at \"${lodInfo.path}\" ${JSON.stringify(lastMeshInfo)} → ${JSON.stringify(meshInfo)}`);
-                                shouldOmitLevel = true;
-                            }
-                            else if (vertexDifference < 32 || diff01 < 0.05) {
-                                logger.warn(`[${NAME}] Flag mesh LOD ${level}: vertex count difference below threshold (removed ${vertexDifference.toFixed(0)} vertices, ${(-diff01 * 100).toFixed(4)}%) → LOD ${level} will be omitted. \"${mesh.getName()}\" at \"${lodInfo.path}\"`);
-                                shouldOmitLevel = true;
-                            }
-                        }
-                        if (shouldOmitLevel && opts.useCache != false && lodInfo.cacheKey != undefined) {
-                            // we invalidate the cached entry because the mesh change was too small
-                            addToCache(lodInfo.cacheKey, new Uint8Array(0));
-                        }
-                    }
-                    if (shouldOmitLevel) {
-                        generatedLODInfos.splice(i, 1);
-                        rmSync(fullPath);
-                        i--;
-                    }
-                    else {
-                        prevSize = sizeOnDisc;
-                    }
-                }
-            }
-            let maxDensity = 0;
-            let primitiveIndex = 0;
-            const lodLevelInFile = generatedLODInfos.length;
-            const clonedData = { primitives: [], weights: [...mesh.getWeights()] };
-            for (const prim of mesh.listPrimitives()) {
-                const data = clonePrimitiveData(prim, logger);
-                if (data != null) {
-                    clonedData.primitives.push(data);
-                }
-                logger.info(`[${NAME}] Simplify mesh[${index}] primitive[${primitiveIndex}] (embedded)`);
-                const lastLod = LODS[lodLevelInFile];
-                // TODO: this should be run after simplification but then we need to change the runtime to use the LOD 0 density
-                const density = calculateMeshDensity(prim);
-                maxDensity = Math.max(maxDensity, density);
-                const task = simplifyMesh(doc, mesh, prim, primitiveIndex++, lastLod);
-                tasks.push(task);
-            }
-            await Promise.all(tasks);
-            tasks.length = 0;
-            const { totalVertexCount: totalVertexCountAfter } = getMeshInformation(mesh);
-            const difference = originalTotalVertexCount - totalVertexCountAfter;
-            const diff01 = difference / originalTotalVertexCount;
-            if (totalVertexCountAfter <= 0) {
-                logger.error(`ERR: [${NAME}]: Mesh[${index}] has no vertices after simplification: ${mesh.getName()}`);
-            }
-            else if (difference < 32 || diff01 <= 0.05) {
-                // the lowest LOD has the same vertex count as the original mesh → we don't need to write the extension and can also delete previously generated LODs
-                logger.info(`[${NAME}]: Flag mesh LOD ${generatedLODInfos.length} (embedded): vertex count difference below threshold (removed ${difference} vertices, ${(-diff01 * 100).toFixed(2)} %) → will remove all LODs. \"${mesh.getName()}\"`);
-                try {
-                    for (const lodInfo of generatedLODInfos) {
-                        rmSync(outputDirectory + "/" + lodInfo.path);
-                    }
-                }
-                catch (err) {
-                    logger.error(`ERR: [${NAME}] Failed to remove LOD files for \"${mesh.getName()}\"`);
-                }
-                // reset data (simplify might have changed the mesh data that we cloned before)
-                const primitives = mesh.listPrimitives();
-                if (clonedData.primitives.length == primitives.length) {
-                    if (clonedData.weights?.length > 0) {
-                        mesh.setWeights(clonedData.weights);
-                    }
-                    for (let i = 0; i < primitives.length; i++) {
-                        setPrimitiveData(primitives[i], clonedData.primitives[i]);
-                    }
-                }
-                return;
-            }
-            if (generatedLODInfos.length > 0) {
-                const model = progressiveExt.createMesh({
-                    guid: settings.guid,
-                    lods: generatedLODInfos.map(l => {
-                        opts.results.push(resolve(outputDirectory, l.path));
-                        return {
-                            path: l.path,
-                            hash: l.content_hash.toString(),
-                            density: l.density,
-                            vertexCount: l.lodMeshInfo?.totalVertexCount,
-                            indexCount: l.lodMeshInfo?.totalIndexCount,
-                        };
-                    }),
-                    density: maxDensity,
-                });
-                mesh.setExtension(NEEDLE_PROGRESSIVE_EXTENSION_NAME, model);
-                index++;
-                if (!visited.has(settings.guid)) {
-                    visited.set(settings.guid, {
-                        model: model,
-                        infos: generatedLODInfos,
-                    });
-                }
-            }
-        }
-    });
-}
-function clonePrimitiveData(prim, logger) {
-    const semantics = prim.listSemantics();
-    if (semantics.some(s => s.includes("JOINTS"))) {
-        return null;
-    }
-    const prevIndices = prim.getIndices();
-    const indices = !prevIndices ? new Uint32Array() : new Uint32Array(prevIndices.getArray());
-    const attributes = {};
-    for (const attr of semantics) {
-        logger.info(`[${NAME}] Clone attribute ${attr}`);
-        const accessor = prim.getAttribute(attr);
-        if (accessor) {
-            attributes[attr] = new Float32Array(accessor.getArray());
-        }
-    }
-    return { indices, attributes };
-}
-function setPrimitiveData(prim, data) {
-    const indices = prim.getIndices();
-    if (indices) {
-        indices.setArray(data.indices);
-    }
-    for (const attr of prim.listSemantics()) {
-        const accessor = prim.getAttribute(attr);
-        if (accessor) {
-            accessor.setArray(data.attributes[attr]);
-        }
-    }
-}
-/**
- * @param basePath the base path to save the lod files
- * @param level: 0 = original, 1 = first lod, 2 = second lod, ...
- * @param mesh the mesh
- * @param guid a unique identifier for the mesh
- * @param error the error to use for simplification. Higher means more simplification
- */
-async function createMeshLod(doc, basePath, level, mesh, meshInfo, guid, lodLevel, opts) {
-    const logger = doc.getLogger();
-    const fileExtension = ".glb";
-    const fileName_withoutExtension = "mesh_lod_" + level + "_" + guid;
-    const fileName = fileName_withoutExtension + fileExtension;
-    const outPath = basePath + fileName;
-    const primitives = mesh.listPrimitives();
-    let cacheKey = undefined;
-    // generate hash for mesh
-    let hash = mesh["needle:mesh-hash"];
-    if (hash === undefined) {
-        hash = getHash(mesh);
-        mesh["needle:mesh-hash"] = hash;
-    }
-    hash += getHash(lodLevel);
-    hash += getHash({
-        guid,
-        config: opts.config,
-    });
-    if (opts.useCache !== false) {
-        cacheKey = `mesh_lod_${level}_${hash}`;
-        const cachedValue = tryGetFromCache(cacheKey);
-        const meta = tryGetMetaFromCache(cacheKey);
-        if (cachedValue && meta) {
-            logger.info(`[${NAME}] LOD ${level} loaded from cache for \"${mesh.getName()}\"`);
-            writeFileSync(outPath, cachedValue);
-            return { level, path: fileName, success: true, cacheKey, content_hash: hash, lodMeshInfo: meta.meshInfo, density: meta.density };
-        }
-    }
-    const newDoc = new Document();
-    writeNeedleAsset(newDoc);
-    const newScene = newDoc.createScene();
-    newDoc.createBuffer();
-    const newNode = newDoc.createNode();
-    newScene.addChild(newNode);
-    newNode.setName("LOD " + level + "_" + guid);
-    newNode.setTranslation([0, 0, 0]);
-    const newMesh = newDoc.createMesh();
-    newMesh.setName((mesh.getName() || "Unnamed") + " LOD " + level);
-    newNode.setMesh(newMesh);
-    const newMat = newDoc.createMaterial();
-    const weights = mesh.getWeights();
-    if (weights) {
-        newMesh.setWeights(weights);
-    }
-    const tasks = new Array();
-    // let didRunSimplification = false;
-    for (const prim of primitives) {
-        const newPrim = newDoc.createPrimitive();
-        newMesh.addPrimitive(newPrim);
-        newPrim.setName(prim.getName());
-        newPrim.setMode(prim.getMode());
-        newPrim.setMaterial(newMat);
-        const semantics = prim.listSemantics();
-        for (let i = 0; i < semantics.length; i++) {
-            const attr = prim.getAttribute(semantics[i]);
-            if (attr) {
-                const newAttr = newDoc.createAccessor();
-                newAttr.setArray(attr.getArray());
-                newAttr.setType(attr.getType());
-                newPrim.setAttribute(semantics[i], newAttr);
-            }
-            else {
-                logger.warn(`[${NAME}] Missing attribute ${semantics[i]} in mesh LOD ${level}`);
-            }
-        }
-        const indices = prim.getIndices();
-        if (indices) {
-            const newIndices = newDoc.createAccessor();
-            newIndices.setArray(indices.getArray());
-            newIndices.setType(indices.getType());
-            newPrim.setIndices(newIndices);
-        }
-        const targets = prim.listTargets();
-        for (const target of targets) {
-            const newTarget = newDoc.createPrimitiveTarget(target.getName());
-            newPrim.addTarget(newTarget);
-            for (const attr of target.listSemantics()) {
-                const accessor = target.getAttribute(attr);
-                if (accessor) {
-                    const newAccessor = newDoc.createAccessor();
-                    newAccessor.setArray(accessor.getArray());
-                    newAccessor.setType(accessor.getType());
-                    newTarget.setAttribute(attr, newAccessor);
-                }
-            }
-        }
-        ;
-        const extensions = prim.listExtensions();
-        for (const ext of extensions) {
-            const PropertyClass = ext.constructor;
-            const newProp = new PropertyClass(newDoc.getGraph());
-            try {
-                const copy = newProp.copy(ext);
-                const name = ext.extensionName;
-                newPrim.setExtension(name, copy);
-            }
-            catch (err) {
-                logger.error(`[${NAME}] Failed to copy extension ${ext.extensionName} for mesh LOD ${level} → ${err}`);
-            }
-        }
-    }
-    let primitiveIndex = 0;
-    if (lodLevel.error != undefined || lodLevel.ratio != undefined) {
-        if (lodLevel.error > 0 || lodLevel.ratio < 1) {
-            for (const newPrim of newMesh.listPrimitives()) {
-                // didRunSimplification = true;
-                const task = simplifyMesh(newDoc, newMesh, newPrim, primitiveIndex++, lodLevel);
-                tasks.push(task);
-            }
-        }
-    }
-    await Promise.all(tasks);
-    tasks.length = 0;
-    const newMeshInformation = getMeshInformation(newMesh);
-    if (newMeshInformation.totalVertexCount < 4) {
-        logger.error(`[${NAME}] mesh LOD ${level} is has less than 4 vertices → skipping`);
-        return { level, path: fileName, success: false, cacheKey: cacheKey, content_hash: hash, lodMeshInfo: null, density: null, };
-    }
-    let density = 0;
-    for (const prim of newMesh.listPrimitives()) {
-        const d = calculateMeshDensity(prim);
-        density = Math.max(density, d);
-    }
-    const progressiveExt = newDoc.createExtension(NEEDLE_progressive);
-    if (!progressiveExt || !progressiveExt.createMesh) {
-        logger.error("Failed to create progressive extension");
-        return;
-    }
-    newMesh.setExtension(NEEDLE_PROGRESSIVE_EXTENSION_NAME, progressiveExt.createMesh({
-        guid: guid,
-        density: density,
-    }));
-    // we need to compress the mesh with the same compression method as the original file
-    const root = doc.getRoot();
-    const compressionExt = root.getExtension(NEEDLE_mesh_compression.EXTENSION_NAME);
-    if (compressionExt) {
-        const newExt = newDoc.createExtension(NEEDLE_mesh_compression);
-        const newProp = newExt.create(compressionExt.model);
-        logger.info(`[${NAME}] Pass compression format to mesh LOD ${level} → ${JSON.stringify(compressionExt.model)}`);
-        newDoc.getRoot().setExtension(NEEDLE_mesh_compression.EXTENSION_NAME, newProp);
-    }
-    await newDoc.transform(sparse());
-    const newIo = new NodeIO();
-    registerExtensions(newIo);
-    logger.info(`[${NAME}] Write mesh LOD ${level} with to \"${fileName}\"`);
-    await newIo.write(outPath, newDoc);
-    // const hasChanged = meshInfo.maxVertexCount == newMeshInformation.maxVertexCount && meshInfo.totalVertexCount == newMeshInformation.totalVertexCount;
-    // add to cache
-    if (cacheKey != undefined) {
-        const bytes = readFileSync(outPath);
-        addToCache(cacheKey, bytes);
-        addMetaToCache(cacheKey, { meshInfo: newMeshInformation, density: density });
-    }
-    return { level, path: fileName, success: true, lodMeshInfo: newMeshInformation, cacheKey: cacheKey, content_hash: hash, density: density };
-}
-async function simplifyMesh(doc, mesh, prim, index, lodinfo) {
-    const weldOptions = {
-        ...WELD_DEFAULTS,
-        overwrite: true,
-        cleanup: false,
-        tolerance: 0.00000000001,
-        ...lodinfo,
-    };
-    const simplifyOptions = {
-        ...SIMPLIFY_DEFAULTS,
-        ...lodinfo,
-        simplifier: MeshoptSimplifier,
-    };
-    return compressPrimitive(doc, mesh, prim, index, weldOptions, simplifyOptions);
-}
-export function isMeshLOD(filepath) {
-    return filepath.includes("mesh_lod_");
-}
-export function isImageLOD(filepath) {
-    return filepath.includes("image_");
-}
-export function isLOD(filepath) {
-    return isMeshLOD(filepath) || isImageLOD(filepath);
-}
+import { BufferUtils, Document, NodeIO, PropertyType, TextureChannel, Verbosity } from '@gltf-transform/core';
+import { SIMPLIFY_DEFAULTS, WELD_DEFAULTS, listTextureChannels, listTextureSlots, sparse } from '@gltf-transform/functions';
+import draco3d from 'draco3dgltf';
+import { NEEDLE_PROGRESSIVE_EXTENSION_NAME, NEEDLE_progressive } from "../extensions/NEEDLE_progressive/index.js";
+import { createOpaqueExtension, currentGenerator, NEEDLE_compression_texture, NEEDLE_mesh_compression, NEEDLE_progressive_mesh_settings, NEEDLE_progressive_texture_settings, registerExtensions as registerDefaultExtensions } from '../extensions/index.js';
+import path, { basename, resolve } from 'path';
+import { existsSync, readFileSync, rmSync, statSync, writeFileSync } from 'fs';
+import { addMetaToCache, addToCache, getHash, getKey, tryGetFromCache, tryGetMetaFromCache } from '../cache/index.js';
+import sharp from "sharp";
+import { detectTextureCompressionMode, foreachGLTF, generateGuid, writeNodeIO } from '../utils/index.js';
+import { needle_asset, writeNeedleAsset } from './needle_asset.js';
+import { MeshoptDecoder, MeshoptSimplifier } from 'meshoptimizer';
+import { compressPrimitive } from './needle_mesh_transform.js';
+import { calculateMeshDensity, getMeshInformation } from "../utils/mesh.js";
+export async function make_progressive(opts) {
+    const file = opts.path;
+    let success = true;
+    await foreachGLTF(file, async (f) => {
+        // Should we stop if one file fails?
+        if (!success) {
+            return;
+        }
+        // Don't re-process files that are already LODs
+        if (isMeshLOD(f) || isImageLOD(f)) {
+            console.log(`Progressive Transform: Ignore existing LOD file at ${f}`);
+            return;
+        }
+        const res = await onProcess(f, opts);
+        if (!res)
+            success = false;
+    });
+    return success;
+}
+function registerExtensions(io) {
+    registerDefaultExtensions(io);
+    io.registerExtensions([
+        NEEDLE_progressive,
+        NEEDLE_progressive_texture_settings,
+        NEEDLE_progressive_mesh_settings,
+        NEEDLE_mesh_compression,
+        //@ts-ignore
+        createOpaqueExtension(NEEDLE_compression_texture.EXTENSION_NAME, PropertyType.TEXTURE),
+        //@ts-ignore
+        // createOpaqueExtension(NEEDLE_mesh_compression.EXTENSION_NAME, [PropertyType.ROOT, PropertyType.MESH, PropertyType.PRIMITIVE]),
+    ]);
+}
+async function onProcess(file, opts) {
+    if (!file.endsWith(".glb") && !file.endsWith(".gltf") && !file.endsWith(".vrm")) {
+        console.log("ERR: file is not gltf/glb");
+        return false;
+    }
+    if (!existsSync(file)) {
+        console.log("ERR: file does not exist: " + file);
+        return false;
+    }
+    try {
+        const io = new NodeIO();
+        registerExtensions(io);
+        io.registerDependencies({
+            'meshopt.decoder': MeshoptDecoder,
+            'draco3d.decoder': await draco3d.createDecoderModule(),
+            'draco3d.encoder': await draco3d.createEncoderModule(),
+        });
+        let document = await io.read(file);
+        if (document) {
+            const logger = document.getLogger();
+            //@ts-ignore
+            logger.verbosity = opts.debug || opts.verbose ? Verbosity.DEBUG : Verbosity.WARN;
+            let smallesTextureSize = 128;
+            if (opts.config.usecase === "product") {
+                smallesTextureSize = 512;
+            }
+            const transforms = [
+                needle_asset(),
+            ];
+            if (opts.config?.textures?.lods !== false) {
+                transforms.push(make_progressive_textures(file, { size: [smallesTextureSize, smallesTextureSize] }, opts));
+            }
+            // TODO: progressive meshes aren't supported yet for VRMs
+            const isVRM = file.endsWith(".vrm");
+            if (!isVRM && opts.config?.meshes?.lods !== false) {
+                transforms.push(make_progressive_meshes(file, {}, opts));
+            }
+            else if (isVRM)
+                logger.warn("WARN: Progressive meshes are not supported for VRM files yet");
+            transforms.push(sparse());
+            logger.info("→ Transforming: " + file);
+            await document.transform(...transforms);
+            const filename = file;
+            await writeNodeIO(io, filename, document);
+            opts.results.push(filename);
+            logger.info("← Transforming done: " + filename);
+        }
+    }
+    catch (err) {
+        console.log("ERR: failed to process file \"" + file + "\", Reason: " + err.message, "\nStack:\n" + err.stack);
+        return false;
+    }
+    return true;
+}
+// basic idea:
+// 1. iterate all images that have an extension marking them to be progressively loaded
+// 2. for each image, create a new image that is a downsampled version of the original and create a new gltf that contains the high res texture
+// 3. add extension to low res image containing info about where to find the high res texture
+export function createTransform(name, fn) {
+    Object.defineProperty(fn, 'name', { value: name });
+    return fn;
+}
+const NAME = 'NEEDLE_progressive';
+export function make_progressive_textures(filePath, _options = TEXTURE_RESIZE_DEFAULTS, opts) {
+    const startTime = Date.now();
+    const filename = basename(filePath);
+    const options = { ...TEXTURE_RESIZE_DEFAULTS, ..._options };
+    const directory = path.dirname(filePath);
+    // const fileNameWithoutExtension = path.basename(filePath, path.extname(filePath));
+    const textureLodBasePath = directory + "/";
+    return createTransform(NAME, async (doc) => {
+        const logger = doc.getLogger();
+        if (isLOD(filePath)) {
+            logger.info("Progressive Image Transform: skip lod at " + filePath);
+            return Promise.resolve();
+        }
+        let index = 0;
+        for (const texture of doc.getRoot().listTextures()) {
+            const textureIndex = index++;
+            const name = texture.getName();
+            const uri = texture.getURI();
+            const match = !options.pattern || options.pattern.test(name) || options.pattern.test(uri);
+            if (!match) {
+                logger.debug(`[${NAME}] Skipping, excluded by "pattern" parameter. ${textureIndex}`);
+                continue;
+            }
+            if (texture.getMimeType() !== 'image/png' && texture.getMimeType() !== 'image/jpeg') {
+                logger.warn(`[${NAME}] Skipping, unsupported texture type "${texture.getMimeType()} at ${textureIndex}".`);
+                continue;
+            }
+            const slots = listTextureSlots(texture);
+            if (options.slots && !slots.some((slot) => options.slots?.test(slot))) {
+                logger.debug(`[${NAME}] Skipping, [${slots.join(', ')}] excluded by "slots" parameter. ${textureIndex}`);
+                continue;
+            }
+            let settings = texture.getExtension(NEEDLE_progressive_texture_settings.EXTENSION_NAME);
+            if (!settings) {
+                const size = texture.getSize();
+                if (size?.length >= 2 && size[0] <= options.size[0] && size[1] <= options.size[1]) {
+                    logger.warn(`[${NAME}] Skipping texture[${textureIndex}], no settings found and the texture is already <= ${size[0]}x${size[1]}`);
+                    continue;
+                }
+                else {
+                    settings = {
+                        guid: generateGuid(filename + "_texture_" + index.toString()),
+                        maxSize: _options.size[0],
+                    };
+                    logger.debug(`[${NAME}] No settings found for texture[${index}] - will use default settings (maxSize: ${settings.maxSize}, guid: ${settings.guid})`);
+                }
+            }
+            else if (settings.generateLods === false) {
+                logger.debug(`[${NAME}] Skipping texture[${textureIndex}]: progressive texture disabled`);
+                continue;
+            }
+            if (settings.maxSize == undefined || settings.maxSize <= 0) {
+                logger.warn(`[${NAME}] Skipping texture[${textureIndex}], settings are invalid (maxSize: ${settings.maxSize})`);
+                continue;
+            }
+            const existingExtension = texture.getExtension(NEEDLE_PROGRESSIVE_EXTENSION_NAME);
+            if (existingExtension !== undefined && existingExtension !== null) {
+                logger.debug(`[${NAME}] Skipping, texture is already progressive ${textureIndex}`);
+                continue;
+            }
+            const progressiveExt = doc.createExtension(NEEDLE_progressive);
+            if (!progressiveExt || !progressiveExt.createTexture) {
+                logger.debug(`[${NAME}] Skipping because progressive extension is not available. ${textureIndex}`);
+                continue;
+            }
+            /** This is the current texture's size  */
+            const currentSize = Math.min(...texture.getSize());
+            if (currentSize <= settings.maxSize) {
+                logger.debug(`[${NAME}] Skipping, texture[${textureIndex}] is already smaller than the requested size: ${currentSize}px <= ${settings.maxSize}px`);
+                continue;
+            }
+            const textureGuid = settings.guid?.length ? settings.guid : generateGuid(filename + "_texture_" + index.toString());
+            /** This is the size of the texture that is embedded in the glTF. No LOD should be smaller than this */
+            const maxSize = settings.maxSize;
+            const LOD_LEVEL = new Array();
+            LOD_LEVEL.push({ size: currentSize });
+            let generateLods = true; //opts.config?.usecase === "world";
+            // If lods are enabled in the config
+            // generateLods ||= opts.config?.textures?.lods === true;
+            // // Ensure that texture lods are not disabled by { textures: { lods: false } }
+            // generateLods &&= opts.config?.textures?.lods !== false;
+            if (generateLods) {
+                const LEVEL = 6;
+                let lastSize = currentSize;
+                for (let i = 1; i < LEVEL; i++) {
+                    const size = lastSize * .5;
+                    if (size <= maxSize)
+                        break;
+                    lastSize = size;
+                    LOD_LEVEL.push({ size: size });
+                }
+            }
+            const results = new Array();
+            for (let i = 0; i < LOD_LEVEL.length; i++) {
+                const level = LOD_LEVEL[i];
+                const lodResult = await createTextureLod({
+                    doc,
+                    file: filePath,
+                    basePath: textureLodBasePath,
+                    level: i,
+                    texture,
+                    slots,
+                    guid: textureGuid,
+                    textureIndex,
+                    maxSize: level.size
+                }, opts);
+                if (!lodResult) {
+                    continue;
+                }
+                const { 0: width, 1: height } = lodResult.texture.getSize();
+                const outpath = lodResult?.outpath;
+                const relName = path.relative(directory, outpath);
+                results.push({
+                    path: relName,
+                    hash: lodResult.hash,
+                    width,
+                    height,
+                });
+                opts.results.push(outpath);
+            }
+            const key = getKey(texture);
+            // TODO: this path should be added to the NEEDLE dependencies extension
+            const model = {
+                guid: textureGuid,
+                lods: results,
+            };
+            texture.setExtension(NEEDLE_PROGRESSIVE_EXTENSION_NAME, progressiveExt.createTexture(model));
+            if (opts.useCache) {
+                const cached = tryGetFromCache(key);
+                if (cached) {
+                    logger.debug(`Progressive image ${index}: using cached preview version (size: ${options.size}))`);
+                    texture.setImage(cached);
+                    continue;
+                }
+            }
+            options.size[0] = settings.maxSize;
+            options.size[1] = settings.maxSize;
+            logger.debug(`[${NAME}] Resizing embedded texture[${index}] to ${options.size[0]}x${options.size[1]}`);
+            await resizeTexture(options, texture, logger, uri || name, slots);
+            if (opts?.useCache === false) {
+            }
+            else
+                addToCache(key, texture.getImage());
+        }
+        logger.debug(`Progressive transform finished in ${((Date.now() - startTime) / 1000).toFixed(1)} sec.`);
+    });
+}
+async function createTextureLod(args, opts) {
+    const { doc, file, basePath, level, texture, guid, textureIndex } = args;
+    let slots = args.slots;
+    const logger = doc.getLogger();
+    const newDoc = new Document();
+    writeNeedleAsset(newDoc);
+    const scene = newDoc.createScene();
+    const buffer = newDoc.createBuffer();
+    // add texture
+    const newTexture = newDoc.createTexture();
+    const img = texture.getImage();
+    newTexture.setImage(img);
+    newTexture.setURI(texture.getURI());
+    newTexture.setMimeType(texture.getMimeType());
+    if (args.maxSize && args.maxSize >= 16) {
+        const currentSize = newTexture.getSize();
+        if (currentSize[0] > args.maxSize && currentSize[1] > args.maxSize) {
+            await resizeTexture({ size: [args.maxSize, args.maxSize] }, newTexture, logger, texture.getURI(), slots);
+        }
+    }
+    if (!slots?.length) {
+        logger.warn(`WARN: No material slots found for texture at index ${textureIndex} (name: \"${texture.getName()}\") → will assume slot \"baseColorTexture\"`);
+        slots = ["baseColorTexture"];
+    }
+    let slot_index = 0;
+    // create material adding the texture to the same slot
+    for (const slot of slots) {
+        const newMaterial = newDoc.createMaterial(newTexture.getName());
+        const channels = listTextureChannels(texture);
+        // Ensure that we use the alpha channel if it is present
+        if (channels.includes(TextureChannel.A)) {
+            newMaterial.setAlphaMode("BLEND");
+        }
+        switch (slot) {
+            case "baseColorTexture":
+                newMaterial.setBaseColorTexture(newTexture);
+                break;
+            case "metallicRoughnessTexture":
+                newMaterial.setMetallicRoughnessTexture(newTexture);
+                break;
+            case "normalTexture":
+                newMaterial.setNormalTexture(newTexture);
+                break;
+            case "occlusionTexture":
+                newMaterial.setOcclusionTexture(newTexture);
+                break;
+            case "emissiveTexture":
+                newMaterial.setEmissiveTexture(newTexture);
+                break;
+            default:
+                if (slot.startsWith("/textures/")) {
+                    // Ensure the texture is using the alpha channel since we don't know what slots the original texture was used for
+                    // see https://linear.app/needle/issue/NE-4985
+                    newMaterial.setAlphaMode("BLEND");
+                    newMaterial.setBaseColorTexture(newTexture);
+                    continue;
+                }
+                logger.warn(`WARN: Unknown texture slot: ${slot} for texture ${textureIndex} → can not load progressively`);
+                return null;
+        }
+        // Make sure the material is used
+        createMeshForMaterial(newDoc, newMaterial, slot_index++);
+    }
+    const compressionSettingsExt = texture.getExtension(NEEDLE_compression_texture.EXTENSION_NAME);
+    if (compressionSettingsExt !== undefined && compressionSettingsExt !== null && compressionSettingsExt.getExtensionDefinition) {
+        logger.info("> Pass compression extension to new texture");
+        const newExt = newDoc.createExtension(NEEDLE_compression_texture);
+        const compressionSettings = compressionSettingsExt.getExtensionDefinition();
+        if (compressionSettings?.mode === "none") {
+            // if the mode is set to None then we keep that setting for the new texture
+        }
+        else {
+            switch (opts.config.usecase) {
+                // For world scenarios we use ETC1S
+                case "world":
+                    compressionSettings.mode = "ETC1S";
+                    break;
+                case "product":
+                    compressionSettings.mode = detectTextureCompressionMode(slots);
+                    compressionSettings.quality = 100;
+                    break;
+                default:
+                    compressionSettings.mode = detectTextureCompressionMode(slots);
+                    break;
+            }
+        }
+        compressionSettings.slot = slots[0];
+        const newCompressionSettings = newExt.create(compressionSettings);
+        newTexture.setExtension(NEEDLE_compression_texture.EXTENSION_NAME, newCompressionSettings);
+    }
+    // add progressive texture extension
+    const progressiveExt = newDoc.createExtension(NEEDLE_progressive);
+    newTexture.setExtension(NEEDLE_PROGRESSIVE_EXTENSION_NAME, progressiveExt.createTexture({
+        guid: guid,
+    }));
+    const newIo = new NodeIO();
+    registerExtensions(newIo);
+    const ext = ".glb";
+    const imageName = "image_" + level + "_" + guid;
+    const filename = imageName + ext;
+    const outName = basePath + filename;
+    logger.info(`Write texture LOD ${level} to \"${filename}\"`);
+    newIo.write(outName, newDoc);
+    return {
+        outpath: outName,
+        texture: newTexture,
+        hash: getHash(newTexture).toString(),
+    };
+}
+function createMeshForMaterial(doc, mat, i) {
+    const buffer = doc.getRoot().listBuffers()[0];
+    const scene = doc.getRoot().listScenes()[0];
+    const node = doc.createNode();
+    const mesh = doc.createMesh();
+    const prim = doc.createPrimitive();
+    const accessor = doc.createAccessor();
+    accessor.setType('VEC3');
+    // create quad mesh
+    accessor.setArray(new Float32Array([
+        -.5, -.5, 0,
+        .5, -.5, 0,
+        -.5, .5, 0,
+        .5, .5, 0,
+    ]));
+    accessor.setBuffer(buffer);
+    prim.setAttribute('POSITION', accessor);
+    const indices = doc.createAccessor();
+    indices.setType('SCALAR');
+    indices.setArray(new Uint32Array([0, 1, 2, 2, 1, 3]));
+    indices.setBuffer(buffer);
+    prim.setIndices(indices);
+    const uv = doc.createAccessor();
+    uv.setType('VEC2');
+    uv.setArray(new Float32Array([
+        0, 0,
+        1, 0,
+        0, 1,
+        1, 1,
+    ]));
+    uv.setBuffer(buffer);
+    prim.setAttribute('TEXCOORD_0', uv);
+    prim.setMaterial(mat);
+    mesh.addPrimitive(prim);
+    node.setMesh(mesh);
+    scene.addChild(node);
+    node.setName(`Quad_${i}`);
+    const pos = [i, 0, 0];
+    node.setTranslation(pos);
+    return { node, mesh, prim };
+}
+/** Resampling filter methods. LANCZOS3 is sharper, LANCZOS2 is smoother. */
+export var TextureResizeFilter;
+(function (TextureResizeFilter) {
+    /** Lanczos3 (sharp) */
+    TextureResizeFilter["LANCZOS3"] = "lanczos3";
+    /** Lanczos2 (smooth) */
+    TextureResizeFilter["LANCZOS2"] = "lanczos2";
+})(TextureResizeFilter = TextureResizeFilter || (TextureResizeFilter = {}));
+export const TEXTURE_RESIZE_DEFAULTS = {
+    size: [2048, 2048],
+    filter: TextureResizeFilter.LANCZOS3,
+    pattern: null,
+    slots: null,
+};
+export async function resizeTextureToMax(texture, maxSize, logger) {
+    const options = { ...TEXTURE_RESIZE_DEFAULTS };
+    options.size = [maxSize, maxSize];
+    await resizeTexture(options, texture, logger);
+}
+async function resizeTexture(options, texture, logger, uri, slots) {
+    const [maxWidth, maxHeight] = options.size;
+    const [srcWidth, srcHeight] = texture.getSize();
+    if (srcWidth <= maxWidth && srcHeight <= maxHeight) {
+        logger.debug(`[${NAME}] Skipping, the texture is already smaller than the requested size ${maxWidth}x${maxHeight}}`);
+        return;
+    }
+    if (maxWidth <= 0 || maxHeight <= 0) {
+        logger.debug(`${uri}: Skipping, invalid size range: ${maxWidth}x${maxHeight}`);
+        return;
+    }
+    let dstWidth = srcWidth;
+    let dstHeight = srcHeight;
+    if (dstWidth > maxWidth) {
+        dstHeight = Math.floor(dstHeight * (maxWidth / dstWidth));
+        dstWidth = maxWidth;
+    }
+    if (dstHeight > maxHeight) {
+        dstWidth = Math.floor(dstWidth * (maxHeight / dstHeight));
+        dstHeight = maxHeight;
+    }
+    logger.info("> Resize texture to " + dstWidth + "x" + dstHeight + " (from " + srcWidth + "x" + srcHeight + ")");
+    // https://sharp.pixelplumbing.com/api-resize
+    const buffer = await sharp(texture.getImage())
+        .resize(dstWidth, dstHeight, {
+        fit: 'inside',
+        kernel: "lanczos3",
+        withoutEnlargement: true,
+    })
+        .toBuffer();
+    texture.setImage(BufferUtils.toView(buffer));
+    return {
+        width: dstWidth,
+        height: dstHeight,
+    };
+}
+export function make_progressive_meshes(filePath, _options, opts) {
+    const directory = path.dirname(filePath);
+    // const fileNameWithoutExtension = path.basename(filePath, path.extname(filePath));
+    const outputDirectory = directory + "/";
+    return createTransform("PROGRESSIVE_MESHES", async (doc, _context) => {
+        const logger = doc.getLogger();
+        // this is to ensure we're not creating progressive meshes for engine versions that don't support loading them yet
+        // the generator should include the version or the app that produced the GLB too (needle engine repo: 2c00d0e304e205cf9d4ac0499faabb92a706a5c4)
+        if (currentGenerator == "Needle Engine") {
+            logger.warn("WARN: Skip creating mesh LODs - Unsupported generator found... Please update your editor integration");
+            return;
+        }
+        if (isLOD(filePath)) {
+            logger.info("Progressive Mesh Transform: skip lod at " + filePath);
+            return Promise.resolve();
+        }
+        await MeshoptSimplifier.ready;
+        const filename = path.basename(filePath);
+        logger.info(`[${NAME}]: Begin generating progressive meshes for \"${filename}\"`);
+        let index = 0;
+        // the lowest LOD (last entry) will be saved in the original file
+        let MAX_LODS = 6;
+        if (opts.config.usecase === "product") {
+            MAX_LODS = 3;
+        }
+        const LODS = [
+            {
+                ratio: 1,
+                error: 0,
+                lockBorder: true
+            },
+        ];
+        for (let l = 0; l < MAX_LODS; l++) {
+            // const t = l / MAX_LODS;
+            const latest = LODS[LODS.length - 1];
+            const ratio = latest.ratio * .5;
+            let error = Math.min(.013 * (l + 1), 0.05);
+            if (opts.config.usecase === "product") {
+                error *= .5;
+            }
+            LODS.push({
+                ratio: ratio,
+                error,
+                lockBorder: true,
+                // toleranceNormal: 0.1 + t * 0.1,
+            });
+        }
+        /** Map of visited GUID -> extension */
+        const visited = new Map();
+        const root = doc.getRoot();
+        const meshes = root.listMeshes();
+        for (const mesh of meshes) {
+            await processMesh(mesh, { filename });
+        }
+        logger.info(`[${NAME}]: Finished generating progressive meshes for \"${filename}\"`);
+        async function processMesh(mesh, args) {
+            /** The size and vertex count of the original mesh */
+            const originalMeshInformation = getMeshInformation(mesh);
+            const { totalVertexCount: originalTotalVertexCount, maxVertexCount: originalMaxVertexCount } = originalMeshInformation;
+            let settings = mesh.getExtension(NEEDLE_progressive_mesh_settings.EXTENSION_NAME);
+            if (!settings) {
+                if (originalMaxVertexCount < 32) {
+                    logger.debug(`[${NAME}] Skipping, no settings found and no primitive with more than 32 vertices. mesh[${index}] has ${originalTotalVertexCount} vertices (max: ${originalMaxVertexCount})`);
+                    return;
+                }
+                else {
+                    settings = {
+                        guid: generateGuid(args.filename + "_mesh_" + index.toString()),
+                        generateLods: true,
+                    };
+                    logger.debug(`[${NAME}] No settings found for mesh[${index}] with ${originalTotalVertexCount} vertices (max: ${originalMaxVertexCount}) - will use default settings (guid: ${settings.guid})`);
+                }
+            }
+            else if (settings.generateLods === false) {
+                logger.debug(`[${NAME}] progressive mesh disabled for mesh at index ${index++}`);
+                return;
+            }
+            const progressiveExt = doc.createExtension(NEEDLE_progressive);
+            if (!progressiveExt || !progressiveExt.createMesh) {
+                logger.debug(`[${NAME}] Skipping because progressive extension is not available. ${index++}`);
+                return;
+            }
+            // check if we have already produced LODs for this mesh
+            let needsToGenerateLODs = true;
+            const generatedLODInfos = new Array();
+            if (visited.has(settings.guid)) {
+                // we can not just set the extension here...
+                logger.debug(`[${NAME}] Mesh has already been processed ${index} - will use previously generated LODs`);
+                needsToGenerateLODs = false;
+                const existingPaths = visited.get(settings.guid);
+                generatedLODInfos.push(...existingPaths.infos);
+            }
+            /** async simplification tasks... */
+            const tasks = new Array();
+            if (needsToGenerateLODs) {
+                logger.info(`[${NAME}] Begin generating mesh LODs for \"${mesh.getName()}\"`);
+                // produce LODS, skip the last level because it will be saved in the original file
+                for (let level = 0; level < LODS.length - 1; level++) {
+                    const lod = LODS[level];
+                    const guid = settings.guid;
+                    // TODO: check if the LOD level did actually change the mesh - otherwise we can just skip generating lower resolutions
+                    const lodTask = createMeshLod(doc, outputDirectory, level, mesh, originalMeshInformation, guid, lod, opts);
+                    lodTask.then(res => {
+                        if (res?.success) {
+                            generatedLODInfos[level] = res;
+                        }
+                    });
+                    tasks.push(lodTask);
+                }
+                // wait for all LODs to be generated
+                await Promise.all(tasks);
+                tasks.length = 0;
+            }
+            // compare LOD results and ignore if the mesh did not change
+            // TODO: this should actually check mesh semantics (perhaps hash the mesh using the caching system?)
+            let prevSize = -Infinity;
+            for (let i = 0; i < generatedLODInfos.length; i++) {
+                const lodInfo = generatedLODInfos[i];
+                if (!lodInfo) {
+                    console.log(`[${NAME}] LOD ${i} doesnt exist`);
+                    continue;
+                }
+                const fullPath = outputDirectory + lodInfo.path;
+                if (existsSync(fullPath)) {
+                    const lastSize = prevSize;
+                    const sizeOnDisc = statSync(fullPath).size;
+                    const diff = lastSize - sizeOnDisc;
+                    const level = lodInfo.level;
+                    let shouldOmitLevel = false;
+                    // if the mesh size on disc is identical to the last level, we can omit this level
+                    if (sizeOnDisc <= 0) {
+                        logger.info(`[${NAME}] Flag mesh LOD ${level}: size on disc is 0 → level will be omitted (if this mesh is is taken from cache it can mean that the LOD level was omitted before). \"${mesh.getName()}\" at \"${lodInfo.path}\"`);
+                        shouldOmitLevel = true;
+                    }
+                    else if (diff == 0) {
+                        logger.info(`[${NAME}] Flag mesh LOD ${level}: size on disc did not change compared to previous level → level will be omitted. \"${mesh.getName()}\" at \"${lodInfo.path}\"`);
+                        shouldOmitLevel = true;
+                    }
+                    else if (!shouldOmitLevel) {
+                        // if the mesh vertex count difference to the last valid level is less than 32 vertices or less than 5% of the last level, we can omit this level
+                        const meshInfo = lodInfo.lodMeshInfo;
+                        const lastMeshInfo = generatedLODInfos[i - 1]?.lodMeshInfo;
+                        if (meshInfo && lastMeshInfo) {
+                            const vertexDifference = lastMeshInfo.totalVertexCount - meshInfo.totalVertexCount;
+                            const diff01 = vertexDifference / lastMeshInfo.totalVertexCount;
+                            if (vertexDifference < 0) {
+                                console.log(`WARN: ❌ [${NAME}] Flag mesh LOD ${level}: vertex count did increase (${-vertexDifference.toFixed(0)} vertices, ${(-diff01 * 100).toFixed(4)}%) → LOD ${level} will be omitted. \"${mesh.getName()}\" at \"${lodInfo.path}\" ${JSON.stringify(lastMeshInfo)} → ${JSON.stringify(meshInfo)}`);
+                                shouldOmitLevel = true;
+                            }
+                            else if (vertexDifference < 32 || diff01 < 0.05) {
+                                logger.warn(`[${NAME}] Flag mesh LOD ${level}: vertex count difference below threshold (removed ${vertexDifference.toFixed(0)} vertices, ${(-diff01 * 100).toFixed(4)}%) → LOD ${level} will be omitted. \"${mesh.getName()}\" at \"${lodInfo.path}\"`);
+                                shouldOmitLevel = true;
+                            }
+                        }
+                        if (shouldOmitLevel && opts.useCache != false && lodInfo.cacheKey != undefined) {
+                            // we invalidate the cached entry because the mesh change was too small
+                            addToCache(lodInfo.cacheKey, new Uint8Array(0));
+                        }
+                    }
+                    if (shouldOmitLevel) {
+                        generatedLODInfos.splice(i, 1);
+                        rmSync(fullPath);
+                        i--;
+                    }
+                    else {
+                        prevSize = sizeOnDisc;
+                    }
+                }
+            }
+            let maxDensity = 0;
+            let primitiveIndex = 0;
+            const lodLevelInFile = generatedLODInfos.length;
+            const clonedData = { primitives: [], weights: [...mesh.getWeights()] };
+            for (const prim of mesh.listPrimitives()) {
+                const data = clonePrimitiveData(prim, logger);
+                if (data != null) {
+                    clonedData.primitives.push(data);
+                }
+                logger.info(`[${NAME}] Simplify mesh[${index}] primitive[${primitiveIndex}] (embedded)`);
+                const lastLod = LODS[lodLevelInFile];
+                // TODO: this should be run after simplification but then we need to change the runtime to use the LOD 0 density
+                const density = calculateMeshDensity(prim);
+                maxDensity = Math.max(maxDensity, density);
+                const task = simplifyMesh(doc, mesh, prim, primitiveIndex++, lastLod);
+                tasks.push(task);
+            }
+            await Promise.all(tasks);
+            tasks.length = 0;
+            const { totalVertexCount: totalVertexCountAfter } = getMeshInformation(mesh);
+            const difference = originalTotalVertexCount - totalVertexCountAfter;
+            const diff01 = difference / originalTotalVertexCount;
+            if (totalVertexCountAfter <= 0) {
+                logger.error(`ERR: [${NAME}]: Mesh[${index}] has no vertices after simplification: ${mesh.getName()}`);
+            }
+            else if (difference < 32 || diff01 <= 0.05) {
+                // the lowest LOD has the same vertex count as the original mesh → we don't need to write the extension and can also delete previously generated LODs
+                logger.info(`[${NAME}]: Flag mesh LOD ${generatedLODInfos.length} (embedded): vertex count difference below threshold (removed ${difference} vertices, ${(-diff01 * 100).toFixed(2)} %) → will remove all LODs. \"${mesh.getName()}\"`);
+                try {
+                    for (const lodInfo of generatedLODInfos) {
+                        rmSync(outputDirectory + "/" + lodInfo.path);
+                    }
+                }
+                catch (err) {
+                    logger.error(`ERR: [${NAME}] Failed to remove LOD files for \"${mesh.getName()}\"`);
+                }
+                // reset data (simplify might have changed the mesh data that we cloned before)
+                const primitives = mesh.listPrimitives();
+                if (clonedData.primitives.length == primitives.length) {
+                    if (clonedData.weights?.length > 0) {
+                        mesh.setWeights(clonedData.weights);
+                    }
+                    for (let i = 0; i < primitives.length; i++) {
+                        setPrimitiveData(primitives[i], clonedData.primitives[i]);
+                    }
+                }
+                return;
+            }
+            if (generatedLODInfos.length > 0) {
+                const model = progressiveExt.createMesh({
+                    guid: settings.guid,
+                    lods: generatedLODInfos.map(l => {
+                        opts.results.push(resolve(outputDirectory, l.path));
+                        return {
+                            path: l.path,
+                            hash: l.content_hash.toString(),
+                            density: l.density,
+                            vertexCount: l.lodMeshInfo?.totalVertexCount,
+                            indexCount: l.lodMeshInfo?.totalIndexCount,
+                        };
+                    }),
+                    density: maxDensity,
+                });
+                mesh.setExtension(NEEDLE_PROGRESSIVE_EXTENSION_NAME, model);
+                index++;
+                if (!visited.has(settings.guid)) {
+                    visited.set(settings.guid, {
+                        model: model,
+                        infos: generatedLODInfos,
+                    });
+                }
+            }
+        }
+    });
+}
+function clonePrimitiveData(prim, logger) {
+    const semantics = prim.listSemantics();
+    if (semantics.some(s => s.includes("JOINTS"))) {
+        return null;
+    }
+    const prevIndices = prim.getIndices();
+    const indices = !prevIndices ? new Uint32Array() : new Uint32Array(prevIndices.getArray());
+    const attributes = {};
+    for (const attr of semantics) {
+        logger.info(`[${NAME}] Clone attribute ${attr}`);
+        const accessor = prim.getAttribute(attr);
+        if (accessor) {
+            attributes[attr] = new Float32Array(accessor.getArray());
+        }
+    }
+    return { indices, attributes };
+}
+function setPrimitiveData(prim, data) {
+    const indices = prim.getIndices();
+    if (indices) {
+        indices.setArray(data.indices);
+    }
+    for (const attr of prim.listSemantics()) {
+        const accessor = prim.getAttribute(attr);
+        if (accessor) {
+            accessor.setArray(data.attributes[attr]);
+        }
+    }
+}
+/**
+ * @param basePath the base path to save the lod files
+ * @param level: 0 = original, 1 = first lod, 2 = second lod, ...
+ * @param mesh the mesh
+ * @param guid a unique identifier for the mesh
+ * @param error the error to use for simplification. Higher means more simplification
+ */
+async function createMeshLod(doc, basePath, level, mesh, meshInfo, guid, lodLevel, opts) {
+    const logger = doc.getLogger();
+    const fileExtension = ".glb";
+    const fileName_withoutExtension = "mesh_lod_" + level + "_" + guid;
+    const fileName = fileName_withoutExtension + fileExtension;
+    const outPath = basePath + fileName;
+    const primitives = mesh.listPrimitives();
+    let cacheKey = undefined;
+    // generate hash for mesh
+    let hash = mesh["needle:mesh-hash"];
+    if (hash === undefined) {
+        hash = getHash(mesh);
+        mesh["needle:mesh-hash"] = hash;
+    }
+    hash += getHash(lodLevel);
+    hash += getHash({
+        guid,
+        config: opts.config,
+    });
+    if (opts.useCache !== false) {
+        cacheKey = `mesh_lod_${level}_${hash}`;
+        const cachedValue = tryGetFromCache(cacheKey);
+        const meta = tryGetMetaFromCache(cacheKey);
+        if (cachedValue && meta) {
+            logger.info(`[${NAME}] LOD ${level} loaded from cache for \"${mesh.getName()}\"`);
+            writeFileSync(outPath, cachedValue);
+            return { level, path: fileName, success: true, cacheKey, content_hash: hash, lodMeshInfo: meta.meshInfo, density: meta.density };
+        }
+    }
+    const newDoc = new Document();
+    writeNeedleAsset(newDoc);
+    const newScene = newDoc.createScene();
+    newDoc.createBuffer();
+    const newNode = newDoc.createNode();
+    newScene.addChild(newNode);
+    newNode.setName("LOD " + level + "_" + guid);
+    newNode.setTranslation([0, 0, 0]);
+    const newMesh = newDoc.createMesh();
+    newMesh.setName((mesh.getName() || "Unnamed") + " LOD " + level);
+    newNode.setMesh(newMesh);
+    const newMat = newDoc.createMaterial();
+    const weights = mesh.getWeights();
+    if (weights) {
+        newMesh.setWeights(weights);
+    }
+    const tasks = new Array();
+    // let didRunSimplification = false;
+    for (const prim of primitives) {
+        const newPrim = newDoc.createPrimitive();
+        newMesh.addPrimitive(newPrim);
+        newPrim.setName(prim.getName());
+        newPrim.setMode(prim.getMode());
+        newPrim.setMaterial(newMat);
+        const semantics = prim.listSemantics();
+        for (let i = 0; i < semantics.length; i++) {
+            const attr = prim.getAttribute(semantics[i]);
+            if (attr) {
+                const newAttr = newDoc.createAccessor();
+                newAttr.setArray(attr.getArray());
+                newAttr.setType(attr.getType());
+                newPrim.setAttribute(semantics[i], newAttr);
+            }
+            else {
+                logger.warn(`[${NAME}] Missing attribute ${semantics[i]} in mesh LOD ${level}`);
+            }
+        }
+        const indices = prim.getIndices();
+        if (indices) {
+            const newIndices = newDoc.createAccessor();
+            newIndices.setArray(indices.getArray());
+            newIndices.setType(indices.getType());
+            newPrim.setIndices(newIndices);
+        }
+        const targets = prim.listTargets();
+        for (const target of targets) {
+            const newTarget = newDoc.createPrimitiveTarget(target.getName());
+            newPrim.addTarget(newTarget);
+            for (const attr of target.listSemantics()) {
+                const accessor = target.getAttribute(attr);
+                if (accessor) {
+                    const newAccessor = newDoc.createAccessor();
+                    newAccessor.setArray(accessor.getArray());
+                    newAccessor.setType(accessor.getType());
+                    newTarget.setAttribute(attr, newAccessor);
+                }
+            }
+        }
+        ;
+        const extensions = prim.listExtensions();
+        for (const ext of extensions) {
+            const PropertyClass = ext.constructor;
+            const newProp = new PropertyClass(newDoc.getGraph());
+            try {
+                const copy = newProp.copy(ext);
+                const name = ext.extensionName;
+                newPrim.setExtension(name, copy);
+            }
+            catch (err) {
+                logger.error(`[${NAME}] Failed to copy extension ${ext.extensionName} for mesh LOD ${level} → ${err}`);
+            }
+        }
+    }
+    let primitiveIndex = 0;
+    if (lodLevel.error != undefined || lodLevel.ratio != undefined) {
+        if (lodLevel.error > 0 || lodLevel.ratio < 1) {
+            for (const newPrim of newMesh.listPrimitives()) {
+                // didRunSimplification = true;
+                const task = simplifyMesh(newDoc, newMesh, newPrim, primitiveIndex++, lodLevel);
+                tasks.push(task);
+            }
+        }
+    }
+    await Promise.all(tasks);
+    tasks.length = 0;
+    const newMeshInformation = getMeshInformation(newMesh);
+    if (newMeshInformation.totalVertexCount < 4) {
+        logger.error(`[${NAME}] mesh LOD ${level} is has less than 4 vertices → skipping`);
+        return { level, path: fileName, success: false, cacheKey: cacheKey, content_hash: hash, lodMeshInfo: null, density: null, };
+    }
+    let density = 0;
+    for (const prim of newMesh.listPrimitives()) {
+        const d = calculateMeshDensity(prim);
+        density = Math.max(density, d);
+    }
+    const progressiveExt = newDoc.createExtension(NEEDLE_progressive);
+    if (!progressiveExt || !progressiveExt.createMesh) {
+        logger.error("Failed to create progressive extension");
+        return;
+    }
+    newMesh.setExtension(NEEDLE_PROGRESSIVE_EXTENSION_NAME, progressiveExt.createMesh({
+        guid: guid,
+        density: density,
+    }));
+    // we need to compress the mesh with the same compression method as the original file
+    const root = doc.getRoot();
+    const compressionExt = root.getExtension(NEEDLE_mesh_compression.EXTENSION_NAME);
+    if (compressionExt) {
+        const newExt = newDoc.createExtension(NEEDLE_mesh_compression);
+        const newProp = newExt.create(compressionExt.model);
+        logger.info(`[${NAME}] Pass compression format to mesh LOD ${level} → ${JSON.stringify(compressionExt.model)}`);
+        newDoc.getRoot().setExtension(NEEDLE_mesh_compression.EXTENSION_NAME, newProp);
+    }
+    await newDoc.transform(sparse());
+    const newIo = new NodeIO();
+    registerExtensions(newIo);
+    logger.info(`[${NAME}] Write mesh LOD ${level} with to \"${fileName}\"`);
+    await newIo.write(outPath, newDoc);
+    // const hasChanged = meshInfo.maxVertexCount == newMeshInformation.maxVertexCount && meshInfo.totalVertexCount == newMeshInformation.totalVertexCount;
+    // add to cache
+    if (cacheKey != undefined) {
+        const bytes = readFileSync(outPath);
+        addToCache(cacheKey, bytes);
+        addMetaToCache(cacheKey, { meshInfo: newMeshInformation, density: density });
+    }
+    return { level, path: fileName, success: true, lodMeshInfo: newMeshInformation, cacheKey: cacheKey, content_hash: hash, density: density };
+}
+async function simplifyMesh(doc, mesh, prim, index, lodinfo) {
+    const weldOptions = {
+        ...WELD_DEFAULTS,
+        overwrite: true,
+        cleanup: false,
+        tolerance: 0.00000000001,
+        ...lodinfo,
+    };
+    const simplifyOptions = {
+        ...SIMPLIFY_DEFAULTS,
+        ...lodinfo,
+        simplifier: MeshoptSimplifier,
+    };
+    return compressPrimitive(doc, mesh, prim, index, weldOptions, simplifyOptions);
+}
+export function isMeshLOD(filepath) {
+    return filepath.includes("mesh_lod_");
+}
+export function isImageLOD(filepath) {
+    return filepath.includes("image_");
+}
+export function isLOD(filepath) {
+    return isMeshLOD(filepath) || isImageLOD(filepath);
+}