@woosh/meep-engine 2.34.49 → 2.35.2

package/engine/graphics/material/optimization/MaterialOptimizationContext.js

@@ -1,9 +1,6 @@
 import { traverseThreeObject } from "../../ecs/highlight/renderer/traverseThreeObject.js";
 import { TextureAttachmentsByMaterialType } from "../../../asset/loaders/material/TextureAttachmensByMaterialType.js";
 import { HashMap } from "../../../../core/collection/HashMap.js";
-import Vector2 from "../../../../core/geom/Vector2.js";
-import { traverseMaterialTextures } from "../../../asset/loaders/material/traverseMaterialTextures.js";
-import { max2 } from "../../../../core/math/max2.js";
 import AABB2 from "../../../../core/geom/AABB2.js";
 import { MaxRectanglesPacker } from "../../../../core/geom/packing/MaxRectangles.js";
 import { Sampler2D } from "../../texture/sampler/Sampler2D.js";
@@ -12,192 +9,358 @@ import { computeMaterialHash } from "../../../asset/loaders/material/computeMate
 import { computeMaterialEquality } from "../../../asset/loaders/material/computeMaterialEquality.js";
 import { collectIteratorValueToArray } from "../../../../core/collection/IteratorUtils.js";
 import {
+    AdditiveBlending,
     ClampToEdgeWrapping,
     DataTexture,
-    LinearEncoding,
-    LinearFilter,
-    LinearMipmapLinearFilter,
     Matrix3,
-    sRGBEncoding,
-    UnsignedByteType
+    MeshStandardMaterial,
+    MultiplyBlending,
+    NormalBlending
 } from "three";
 import { convertTexture2Sampler2D } from "../../texture/sampler/convertTexture2Sampler2D.js";
+import { BUFFER_GEOMETRY_UVS } from "./BUFFER_GEOMETRY_UVS.js";
+import { is_compliant_mesh } from "./is_compliant_mesh.js";
+import { MaterialDescriptor } from "./MaterialDescriptor.js";
+import { computeThreeTextureTypeFromDataType } from "../../render/forward_plus/data/computeThreeTextureTypeFromDataType.js";
+import { typedArrayToDataType } from "../../../../core/collection/array/typedArrayToDataType.js";
+import { DataType } from "../../../../core/collection/table/DataType.js";
+import { compute_typed_array_constructor_from_data_type } from "../../../../core/collection/table/DataType2TypedArrayConstructorMapping.js";
+import { copy_Sampler2D_channel_data } from "../../texture/sampler/copy_Sampler2D_channel_data.js";
+import { channelCountToThreeTextureFormat } from "../../texture/channelCountToThreeTextureFormat.js";
+import { prepare_atlas_texture } from "./prepare_atlas_texture.js";
+import { sampler2d_copy_channel_data } from "../../texture/sampler/sampler2d_copy_channel_data.js";
+import { normalized_internal_format } from "../../texture/normalized_internal_format.js";
+
+const ATLAS_PATCH_BORDER = 0;
 
-const ATLAS_PATCH_BORDER = 4;
 
-const BUFFER_GEOMETRY_UVS = [
-    {
-        name: 'uv',
-        index: 0,
-    },
-    {
-        name: 'uv2',
-        index: 1
-    }
-];
+/**
+ *
+ * @param {THREE.Material} a
+ * @param {THREE.Material} b
+ * @returns {boolean}
+ */
+function materialsSimilarForCharting(a, b) {
+
+    return a.visible === b.visible
+        && a.transparent === b.transparent
+        && a.blending === b.blending
+        && a.alphaTest === b.alphaTest
+        && a.depthTest === b.depthTest
+        && a.depthWrite === b.depthWrite
+        ;
+}
 
-class TextureReference {
-    constructor() {
-        /**
-         *
-         * @type {TextureAttachment|null}
-         */
-        this.attachment = null;
-        /**
-         *
-         * @type {THREE.Material|null}
-         */
-        this.material = null;
-        /**
-         *
-         * @type {THREE.Texture|null}
-         */
-        this.source_texture = null;
-    }
+/**
+ *
+ * @param {THREE.Material} a
+ * @returns {number}
+ */
+function materialChartingHash(a) {
+    const flags = (a.visible ? 1 : 0)
+        | ((a.transparent ? 1 : 0) << 1)
+        | ((a.depthTest ? 1 : 0) << 2)
+        | ((a.depthWrite ? 1 : 0) << 3)
+        | (([NormalBlending, AdditiveBlending, MultiplyBlending].indexOf(a.blending) & 0b11) << 4)
+        | ((Math.floor(a.alphaTest * 15)) << 6) // 4 bit
+    ;
+    return flags;
 }
 
 /**
  *
- * @param {THREE.Mesh} mesh
- * @returns {boolean}
+ * @param {THREE.DataTexture} metalness
+ * @param {THREE.DataTexture} roughness
+ * @returns {THREE.DataTexture}
  */
-function is_compliant_mesh(mesh) {
-    const material = mesh.material;
+function merge_textures_metalness_rougness({
+                                               metalness,
+                                               roughness
+                                           }) {
+    const ref = metalness !== undefined ? metalness : roughness;
 
-    const attachments = TextureAttachmentsByMaterialType[material.type];
+    const pixel_count = ref.image.width * ref.image.height;
+    const result_data = new Uint8Array(pixel_count * 4);
 
-    const uv_scales = [1, 1, 1, 1];
+    const result = new DataTexture(result_data, ref.image.width, ref.image.height);
 
-    for (let i = 0; i < attachments.length; i++) {
-        const attachment = attachments[i];
+    result.encoding = ref.encoding;
 
-        const texture = attachment.read(material);
-        if (texture === undefined || texture === null) {
-            continue;
+    if (metalness !== undefined) {
+        for (let i = 0; i < pixel_count; i++) {
+            result_data[i * 4 + 2] = metalness.image.data[i];
         }
-
-        const uv_index = attachment.uv_index;
-
-        uv_scales[uv_index * 2] = max2(uv_scales[uv_index * 2], texture.repeat.x)
-        uv_scales[uv_index * 2 + 1] = max2(uv_scales[uv_index * 2 + 1], texture.repeat.y)
     }
 
-    const geometry = mesh.geometry;
+    if (roughness !== undefined) {
+        for (let i = 0; i < pixel_count; i++) {
+            result_data[i * 4 + 1] = roughness.image.data[i];
+        }
+    }
 
-    for (let i = 0; i < BUFFER_GEOMETRY_UVS.length; i++) {
-        const uv_metadata = BUFFER_GEOMETRY_UVS[i];
+    result.needsUpdate = true;
 
-        /**
-         *
-         * @type {THREE.BufferAttribute }
-         */
-        const attribute = geometry.attributes[uv_metadata.name];
+    return result;
+}
 
-        if (attribute === undefined) {
-            continue;
+/**
+ *
+ * @param {THREE.Material[]} source
+ * @param {Map<string, THREE.Texture>} textures
+ * @returns {Map<THREE.Material, THREE.Material>}
+ */
+function merge_materials(source, textures) {
+    // collect unique materials
+    const unique_materials = new HashMap({
+        keyEqualityFunction: materialsSimilarForCharting,
+        keyHashFunction: materialChartingHash
+    });
+
+    for (let i = 0; i < source.length; i++) {
+        const material = source[i];
+
+        let bucket = unique_materials.get(material);
+        if (bucket === undefined) {
+            bucket = [];
+            unique_materials.set(material, bucket);
         }
 
-        const attribute_data = attribute.array;
-        const n = attribute_data.length;
+        bucket.push(material);
+    }
 
-        const uv_index = uv_metadata.index;
-        const uv_index_2 = uv_index * 2;
+    // build new materials
+    const source_unique_keys = [];
+    collectIteratorValueToArray(source_unique_keys, unique_materials.keys());
 
-        for (let j = 0; j < n; j += 2) {
-            const x = attribute_data[j];
-            const y = attribute_data[j + 1];
+    /**
+     *
+     * @type {Map<THREE.Material, THREE.Material>}
+     */
+    const result = new Map();
 
-            const scaled_u = x * uv_scales[uv_index_2];
-            const scaled_v = y * uv_scales[uv_index_2 + 1];
+    for (let i = 0; i < source_unique_keys.length; i++) {
+        const source_material = source_unique_keys[i];
 
-            if (scaled_u > 1 || scaled_u < 0 || scaled_v > 1 || scaled_v < 0) {
-                // repeating/negative UV value
-                return false;
-            }
+        const result_material = new MeshStandardMaterial();
 
-        }
+        result_material.name = `Generated charted material ${i}`;
 
-    }
+        result_material.visible = source_material.visible;
+        result_material.transparent = source_material.transparent;
+        result_material.blending = source_material.blending;
+        result_material.alphaTest = source_material.alphaTest;
+        result_material.depthTest = source_material.depthTest;
+        result_material.depthWrite = source_material.depthWrite;
 
-    return true;
-}
+        // write atlased texture
+        const texture_attachments = TextureAttachmentsByMaterialType[result_material.type];
 
-class UvContext {
-    constructor() {
+        for (let j = 0; j < texture_attachments.length; j++) {
+            const textureAttachment = texture_attachments[j];
 
-        this.resolution = new Vector2(1, 1);
+            const existing_texture = textures.get(textureAttachment.name);
 
-        /**
-         *
-         * @type {AABB2}
-         */
-        this.atlas_patch = new AABB2();
+            if (existing_texture !== undefined) {
+                textureAttachment.write(result_material, existing_texture);
+            }
+        }
+
+        // write result mapping
+        const destination_materials = unique_materials.get(source_material);
+        for (let j = 0; j < destination_materials.length; j++) {
+            result.set(destination_materials[j], result_material);
+        }
     }
+
+    return result;
 }
 
 /**
  *
- * @param {Texture} texture
- * @param {string} attachment_name
+ * @param {Sampler2D} destination
+ * @param {Sampler2D} source
+ * @param {string} texture_name
  */
-function prepare_atlas_texture(texture, attachment_name) {
-
-    switch (attachment_name) {
-        case 'diffuse':
-            texture.encoding = sRGBEncoding;
+function extract_texture_data(destination, source, texture_name) {
+    switch (texture_name) {
+        case 'ao':
+            sampler2d_copy_channel_data(source, 0, destination, 0);
+            break;
+        case 'roughness':
+            sampler2d_copy_channel_data(source, 1, destination, 0);
+            break;
+        case 'metalness':
+            sampler2d_copy_channel_data(source, 2, destination, 0);
             break;
         default:
-            texture.encoding = LinearEncoding;
+            copy_Sampler2D_channel_data(source, destination);
     }
+}
 
-    texture.minFilter = LinearMipmapLinearFilter;
-    texture.magFilter = LinearFilter;
+/**
+ *
+ * @param {number[]} destination
+ * @param {THREE.Material|THREE.MeshStandardMaterial} source_material
+ * @param {string} texture_name
+ */
+function compute_default_texture_texel_value(destination, source_material, texture_name) {
+    switch (texture_name) {
+        case 'diffuse':
+            destination[0] = 255;
+            destination[1] = 255;
+            destination[2] = 255;
 
-    texture.generateMipmaps = true;
+            if (destination.length > 3) {
+                destination[3] = 255;
+            }
+            break;
+        case 'metalness':
+            for (let i = 0; i < destination.length; i++) {
+                destination[i] = Math.round(source_material.metalness * 255);
+            }
+            if (destination.length > 3) {
+                destination[3] = 255;
+            }
+            break;
+        case 'roughness':
+            for (let i = 0; i < destination.length; i++) {
+                destination[i] = Math.round(source_material.roughness * 255);
+            }
+            if (destination.length > 3) {
+                destination[3] = 255;
+            }
+            break;
+        case 'ao':
+            for (let i = 0; i < destination.length; i++) {
+                destination[i] = 255;
+            }
+            break;
+        case 'normal':
+            destination[0] = 127;
+            destination[1] = 127;
+            destination[2] = 255;
+            break;
+    }
 }
 
+/**
+ *
+ * @param {Sampler2D} sampler
+ * @param {THREE.MeshStandardMaterial} material
+ * @param {string} texture_name
+ */
+function apply_material_shading_to_texture(sampler, material, texture_name) {
+    switch (texture_name) {
+        case 'diffuse': {
+            const r = material.color.r;
+            const g = material.color.g;
+            const b = material.color.b;
+            const opacity = material.opacity;
+
+            const itemSize = sampler.itemSize;
+
+            const data = sampler.data;
+            const data_size = data.length;
+
+            if (r < 1 || g < 1 || b < 1) {
+                // apply color tint
+                for (let i = 0; i < data_size; i += itemSize) {
+                    data[i] *= r;
+                    data[i + 1] *= g;
+                    data[i + 2] *= b;
+                }
+            }
 
-class MaterialDescriptor {
-    constructor() {
-
-        /**
-         *
-         * @type {THREE.Material|null}
-         */
-        this.source_material = null;
+            if (itemSize > 3 && opacity < 1) {
+                // apply opacity
+                for (let i = 3; i < data_size; i += itemSize) {
+                    data[i] *= opacity;
+                }
 
-        /**
-         *
-         * @type {UvContext[]}
-         */
-        this.uvs = [];
+            }
+        }
+            break;
+        default:
+        // do nothing
     }
+}
+
+/**
+ *
+ * @param {Sampler2D} destination
+ * @param {THREE.Material} source_material
+ * @param {string} texture_name
+ */
+function compute_default_texture_value(destination, source_material, texture_name) {
+    const itemSize = destination.itemSize;
 
-    build_uvs() {
+    const texel = new Array(itemSize);
 
-        traverseMaterialTextures(this.source_material, (t, attachment) => {
-            const uv_index = attachment.uv_index;
+    compute_default_texture_texel_value(texel, source_material, texture_name);
 
-            let uv_context = this.uvs[uv_index];
+    const width = destination.width;
+    const height = destination.height;
 
-            if (uv_context === undefined) {
-                uv_context = new UvContext();
-                uv_context.resolution.set(1, 1);
+    const destination_data = destination.data;
 
-                this.uvs[uv_index] = uv_context;
-            }
+    if (itemSize === 1) {
+        // special fast case
+        destination_data.fill(texel[0]);
+    } else {
 
-            const image = t.image;
+        const texel_count = width * height;
 
-            if (image !== undefined && image.width !== undefined) {
-                uv_context.resolution.x = max2(uv_context.resolution.x, image.width);
-                uv_context.resolution.y = max2(uv_context.resolution.y, image.height);
-            }
+        for (let i = 0; i < texel_count; i++) {
+            const destination_offset = i * itemSize;
 
-        });
+            destination_data.set(texel, destination_offset);
+        }
+    }
+}
 
+/**
+ *
+ * @param {string} texture_name
+ * @returns {{type:DataType,itemSize:number, default_value:[]}}
+ */
+function build_atlas_sampler_options_texture_name(texture_name) {
+    let type;
+    let itemSize;
+    let default_value;
+
+    switch (texture_name) {
+        case 'normal':
+            type = DataType.Uint8;
+            itemSize = 3;
+            default_value = [127, 127, 255];
+            break;
+        case 'ao':
+            type = DataType.Uint8;
+            itemSize = 1;
+            default_value = [255];
+            break;
+        case "metalness":
+            type = DataType.Uint8;
+            itemSize = 1;
+            default_value = [0];
+            break;
+        case "roughness":
+            type = DataType.Uint8;
+            itemSize = 1;
+            default_value = [255];
+            break;
+        default:
+            type = DataType.Uint8;
+            itemSize = 4;
+            default_value = [255, 255, 255, 255];
+            break;
     }
 
+    return {
+        type,
+        itemSize,
+        default_value
+    };
 }
 
 export class MaterialOptimizationContext {
@@ -304,12 +467,16 @@ export class MaterialOptimizationContext {
      */
     build_atlas_samplers(materials) {
 
+        let i;
+
         this.atlases.clear();
 
         const names = [];
         const uv_indices = [];
 
-        for (let i = 0; i < materials.length; i++) {
+        const material_count = materials.length;
+
+        for (i = 0; i < material_count; i++) {
             const material = materials[i];
 
             const source_material = material.source_material;
@@ -324,6 +491,13 @@ export class MaterialOptimizationContext {
             for (let i = 0; i < attachments.length; i++) {
                 const attachment = attachments[i];
 
+                const attachment_texture = attachment.read(source_material);
+
+                if (!attachment_texture) {
+                    // no attachment on the material
+                    continue;
+                }
+
                 if (array_push_if_unique(names, attachment.name)) {
                     // added
                     uv_indices[names.length - 1] = attachment.uv_index;
@@ -332,13 +506,29 @@ export class MaterialOptimizationContext {
             }
         }
 
-        for (let i = 0; i < names.length; i++) {
+        for (i = 0; i < names.length; i++) {
             const name = names[i];
             const uv_index = uv_indices[i];
 
             const size = this.atlas_size[uv_index];
 
-            this.atlases.set(name, Sampler2D.uint8(4, size.x, size.y));
+            const width = size.x;
+            const height = size.y;
+
+            const sampler_options = build_atlas_sampler_options_texture_name(name);
+
+            const TA = compute_typed_array_constructor_from_data_type(sampler_options.type);
+
+            const itemSize = sampler_options.itemSize;
+            const sampler_data_size = itemSize * width * height;
+            const sampler_data = new TA(sampler_data_size);
+
+            for (let j = 0; j < sampler_data_size; j += itemSize) {
+                sampler_data.set(sampler_options.default_value, j);
+            }
+
+            const atlas_sampler = new Sampler2D(sampler_data, itemSize, width, height);
+            this.atlases.set(name, atlas_sampler);
         }
     }
 
@@ -357,9 +547,17 @@ export class MaterialOptimizationContext {
          */
         const attachments = TextureAttachmentsByMaterialType[materialType];
 
+        const attachment_names = Array.from(this.atlases.keys());
+
         for (let i = 0; i < attachments.length; i++) {
             const attachment = attachments[i];
 
+            const texture_name = attachment.name;
+
+            if (!attachment_names.includes(texture_name)) {
+                continue;
+            }
+
             const uv_context = material.uvs[attachment.uv_index];
 
             if (uv_context === undefined) {
@@ -367,28 +565,45 @@ export class MaterialOptimizationContext {
                 continue;
             }
 
+            const atlas_sampler = this.atlases.get(texture_name);
+
             let source_sampler;
 
             const texture = attachment.read(source_material);
 
-            const texture_width = uv_context.resolution.x;
-            const texture_height = uv_context.resolution.y;
+            const resolution = uv_context.resolution;
+
+            const texture_width = resolution.x;
+            const texture_height = resolution.y;
+
             if (texture !== undefined && texture !== null) {
                 // source_sampler = Sampler2D.uint8(5, texture_width, texture_height);
                 //
                 // source_sampler.fill(0, 0, texture_width, texture_height, [255, 255, 255, 255]);
 
                 source_sampler = convertTexture2Sampler2D(texture, texture_width, texture_height, false);
+
+                if (source_sampler.itemSize !== atlas_sampler.itemSize) {
+                    const destination = Sampler2D.uint8(atlas_sampler.itemSize, texture_width, texture_height);
+
+                    extract_texture_data(destination, source_sampler, texture_name);
+
+                    source_sampler = destination;
+                }
+
             } else {
-                // TODO proper defaults when a texture is missing
-                source_sampler = Sampler2D.uint8(4, texture_width, texture_height);
+                // texture for a given slot is missing, create a default
+                source_sampler = Sampler2D.uint8(atlas_sampler.itemSize, texture_width, texture_height);
+
+                compute_default_texture_value(source_sampler, source_material, texture_name);
             }
 
-            const atlas = this.atlases.get(attachment.name);
+            // apply modification to texture to remove dependency on source material
+            apply_material_shading_to_texture(source_sampler, source_material, texture_name);
 
             const patch = uv_context.atlas_patch;
 
-            atlas.copy_sameItemSize(
+            atlas_sampler.copy_sameItemSize(
                 source_sampler,
                 0, 0,
                 patch.x0, patch.y0, patch.getWidth(), patch.getHeight()
@@ -406,7 +621,7 @@ export class MaterialOptimizationContext {
         if (material.isMeshStandardMaterial) {
             this.meshes.push(mesh);
         } else {
-            throw new Error(`Unsupported material type '${material.type}'`);
+            // throw new Error(`Unsupported material type '${material.type}'`);
         }
     }
 
@@ -488,8 +703,10 @@ export class MaterialOptimizationContext {
         const unique_material_array = [];
         collectIteratorValueToArray(unique_material_array, unique_materials.values());
 
-        if (unique_material_array.length <= 4) {
-            // no point in atlasing
+        const unique_material_count = unique_material_array.length;
+
+        if (unique_material_count <= 4) {
+            // too few unique materials, no point in atlasing
             return;
         }
 
@@ -497,28 +714,10 @@ export class MaterialOptimizationContext {
 
         this.build_atlas_samplers(unique_material_array);
 
-        const textures = new Map();
-        //build new textures
-        for (const [name, sampler] of this.atlases) {
-            const texture = new DataTexture();
-
-            texture.image = {
-                data: sampler.data,
-                width: sampler.width,
-                height: sampler.height
-            };
-
-            texture.wrapS = ClampToEdgeWrapping;
-            texture.wrapT = ClampToEdgeWrapping;
-            texture.type = UnsignedByteType;
-            texture.anisotropy = 4;
-
-            prepare_atlas_texture(texture, name);
+        const textures = this.initialize_atlas_textures();
 
-            textures.set(name, texture);
-        }
 
-        for (let i = 0; i < unique_material_array.length; i++) {
+        for (let i = 0; i < unique_material_count; i++) {
             const mat = unique_material_array[i];
 
             this.write_material_to_atlas(mat);
@@ -529,65 +728,135 @@ export class MaterialOptimizationContext {
             for (let j = 0; j < geometries.length; j++) {
                 const bufferGeometry = geometries[j];
 
-                for (let k = 0; k < BUFFER_GEOMETRY_UVS.length; k++) {
-                    const uv_metadata = BUFFER_GEOMETRY_UVS[k];
+                this.apply_geometry_uv_changes(bufferGeometry, mat);
+            }
+        }
+
+        /*
+         merge roughness and metalness. Three.js shaders sample roughness from G channel (index = 1) and metalness from B channel (index 2)
+         Because of this, we can't pass B/W textures with only Red channel set, so we are forced to create a merged texture from metalness and roughnes
+         */
+        if (textures.get('roughness') !== undefined || textures.get('metalness') !== undefined) {
+            const result_texture = merge_textures_metalness_rougness({
+                roughness: textures.get('roughness'),
+                metalness: textures.get('metalness')
+            });
+
+            if (textures.get('roughness') !== undefined) {
+                textures.set('roughness', result_texture);
+            }
+            if (textures.get('metalness') !== undefined) {
+                textures.set('roughness', result_texture);
+            }
+        }
+
+        // update textures
+        for (const [name, texture] of textures) {
+            texture.needsUpdate = true;
+        }
+
+        // compute merged materials
+        const unique_source_materials = [];
+        collectIteratorValueToArray(unique_source_materials, unique_materials.keys());
 
-                    // update UVs
-                    const uv_attribute = bufferGeometry.attributes[uv_metadata.name];
+        const merged_materials = merge_materials(unique_source_materials, textures);
+
+        for (let i = 0; i < unique_material_count; i++) {
+            const mat = unique_material_array[i];
 
-                    if (uv_attribute === undefined) {
-                        // no UVs, nothing to update
-                        continue;
-                    }
+            // bind material
+            const new_material = merged_materials.get(mat.source_material);
+
+            // set new material to all associated meshes
+            const meshes = material_to_mesh_map.get(mat);
+
+            for (let j = 0; j < meshes.length; j++) {
+                const mesh = meshes[j];
+                mesh.material = new_material;
+            }
+        }
 
+    }
 
-                    const uv_index = uv_metadata.index;
-                    const uv_context = mat.uvs[uv_index];
+    /**
+     *
+     * @return {Map<string, THREE.DataTexture>}
+     */
+    initialize_atlas_textures() {
+        const textures = new Map();
+        //build new textures
+        for (const [name, sampler] of this.atlases) {
 
-                    if (uv_context === undefined) {
-                        // no UV context present
-                        // TODO need to force context to exist in this case or remove the attribute
-                        continue;
-                    }
+            const sampler_data_type = typedArrayToDataType(sampler.data);
 
-                    const atlas_size = this.atlas_size[uv_index];
+            const format = channelCountToThreeTextureFormat(sampler.itemSize);
+            const type = computeThreeTextureTypeFromDataType(sampler_data_type);
 
-                    const atlas_width = atlas_size.x;
-                    const atlas_height = atlas_size.y;
+            const texture = new DataTexture(sampler.data, sampler.width, sampler.height, format, type);
 
-                    const patch = uv_context.atlas_patch;
+            texture.wrapS = ClampToEdgeWrapping;
+            texture.wrapT = ClampToEdgeWrapping;
+            texture.name = name;
 
-                    const matrix3 = new Matrix3();
-                    matrix3.setUvTransform(
-                        patch.x0 / atlas_width,
-                        patch.y0 / atlas_height,
-                        patch.getWidth() / atlas_width,
-                        patch.getHeight() / atlas_height,
-                        0,
-                        0, 0
-                    );
+            texture.internalFormat = normalized_internal_format(sampler_data_type, sampler.itemSize);
 
-                    uv_attribute.applyMatrix3(matrix3);
+            prepare_atlas_texture(texture, name);
 
-                    uv_attribute.needsUpdate = true;
-                }
+            textures.set(name, texture);
+        }
+        return textures;
+    }
+
+    /**
+     *
+     * @param {THREE.BufferGeometry} bufferGeometry
+     * @param {MaterialDescriptor} mat
+     */
+    apply_geometry_uv_changes(bufferGeometry, mat) {
+        const uv_count = BUFFER_GEOMETRY_UVS.length;
+
+        for (let k = 0; k < uv_count; k++) {
+            const uv_metadata = BUFFER_GEOMETRY_UVS[k];
+
+            // update UVs
+            const uv_attribute = bufferGeometry.attributes[uv_metadata.name];
+
+            if (uv_attribute === undefined) {
+                // no UVs, nothing to update
+                continue;
             }
 
-            // build material
-            const new_material = mat.source_material.clone();
 
-            traverseMaterialTextures(new_material, (old_texture, attachment) => {
-                attachment.write(new_material, textures.get(attachment.name));
-            });
+            const uv_index = uv_metadata.index;
+            const uv_context = mat.uvs[uv_index];
 
-            // set new material to all associated meshes
-            const meshes = material_to_mesh_map.get(mat);
-            for (let j = 0; j < meshes.length; j++) {
-                const mesh = meshes[j];
-                mesh.material = new_material;
+            if (uv_context === undefined) {
+                // no UV context present
+                // TODO need to force context to exist in this case or remove the attribute
+                continue;
             }
-        }
 
+            const atlas_size = this.atlas_size[uv_index];
+
+            const atlas_width = atlas_size.x;
+            const atlas_height = atlas_size.y;
+
+            const patch = uv_context.atlas_patch;
+
+            const matrix3 = new Matrix3();
+            matrix3.setUvTransform(
+                patch.x0 / atlas_width,
+                patch.y0 / atlas_height,
+                patch.getWidth() / atlas_width,
+                patch.getHeight() / atlas_height,
+                0,
+                0, 0
+            );
+
+            uv_attribute.applyMatrix3(matrix3);
+
+            uv_attribute.needsUpdate = true;
+        }
     }
 }