@downdraft/engine 0.1.0 → 0.1.2-alpha.5

package/dist/libraries/models/src/dae.js

@@ -0,0 +1,665 @@
+import { parseMiniXml } from "./mini-xml.js";
+/**
+ * Parse Collada XML into a Document. Uses a real DOMParser when available;
+ * on the native runtime DOMParser is an empty stub, so fall back to the
+ * built-in mini parser when the result has no COLLADA root.
+ */
+function parseColladaDocument(text) {
+    if (typeof DOMParser !== "undefined") {
+        try {
+            const doc = new DOMParser().parseFromString(text, "application/xml");
+            if (doc.getElementsByTagName("COLLADA").length > 0)
+                return doc;
+        }
+        catch { /* stub or unavailable — fall through */ }
+    }
+    return parseMiniXml(text);
+}
+function parseFloatArray(text) {
+    return text.trim().split(/\s+/).map(Number).filter(v => !isNaN(v));
+}
+function parseIntArray(text) {
+    return text.trim().split(/\s+/).map(Number).filter(v => !isNaN(v));
+}
+function getAttr(el, name) {
+    const val = el.getAttribute(name);
+    return val ?? undefined;
+}
+function parseSources(geometryEl) {
+    const sources = new Map();
+    const sourceEls = geometryEl.getElementsByTagName("source");
+    for (let i = 0; i < sourceEls.length; i++) {
+        const src = sourceEls[i];
+        const id = src.getAttribute("id") ?? "";
+        const floatArrayEl = src.getElementsByTagName("float_array")[0];
+        if (!floatArrayEl)
+            continue;
+        const data = parseFloatArray(floatArrayEl.textContent ?? "");
+        const techniqueEl = src.getElementsByTagName("accessor")[0];
+        const stride = techniqueEl ? parseInt(techniqueEl.getAttribute("stride") ?? "3") : 3;
+        sources.set(id, { id, data, stride });
+    }
+    return sources;
+}
+function parseInputs(parentEl) {
+    const inputs = [];
+    const inputEls = parentEl.getElementsByTagName("input");
+    for (let i = 0; i < inputEls.length; i++) {
+        const input = inputEls[i];
+        const semantic = input.getAttribute("semantic") ?? "";
+        const source = (input.getAttribute("source") ?? "").replace("#", "");
+        const offset = parseInt(input.getAttribute("offset") ?? "0");
+        const setAttr = input.getAttribute("set");
+        inputs.push({ semantic, source, offset, set: setAttr ? parseInt(setAttr) : undefined });
+    }
+    return inputs;
+}
+function parseGeometries(doc) {
+    const geometries = new Map();
+    const geomEls = doc.getElementsByTagName("geometry");
+    for (let i = 0; i < geomEls.length; i++) {
+        const geomEl = geomEls[i];
+        const id = geomEl.getAttribute("id") ?? `geom_${i}`;
+        const name = geomEl.getAttribute("name") ?? id;
+        const meshEl = geomEl.getElementsByTagName("mesh")[0];
+        if (!meshEl)
+            continue;
+        const sources = parseSources(meshEl);
+        // Parse vertices elements (Collada VERTEX semantic points to these)
+        const verticesMap = new Map();
+        const vertEls = meshEl.getElementsByTagName("vertices");
+        for (let j = 0; j < vertEls.length; j++) {
+            const vertEl = vertEls[j];
+            const vertId = vertEl.getAttribute("id") ?? "";
+            const vertInputs = [];
+            const vertInputEls = vertEl.getElementsByTagName("input");
+            for (let k = 0; k < vertInputEls.length; k++) {
+                const inp = vertInputEls[k];
+                vertInputs.push({
+                    semantic: inp.getAttribute("semantic") ?? "",
+                    source: (inp.getAttribute("source") ?? "").replace("#", ""),
+                    offset: parseInt(inp.getAttribute("offset") ?? "0"),
+                    set: inp.getAttribute("set") ? parseInt(inp.getAttribute("set")) : undefined,
+                });
+            }
+            verticesMap.set(vertId, { id: vertId, inputs: vertInputs });
+        }
+        const primitives = [];
+        // Parse triangles
+        const triEls = meshEl.getElementsByTagName("triangles");
+        for (let j = 0; j < triEls.length; j++) {
+            const triEl = triEls[j];
+            const count = parseInt(triEl.getAttribute("count") ?? "0");
+            const inputs = parseInputs(triEl);
+            const pEl = triEl.getElementsByTagName("p")[0];
+            const indices = pEl ? parseIntArray(pEl.textContent ?? "") : [];
+            const material = getAttr(triEl, "material");
+            primitives.push({ type: "triangles", count, inputs, indices, material });
+        }
+        // Parse polylist
+        const polyEls = meshEl.getElementsByTagName("polylist");
+        for (let j = 0; j < polyEls.length; j++) {
+            const polyEl = polyEls[j];
+            const count = parseInt(polyEl.getAttribute("count") ?? "0");
+            const inputs = parseInputs(polyEl);
+            const pEl = polyEl.getElementsByTagName("p")[0];
+            const indices = pEl ? parseIntArray(pEl.textContent ?? "") : [];
+            const vcountEl = polyEl.getElementsByTagName("vcount")[0];
+            const vcount = vcountEl ? parseIntArray(vcountEl.textContent ?? "") : [];
+            const material = getAttr(polyEl, "material");
+            primitives.push({ type: "polylist", count, inputs, indices, vcount, material });
+        }
+        // Parse tristrips
+        const stripEls = meshEl.getElementsByTagName("tristrips");
+        for (let j = 0; j < stripEls.length; j++) {
+            const stripEl = stripEls[j];
+            const count = parseInt(stripEl.getAttribute("count") ?? "0");
+            const inputs = parseInputs(stripEl);
+            const pEl = stripEl.getElementsByTagName("p")[0];
+            const indices = pEl ? parseIntArray(pEl.textContent ?? "") : [];
+            const material = getAttr(stripEl, "material");
+            primitives.push({ type: "tristrips", count, inputs, indices, material });
+        }
+        geometries.set(id, { id, name, sources, vertices: verticesMap, primitives });
+    }
+    return geometries;
+}
+function parseMaterials(doc) {
+    const materials = new Map();
+    const matEls = doc.getElementsByTagName("material");
+    const effectMap = new Map();
+    // Build effect map
+    const effectEls = doc.getElementsByTagName("effect");
+    for (let i = 0; i < effectEls.length; i++) {
+        const id = effectEls[i].getAttribute("id") ?? "";
+        effectMap.set(id, effectEls[i]);
+    }
+    for (let i = 0; i < matEls.length; i++) {
+        const matEl = matEls[i];
+        const id = matEl.getAttribute("id") ?? `mat_${i}`;
+        const name = matEl.getAttribute("name") ?? id;
+        let diffuseColor = [0.7, 0.7, 0.7, 1];
+        let diffuseTexture;
+        let normalTexture;
+        let specularColor = [0, 0, 0];
+        let shininess = 0;
+        // Find instance_effect
+        const instEffect = matEl.getElementsByTagName("instance_effect")[0];
+        if (instEffect) {
+            const effectUrl = (instEffect.getAttribute("url") ?? "").replace("#", "");
+            const effectEl = effectMap.get(effectUrl);
+            if (effectEl) {
+                // Find phong/lambert/Blinn profile
+                const profileEls = effectEl.getElementsByTagName("profile_COMMON");
+                for (let p = 0; p < profileEls.length; p++) {
+                    const profile = profileEls[p];
+                    const techniqueEls = profile.getElementsByTagName("technique");
+                    for (let t = 0; t < techniqueEls.length; t++) {
+                        const technique = techniqueEls[t];
+                        const shadingEls = ["phong", "lambert", "blinn", "Blinn"];
+                        for (let s = 0; s < shadingEls.length; s++) {
+                            const shadingEl = technique.getElementsByTagName(shadingEls[s])[0];
+                            if (!shadingEl)
+                                continue;
+                            const diffuseEl = shadingEl.getElementsByTagName("diffuse")[0];
+                            if (diffuseEl) {
+                                const colorEl = diffuseEl.getElementsByTagName("color")[0];
+                                const textureEl = diffuseEl.getElementsByTagName("texture")[0];
+                                if (colorEl) {
+                                    const c = parseFloatArray(colorEl.textContent ?? "");
+                                    if (c.length >= 3) {
+                                        diffuseColor = [c[0], c[1], c[2], c[3] ?? 1];
+                                    }
+                                }
+                                if (textureEl) {
+                                    const texName = textureEl.getAttribute("texture") ?? "";
+                                    // Find the surface/sampler to get the image URI
+                                    const newParamEls = profile.getElementsByTagName("newparam");
+                                    for (let np = 0; np < newParamEls.length; np++) {
+                                        const sid = newParamEls[np].getAttribute("sid");
+                                        if (sid === texName) {
+                                            const samplerEl = newParamEls[np].getElementsByTagName("sampler2D")[0];
+                                            if (samplerEl) {
+                                                const sourceEl = samplerEl.getElementsByTagName("source")[0];
+                                                if (sourceEl) {
+                                                    const surfaceName = sourceEl.textContent?.trim();
+                                                    if (surfaceName) {
+                                                        // Find the surface newparam
+                                                        for (let np2 = 0; np2 < newParamEls.length; np2++) {
+                                                            const surfSid = newParamEls[np2].getAttribute("sid");
+                                                            if (surfSid === surfaceName) {
+                                                                const initFromEl = newParamEls[np2].getElementsByTagName("init_from")[0];
+                                                                if (initFromEl) {
+                                                                    const imageId = initFromEl.textContent?.trim();
+                                                                    if (imageId) {
+                                                                        const imageEl = doc.getElementById(imageId);
+                                                                        if (imageEl) {
+                                                                            const initFrom = imageEl.getElementsByTagName("init_from")[0];
+                                                                            diffuseTexture = initFrom?.textContent?.trim();
+                                                                        }
+                                                                    }
+                                                                }
+                                                            }
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                            const specularEl = shadingEl.getElementsByTagName("specular")[0];
+                            if (specularEl) {
+                                const colorEl = specularEl.getElementsByTagName("color")[0];
+                                if (colorEl) {
+                                    const c = parseFloatArray(colorEl.textContent ?? "");
+                                    if (c.length >= 3)
+                                        specularColor = [c[0], c[1], c[2]];
+                                }
+                            }
+                            const shininessEl = shadingEl.getElementsByTagName("shininess")[0];
+                            if (shininessEl) {
+                                const floatEl = shininessEl.getElementsByTagName("float")[0];
+                                if (floatEl) {
+                                    shininess = parseFloat(floatEl.textContent?.trim() ?? "0");
+                                }
+                            }
+                            // Bump/normal map
+                            const bumpEl = shadingEl.getElementsByTagName("bump")[0];
+                            if (bumpEl) {
+                                const textureEl = bumpEl.getElementsByTagName("texture")[0];
+                                if (textureEl) {
+                                    normalTexture = textureEl.getAttribute("texture") ?? undefined;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        materials.set(id, { id, name, diffuseColor, diffuseTexture, normalTexture, specularColor, shininess });
+    }
+    return materials;
+}
+function parseNodes(doc) {
+    const result = [];
+    const nodeEls = doc.getElementsByTagName("node");
+    for (let i = 0; i < nodeEls.length; i++) {
+        const nodeEl = nodeEls[i];
+        const name = nodeEl.getAttribute("name") ?? nodeEl.getAttribute("id") ?? `node_${i}`;
+        const id = nodeEl.getAttribute("id") ?? `node_${i}`;
+        let translation;
+        let rotation;
+        let scale;
+        // Parse transforms
+        const childEls = nodeEl.children;
+        const rotations = [];
+        for (let j = 0; j < childEls.length; j++) {
+            const child = childEls[j];
+            const tagName = child.tagName.toLowerCase();
+            if (tagName === "translate") {
+                const v = parseFloatArray(child.textContent ?? "");
+                if (v.length >= 3)
+                    translation = [v[0], v[1], v[2]];
+            }
+            else if (tagName === "rotate") {
+                const v = parseFloatArray(child.textContent ?? "");
+                if (v.length >= 4) {
+                    rotations.push({ axis: [v[0], v[1], v[2]], angle: v[3] * Math.PI / 180 });
+                }
+            }
+            else if (tagName === "scale") {
+                const v = parseFloatArray(child.textContent ?? "");
+                if (v.length >= 3)
+                    scale = [v[0], v[1], v[2]];
+            }
+            else if (tagName === "matrix") {
+                const v = parseFloatArray(child.textContent ?? "");
+                if (v.length >= 16) {
+                    // Extract translation from matrix
+                    translation = [v[12], v[13], v[14]];
+                }
+            }
+        }
+        // Combine rotations into a single quaternion
+        if (rotations.length > 0) {
+            let qx = 0, qy = 0, qz = 0, qw = 1;
+            for (let r = 0; r < rotations.length; r++) {
+                const rot = rotations[r];
+                const halfAngle = rot.angle / 2;
+                const s = Math.sin(halfAngle);
+                const c = Math.cos(halfAngle);
+                const ax = rot.axis[0], ay = rot.axis[1], az = rot.axis[2];
+                const len = Math.sqrt(ax * ax + ay * ay + az * az) || 1;
+                const nx = ax / len, ny = ay / len, nz = az / len;
+                const rqx = s * nx, rqy = s * ny, rqz = s * nz, rqw = c;
+                // Quaternion multiplication: q = q * rq
+                const newW = qw * rqw - qx * rqx - qy * rqy - qz * rqz;
+                const newX = qw * rqx + qx * rqw + qy * rqz - qz * rqy;
+                const newY = qw * rqy - qx * rqz + qy * rqw + qz * rqx;
+                const newZ = qw * rqz + qx * rqy - qy * rqx + qz * rqw;
+                qx = newX;
+                qy = newY;
+                qz = newZ;
+                qw = newW;
+            }
+            rotation = [qx, qy, qz, qw];
+        }
+        result.push({ name, children: undefined, translation, rotation, scale });
+    }
+    return result;
+}
+function parseAnimations(doc) {
+    const animations = [];
+    const animEls = doc.getElementsByTagName("animation");
+    const sourceMap = new Map();
+    // Collect all sources from all animations
+    const allSourceEls = doc.getElementsByTagName("source");
+    for (let i = 0; i < allSourceEls.length; i++) {
+        const srcEl = allSourceEls[i];
+        const id = srcEl.getAttribute("id") ?? "";
+        const floatArrayEl = srcEl.getElementsByTagName("float_array")[0];
+        if (floatArrayEl) {
+            sourceMap.set(id, parseFloatArray(floatArrayEl.textContent ?? ""));
+        }
+    }
+    for (let i = 0; i < animEls.length; i++) {
+        const animEl = animEls[i];
+        const name = animEl.getAttribute("name") ?? animEl.getAttribute("id") ?? `anim_${i}`;
+        const channels = [];
+        let maxTime = 0;
+        // Parse samplers
+        const samplerEls = animEl.getElementsByTagName("sampler");
+        const samplers = [];
+        for (let j = 0; j < samplerEls.length; j++) {
+            const samplerEl = samplerEls[j];
+            let input = [];
+            let output = [];
+            let interpolation = "LINEAR";
+            const inputEls = samplerEl.getElementsByTagName("input");
+            for (let k = 0; k < inputEls.length; k++) {
+                const inputEl = inputEls[k];
+                const semantic = inputEl.getAttribute("semantic");
+                const source = (inputEl.getAttribute("source") ?? "").replace("#", "");
+                if (semantic === "INPUT") {
+                    input = sourceMap.get(source) ?? [];
+                }
+                else if (semantic === "OUTPUT") {
+                    output = sourceMap.get(source) ?? [];
+                }
+                else if (semantic === "INTERPOLATION") {
+                    const interpData = sourceMap.get(source);
+                    if (interpData && interpData.length > 0) {
+                        // Names array - not float_array, need to get from Name_array
+                        const nameArrayEl = samplerEl.ownerDocument.getElementById(source);
+                        if (nameArrayEl) {
+                            const nameArray = nameArrayEl.getElementsByTagName("Name_array")[0] ??
+                                nameArrayEl.getElementsByTagName("float_array")[0];
+                            if (nameArray) {
+                                const interpText = (nameArray.textContent ?? "").trim().split(/\s+/);
+                                if (interpText.length > 0)
+                                    interpolation = interpText[0];
+                            }
+                        }
+                    }
+                }
+            }
+            samplers.push({ input, output, interpolation });
+        }
+        // Parse channel targets
+        const channelEls = animEl.getElementsByTagName("channel");
+        for (let j = 0; j < channelEls.length; j++) {
+            const channelEl = channelEls[j];
+            const target = channelEl.getAttribute("target") ?? "";
+            const source = (channelEl.getAttribute("source") ?? "").replace("#", "");
+            // Find the sampler index
+            const samplerIdx = samplers.findIndex((_, idx) => {
+                const samplerEl = samplerEls[idx];
+                return samplerEl.getAttribute("id") === source;
+            });
+            if (samplerIdx < 0)
+                continue;
+            const sampler = samplers[samplerIdx];
+            // Parse target: "nodeName/transform(0)" or "nodeName/transform"
+            const targetParts = target.split("/");
+            if (targetParts.length < 2)
+                continue;
+            const nodeName = targetParts[0];
+            const transformPart = targetParts[1].split("(")[0].toLowerCase();
+            let path = "translation";
+            if (transformPart.includes("translate"))
+                path = "translation";
+            else if (transformPart.includes("rotate"))
+                path = "rotation";
+            else if (transformPart.includes("scale"))
+                path = "scale";
+            // Determine component count
+            const components = path === "rotation" ? 4 : 3;
+            const keyframeCount = sampler.input.length;
+            for (let t = 0; t < keyframeCount; t++) {
+                if (sampler.input[t] > maxTime)
+                    maxTime = sampler.input[t];
+            }
+            const times = new Float32Array(keyframeCount);
+            for (let t = 0; t < keyframeCount; t++) {
+                times[t] = sampler.input[t];
+            }
+            const values = new Float32Array(keyframeCount * components);
+            for (let t = 0; t < keyframeCount; t++) {
+                for (let c = 0; c < components && t * components + c < sampler.output.length; c++) {
+                    values[t * components + c] = sampler.output[t * components + c];
+                }
+            }
+            channels.push({
+                targetNode: nodeName,
+                path,
+                keyframeTimes: times,
+                keyframeValues: values,
+                interpolation: sampler.interpolation,
+            });
+        }
+        if (channels.length > 0) {
+            animations.push({ name, duration: maxTime, channels });
+        }
+    }
+    return animations;
+}
+function geometryToMeshes(geom, materials) {
+    const meshes = [];
+    for (let p = 0; p < geom.primitives.length; p++) {
+        const prim = geom.primitives[p];
+        // Find input offsets and sources
+        const maxOffset = Math.max(...prim.inputs.map(inp => inp.offset));
+        const stride = maxOffset + 1;
+        // Map semantic to source
+        const posSource = prim.inputs.find(inp => inp.semantic === "VERTEX");
+        const normSource = prim.inputs.find(inp => inp.semantic === "NORMAL");
+        const uvSource = prim.inputs.find(inp => inp.semantic === "TEXCOORD");
+        // Resolve vertex source (VERTEX semantic points to a source that may reference POSITION)
+        let posData = [];
+        let posStride = 3;
+        let normData = [];
+        let normStride = 3;
+        let uvData = [];
+        let uvStride = 2;
+        if (posSource) {
+            // In Collada, VERTEX semantic points to a <vertices> element,
+            // which has inputs (e.g. POSITION) that point to actual <source> elements
+            const vertEl = geom.vertices.get(posSource.source);
+            if (vertEl) {
+                // Resolve POSITION input from vertices element
+                const posInput = vertEl.inputs.find(inp => inp.semantic === "POSITION");
+                if (posInput) {
+                    const src = geom.sources.get(posInput.source);
+                    if (src) {
+                        posData = src.data;
+                        posStride = src.stride;
+                    }
+                }
+            }
+            else {
+                // Direct source reference (non-standard but handle it)
+                const src = geom.sources.get(posSource.source);
+                if (src) {
+                    posData = src.data;
+                    posStride = src.stride;
+                }
+            }
+        }
+        if (normSource) {
+            const src = geom.sources.get(normSource.source);
+            if (src) {
+                normData = src.data;
+                normStride = src.stride;
+            }
+        }
+        if (uvSource) {
+            const src = geom.sources.get(uvSource.source);
+            if (src) {
+                uvData = src.data;
+                uvStride = src.stride;
+            }
+        }
+        if (posData.length === 0)
+            continue;
+        // Build vertices
+        const vertexMap = new Map();
+        const vertices = [];
+        const uvs = [];
+        const colors = [];
+        const indices = [];
+        // Get material color for this primitive
+        let matColor = [0.7, 0.7, 0.75];
+        if (prim.material && materials.has(prim.material)) {
+            const mat = materials.get(prim.material);
+            matColor = [mat.diffuseColor[0], mat.diffuseColor[1], mat.diffuseColor[2]];
+        }
+        function addVertex(posIdx, normIdx, uvIdx) {
+            const key = `${posIdx}/${normIdx}/${uvIdx}`;
+            let idx = vertexMap.get(key);
+            if (idx === undefined) {
+                idx = vertices.length / 6;
+                const px = posData[posIdx * posStride] ?? 0;
+                const py = posData[posIdx * posStride + 1] ?? 0;
+                const pz = posData[posIdx * posStride + 2] ?? 0;
+                let nx = 0, ny = 1, nz = 0;
+                if (normData.length > 0) {
+                    nx = normData[normIdx * normStride] ?? 0;
+                    ny = normData[normIdx * normStride + 1] ?? 0;
+                    nz = normData[normIdx * normStride + 2] ?? 0;
+                }
+                vertices.push(px, py, pz, nx, ny, nz);
+                if (uvData.length > 0) {
+                    const u = uvData[uvIdx * uvStride] ?? 0;
+                    const v = 1.0 - (uvData[uvIdx * uvStride + 1] ?? 0);
+                    uvs.push(u, v);
+                }
+                else {
+                    uvs.push(0, 0);
+                }
+                colors.push(matColor[0], matColor[1], matColor[2]);
+                vertexMap.set(key, idx);
+            }
+            return idx;
+        }
+        const posOff = posSource?.offset ?? 0;
+        const normOff = normSource?.offset ?? 0;
+        const uvOff = uvSource?.offset ?? 0;
+        if (prim.type === "triangles") {
+            const triCount = prim.count;
+            for (let t = 0; t < triCount; t++) {
+                for (let v = 0; v < 3; v++) {
+                    const idxBase = (t * 3 + v) * stride;
+                    const posIdx = prim.indices[idxBase + posOff];
+                    const normIdx = normSource ? prim.indices[idxBase + normOff] : posIdx;
+                    const uvIdx = uvSource ? prim.indices[idxBase + uvOff] : posIdx;
+                    indices.push(addVertex(posIdx, normIdx, uvIdx));
+                }
+            }
+        }
+        else if (prim.type === "polylist" && prim.vcount) {
+            let idxPtr = 0;
+            for (let poly = 0; poly < prim.vcount.length; poly++) {
+                const vcount = prim.vcount[poly];
+                const polyVerts = [];
+                for (let v = 0; v < vcount; v++) {
+                    const posIdx = prim.indices[idxPtr + posOff];
+                    const normIdx = normSource ? prim.indices[idxPtr + normOff] : posIdx;
+                    const uvIdx = uvSource ? prim.indices[idxPtr + uvOff] : posIdx;
+                    polyVerts.push(addVertex(posIdx, normIdx, uvIdx));
+                    idxPtr += stride;
+                }
+                // Fan triangulation
+                for (let v = 1; v < polyVerts.length - 1; v++) {
+                    indices.push(polyVerts[0], polyVerts[v], polyVerts[v + 1]);
+                }
+            }
+        }
+        else if (prim.type === "tristrips") {
+            // Triangle strips: each strip of N vertices produces N-2 triangles
+            const vertCount = prim.count;
+            for (let v = 0; v < vertCount; v++) {
+                const posIdx = prim.indices[v * stride + posOff];
+                const normIdx = normSource ? prim.indices[v * stride + normOff] : posIdx;
+                const uvIdx = uvSource ? prim.indices[v * stride + uvOff] : posIdx;
+                const mappedIdx = addVertex(posIdx, normIdx, uvIdx);
+                if (v >= 2) {
+                    // Alternate winding for strips
+                    if (v % 2 === 0) {
+                        indices.push(mappedIdx - 2, mappedIdx - 1, mappedIdx);
+                    }
+                    else {
+                        indices.push(mappedIdx - 1, mappedIdx - 2, mappedIdx);
+                    }
+                }
+            }
+        }
+        const vertArray = new Float32Array(vertices);
+        const idxArray = indices.length > 65535
+            ? new Uint32Array(indices)
+            : new Uint16Array(indices);
+        meshes.push({
+            vertices: vertArray,
+            indices: idxArray,
+            vertexCount: vertices.length / 6,
+            indexCount: indices.length,
+            uvs: uvData.length > 0 ? new Float32Array(uvs) : null,
+            colors: new Float32Array(colors),
+        });
+    }
+    return meshes;
+}
+export function parseDAE(data, name) {
+    const text = new TextDecoder().decode(data);
+    const doc = parseColladaDocument(text);
+    // Check for parse errors
+    const parseError = doc.getElementsByTagName("parsererror");
+    if (parseError.length > 0) {
+        throw new Error("Failed to parse DAE XML");
+    }
+    const geometries = parseGeometries(doc);
+    const materials = parseMaterials(doc);
+    const nodes = parseNodes(doc);
+    const animations = parseAnimations(doc);
+    // Parse <asset> element for up-axis and unit metadata.
+    // Collada defaults: Y-up, 1 meter.
+    let sourceUpAxis = "y";
+    let sourceUnits = "meters";
+    const assetElements = doc.getElementsByTagName("asset");
+    if (assetElements.length > 0) {
+        const asset = assetElements[0];
+        const upAxisEl = asset.getElementsByTagName("up_axis");
+        if (upAxisEl.length > 0) {
+            const val = upAxisEl[0].textContent?.trim().toUpperCase() ?? "";
+            if (val === "Z_UP")
+                sourceUpAxis = "z";
+        }
+        const unitEl = asset.getElementsByTagName("unit");
+        if (unitEl.length > 0) {
+            const meterAttr = unitEl[0].getAttribute("meter");
+            if (meterAttr) {
+                const metersPerUnit = parseFloat(meterAttr);
+                if (metersPerUnit === 1)
+                    sourceUnits = "meters";
+                else if (metersPerUnit === 0.01)
+                    sourceUnits = "centimeters";
+                else if (metersPerUnit === 0.0254)
+                    sourceUnits = "inches";
+                else if (metersPerUnit === 0.001)
+                    sourceUnits = "millimeters";
+                else
+                    sourceUnits = "units";
+            }
+        }
+    }
+    // Convert geometries to meshes
+    const meshes = [];
+    const materialList = [];
+    // Build material list
+    for (const [, mat] of materials.entries()) {
+        materialList.push({
+            name: mat.name,
+            baseColor: mat.diffuseColor,
+            metallic: 0,
+            roughness: mat.shininess > 0 ? Math.max(0.1, 1 - mat.shininess / 1000) : 1,
+            textureUri: mat.diffuseTexture,
+            normalTextureUri: mat.normalTexture,
+        });
+    }
+    for (const [, geom] of geometries.entries()) {
+        const geomMeshes = geometryToMeshes(geom, materials);
+        for (let i = 0; i < geomMeshes.length; i++) {
+            meshes.push(geomMeshes[i]);
+        }
+    }
+    return {
+        meshes,
+        name,
+        format: "dae",
+        materials: materialList.length > 0 ? materialList : undefined,
+        animations: animations.length > 0 ? animations : undefined,
+        nodes: nodes.length > 0 ? nodes : undefined,
+        sourceUpAxis,
+        sourceUnits,
+    };
+}