@meimu/mutracer 0.1.5 → 0.2.0

package/lib/renderer/MaterialTable.d.ts

@@ -1,111 +1,24 @@
-import { type MaterialTextureIndex } from './materialTextureSlots.js';
-import { ShadowCatcherMaterial, UnlitMaterial } from '../constants.js';
-import { vec2 } from '../math.js';
+import type { MaterialTableOptions, TextureAtlasStats } from './textureAtlas.js';
 import { Texture2DArray as WebGLTexture2DArray } from './webgl.js';
-import OpenPBRMaterial from '../scene/OpenPBRMaterial.js';
-import { ColorRGB } from '../types.js';
-import Texture from '../scene/Texture.js';
-import { SceneLight } from '../scene/Scene.js';
-export declare const DEFAULT_MAX_TEXTURE_ARRAY_BYTES: number;
-export interface MaterialTableOptions {
-    maxTextureArrayBytes?: number;
-    maxTextureArrayLayers?: number;
-    maxTextureDimension2D?: number;
-}
-export interface TextureAtlasStats {
-    estimatedBytes: number;
-    height: number;
-    layers: number;
-    packTimeMs: number;
-    scale: number;
-    sourcePixels: number;
-    textureCount: number;
-    width: number;
-}
-export declare function materialUsesMedium(material: OpenPBRMaterial): boolean;
-export declare const uvProjectionConstants: {
-    none: number;
-    spherical: number;
-    cylindrical: number;
-    triplanar: number;
-};
-export interface BufferData extends Record<MaterialTextureIndex, number[]> {
-    color: ColorRGB[];
-    roughness: number[];
-    metallic: number[];
-    emission: ColorRGB[];
-    ior: number[];
-    transmission: number[];
-    dispersion: number[];
-    thinFilmThickness: number[];
-    thinFilmThicknessMinimum: number[];
-    thinFilmMapChannel: number[];
-    thinFilmIor: number[];
-    anisotropy: number[];
-    thin: number[];
-    doubleSided: number[];
-    bevelSize: number[];
-    mapAlphaUsage: number[];
-    normalScale: vec2.Vec2Array[];
-    type: (typeof ShadowCatcherMaterial | typeof UnlitMaterial | 0)[];
-    mapInfo: number[];
-    mapTransform: number[];
-    mapWrap: number[];
-    mapUvChannel: number[];
-    mapColorLinear: number[];
-    mediumType: number[];
-    specularAnisotropyModel: number[];
-    specularAnisotropyRotation: number[];
-    coatAnisotropyRotation: number[];
-    coatNormalScale: vec2.Vec2Array[];
-    uvProjection: number[];
-    uvScale: vec2.Vec2Array[];
-    displacementUvProjection: number[];
-    displacementUvProjectionScale: number[];
-    displacementStepSize: number[];
-    displacementBias: number[];
-    alpha: number[];
-    alphaMode: number[];
-    alphaCutoff: number[];
-    baseWeight: number[];
-    baseDiffuseRoughness: number[];
-    specularWeight: number[];
-    specularColor: ColorRGB[];
-    transmissionColor: ColorRGB[];
-    transmissionDepth: number[];
-    transmissionScatter: ColorRGB[];
-    transmissionScatterAnisotropy: number[];
-    subsurfaceWeight: number[];
-    subsurfaceColor: ColorRGB[];
-    subsurfaceRadius: number[];
-    subsurfaceRadiusScale: ColorRGB[];
-    subsurfaceScatterAnisotropy: number[];
-    fuzzWeight: number[];
-    fuzzColor: ColorRGB[];
-    fuzzRoughness: number[];
-    coatWeight: number[];
-    coatColor: ColorRGB[];
-    coatRoughness: number[];
-    coatAnisotropy: number[];
-    coatIor: number[];
-    coatDarkening: number[];
-    thinFilmWeight: number[];
-    dispersionAbbeNumber: number[];
-    mediumExtinction: ColorRGB[];
-    mediumScattering: ColorRGB[];
-    mediumAnisotropy: number[];
-}
+import type OpenPBRMaterial from '../scene/OpenPBRMaterial.js';
+import type Texture from '../scene/Texture.js';
+import type { SceneLight } from '../scene/Scene.js';
+export { DEFAULT_MAX_TEXTURE_ARRAY_BYTES } from './textureAtlas.js';
+export type { MaterialTableOptions, TextureAtlasStats } from './textureAtlas.js';
+export { materialUsesMedium } from './materialParams.js';
+export { uvProjectionConstants } from './materialConstants.js';
+export type { BufferData } from './materialBufferData.js';
+import type { BufferData } from './materialBufferData.js';
 declare class MaterialTable {
     texture: WebGLTexture2DArray | undefined;
     textureAtlasStats: TextureAtlasStats;
-    defines: Record<string, string | number>;
+    defines: Record<string, number>;
     bufferData: BufferData;
     private _matBufferTex;
     private _materialBufferColumnsLog;
     private _displacementMaps;
     private _lightTexturesIndices;
     constructor(materials: OpenPBRMaterial[], lights: SceneLight[], options?: MaterialTableOptions);
-    private _packParams;
     /** Repack parameters with the same material slots and unchanged texture metadata. */
     repackParams(materials: OpenPBRMaterial[]): void;
     getBufferArray(): Float32Array<ArrayBufferLike>;

package/lib/renderer/MaterialTable.js

@@ -1,106 +1,19 @@
-import { specularAnisotropyModelIndex, finiteAnisotropySource } from '../scene/anisotropyParameters.js';
-import { finiteFilmThickness, thinFilmMapChannelIndex } from '../scene/thinFilmParameters.js';
-import { MATERIAL_TEXTURE_NAMES, MATERIAL_TEXTURE_SLOTS } from './materialTextureSlots.js';
+import { isProceduralSkyImage } from '../scene/skyParameters.js';
+import MaterialData from './MaterialData.js';
 import { packMaterialBuffer } from './materialLayout.js';
+import { repackMaterialParams } from './materialParams.js';
+import { writeAtlasPixel, writeRawAtlasPlacement } from './textureAtlasPixels.js';
 import { float16Bits } from './float16.js';
 import { createCanvas } from '../util/canvas.js';
-import { mapAlphaUsageConstants } from './materialConstants.js';
 // Portions adapted from ray-tracing-renderer@0.10.15
 // (https://github.com/hoverinc/ray-tracing-renderer).
 // Copyright (c) 2019 HOVER, MIT license; see LICENSES/RayTracingRenderer-MIT.txt.
-import { ShadowCatcherMaterial, UnlitMaterial } from '../constants.js';
-import { materialEmission } from './materialEmission.js';
 import { Texture2DArray as WebGLTexture2DArray, constants, Texture2D } from './webgl.js';
-import { materialAlphaModeConstants, resolveMaterialAlphaMode } from '../scene/OpenPBRMaterial.js';
-import { mergeTexturesFromMaterials } from './texturesFromMaterials.js';
-import { isTextureDataSource, textureWrapIndex } from '../scene/Texture.js';
+import { isTextureDataSource } from '../scene/Texture.js';
 import { commonNearestFloatProps, setDataTexture } from './dataTextureUtil.js';
-export const DEFAULT_MAX_TEXTURE_ARRAY_BYTES = 384 * 1024 * 1024;
-export function materialUsesMedium(material) {
-    return !material.thinWalled && ((material.transmissionWeight > 0 && material.transmissionDepth > 0) ||
-        material.subsurfaceWeight > 0);
-}
-export const uvProjectionConstants = {
-    none: 0,
-    spherical: 1,
-    cylindrical: 2,
-    triplanar: 3
-};
-/**
- * Packs material textures into a small 2D-array atlas.
- *
- * The input rectangles are sorted from tallest/largest to smallest, then
- * placed with a shelf allocator. Each atlas layer contains horizontal shelves;
- * a texture is inserted into the first shelf with enough remaining width, or a
- * new shelf is opened below the existing ones. A new array layer is allocated
- * only when none of the current layers has enough room.
- *
- * `makeTextureArray` first tries this packing at full resolution. If the result
- * exceeds the adapter layer limit or the configured memory budget, it performs
- * a binary search for the largest uniform scale that fits. This preserves full
- * resolution whenever packing alone is sufficient and degrades predictably on
- * constrained hardware.
- *
- * The returned placements keep the original logical texture indices. Shaders
- * use per-texture atlas metadata instead of treating the logical index as the
- * physical array layer.
- */
-function packTextureAtlas(textures, pageSize, scale) {
-    const pages = [];
-    const placements = new Array(textures.length);
-    const items = textures
-        .map((texture, index) => ({
-        height: Math.max(1, Math.floor(texture.image.height * scale)),
-        index,
-        width: Math.max(1, Math.floor(texture.image.width * scale))
-    }))
-        .sort((a, b) => b.height - a.height || b.width - a.width);
-    for (const item of items) {
-        let placement;
-        for (let layer = 0; layer < pages.length && !placement; layer++) {
-            const page = pages[layer];
-            for (const shelf of page.shelves) {
-                if (item.height <= shelf.height &&
-                    shelf.x + item.width <= pageSize) {
-                    placement = {
-                        ...item,
-                        layer,
-                        x: shelf.x,
-                        y: shelf.y
-                    };
-                    shelf.x += item.width;
-                    break;
-                }
-            }
-            if (!placement && page.nextY + item.height <= pageSize) {
-                placement = {
-                    ...item,
-                    layer,
-                    x: 0,
-                    y: page.nextY
-                };
-                page.shelves.push({
-                    height: item.height,
-                    x: item.width,
-                    y: page.nextY
-                });
-                page.nextY += item.height;
-            }
-        }
-        if (!placement) {
-            const layer = pages.length;
-            placement = { ...item, layer, x: 0, y: 0 };
-            pages.push({
-                nextY: item.height,
-                placements: [],
-                shelves: [{ height: item.height, x: item.width, y: 0 }]
-            });
-        }
-        pages[placement.layer].placements.push(placement);
-        placements[item.index] = placement;
-    }
-    return { pages, placements };
-}
+export { DEFAULT_MAX_TEXTURE_ARRAY_BYTES } from './textureAtlas.js';
+export { materialUsesMedium } from './materialParams.js';
+export { uvProjectionConstants } from './materialConstants.js';
 function createAtlasCanvas(width, height) {
     return createCanvas(width, height);
 }
@@ -118,34 +31,14 @@ function createDataAtlasPage(width, height, page, textures, floatStorage) {
             drawAtlasImage(context, placement, textures[placement.index]);
         const pixels = context.getImageData(0, 0, width, height).data;
         for (let i = 0; i < pixels.length; i++)
-            data[i] = floatStorage ? float16Bits(pixels[i] / 255) : pixels[i];
+            writeAtlasPixel(data, i, floatStorage ? float16Bits(pixels[i] / 255) : pixels[i]);
     }
     for (const placement of page.placements) {
         const texture = textures[placement.index];
         const source = texture.image;
         if (!isTextureDataSource(source))
             continue;
-        const bytes = source.data instanceof Uint8Array || source.data instanceof Uint8ClampedArray;
-        if (!bytes && !(source.data instanceof Float32Array) && !(source.data instanceof Int32Array)) {
-            throw new Error('Material texture data must be Uint8Array, Uint8ClampedArray, Float32Array or Int32Array.');
-        }
-        if (source.data.length !== source.width * source.height * 4) {
-            throw new Error('Material texture RGBA source length does not match its dimensions.');
-        }
-        for (let y = 0; y < placement.height; y++) {
-            let sourceY = Math.min(source.height - 1, Math.floor(((y + 0.5) * source.height) / placement.height));
-            if (texture.flipY)
-                sourceY = source.height - 1 - sourceY;
-            for (let x = 0; x < placement.width; x++) {
-                const sourceX = Math.min(source.width - 1, Math.floor(((x + 0.5) * source.width) / placement.width));
-                const sourceOffset = (sourceY * source.width + sourceX) * 4;
-                const targetOffset = ((placement.y + y) * width + placement.x + x) * 4;
-                for (let c = 0; c < 4; c++) {
-                    const value = source.data[sourceOffset + c];
-                    data[targetOffset + c] = floatStorage ? float16Bits(bytes ? value / 255 : value) : value;
-                }
-            }
-        }
+        writeRawAtlasPlacement(data, width, placement, { image: source, flipY: texture.flipY }, floatStorage);
     }
     return { data, width, height };
 }
@@ -161,15 +54,10 @@ function drawAtlasImage(context, placement, texture) {
         context.drawImage(texture.image, placement.x, placement.y, placement.width, placement.height);
     }
 }
-function makeTextureArray(textures, sRGB = false, options = {}) {
+function makeTextureArray(textures, plan, sRGB = false) {
     const packStart = performance.now();
     if (!textures.length) {
         return {
-            mapInfo: [],
-            mapTransform: [],
-            mapUvChannel: [],
-            mapColorLinear: [],
-            mapWrap: [],
             stats: {
                 estimatedBytes: 0,
                 height: 1,
@@ -192,54 +80,9 @@ function makeTextureArray(textures, sRGB = false, options = {}) {
             })
         };
     }
-    const dataBacked = textures.some((texture) => isTextureDataSource(texture.image));
-    const mapColorLinear = textures.map(texture => {
-        const image = texture.image;
-        return Number(texture.colorSpace ? texture.colorSpace === 'linear' : isTextureDataSource(image) &&
-            !(image.data instanceof Uint8Array) && !(image.data instanceof Uint8ClampedArray));
-    });
-    // Storage precision depends on the pixels, independently of their transfer function.
-    const floatStorage = textures.some(({ image }) => isTextureDataSource(image) &&
-        !(image.data instanceof Uint8Array) && !(image.data instanceof Uint8ClampedArray));
-    const bytesPerPixel = floatStorage ? 8 : 4;
-    const maxTextureArrayLayers = options.maxTextureArrayLayers ?? Infinity;
-    const maxTextureDimension2D = options.maxTextureDimension2D ?? Infinity;
-    const maxTextureArrayBytes = options.maxTextureArrayBytes ?? DEFAULT_MAX_TEXTURE_ARRAY_BYTES;
-    const sourcePixels = textures.reduce((sum, texture) => sum + texture.image.width * texture.image.height, 0);
-    const maxSourceDimension = textures.reduce((max, texture) => Math.max(max, texture.image.width, texture.image.height), 1);
-    const maxPageSizeFromBudget = Math.max(1, Math.floor(Math.sqrt(maxTextureArrayBytes / bytesPerPixel)));
-    const pageSize = Math.max(1, Math.floor(Math.min(maxSourceDimension, maxTextureDimension2D, maxPageSizeFromBudget)));
-    const pageBytes = pageSize * pageSize * bytesPerPixel;
-    const maxPageCount = Math.max(1, Math.min(maxTextureArrayLayers, Math.floor(maxTextureArrayBytes / pageBytes)));
-    const maxScale = Math.min(1, pageSize / maxSourceDimension);
-    let packed = packTextureAtlas(textures, pageSize, maxScale);
-    let scale = maxScale;
-    if (packed.pages.length > maxPageCount) {
-        let low = 0;
-        let high = maxScale;
-        let bestPacked;
-        let bestScale = 0;
-        for (let i = 0; i < 14; i++) {
-            const candidateScale = (low + high) / 2;
-            const candidate = packTextureAtlas(textures, pageSize, candidateScale);
-            if (candidate.pages.length <= maxPageCount) {
-                low = candidateScale;
-                bestScale = candidateScale;
-                bestPacked = candidate;
-            }
-            else {
-                high = candidateScale;
-            }
-        }
-        if (!bestPacked) {
-            throw new Error(`Unable to fit ${textures.length} textures into ${maxPageCount} atlas layers.`);
-        }
-        packed = bestPacked;
-        scale = bestScale;
-    }
-    const atlasWidth = Math.max(1, ...packed.placements.map((placement) => placement.x + placement.width));
-    const atlasHeight = Math.max(1, ...packed.placements.map((placement) => placement.y + placement.height));
-    const pages = packed.pages.map((page) => {
+    const dataBacked = textures.some(texture => isTextureDataSource(texture.image));
+    const atlasWidth = plan.width, atlasHeight = plan.height, floatStorage = plan.floatStorage;
+    const pages = plan.pages.map((page) => {
         if (dataBacked) {
             return createDataAtlasPage(atlasWidth, atlasHeight, page, textures, floatStorage);
         }
@@ -252,22 +95,8 @@ function makeTextureArray(textures, sRGB = false, options = {}) {
             drawAtlasImage(context, placement, textures[placement.index]);
         return canvas;
     });
-    if (scale < 0.999) {
-        console.warn(`Texture atlas downscaled to ${(scale * 100).toFixed(1)}% to fit the GPU budget.`);
-    }
-    // mapInfo = [uvScale.x, uvScale.y, layer + uvOffset.x, uvOffset.y].
-    // Packing layer and X offset into one float keeps the shader metadata to one
-    // vec4 per logical texture; floor(z) restores the layer and fract(z) the X.
-    const mapInfo = packed.placements.flatMap((placement) => {
-        const offsetX = (placement.x + 0.5) / atlasWidth;
-        const offsetY = (placement.y + 0.5) / atlasHeight;
-        return [
-            Math.max(placement.width - 1, 0) / atlasWidth,
-            Math.max(placement.height - 1, 0) / atlasHeight,
-            placement.layer + offsetX,
-            offsetY
-        ];
-    });
+    if (plan.stats.scale < 0.999)
+        console.warn(`Texture atlas downscaled to ${(plan.stats.scale * 100).toFixed(1)}% to fit the GPU budget.`);
     const texture = new WebGLTexture2DArray({
         width: atlasWidth,
         height: atlasHeight,
@@ -281,114 +110,7 @@ function makeTextureArray(textures, sRGB = false, options = {}) {
         wrapS: constants.CLAMP_TO_EDGE,
         wrapT: constants.CLAMP_TO_EDGE
     });
-    return {
-        texture,
-        mapInfo,
-        mapTransform: textures.flatMap((texture) => [
-            texture.uvScale[0],
-            texture.uvScale[1],
-            texture.uvOffset[0],
-            texture.uvOffset[1]
-        ]),
-        mapUvChannel: textures.map((texture) => texture.uvChannel),
-        mapWrap: textures.flatMap(texture => [textureWrapIndex(texture.wrapS), textureWrapIndex(texture.wrapT)]),
-        mapColorLinear,
-        stats: {
-            estimatedBytes: atlasWidth * atlasHeight * pages.length * bytesPerPixel,
-            height: atlasHeight,
-            layers: pages.length,
-            packTimeMs: performance.now() - packStart,
-            scale,
-            sourcePixels,
-            textureCount: textures.length,
-            width: atlasWidth
-        }
-    };
-}
-function clampColor(color, fallback = 0) {
-    return [0, 1, 2].map((channel) => {
-        const value = Number(color[channel]);
-        return Number.isFinite(value) ? Math.min(1, Math.max(0, value)) : fallback;
-    });
-}
-function emptyOpenPbrMedium() {
-    return {
-        anisotropy: 0,
-        extinction: [0, 0, 0],
-        scattering: [0, 0, 0]
-    };
-}
-function transmissionMedium(material) {
-    const weight = Math.min(1, Math.max(0, material.transmissionWeight));
-    const depth = Math.max(0, material.transmissionDepth);
-    if (weight <= 0 || depth <= 0 || material.thinWalled)
-        return undefined;
-    const color = clampColor(material.transmissionColor, 1);
-    const scatterColor = clampColor(material.transmissionScatter);
-    const extinction = color.map((channel) => Math.max(0, -Math.log(Math.max(channel, 1e-6)) / depth));
-    const scattering = scatterColor.map((channel, index) => extinction[index] * channel);
-    return {
-        anisotropy: Math.min(0.999, Math.max(-0.999, material.transmissionScatterAnisotropy)),
-        extinction,
-        scattering
-    };
-}
-function subsurfaceMedium(material) {
-    const weight = Math.min(1, Math.max(0, material.subsurfaceWeight));
-    if (weight <= 0 || material.thinWalled)
-        return undefined;
-    // OpenPBR's radius is the extinction mean free path. The van de Hulst
-    // mapping converts the artist-facing multiple-scattering color to a
-    // single-scattering albedo while compensating for phase anisotropy.
-    const radius = Math.max(material.subsurfaceRadius, 1e-3);
-    const radiusScale = clampColor(material.subsurfaceRadiusScale, 1);
-    const color = clampColor(material.subsurfaceColor);
-    const anisotropy = Math.min(0.999, Math.max(-0.999, material.subsurfaceAnisotropy));
-    const extinction = radiusScale.map((scale) => 1 / Math.max(radius * scale, 1e-3));
-    const scattering = color.map((channel, index) => {
-        const s = 4.09712 + 4.20863 * channel - Math.sqrt(9.59217 + 41.6808 * channel + 17.7126 * channel * channel);
-        const sSquared = s * s;
-        const albedo = Math.min(1, Math.max(0, (1 - sSquared) / (1 - anisotropy * sSquared)));
-        return extinction[index] * albedo;
-    });
-    return { anisotropy, extinction, scattering };
-}
-function combineOpenPbrMedia(material, transmission, subsurface) {
-    const transmissionFraction = transmission
-        ? Math.min(1, Math.max(0, material.transmissionWeight))
-        : 0;
-    const subsurfaceFraction = subsurface
-        ? (1 - transmissionFraction)
-            * Math.min(1, Math.max(0, material.subsurfaceWeight))
-        : 0;
-    const total = transmissionFraction + subsurfaceFraction;
-    if (total <= 0)
-        return undefined;
-    const transmissionWeight = transmissionFraction / total;
-    const subsurfaceWeight = subsurfaceFraction / total;
-    const extinction = [0, 1, 2].map((channel) => {
-        const transmissionAbsorption = transmission
-            ? transmission.extinction[channel] - transmission.scattering[channel]
-            : 0;
-        const subsurfaceAbsorption = subsurface
-            ? subsurface.extinction[channel] - subsurface.scattering[channel]
-            : 0;
-        const absorption = transmissionAbsorption * transmissionWeight
-            + subsurfaceAbsorption * subsurfaceWeight;
-        const scattering = (transmission?.scattering[channel] || 0)
-            * transmissionWeight
-            + (subsurface?.scattering[channel] || 0) * subsurfaceWeight;
-        return Math.max(0, absorption + scattering);
-    });
-    const scattering = [0, 1, 2].map((channel) => (transmission?.scattering[channel] || 0) * transmissionWeight
-        + (subsurface?.scattering[channel] || 0) * subsurfaceWeight);
-    const anisotropy = (transmission?.anisotropy || 0) * transmissionWeight
-        + (subsurface?.anisotropy || 0) * subsurfaceWeight;
-    return { anisotropy, extinction, scattering };
-}
-function openPbrMedium(material) {
-    const volume = combineOpenPbrMedia(material, transmissionMedium(material), subsurfaceMedium(material));
-    return volume ?? emptyOpenPbrMedium();
+    return { texture, stats: { ...plan.stats, packTimeMs: performance.now() - packStart } };
 }
 class MaterialTable {
     texture;
@@ -400,128 +122,28 @@ class MaterialTable {
     _displacementMaps = [];
     _lightTexturesIndices = [];
     constructor(materials, lights, options = {}) {
-        const maps = mergeTexturesFromMaterials(materials, MATERIAL_TEXTURE_NAMES);
-        this._displacementMaps =
-            maps.indices.displacementMap
-                .map((idx) => {
-                return maps.textures[idx];
-            })
-                .filter((a) => !!a);
-        const bufferData = this._packParams(materials);
-        const allTextures = maps.textures.slice();
-        const lightTexturesIndices = [];
-        for (let i = 0; i < lights.length; i++) {
-            const light = lights[i];
-            if (light.type === 'RectLight' && light.texture) {
-                lightTexturesIndices.push(allTextures.length);
-                allTextures.push(light.texture);
-            }
-            else {
-                lightTexturesIndices.push(-1);
-            }
-        }
-        const { mapInfo, mapTransform, mapUvChannel, mapColorLinear, mapWrap, stats, texture } = makeTextureArray(allTextures, false, options);
+        const packStart = performance.now();
+        const data = new MaterialData(materials, lights.map(light => light.type === 'RectLight' ? light.texture : undefined), texture => {
+            const image = texture.image;
+            return Number(texture.colorSpace ? texture.colorSpace === 'linear' : isTextureDataSource(image) && !(image.data instanceof Uint8Array) && !(image.data instanceof Uint8ClampedArray));
+        }, options, texture => {
+            const image = texture.image;
+            return isTextureDataSource(image) && !(image.data instanceof Uint8Array) && !(image.data instanceof Uint8ClampedArray);
+        });
+        if (data.textures.some(texture => isProceduralSkyImage(texture.image)))
+            throw new Error('ProceduralSky is only supported as an environment or background.');
+        const { texture, stats } = makeTextureArray(data.textures, data.atlas);
         this.texture = texture;
-        this.textureAtlasStats = stats;
-        bufferData.mapInfo = mapInfo;
-        bufferData.mapTransform = mapTransform;
-        bufferData.mapWrap = mapWrap;
-        bufferData.mapUvChannel = mapUvChannel;
-        bufferData.mapColorLinear = mapColorLinear;
-        for (const slot of MATERIAL_TEXTURE_SLOTS) {
-            bufferData[slot.index] = maps.indices[slot.property];
-        }
-        this.bufferData = bufferData;
-        this._lightTexturesIndices = lightTexturesIndices;
-        function countMaps(indices) {
-            return indices.filter((idx) => idx >= 0).length;
-        }
-        this.defines = {
-            NUM_MAPS: allTextures.length,
-            ...Object.fromEntries(MATERIAL_TEXTURE_SLOTS.flatMap(slot => slot.define
-                ? [[slot.define, countMaps(maps.indices[slot.property])]] : []))
-        };
+        this.textureAtlasStats = { ...stats, packTimeMs: performance.now() - packStart };
+        this.bufferData = data.bufferData;
+        this.defines = data.defines;
+        this._displacementMaps = data.displacementMaps;
+        this._lightTexturesIndices = data.lightTexturesIndices;
         this._updateBuffer();
     }
-    _packParams(materials) {
-        const media = materials.map(openPbrMedium);
-        return {
-            color: materials.map((m) => m.baseColor.slice(0, 3)),
-            roughness: materials.map(m => m.specularAnisotropyModel === 'gltf' ? finiteAnisotropySource(m.specularRoughness, 0.3) : m.specularRoughness),
-            emission: materials.map(materialEmission),
-            metallic: materials.map((m) => m.baseMetalness),
-            ior: materials.map((m) => m.specularIor),
-            dispersion: materials.map((m) => m.transmissionDispersionScale),
-            thin: materials.map((m) => +m.thinWalled),
-            bevelSize: materials.map((m) => m.bevelSize),
-            transmission: materials.map((m) => m.transmissionWeight),
-            anisotropy: materials.map(m => m.specularAnisotropyModel === 'gltf' ? finiteAnisotropySource(m.specularAnisotropy, 0) : m.specularAnisotropy),
-            specularAnisotropyModel: materials.map(m => specularAnisotropyModelIndex(m.specularAnisotropyModel)),
-            thinFilmThickness: materials.map((m) => finiteFilmThickness(m.thinFilmThickness, 0.5)),
-            thinFilmThicknessMinimum: materials.map((m) => finiteFilmThickness(m.thinFilmThicknessMinimum, 0)),
-            thinFilmMapChannel: materials.map((m) => thinFilmMapChannelIndex(m.thinFilmMapChannel)),
-            thinFilmIor: materials.map((m) => m.thinFilmIor),
-            normalScale: materials.map((m) => m.normalScale),
-            mapAlphaUsage: materials.map((m) => mapAlphaUsageConstants[m.mapAlphaUsage]),
-            type: materials.map((m) => {
-                if (m.shadowCatcher) {
-                    return ShadowCatcherMaterial;
-                }
-                if (m.unlit) {
-                    return UnlitMaterial;
-                }
-                // Standard material
-                return 0;
-            }),
-            // Retain mediumType until both legacy readers are migrated; the
-            // direction and coat-normal inputs are reserved for later C1 steps.
-            mediumType: materials.map((m) => Number(materialUsesMedium(m))),
-            specularAnisotropyRotation: materials.map(m => Number.isFinite(m.specularAnisotropyRotation) ? m.specularAnisotropyRotation : 0),
-            coatAnisotropyRotation: materials.map(m => Number.isFinite(m.coatAnisotropyRotation) ? m.coatAnisotropyRotation : 0),
-            coatNormalScale: materials.map(m => m.coatNormalScale),
-            uvProjection: materials.map((m) => uvProjectionConstants[m.uvProjection] || 0),
-            uvScale: materials.map((m) => m.uvProjectionScale || [1, 1]),
-            displacementUvProjection: materials.map((m) => uvProjectionConstants[m.displacementUvProjection] || 0),
-            displacementUvProjectionScale: materials.map((m) => m.displacementUvProjectionScale || 1),
-            displacementBias: materials.map((m) => m.displacementBias),
-            displacementStepSize: materials.map((m) => Number.isFinite(m.displacementStepSize) && m.displacementStepSize > 0 ? m.displacementStepSize : 0),
-            // Alpha
-            alpha: materials.map((m) => m.opacity),
-            alphaMode: materials.map((m) => materialAlphaModeConstants[resolveMaterialAlphaMode(m)]),
-            alphaCutoff: materials.map((m) => Math.max(0, m.alphaCutoff)),
-            doubleSided: materials.map((m) => Number(m.doubleSided)),
-            baseWeight: materials.map((m) => m.baseWeight),
-            baseDiffuseRoughness: materials.map((m) => m.baseDiffuseRoughness),
-            specularWeight: materials.map((m) => m.specularWeight),
-            specularColor: materials.map((m) => clampColor(m.specularColor, 1)),
-            transmissionColor: materials.map((m) => clampColor(m.transmissionColor, 1)),
-            transmissionDepth: materials.map((m) => Math.max(0, m.transmissionDepth)),
-            transmissionScatter: materials.map((m) => clampColor(m.transmissionScatter)),
-            transmissionScatterAnisotropy: materials.map((m) => m.transmissionScatterAnisotropy),
-            subsurfaceWeight: materials.map((m) => m.subsurfaceWeight),
-            subsurfaceColor: materials.map((m) => clampColor(m.subsurfaceColor)),
-            subsurfaceRadius: materials.map((m) => Math.max(0, m.subsurfaceRadius)),
-            subsurfaceRadiusScale: materials.map((m) => clampColor(m.subsurfaceRadiusScale)),
-            subsurfaceScatterAnisotropy: materials.map((m) => m.subsurfaceAnisotropy),
-            fuzzWeight: materials.map((m) => m.fuzzWeight),
-            fuzzColor: materials.map((m) => clampColor(m.fuzzColor, 1)),
-            fuzzRoughness: materials.map((m) => m.fuzzRoughness),
-            coatWeight: materials.map((m) => m.coatWeight),
-            coatColor: materials.map((m) => clampColor(m.coatColor, 1)),
-            coatRoughness: materials.map((m) => m.coatRoughness),
-            coatAnisotropy: materials.map((m) => m.coatAnisotropy),
-            coatIor: materials.map((m) => m.coatIor),
-            coatDarkening: materials.map((m) => m.coatDarkening),
-            thinFilmWeight: materials.map((m) => m.thinFilmWeight),
-            dispersionAbbeNumber: materials.map((m) => m.transmissionDispersionAbbeNumber),
-            mediumExtinction: media.map((medium) => medium.extinction),
-            mediumScattering: media.map((medium) => medium.scattering),
-            mediumAnisotropy: media.map((medium) => medium.anisotropy),
-        };
-    }
     /** Repack parameters with the same material slots and unchanged texture metadata. */
     repackParams(materials) {
-        Object.assign(this.bufferData, this._packParams(materials));
+        repackMaterialParams(this.bufferData, materials);
         this._updateBuffer();
     }
     getBufferArray() {