@jfk-solutions/demo3d-file-format 1.7.0 → 1.9.0

package/dist/three/raw3d.js

@@ -1,3 +1,6 @@
+import { bindRaw3DThreeSkin } from "./skinning.js";
+import { applyRaw3DThreeEffects, configureRaw3DDrawable } from "./effects.js";
+import { raw3DNodeBackend } from "./backend.js";
 import { Raw3DMaterial, Raw3DMesh, Raw3DPackage, Raw3DProject } from "../raw3d.js";
 export async function createRaw3DThreeScene(parsed, options = {}) {
     const three = await resolveThree(options);
@@ -14,6 +17,9 @@ export async function createRaw3DThreeScene(parsed, options = {}) {
     };
 }
 export async function createRaw3DThreeGroup(parsed, options = {}) {
+    return (await buildRaw3DThreeGroup(parsed, options)).group;
+}
+async function buildRaw3DThreeGroup(parsed, options) {
     const three = await resolveThree(options);
     const project = parsed instanceof Raw3DPackage ? parsed.model : parsed;
     const warnings = [];
@@ -36,12 +42,16 @@ export async function createRaw3DThreeGroup(parsed, options = {}) {
     };
     const textures = await loadTextures(project, three, stats, warn);
     const materials = project.materials.map((material) => createMaterial(material, textures, three));
+    for (const material of materials)
+        material.userData.raw3DHeightChannel = options.parallaxHeightChannel ?? "a";
     const defaultMaterial = new three.MeshStandardMaterial({ color: 0x9aa0a6, roughness: 0.8 });
     const geometryCache = new Map();
     const objects = new Map();
+    const sourceNodes = new Map(project.nodes.map((node) => [node.index, node]));
     const root = new three.Group();
     root.name = "RAW3D";
     for (const node of project.nodes) {
+        const annotationHidden = !options.showAnnotations && isAnnotationNode(node, sourceNodes);
         const object = new three.Group();
         object.name = node.name;
         applyTransform(object, node);
@@ -61,10 +71,11 @@ export async function createRaw3DThreeGroup(parsed, options = {}) {
                 endPosition: text.endPosition
             } : undefined,
             interactionMode: node.interactionMode,
+            annotationHidden,
             customAttributes: Object.fromEntries(node.customAttributes)
         };
         objects.set(node.index, object);
-        if (node.meshIndex !== undefined) {
+        if (!annotationHidden && node.meshIndex !== undefined) {
             const sourceMesh = project.meshes[node.meshIndex];
             if (!sourceMesh) {
                 warn({
@@ -93,21 +104,36 @@ export async function createRaw3DThreeGroup(parsed, options = {}) {
                 }
                 if (geometry) {
                     const nodeMaterials = resolveNodeMaterials(node, sourceMesh, project, materials, defaultMaterial);
-                    const mesh = new three.Mesh(geometry, nodeMaterials.length === 1 ? nodeMaterials[0] : nodeMaterials);
-                    mesh.name = `${node.name} Mesh`;
-                    mesh.castShadow = node.castsShadow;
-                    mesh.receiveShadow = true;
-                    mesh.userData.raw3d = { kind: "mesh", nodeIndex: node.index, meshIndex: node.meshIndex };
-                    object.add(mesh);
+                    const drawable = createDrawable(sourceMesh, geometry, nodeMaterials, three);
+                    drawable.name = `${node.name} ${sourceMesh.meshType}`;
+                    drawable.castShadow = node.castsShadow && drawable instanceof three.Mesh;
+                    drawable.visible = node.visible;
+                    drawable.receiveShadow = drawable instanceof three.Mesh;
+                    drawable.userData.raw3d = {
+                        kind: primitiveKind(sourceMesh.meshType),
+                        nodeIndex: node.index,
+                        meshIndex: node.meshIndex,
+                        meshType: sourceMesh.meshType,
+                        sourceVisible: node.visible
+                    };
+                    object.add(drawable);
                     stats.meshes += 1;
                 }
             }
         }
-    }
-    for (const source of project.lights) {
-        if (!source.enabled) {
-            continue;
+        if (!annotationHidden && text) {
+            const textMaterialIndex = text.materialIndex ?? node.materialIndices[0];
+            const sourceMaterial = textMaterialIndex === undefined ? undefined : project.materials[textMaterialIndex];
+            const sprite = createTextSprite(text, sourceMaterial, three);
+            if (sprite) {
+                sprite.name = `${node.name} Text`;
+                sprite.visible = node.visible;
+                sprite.userData.raw3d = { kind: "text", nodeIndex: node.index, textIndex: node.textIndex, sourceVisible: node.visible };
+                object.add(sprite);
+            }
         }
+    }
+    for (const [sourceIndex, source] of project.lights.entries()) {
         const parent = source.nodeIndex === undefined ? undefined : objects.get(source.nodeIndex);
         if (!parent) {
             warn({
@@ -127,10 +153,12 @@ export async function createRaw3DThreeGroup(parsed, options = {}) {
                 light = new three.AmbientLight(color, 1);
                 break;
             case "point":
-                light = new three.PointLight(color, 1, 0, 2);
+                light = raw3DNodeBackend(three)?.point() ?? new three.PointLight(color, 1, 0, 2);
+                light.color.copy(color);
                 break;
             case "spot":
-                light = new three.SpotLight(color, 1);
+                light = raw3DNodeBackend(three)?.spot() ?? new three.SpotLight(color, 1);
+                light.color.copy(color);
                 break;
             default: {
                 const directional = new three.DirectionalLight(color, 1);
@@ -141,8 +169,10 @@ export async function createRaw3DThreeGroup(parsed, options = {}) {
             }
         }
         light.name = `${parent.name} ${source.type} light`;
+        light.visible = source.enabled;
         light.userData.raw3d = {
             kind: "light",
+            index: source.index ?? sourceIndex,
             nodeIndex: source.nodeIndex,
             materialIndex: source.materialIndex,
             type: source.type,
@@ -177,7 +207,327 @@ export async function createRaw3DThreeGroup(parsed, options = {}) {
     // Match the metadata shape used by the Demo3D adapter so generic viewers can
     // display stats without special-casing the property name.
     root.userData.demo3d = { kind: "raw3d-package", stats, warnings };
-    return root;
+    const skinBindings = new Map();
+    for (const node of project.nodes) {
+        const owner = objects.get(node.index);
+        const drawable = owner.children.find(child => child instanceof three.Mesh);
+        if (drawable && node.meshIndex !== undefined && project.meshes[node.meshIndex]?.bones.length) {
+            const binding = bindRaw3DThreeSkin(drawable, node.meshIndex, project, objects, three);
+            skinBindings.set(binding.drawable, binding);
+        }
+        for (const child of owner.children)
+            if (["mesh", "lines", "points"].includes(child.userData.raw3d?.kind))
+                configureRaw3DDrawable(child, node.isBillboard, node.isDecal, three);
+    }
+    root.updateMatrixWorld(true);
+    for (const binding of skinBindings.values())
+        binding.update();
+    applyRaw3DThreeEffects(root, project.animation.effects.sample(0), project, three);
+    return { group: root, three, project, objects, materials, textures, geometryCache, defaultMaterial, skinBindings };
+}
+/** Optional Three.js binding. Animation data and interpolation live in the core. */
+export async function createRaw3DThreePlayback(parsed, options = {}) {
+    const project = parsed instanceof Raw3DPackage ? parsed.model : parsed;
+    const animation = project.animation;
+    const resources = await buildRaw3DThreeGroup(parsed, options);
+    const { group, three, objects, materials, geometryCache, defaultMaterial, skinBindings } = resources;
+    let frame = animation.sampleFrame(0);
+    for (const warning of animation.warnings) {
+        const item = { code: warning.code, message: warning.message };
+        group.userData.raw3d.warnings.push(item);
+        options.onWarning?.(item);
+    }
+    const variants = new Map();
+    const archivedStreams = new Map([...resources.textures].filter(([key]) => key.startsWith("stream:")));
+    const streamRevisions = new Map();
+    const streamWarnings = new Set();
+    const ownedMaterials = new Set([...materials, defaultMaterial]);
+    const ownedTextures = new Set(resources.textures.values());
+    const capture = () => group.traverse(object => {
+        const drawable = object;
+        if (drawable.material)
+            for (const material of Array.isArray(drawable.material) ? drawable.material : [drawable.material]) {
+                ownedMaterials.add(material);
+                const map = material.map;
+                if (map)
+                    ownedTextures.add(map);
+            }
+    });
+    capture();
+    let disposed = false;
+    const palette = (node, state, mesh) => {
+        const layerMaterial = state.layerIndex === undefined ? undefined : project.layers[state.layerIndex]?.materialIndex;
+        return Array.from({ length: Math.max(1, mesh.indexBufferIndices.length) }, (_, slot) => {
+            const index = node.materialIndices[slot] ?? node.materialIndices[0] ?? layerMaterial;
+            const base = (index === undefined ? defaultMaterial : materials[index] ?? defaultMaterial);
+            const values = state.materialProperties[slot] ?? {};
+            const streamIndex = values.StreamableTexture ?? (index === undefined ? -1 : project.materials[index]?.streamableTextureIndex ?? -1);
+            const ordinaryMap = values.Texture === undefined ? base.map : values.Texture < 0 ? null : resources.textures.get(`${values.Texture}:color`);
+            const streamMap = streamIndex < 0 ? undefined : resources.textures.get(`stream:${streamIndex}:color`);
+            const mapSource = streamMap ?? ordinaryMap;
+            if (streamIndex >= 0 && !streamMap && !streamWarnings.has(streamIndex)) {
+                streamWarnings.add(streamIndex);
+                const warning = { code: "RAW3D_STREAM_TEXTURE_UNAVAILABLE", message: `Streamable texture ${streamIndex} has no archived image or resolved external frame.` };
+                group.userData.raw3d.warnings.push(warning);
+                options.onWarning?.(warning);
+            }
+            const key = `${node.index}:${slot}:${index ?? -1}:${values.Texture ?? "base"}:${values.NormalMap ?? values.NormalTexture ?? "base"}:stream:${streamIndex}`;
+            let entry = variants.get(key);
+            if (!entry) {
+                const material = base.clone();
+                const normalIndex = values.NormalMap ?? values.NormalTexture;
+                const normalSource = normalIndex === undefined ? base.normalMap : normalIndex < 0 ? null : resources.textures.get(`${normalIndex}:normal`);
+                if ((values.Texture !== undefined && values.Texture >= 0 && !mapSource) || (normalIndex !== undefined && normalIndex >= 0 && !normalSource))
+                    throw new Error("An animated RAW3D texture resource could not be loaded.");
+                entry = { base, material, map: mapSource?.clone(), normalMap: normalSource?.clone(), mapSource: mapSource ?? undefined };
+                variants.set(key, entry);
+                ownedMaterials.add(material);
+                if (entry.map)
+                    ownedTextures.add(entry.map);
+                if (entry.normalMap)
+                    ownedTextures.add(entry.normalMap);
+            }
+            if (entry.mapSource !== (mapSource ?? undefined)) {
+                if (entry.map) {
+                    entry.map.dispose();
+                    ownedTextures.delete(entry.map);
+                }
+                entry.map = mapSource?.clone();
+                entry.mapSource = mapSource ?? undefined;
+                if (entry.map)
+                    ownedTextures.add(entry.map);
+                entry.material.needsUpdate = true;
+            }
+            if (streamIndex >= 0 && entry.streamRevision !== streamRevisions.get(streamIndex)) {
+                if (entry.map)
+                    entry.map.needsUpdate = true;
+                entry.streamRevision = streamRevisions.get(streamIndex);
+            }
+            const material = entry.material;
+            const wasTransparent = material.transparent;
+            material.copy(base);
+            material.map = entry.map ?? null;
+            material.normalMap = entry.normalMap ?? null;
+            if (values.Diffuse !== undefined) {
+                material.color.setHex(values.Diffuse & 0xffffff, three.SRGBColorSpace);
+                material.opacity = (values.Diffuse >>> 24) / 255;
+            }
+            if (values.Transparency !== undefined)
+                material.opacity = 1 - values.Transparency;
+            if (values.Reflectivity !== undefined)
+                material.roughness = .9 - clamp01(values.Reflectivity) * .75;
+            if (values.Luminosity !== undefined && material.emissive)
+                material.emissive.copy(material.color).multiplyScalar(values.Luminosity);
+            if (values.NormalScale !== undefined && material.normalScale)
+                material.normalScale.setScalar(values.NormalScale);
+            if (values.NormalDepth !== undefined)
+                material.userData.raw3dNormalDepth = values.NormalDepth;
+            for (const texture of [material.map, material.normalMap]) {
+                if (!texture)
+                    continue;
+                texture.offset.set(values.U ?? base.map?.offset.x ?? 0, values.V ?? base.map?.offset.y ?? 0);
+                texture.repeat.set(values.ScaleU ?? base.map?.repeat.x ?? 1, values.ScaleV ?? base.map?.repeat.y ?? 1);
+                if (values.U !== undefined)
+                    texture.offset.x = values.U;
+                if (values.V !== undefined)
+                    texture.offset.y = values.V;
+                if (values.ScaleU !== undefined)
+                    texture.repeat.x = values.ScaleU;
+                if (values.ScaleV !== undefined)
+                    texture.repeat.y = values.ScaleV;
+                if (values.U !== undefined || values.V !== undefined)
+                    texture.wrapS = texture.wrapT = three.RepeatWrapping;
+            }
+            material.transparent = material.opacity < 1 || base.transparent;
+            material.depthWrite = base.depthWrite && !material.transparent;
+            if (wasTransparent !== material.transparent)
+                material.needsUpdate = true;
+            return material;
+        });
+    };
+    let seekRevision = 0, pendingFrames;
+    const apply = (time) => {
+        if (disposed)
+            throw new Error("RAW3D playback has been disposed.");
+        frame = animation.sampleFrame(time);
+        const states = frame.nodes;
+        // Detach first so valid hierarchy changes do not depend on source node order.
+        for (const object of objects.values())
+            group.add(object);
+        for (const node of project.nodes) {
+            const object = objects.get(node.index), state = states.get(node.index);
+            object.position.set(state.location[0], state.location[1], -state.location[2]);
+            object.quaternion.set(-state.quaternion[0], -state.quaternion[1], state.quaternion[2], state.quaternion[3]);
+            object.scale.set(...state.scale);
+            object.visible = !state.deleted;
+            object.userData.raw3d.layerIndex = state.layerIndex;
+            object.userData.raw3d.interactionMode = state.interactionMode;
+            object.userData.raw3d.highlight = state.highlight;
+            object.userData.raw3d.userData = state.userData;
+            object.userData.raw3d.clientOwner = state.clientOwner;
+            object.userData.raw3d.hasBeenOptimized = state.hasBeenOptimized;
+            const parent = state.parentIndex === undefined ? undefined : objects.get(state.parentIndex);
+            if (parent && parent !== object && !isDescendantOf(parent, object))
+                parent.add(object);
+            else if (state.parentIndex !== undefined)
+                throw new Error(`Invalid animated parent ${state.parentIndex} for RAW3D node ${node.index}.`);
+            let drawable = object.children.find(child => ["mesh", "lines", "points"].includes(child.userData.raw3d?.kind));
+            const mesh = state.meshIndex === undefined ? undefined : project.meshes[state.meshIndex];
+            if (state.meshIndex !== undefined && !mesh)
+                throw new Error(`Missing animated RAW3D mesh ${state.meshIndex}.`);
+            if (mesh && !object.userData.raw3d.annotationHidden) {
+                if (!geometryCache.has(state.meshIndex))
+                    geometryCache.set(state.meshIndex, decodeRaw3DThreeGeometry(mesh, project, three));
+                if (!drawable || drawable.userData.raw3d.meshType !== mesh.meshType || (drawable.userData.raw3d.meshIndex !== state.meshIndex && (skinBindings.has(drawable) || mesh.bones.length > 0))) {
+                    if (drawable) {
+                        object.remove(drawable);
+                        skinBindings.get(drawable)?.dispose();
+                        skinBindings.delete(drawable);
+                    }
+                    drawable = createDrawable(mesh, geometryCache.get(state.meshIndex), [defaultMaterial], three);
+                    drawable.userData.raw3d = { kind: primitiveKind(mesh.meshType), nodeIndex: node.index, meshType: mesh.meshType };
+                    drawable.castShadow = node.castsShadow && drawable instanceof three.Mesh;
+                    object.add(drawable);
+                    if (mesh.bones.length && drawable instanceof three.Mesh) {
+                        const binding = bindRaw3DThreeSkin(drawable, state.meshIndex, project, objects, three);
+                        drawable = binding.drawable;
+                        skinBindings.set(drawable, binding);
+                    }
+                    // The line/point factory creates topology-specific materials.
+                    for (const material of Array.isArray(drawable.material) ? drawable.material : [drawable.material])
+                        ownedMaterials.add(material);
+                }
+                if (!skinBindings.has(drawable))
+                    drawable.geometry = geometryCache.get(state.meshIndex);
+                drawable.userData.raw3d.meshIndex = state.meshIndex;
+                const selected = palette(node, state, mesh);
+                if (drawable instanceof three.Mesh)
+                    drawable.material = selected.length === 1 ? selected[0] : selected;
+                else {
+                    const current = Array.isArray(drawable.material) ? drawable.material : [drawable.material];
+                    // Keep topology-specific materials instead of assigning mesh shaders to lines/points.
+                    const adjusted = selected.map((source, slot) => {
+                        const material = current[slot] ?? (drawable instanceof three.Points ? toPointMaterial(source, three) : toLineMaterial(source, three));
+                        ownedMaterials.add(material);
+                        const target = material, original = source;
+                        target.color.copy(original.color);
+                        target.opacity = original.opacity;
+                        target.transparent = original.transparent;
+                        target.depthWrite = original.depthWrite;
+                        target.needsUpdate = true;
+                        if (drawable instanceof three.Points)
+                            target.size = state.materialProperties[slot]?.PointSize ?? project.materials[node.materialIndices[slot] ?? node.materialIndices[0] ?? (state.layerIndex === undefined ? -1 : project.layers[state.layerIndex]?.materialIndex ?? -1)]?.pointSize ?? 1;
+                        return material;
+                    });
+                    drawable.material = adjusted.length === 1 ? adjusted[0] : adjusted;
+                }
+                configureRaw3DDrawable(drawable, state.isBillboard, state.isDecal, three);
+            }
+            if (drawable) {
+                drawable.visible = state.visible && !!mesh && !object.userData.raw3d.annotationHidden;
+                drawable.userData.raw3d.sourceVisible = drawable.visible;
+            }
+            for (const child of object.children)
+                if (child.userData.raw3d?.kind === "text") {
+                    child.visible = state.visible && !object.userData.raw3d.annotationHidden;
+                    child.userData.raw3d.sourceVisible = child.visible;
+                }
+        }
+        // Retain only geometry currently used by nodes; decoded mesh samples are recreatable.
+        const used = new Set([...states.values()].map(state => state.meshIndex));
+        for (const [index, geometry] of geometryCache)
+            if (!used.has(index)) {
+                geometry.dispose();
+                geometryCache.delete(index);
+            }
+        group.updateMatrixWorld(true);
+        for (const binding of skinBindings.values())
+            binding.update();
+        applyRaw3DThreeEffects(group, frame, project, three);
+    };
+    const seek = (time) => { seekRevision++; pendingFrames?.abort(); apply(time); };
+    const seekAsync = async (time) => {
+        if (disposed)
+            throw new Error("RAW3D playback has been disposed.");
+        const next = animation.sampleFrame(time), revision = ++seekRevision;
+        pendingFrames?.abort();
+        const controller = new AbortController();
+        pendingFrames = controller;
+        const requested = new Set();
+        for (const node of project.nodes) {
+            const state = next.nodes.get(node.index);
+            const mesh = state.meshIndex === undefined ? undefined : project.meshes[state.meshIndex];
+            for (let slot = 0; slot < Math.max(1, mesh?.indexBufferIndices.length ?? 1); slot++) {
+                const materialIndex = node.materialIndices[slot] ?? node.materialIndices[0] ?? (state.layerIndex === undefined ? undefined : project.layers[state.layerIndex]?.materialIndex);
+                const stream = state.materialProperties[slot]?.StreamableTexture ?? (materialIndex === undefined ? -1 : project.materials[materialIndex]?.streamableTextureIndex ?? -1);
+                if (stream >= 0)
+                    requested.add(stream);
+            }
+        }
+        try {
+            const resolved = options.resolveStreamTexture ? await Promise.all([...requested].map(async (index) => [index, await options.resolveStreamTexture({ index, time: Math.max(0, time), source: project.streamableTextures.find(source => source.index === index), signal: controller.signal })])) : [];
+            if (disposed || revision !== seekRevision)
+                return false;
+            for (const [index, texture] of resolved) {
+                if (texture !== undefined && !texture.isTexture)
+                    throw new Error("A stream texture resolver must return a Three.js texture or undefined.");
+                const key = `stream:${index}:color`, selected = texture ?? archivedStreams.get(key);
+                if (selected)
+                    resources.textures.set(key, selected);
+                else
+                    resources.textures.delete(key);
+                streamRevisions.set(index, (streamRevisions.get(index) ?? 0) + 1);
+            }
+            apply(time);
+            return true;
+        }
+        catch (error) {
+            if (disposed || revision !== seekRevision)
+                return false;
+            throw error;
+        }
+        finally {
+            if (revision === seekRevision)
+                pendingFrames = undefined;
+        }
+    };
+    const dispose = () => {
+        if (disposed)
+            return;
+        disposed = true;
+        seekRevision++;
+        pendingFrames?.abort();
+        for (const binding of skinBindings.values())
+            binding.dispose();
+        skinBindings.clear();
+        for (const geometry of geometryCache.values())
+            geometry.dispose();
+        group.traverse(object => { if (object.userData.raw3d?.kind === "scene-floor")
+            object.geometry.dispose(); });
+        capture();
+        for (const material of ownedMaterials) {
+            const source = material;
+            if (source.map)
+                ownedTextures.add(source.map);
+            if (source.normalMap)
+                ownedTextures.add(source.normalMap);
+        }
+        for (const material of ownedMaterials)
+            material.dispose();
+        for (const texture of ownedTextures)
+            texture.dispose();
+        group.clear();
+        variants.clear();
+        geometryCache.clear();
+    };
+    try {
+        await seekAsync(0);
+    }
+    catch (error) {
+        dispose();
+        throw error;
+    }
+    return { group, animation, duration: animation.duration, get state() { return frame; }, seek, seekAsync, dispose };
 }
 export function decodeRaw3DThreeGeometry(mesh, project, three) {
     const vertexBuffer = project.vertexBuffers[mesh.vertexBufferIndex];
@@ -199,10 +549,25 @@ export function decodeRaw3DThreeGeometry(mesh, project, three) {
         for (let vertex = 0; vertex < vertexCount; vertex += 1) {
             const base = vertex * vertexBuffer.stride + sourceAttribute.offset;
             for (let component = 0; component < sourceAttribute.componentCount; component += 1) {
-                let value = view.getFloat32(base + component * 4, true);
+                let value;
+                if (/^Color$/i.test(sourceAttribute.type)) {
+                    const packed = view.getUint32(base, true);
+                    value = ((packed >>> [16, 8, 0, 24][component]) & 255) / 255;
+                }
+                else if (/^Byte4$/i.test(sourceAttribute.type))
+                    value = view.getUint8(base + component);
+                else if (/^(?:Normalized)?Short[24]$/i.test(sourceAttribute.type)) {
+                    value = view.getInt16(base + component * 2, true);
+                    if (/^Normalized/i.test(sourceAttribute.type))
+                        value = Math.max(-1, value / 32767);
+                }
+                else
+                    value = view.getFloat32(base + component * 4, true);
                 if ((name === "position" || name === "normal" || name === "tangent") && component === 2) {
                     value = -value;
                 }
+                if (name === "tangent" && component === 3)
+                    value = -value;
                 values[vertex * sourceAttribute.componentCount + component] = value;
             }
         }
@@ -230,10 +595,12 @@ export function decodeRaw3DThreeGeometry(mesh, project, three) {
                 ? indexView.getUint32(offset * 4, true)
                 : indexView.getUint16(offset * 2, true);
         }
-        for (let offset = 0; offset + 2 < indices.length; offset += 3) {
-            const second = indices[offset + 1];
-            indices[offset + 1] = indices[offset + 2];
-            indices[offset + 2] = second;
+        if (isTriangleList(mesh.meshType)) {
+            for (let offset = 0; offset + 2 < indices.length; offset += 3) {
+                const second = indices[offset + 1];
+                indices[offset + 1] = indices[offset + 2];
+                indices[offset + 2] = second;
+            }
         }
         indexArrays.push(indices);
         totalIndexCount += indices.length;
@@ -249,13 +616,117 @@ export function decodeRaw3DThreeGeometry(mesh, project, three) {
         }
         geometry.setIndex(new three.BufferAttribute(combined, 1));
     }
-    if (!geometry.getAttribute("normal")) {
+    if (isTriangleList(mesh.meshType) && !geometry.getAttribute("normal")) {
         geometry.computeVertexNormals();
     }
     geometry.computeBoundingBox();
     geometry.computeBoundingSphere();
     return geometry;
 }
+function createDrawable(mesh, geometry, materials, three) {
+    const material = materials[0] ?? new three.MeshStandardMaterial({ color: 0x9aa0a6, roughness: 0.8 });
+    switch (mesh.meshType.toLowerCase()) {
+        case "linelist": {
+            const lineMaterials = materials.map((source) => toLineMaterial(source, three));
+            return new three.LineSegments(geometry, lineMaterials.length === 1 ? lineMaterials[0] : lineMaterials);
+        }
+        case "pointlist": {
+            const pointMaterials = materials.map((source) => toPointMaterial(source, three));
+            return new three.Points(geometry, pointMaterials.length === 1 ? pointMaterials[0] : pointMaterials);
+        }
+        default:
+            return new three.Mesh(geometry, materials.length === 1 ? material : [...materials]);
+    }
+}
+function toLineMaterial(material, three) {
+    const source = material;
+    return new three.LineBasicMaterial({
+        color: source.color,
+        opacity: source.opacity,
+        transparent: source.transparent,
+        depthWrite: source.depthWrite
+    });
+}
+function toPointMaterial(material, three) {
+    const source = material;
+    return new three.PointsMaterial({
+        color: source.color,
+        opacity: source.opacity,
+        transparent: source.transparent,
+        depthWrite: source.depthWrite,
+        size: source.userData.raw3dPointSize ?? 1,
+        vertexColors: /^(pointcloud|1)$/i.test(source.userData.raw3dShader ?? ""),
+        sizeAttenuation: true
+    });
+}
+function isTriangleList(meshType) {
+    return meshType.toLowerCase() === "trianglelist";
+}
+function primitiveKind(meshType) {
+    switch (meshType.toLowerCase()) {
+        case "linelist": return "lines";
+        case "pointlist": return "points";
+        default: return "mesh";
+    }
+}
+function isAnnotationNode(node, nodes) {
+    for (let current = node; current; current = current.parentIndex === undefined
+        ? undefined
+        : nodes.get(current.parentIndex)) {
+        if (/^(DrawingBlock|Dimension)/i.test(current.name)) {
+            return true;
+        }
+    }
+    return false;
+}
+function createTextSprite(text, sourceMaterial, three) {
+    if (typeof document === "undefined") {
+        return undefined;
+    }
+    const lines = text.value.replace(/\r\n?/g, "\n").split("\n");
+    const fontSize = 100;
+    const lineHeight = 120;
+    const padding = 20;
+    const canvas = document.createElement("canvas");
+    const context = canvas.getContext("2d");
+    if (!context) {
+        return undefined;
+    }
+    context.font = `${fontSize}px ${text.fontFamily || "Arial"}`;
+    const width = Math.max(1, ...lines.map((line) => context.measureText(line).width));
+    canvas.width = Math.ceil(width + padding * 2);
+    canvas.height = Math.max(1, lines.length * lineHeight + padding * 2);
+    const drawContext = canvas.getContext("2d");
+    if (!drawContext) {
+        return undefined;
+    }
+    drawContext.font = `${fontSize}px ${text.fontFamily || "Arial"}`;
+    drawContext.textAlign = "center";
+    drawContext.textBaseline = "middle";
+    const color = sourceMaterial
+        ? `rgb(${Math.round(clamp01(sourceMaterial.red) * 255)}, ${Math.round(clamp01(sourceMaterial.green) * 255)}, ${Math.round(clamp01(sourceMaterial.blue) * 255)})`
+        : "rgb(0, 0, 0)";
+    drawContext.fillStyle = color;
+    lines.forEach((line, index) => {
+        drawContext.fillText(line, canvas.width / 2, padding + lineHeight * (index + 0.5));
+    });
+    const opacity = sourceMaterial ? 1 - clamp01(sourceMaterial.transparency) : 1;
+    const texture = new three.CanvasTexture(canvas);
+    texture.colorSpace = three.SRGBColorSpace;
+    const sprite = new three.Sprite(new three.SpriteMaterial({
+        map: texture,
+        transparent: true,
+        opacity,
+        // Labels share planes with their dimension geometry. Draw them as a readable
+        // annotation layer instead of letting those lines occlude the canvas.
+        depthTest: false,
+        depthWrite: false
+    }));
+    sprite.renderOrder = 1;
+    const scale = Math.max(text.size, 0.001) / fontSize;
+    sprite.scale.set(canvas.width * scale, canvas.height * scale, 1);
+    return sprite;
+}
 function resolveNodeMaterials(node, mesh, project, materials, fallback) {
     const layerMaterial = node.layerIndex === undefined
         ? undefined
@@ -270,6 +741,9 @@ function resolveNodeMaterials(node, mesh, project, materials, fallback) {
 }
 async function loadTextures(project, three, stats, warn) {
     const wanted = new Map();
+    for (const stream of project.streamableTextures)
+        if (stream.data)
+            wanted.set(`stream:${stream.index}:color`, { texture: stream, color: true });
     for (const material of project.materials) {
         if (material.textureIndex !== undefined && project.textures[material.textureIndex]) {
             wanted.set(`${material.textureIndex}:color`, { texture: project.textures[material.textureIndex], color: true });
@@ -278,6 +752,21 @@ async function loadTextures(project, three, stats, warn) {
             wanted.set(`${material.normalTextureIndex}:normal`, { texture: project.textures[material.normalTextureIndex], color: false });
         }
     }
+    for (const update of project.root.child("Updates")?.children ?? []) {
+        if (update.localName !== "Material")
+            continue;
+        const name = update.attributes.find(attribute => attribute.localName === "Name")?.value;
+        if (!["Texture", "NormalMap", "NormalTexture"].includes(name ?? ""))
+            continue;
+        const value = update.attributes.find(attribute => attribute.localName === "Value")?.value ?? "";
+        for (const token of value.trim().split(/\s+/)) {
+            const index = Number(token), texture = project.textures[index];
+            if (texture) {
+                const color = name === "Texture";
+                wanted.set(`${index}:${color ? "color" : "normal"}`, { texture, color });
+            }
+        }
+    }
     const loaded = new Map();
     await Promise.all([...wanted].map(async ([key, item]) => {
         if (!item.texture.data) {
@@ -321,10 +810,13 @@ function createMaterial(source, textures, three) {
         : textures.get(`${source.normalTextureIndex}:normal`);
     const map = sharedMap?.clone();
     const normalMap = sharedNormalMap?.clone();
-    if (map && (source.scaleU !== 1 || source.scaleV !== 1)) {
-        map.wrapS = three.RepeatWrapping;
-        map.wrapT = three.RepeatWrapping;
-        map.repeat.set(source.scaleU, source.scaleV);
+    for (const texture of [map, normalMap]) {
+        if (!texture)
+            continue;
+        if (source.scaleU !== 1 || source.scaleV !== 1 || source.offsetU !== 0 || source.offsetV !== 0)
+            texture.wrapS = texture.wrapT = three.RepeatWrapping;
+        texture.repeat.set(source.scaleU, source.scaleV);
+        texture.offset.set(source.offsetU, source.offsetV);
     }
     const parameters = {
         color: new three.Color(clamp01(source.red), clamp01(source.green), clamp01(source.blue)),
@@ -341,7 +833,26 @@ function createMaterial(source, textures, three) {
         parameters.normalMap = normalMap;
         parameters.normalScale = new three.Vector2(source.normalScale, source.normalScale);
     }
-    return new three.MeshStandardMaterial(parameters);
+    let result;
+    switch (source.shader.toLowerCase()) {
+        case "flattext":
+        case "2":
+            result = new three.MeshBasicMaterial({ color: parameters.color, map: map ?? null, opacity, transparent: opacity < 1 || !!map, depthWrite: opacity >= 1, side: three.DoubleSide });
+            break;
+        case "default":
+        case "0":
+        case "pointcloud":
+        case "1":
+            result = raw3DNodeBackend(three)?.standard(parameters) ?? new three.MeshStandardMaterial(parameters);
+            break;
+        default: throw new Error(`Unsupported RAW3D material shader ${source.shader}.`);
+    }
+    result.userData.raw3dShader = source.shader;
+    result.userData.raw3dPointSize = source.pointSize;
+    result.userData.raw3dNormalDepth = source.normalDepth;
+    if ("emissive" in result)
+        result.emissive.copy(result.color).multiplyScalar(source.luminosity);
+    return result;
 }
 function applyTransform(object, node) {
     object.position.set(node.location[0] ?? 0, node.location[1] ?? 0, -(node.location[2] ?? 0));