@holoscript/core 7.0.0 → 8.0.1

package/dist/USDZExporter-D2HQLQYK.js

@@ -0,0 +1,1035 @@
+import './chunk-OL46QLBJ.js';
+
+// src/export/usdz/USDTypes.ts
+function createUSDXform(name, path) {
+  return {
+    path,
+    type: "Xform",
+    name,
+    attributes: [],
+    children: []
+  };
+}
+function createUSDPreviewSurfaceMaterial(name, path, inputs) {
+  const shaderPath = `${path}/PreviewSurface`;
+  const shaderInputs = [];
+  if (inputs.diffuseColor) {
+    shaderInputs.push({
+      name: "diffuseColor",
+      type: "color3f",
+      value: inputs.diffuseColor
+    });
+  }
+  if (inputs.metallic !== void 0) {
+    shaderInputs.push({
+      name: "metallic",
+      type: "float",
+      value: inputs.metallic
+    });
+  }
+  if (inputs.roughness !== void 0) {
+    shaderInputs.push({
+      name: "roughness",
+      type: "float",
+      value: inputs.roughness
+    });
+  }
+  if (inputs.emissiveColor) {
+    shaderInputs.push({
+      name: "emissiveColor",
+      type: "color3f",
+      value: inputs.emissiveColor
+    });
+  }
+  const material = {
+    path,
+    type: "Material",
+    name,
+    attributes: [],
+    surfaceShader: shaderPath,
+    children: [
+      {
+        path: shaderPath,
+        type: "Shader",
+        name: "PreviewSurface",
+        attributes: [
+          {
+            name: "info:id",
+            type: "token",
+            value: "UsdPreviewSurface"
+          }
+        ]
+      }
+    ]
+  };
+  const shaderPrim = material.children[0];
+  shaderPrim.inputs = shaderInputs;
+  return material;
+}
+function quaternionToEuler(quat) {
+  const [x, y, z, w] = quat;
+  const sinr_cosp = 2 * (w * x + y * z);
+  const cosr_cosp = 1 - 2 * (x * x + y * y);
+  const roll = Math.atan2(sinr_cosp, cosr_cosp);
+  const sinp = 2 * (w * y - z * x);
+  const pitch = Math.abs(sinp) >= 1 ? Math.sign(sinp) * Math.PI / 2 : Math.asin(sinp);
+  const siny_cosp = 2 * (w * z + x * y);
+  const cosy_cosp = 1 - 2 * (y * y + z * z);
+  const yaw = Math.atan2(siny_cosp, cosy_cosp);
+  return [roll * 180 / Math.PI, pitch * 180 / Math.PI, yaw * 180 / Math.PI];
+}
+function sanitizeUSDName(name) {
+  return name.replace(/[^a-zA-Z0-9_]/g, "_");
+}
+
+// src/export/usdz/USDZExporter.ts
+var _USDZExporter = class _USDZExporter {
+  constructor(options = {}) {
+    this.primCounter = 0;
+    this.materialMap = /* @__PURE__ */ new Map();
+    // materialId -> USD path
+    this.meshMap = /* @__PURE__ */ new Map();
+    // meshId -> USD path
+    this.nodePrimMap = /* @__PURE__ */ new Map();
+    // nodeId -> USD prim
+    this.sceneGraphAccessorData = /* @__PURE__ */ new Map();
+    // accessorIndex -> flat data
+    this.textureFiles = [];
+    this.options = { ..._USDZExporter.DEFAULT_OPTIONS, ...options };
+  }
+  /**
+   * Export scene graph to USDZ format
+   * Returns ArrayBuffer containing .usdz package
+   */
+  async export(sceneGraph) {
+    const startTime = performance.now();
+    this.reset();
+    this.stage = this.createStage(sceneGraph);
+    await this.convertSceneGraph(sceneGraph);
+    if (this.options.lookAtCamera || this.options.placementMode) {
+      this.addARMetadata();
+    }
+    const usdzBuffer = await this.packageUSDZ();
+    const endTime = performance.now();
+    const stats = this.calculateStats(usdzBuffer.byteLength, endTime - startTime);
+    return {
+      usdz: usdzBuffer,
+      stage: this.stage,
+      stats
+    };
+  }
+  /**
+   * Convert from GLTF intermediate representation
+   */
+  async convertFromGLTF(gltfResult) {
+    const sceneGraph = this.gltfToSceneGraph(gltfResult);
+    const result = await this.export(sceneGraph);
+    return result.usdz;
+  }
+  // ========================================================================
+  // Private Methods - GLTF Bridge
+  // ========================================================================
+  gltfToSceneGraph(gltfResult) {
+    const doc = gltfResult.document;
+    const buffers = this.extractGLTFBuffers(gltfResult);
+    const sgBuffers = buffers.map((data, i) => ({
+      id: `buf_${i}`,
+      byteLength: data.byteLength,
+      data
+    }));
+    const sgBufferViews = (doc.bufferViews || []).map((bv, i) => ({
+      id: `bv_${i}`,
+      bufferIndex: bv.buffer,
+      byteOffset: bv.byteOffset || 0,
+      byteLength: bv.byteLength,
+      byteStride: bv.byteStride,
+      target: bv.target === 34962 ? "arrayBuffer" : bv.target === 34963 ? "elementArrayBuffer" : void 0
+    }));
+    const componentTypeMap = {
+      5120: "byte",
+      5121: "ubyte",
+      5122: "short",
+      5123: "ushort",
+      5125: "uint",
+      5126: "float"
+    };
+    const accessorTypeMap = {
+      SCALAR: "scalar",
+      VEC2: "vec2",
+      VEC3: "vec3",
+      VEC4: "vec4",
+      MAT2: "mat2",
+      MAT3: "mat3",
+      MAT4: "mat4"
+    };
+    const sgAccessors = (doc.accessors || []).map((acc, i) => ({
+      id: `acc_${i}`,
+      bufferViewIndex: acc.bufferView !== void 0 ? acc.bufferView : 0,
+      byteOffset: acc.byteOffset || 0,
+      componentType: componentTypeMap[acc.componentType] || "float",
+      type: accessorTypeMap[acc.type] || "scalar",
+      count: acc.count,
+      normalized: acc.normalized || false,
+      min: acc.min,
+      max: acc.max
+    }));
+    const sgMeshes = (doc.meshes || []).map((mesh, i) => ({
+      id: `mesh_${i}`,
+      name: mesh.name || `Mesh_${i}`,
+      primitives: mesh.primitives.map((prim) => ({
+        attributes: { ...prim.attributes },
+        indices: prim.indices,
+        mode: this.mapGLTFPrimitiveMode(prim.mode),
+        materialRef: prim.material !== void 0 ? `mat_${prim.material}` : void 0
+      })),
+      bounds: { min: [0, 0, 0], max: [1, 1, 1] }
+    }));
+    const sgMaterials = (doc.materials || []).map((mat, i) => {
+      const pbr = mat.pbrMetallicRoughness;
+      return {
+        id: `mat_${i}`,
+        name: mat.name || `Material_${i}`,
+        type: "pbr",
+        doubleSided: mat.doubleSided || false,
+        alphaMode: mat.alphaMode?.toLowerCase() || "opaque",
+        alphaCutoff: mat.alphaCutoff ?? 0.5,
+        baseColor: pbr?.baseColorFactor || [1, 1, 1, 1],
+        metallic: pbr?.metallicFactor ?? 0,
+        roughness: pbr?.roughnessFactor ?? 0.5,
+        emissiveColor: mat.emissiveFactor || [0, 0, 0],
+        emissiveIntensity: 1,
+        normalScale: mat.normalTexture?.scale ?? 1,
+        occlusionStrength: mat.occlusionTexture?.strength ?? 1,
+        baseColorTexture: pbr?.baseColorTexture ? this.mapGLTFTextureRef(pbr.baseColorTexture.index, pbr.baseColorTexture.texCoord || 0) : void 0,
+        normalTexture: mat.normalTexture ? this.mapGLTFTextureRef(mat.normalTexture.index, mat.normalTexture.texCoord || 0) : void 0,
+        occlusionTexture: mat.occlusionTexture ? this.mapGLTFTextureRef(mat.occlusionTexture.index, mat.occlusionTexture.texCoord || 0) : void 0,
+        emissiveTexture: mat.emissiveTexture ? this.mapGLTFTextureRef(mat.emissiveTexture.index, mat.emissiveTexture.texCoord || 0) : void 0,
+        metallicRoughnessTexture: pbr?.metallicRoughnessTexture ? this.mapGLTFTextureRef(pbr.metallicRoughnessTexture.index, pbr.metallicRoughnessTexture.texCoord || 0) : void 0
+      };
+    });
+    const nodeIdMap = /* @__PURE__ */ new Map();
+    const buildNode = (gltfNode, index) => {
+      const id = `node_${index}`;
+      nodeIdMap.set(index, id);
+      const children = (gltfNode.children || []).map(
+        (ci) => buildNode(doc.nodes[ci], ci)
+      );
+      const components = [];
+      if (gltfNode.mesh !== void 0) {
+        components.push({
+          type: "mesh",
+          meshRef: `mesh_${gltfNode.mesh}`,
+          materialRefs: [],
+          castShadows: true,
+          receiveShadows: true,
+          enabled: true,
+          properties: {}
+        });
+      }
+      return {
+        id,
+        name: gltfNode.name || `Node_${index}`,
+        type: "object",
+        transform: {
+          position: gltfNode.translation || [0, 0, 0],
+          rotation: gltfNode.rotation ? {
+            x: gltfNode.rotation[0],
+            y: gltfNode.rotation[1],
+            z: gltfNode.rotation[2],
+            w: gltfNode.rotation[3]
+          } : { x: 0, y: 0, z: 0, w: 1 },
+          scale: gltfNode.scale || [1, 1, 1]
+        },
+        children,
+        components,
+        active: true,
+        layers: 1,
+        tags: [],
+        metadata: {}
+      };
+    };
+    const scene = doc.scenes?.[doc.scene ?? 0];
+    const rootChildren = (scene?.nodes || []).map((ni) => buildNode(doc.nodes[ni], ni));
+    const root = {
+      id: "root",
+      name: "Root",
+      type: "group",
+      transform: {
+        position: [0, 0, 0],
+        rotation: { x: 0, y: 0, z: 0, w: 1 },
+        scale: [1, 1, 1]
+      },
+      children: rootChildren,
+      components: [],
+      active: true,
+      layers: 1,
+      tags: [],
+      metadata: {}
+    };
+    const sgAnimations = (doc.animations || []).map((anim, i) => {
+      const channels = anim.channels.map((ch) => ({
+        targetNode: nodeIdMap.get(ch.target.node) || `node_${ch.target.node}`,
+        targetPath: ch.target.path,
+        samplerIndex: ch.sampler
+      }));
+      const samplers = anim.samplers.map((s) => ({
+        inputBufferView: s.input,
+        outputBufferView: s.output,
+        interpolation: s.interpolation?.toLowerCase() || "linear"
+      }));
+      return {
+        id: `anim_${i}`,
+        name: anim.name || `Animation_${i}`,
+        duration: 0,
+        channels,
+        samplers
+      };
+    });
+    return {
+      version: "3.3.0",
+      generator: "HoloScript USDZExporter (GLTF bridge)",
+      metadata: {
+        name: "GLTFImport",
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        modifiedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        tags: [],
+        properties: {}
+      },
+      root,
+      materials: sgMaterials,
+      textures: [],
+      meshes: sgMeshes,
+      buffers: sgBuffers,
+      bufferViews: sgBufferViews,
+      accessors: sgAccessors,
+      animations: sgAnimations,
+      skins: [],
+      extensions: {},
+      extras: {}
+    };
+  }
+  extractGLTFBuffers(gltfResult) {
+    const doc = gltfResult.document;
+    if (gltfResult.glb) {
+      const binChunk = this.extractGLBBinChunk(gltfResult.glb);
+      if (binChunk) return [binChunk];
+    }
+    const buffers = [];
+    for (const buffer of doc.buffers || []) {
+      if (buffer.uri) {
+        const resource = gltfResult.resources.get(buffer.uri);
+        if (resource) {
+          buffers.push(resource);
+          continue;
+        }
+      }
+      buffers.push(new ArrayBuffer(buffer.byteLength));
+    }
+    return buffers;
+  }
+  extractGLBBinChunk(glb) {
+    const view = new DataView(glb);
+    const magic = view.getUint32(0, true);
+    if (magic !== 1179937895) return void 0;
+    const version = view.getUint32(4, true);
+    if (version !== 2) return void 0;
+    const length = view.getUint32(8, true);
+    let offset = 12;
+    while (offset < length) {
+      const chunkLength = view.getUint32(offset, true);
+      const chunkType = view.getUint32(offset + 4, true);
+      offset += 8;
+      if (chunkType === 5130562) {
+        return glb.slice(offset, offset + chunkLength);
+      }
+      offset += chunkLength;
+    }
+    return void 0;
+  }
+  mapGLTFPrimitiveMode(mode) {
+    const modes = ["points", "lines", "lineLoop", "lineStrip", "triangles", "triangleStrip", "triangleFan"];
+    return modes[mode ?? 4] || "triangles";
+  }
+  mapGLTFTextureRef(index, uvChannel) {
+    return {
+      id: `tex_${index}`,
+      uvChannel,
+      offset: { u: 0, v: 0 },
+      scale: { u: 1, v: 1 },
+      rotation: 0
+    };
+  }
+  // ========================================================================
+  // Private Methods - Stage Creation
+  // ========================================================================
+  createStage(sceneGraph) {
+    return {
+      metadata: {
+        version: "0.10.0",
+        upAxis: this.options.upAxis,
+        metersPerUnit: this.options.metersPerUnit,
+        comment: `Generated by ${sceneGraph.generator || "HoloScript USDZExporter"}`
+      },
+      defaultPrim: "Root",
+      prims: [],
+      customLayerData: {
+        creator: sceneGraph.generator,
+        holoscriptVersion: sceneGraph.version
+      }
+    };
+  }
+  async convertSceneGraph(sceneGraph) {
+    this.cacheAccessorData(sceneGraph);
+    const rootPrim = createUSDXform("Root", "/Root");
+    this.stage.prims.push(rootPrim);
+    await this.convertMaterials(sceneGraph.materials || []);
+    await this.convertMeshes(sceneGraph.meshes || [], sceneGraph);
+    this.convertNode(sceneGraph.root, rootPrim, sceneGraph);
+    if (this.options.includeAnimations && sceneGraph.animations?.length) {
+      this.convertAnimations(sceneGraph.animations);
+    }
+  }
+  cacheAccessorData(sceneGraph) {
+    for (let i = 0; i < (sceneGraph.accessors || []).length; i++) {
+      const data = this.extractAccessorData(i, sceneGraph);
+      this.sceneGraphAccessorData.set(i, data);
+    }
+  }
+  // ========================================================================
+  // Private Methods - Node Conversion
+  // ========================================================================
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Deep nested scene graph node access
+  convertNode(node, parentPrim, sceneGraph, depth = 0) {
+    if (!node || depth > 100) return;
+    const nodeName = sanitizeUSDName(node.name || `Node_${this.primCounter++}`);
+    const nodePath = `${parentPrim.path}/${nodeName}`;
+    const xformPrim = createUSDXform(nodeName, nodePath);
+    if (node.id) {
+      this.nodePrimMap.set(node.id, xformPrim);
+    }
+    if (node.transform) {
+      this.addTransform(xformPrim, node.transform);
+    }
+    if (!parentPrim.children) parentPrim.children = [];
+    parentPrim.children.push(xformPrim);
+    const meshComp = node.components?.find((c) => c.type === "mesh");
+    if (meshComp?.meshRef) {
+      const meshPath = this.meshMap.get(meshComp.meshRef);
+      if (meshPath) {
+        xformPrim.relationships = [
+          {
+            name: "mesh",
+            targets: [meshPath]
+          }
+        ];
+      }
+    }
+    if (node.children?.length) {
+      for (const child of node.children) {
+        this.convertNode(child, xformPrim, sceneGraph, depth + 1);
+      }
+    }
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Deep nested transform object access (position[0]/y/z, rotation[0]/y/z/w, scale[0]/y/z)
+  addTransform(prim, transform) {
+    const ops = [];
+    if (transform.position) {
+      ops.push({
+        type: "translate",
+        value: [transform.position[0], transform.position[1], transform.position[2]]
+      });
+    }
+    if (transform.rotation) {
+      const euler = quaternionToEuler([
+        transform.rotation[0],
+        transform.rotation[1],
+        transform.rotation[2],
+        transform.rotation[3]
+      ]);
+      ops.push({
+        type: "rotateXYZ",
+        value: euler
+      });
+    }
+    if (transform.scale) {
+      ops.push({
+        type: "scale",
+        value: [transform.scale[0], transform.scale[1], transform.scale[2]]
+      });
+    }
+    if (ops.length > 0) {
+      prim.attributes.push({
+        name: "xformOpOrder",
+        type: "token[]",
+        value: ops.map((op) => `xformOp:${op.type}`)
+      });
+      for (const op of ops) {
+        prim.attributes.push({
+          name: `xformOp:${op.type}`,
+          type: this.getXformOpType(op.type),
+          value: op.value
+        });
+      }
+    }
+  }
+  getXformOpType(opType) {
+    switch (opType) {
+      case "translate":
+        return "float3";
+      case "rotateXYZ":
+        return "float3";
+      case "rotateX":
+      case "rotateY":
+      case "rotateZ":
+        return "float";
+      case "scale":
+        return "float3";
+      case "transform":
+        return "matrix4d";
+      default:
+        return "float3";
+    }
+  }
+  // ========================================================================
+  // Private Methods - Material Conversion
+  // ========================================================================
+  async convertMaterials(materials) {
+    for (const material of materials) {
+      await this.convertMaterial(material);
+    }
+  }
+  async convertMaterial(material) {
+    const matName = sanitizeUSDName(material.name || `Material_${this.primCounter++}`);
+    const matPath = `/Root/Materials/${matName}`;
+    const mapping = this.createMaterialMapping(material);
+    const inputs = {
+      diffuseColor: mapping.baseColor.slice(0, 3),
+      // RGB only
+      metallic: mapping.metallic,
+      roughness: mapping.roughness,
+      emissiveColor: mapping.emissive
+    };
+    if (material.alphaMode === "blend" || material.alphaMode === "mask") {
+      inputs.opacity = mapping.baseColor[3];
+      if (material.alphaMode === "mask") {
+        inputs.opacityThreshold = mapping.alphaCutoff || 0.5;
+      }
+    }
+    const usdMaterial = createUSDPreviewSurfaceMaterial(matName, matPath, inputs);
+    if (mapping.baseColorTexture) {
+      await this.addTextureToMaterial(usdMaterial, "diffuseColor", mapping.baseColorTexture);
+    }
+    if (mapping.normalTexture) {
+      await this.addTextureToMaterial(usdMaterial, "normal", mapping.normalTexture);
+    }
+    if (mapping.occlusionTexture) {
+      await this.addTextureToMaterial(usdMaterial, "occlusion", mapping.occlusionTexture);
+    }
+    if (!this.stage.prims[0].children) this.stage.prims[0].children = [];
+    let materialsScope = this.stage.prims[0].children.find((p) => p.name === "Materials");
+    if (!materialsScope) {
+      materialsScope = {
+        path: "/Root/Materials",
+        type: "Scope",
+        name: "Materials",
+        attributes: [],
+        children: []
+      };
+      this.stage.prims[0].children.push(materialsScope);
+    }
+    materialsScope.children.push(usdMaterial);
+    this.materialMap.set(material.id, matPath);
+  }
+  createMaterialMapping(material) {
+    return {
+      baseColor: material.baseColor || [1, 1, 1, 1],
+      metallic: material.metallic ?? 0,
+      roughness: material.roughness ?? 0.5,
+      emissive: material.emissiveColor || [0, 0, 0],
+      alphaMode: material.alphaMode,
+      alphaCutoff: material.alphaCutoff
+    };
+  }
+  async addTextureToMaterial(material, inputName, textureRef) {
+    const shader = material.children?.[0];
+    if (shader?.inputs) {
+      shader.inputs.push({
+        name: inputName,
+        type: "asset",
+        value: { path: textureRef }
+      });
+    }
+  }
+  // ========================================================================
+  // Private Methods - Mesh Conversion
+  // ========================================================================
+  async convertMeshes(meshes, sceneGraph) {
+    for (const mesh of meshes) {
+      await this.convertMesh(mesh, sceneGraph);
+    }
+  }
+  async convertMesh(mesh, sceneGraph) {
+    const meshName = sanitizeUSDName(mesh.name || `Mesh_${this.primCounter++}`);
+    const meshPath = `/Root/Geometry/${meshName}`;
+    let geometryScope = this.stage.prims[0].children?.find((p) => p.name === "Geometry");
+    if (!geometryScope) {
+      geometryScope = {
+        path: "/Root/Geometry",
+        type: "Scope",
+        name: "Geometry",
+        attributes: [],
+        children: []
+      };
+      if (!this.stage.prims[0].children) this.stage.prims[0].children = [];
+      this.stage.prims[0].children.push(geometryScope);
+    }
+    for (let i = 0; i < mesh.primitives.length; i++) {
+      const primitive = mesh.primitives[i];
+      const primName = mesh.primitives.length > 1 ? `${meshName}_${i}` : meshName;
+      const primPath = mesh.primitives.length > 1 ? `${meshPath}_${i}` : meshPath;
+      const usdMesh = await this.convertMeshPrimitive(primitive, primName, primPath, sceneGraph);
+      geometryScope.children.push(usdMesh);
+      this.meshMap.set(mesh.id, primPath);
+    }
+  }
+  async convertMeshPrimitive(primitive, name, path, sceneGraph) {
+    const positions = this.extractAccessorData(primitive.attributes.POSITION, sceneGraph);
+    const normals = primitive.attributes.NORMAL ? this.extractAccessorData(primitive.attributes.NORMAL, sceneGraph) : void 0;
+    const uvs = primitive.attributes.TEXCOORD_0 ? this.extractAccessorData(primitive.attributes.TEXCOORD_0, sceneGraph) : void 0;
+    const indices = primitive.indices !== void 0 ? this.extractAccessorData(primitive.indices, sceneGraph) : void 0;
+    const { faceVertexCounts, faceVertexIndices } = this.buildFaceData(
+      indices,
+      positions.length / 3
+    );
+    const usdMesh = {
+      path,
+      type: "Mesh",
+      name,
+      attributes: [],
+      faceVertexCounts,
+      faceVertexIndices,
+      points: positions
+    };
+    if (normals) {
+      usdMesh.normals = normals;
+      usdMesh.attributes.push({
+        name: "primvars:normals",
+        type: "normal3f[]",
+        value: normals
+      });
+      usdMesh.attributes.push({
+        name: "primvars:normals:interpolation",
+        type: "token",
+        value: "vertex"
+      });
+    }
+    if (uvs) {
+      usdMesh.primvars = [
+        {
+          name: "st",
+          type: "texCoord2f[]",
+          interpolation: "vertex",
+          values: uvs
+        }
+      ];
+    }
+    if (primitive.materialRef) {
+      const matPath = this.materialMap.get(primitive.materialRef);
+      if (matPath) {
+        usdMesh.relationships = [
+          {
+            name: "material:binding",
+            targets: [matPath]
+          }
+        ];
+      }
+    }
+    return usdMesh;
+  }
+  extractAccessorData(accessorIndex, sceneGraph) {
+    const accessor = sceneGraph.accessors[accessorIndex];
+    if (!accessor) return [];
+    const bufferView = sceneGraph.bufferViews[accessor.bufferViewIndex];
+    const buffer = sceneGraph.buffers[bufferView.bufferIndex];
+    if (!buffer.data) return [];
+    const arrayView = this.getTypedArray(
+      buffer.data,
+      bufferView.byteOffset + accessor.byteOffset,
+      accessor.count * this.getComponentCount(accessor.type),
+      accessor.componentType
+    );
+    return Array.from(arrayView);
+  }
+  getTypedArray(buffer, offset, length, componentType) {
+    switch (componentType) {
+      case "float":
+        return new Float32Array(buffer, offset, length);
+      case "ushort":
+        return new Uint16Array(buffer, offset, length);
+      case "uint":
+        return new Uint32Array(buffer, offset, length);
+      default:
+        return new Float32Array(buffer, offset, length);
+    }
+  }
+  getComponentCount(type) {
+    switch (type.toLowerCase()) {
+      case "scalar":
+        return 1;
+      case "vec2":
+        return 2;
+      case "vec3":
+        return 3;
+      case "vec4":
+        return 4;
+      case "mat2":
+        return 4;
+      case "mat3":
+        return 9;
+      case "mat4":
+        return 16;
+      default:
+        return 1;
+    }
+  }
+  buildFaceData(indices, vertexCount) {
+    if (indices && indices.length > 0) {
+      const faceCount = Math.floor(indices.length / 3);
+      return {
+        faceVertexCounts: new Array(faceCount).fill(3),
+        faceVertexIndices: indices
+      };
+    } else if (vertexCount > 0) {
+      const faceCount = Math.floor(vertexCount / 3);
+      return {
+        faceVertexCounts: new Array(faceCount).fill(3),
+        faceVertexIndices: Array.from({ length: vertexCount }, (_, i) => i)
+      };
+    } else {
+      return {
+        faceVertexCounts: [],
+        faceVertexIndices: []
+      };
+    }
+  }
+  // ========================================================================
+  // Private Methods - Animation Conversion
+  // ========================================================================
+  convertAnimations(animations) {
+    for (const animation of animations) {
+      this.convertAnimation(animation);
+    }
+  }
+  convertAnimation(animation) {
+    const channelsByNode = /* @__PURE__ */ new Map();
+    for (const channel of animation.channels) {
+      const list = channelsByNode.get(channel.targetNode) || [];
+      list.push(channel);
+      channelsByNode.set(channel.targetNode, list);
+    }
+    for (const [nodeId, channels] of Array.from(channelsByNode.entries())) {
+      const prim = this.nodePrimMap.get(nodeId);
+      if (!prim) continue;
+      for (const channel of channels) {
+        this.applyAnimationChannel(prim, channel, animation.samplers);
+      }
+    }
+  }
+  applyAnimationChannel(prim, channel, samplers) {
+    const sampler = samplers[channel.samplerIndex];
+    if (!sampler) return;
+    const times = this.extractAccessorDataFlat(sampler.inputBufferView);
+    const values = this.extractAccessorDataFlat(sampler.outputBufferView);
+    if (times.length === 0 || values.length === 0) return;
+    const timeSamples = /* @__PURE__ */ new Map();
+    switch (channel.targetPath) {
+      case "translation": {
+        for (let i = 0; i < times.length; i++) {
+          timeSamples.set(times[i], [values[i * 3], values[i * 3 + 1], values[i * 3 + 2]]);
+        }
+        this.setXformOpTimeSamples(prim, "xformOp:translate", "float3", timeSamples);
+        break;
+      }
+      case "rotation": {
+        for (let i = 0; i < times.length; i++) {
+          const qx = values[i * 4];
+          const qy = values[i * 4 + 1];
+          const qz = values[i * 4 + 2];
+          const qw = values[i * 4 + 3];
+          const euler = quaternionToEuler([qx, qy, qz, qw]);
+          timeSamples.set(times[i], euler);
+        }
+        this.setXformOpTimeSamples(prim, "xformOp:rotateXYZ", "float3", timeSamples);
+        break;
+      }
+      case "scale": {
+        for (let i = 0; i < times.length; i++) {
+          timeSamples.set(times[i], [values[i * 3], values[i * 3 + 1], values[i * 3 + 2]]);
+        }
+        this.setXformOpTimeSamples(prim, "xformOp:scale", "float3", timeSamples);
+        break;
+      }
+      case "weights": {
+        console.warn(`Morph target animation not yet supported for ${prim.name}`);
+        break;
+      }
+    }
+  }
+  extractAccessorDataFlat(accessorIndex) {
+    return this.sceneGraphAccessorData.get(accessorIndex) || [];
+  }
+  setXformOpTimeSamples(prim, opName, type, timeSamples) {
+    let attr = prim.attributes.find((a) => a.name === opName);
+    if (!attr) {
+      attr = { name: opName, type, value: timeSamples.values().next().value || [] };
+      prim.attributes.push(attr);
+    }
+    attr.timeSamples = timeSamples;
+  }
+  // ========================================================================
+  // Private Methods - AR Metadata
+  // ========================================================================
+  addARMetadata() {
+    const metadata = {
+      arBehaviors: {
+        allowsContentScaling: this.options.allowContentScaling,
+        hasLookAtCamera: this.options.lookAtCamera,
+        initialPlacementMode: this.options.placementMode,
+        enableOcclusion: this.options.enableOcclusion
+      },
+      canonicalCameraDistance: this.options.canonicalCameraDistance
+    };
+    if (!this.stage.customLayerData) this.stage.customLayerData = {};
+    this.stage.customLayerData.arQuickLook = metadata;
+    if (this.stage.prims[0]) {
+      if (!this.stage.prims[0].metadata) this.stage.prims[0].metadata = {};
+      this.stage.prims[0].metadata.arQuickLook = metadata;
+    }
+  }
+  // ========================================================================
+  // Private Methods - USDZ Packaging
+  // ========================================================================
+  async packageUSDZ() {
+    const usdContent = this.serializeUSD(this.stage);
+    const mainFile = {
+      path: "scene.usda",
+      data: new TextEncoder().encode(usdContent).buffer,
+      mimeType: "text/plain"
+    };
+    const package_ = {
+      mainFile,
+      files: this.textureFiles
+    };
+    return this.createZipArchive(package_);
+  }
+  serializeUSD(stage) {
+    const lines = [];
+    lines.push("#usda 1.0");
+    lines.push("(");
+    if (stage.defaultPrim) {
+      lines.push(`    defaultPrim = "${stage.defaultPrim}"`);
+    }
+    if (stage.metadata.upAxis) {
+      lines.push(`    upAxis = "${stage.metadata.upAxis}"`);
+    }
+    if (stage.metadata.metersPerUnit) {
+      lines.push(`    metersPerUnit = ${stage.metadata.metersPerUnit}`);
+    }
+    lines.push(")");
+    lines.push("");
+    for (const prim of stage.prims) {
+      this.serializePrim(prim, lines, 0);
+    }
+    return lines.join("\n");
+  }
+  serializePrim(prim, lines, indent) {
+    const ind = "    ".repeat(indent);
+    lines.push(`${ind}def ${prim.type} "${prim.name}"`);
+    lines.push(`${ind}{`);
+    for (const attr of prim.attributes) {
+      this.serializeAttribute(attr, lines, indent + 1);
+    }
+    if (prim.relationships) {
+      for (const rel of prim.relationships) {
+        const relInd = "    ".repeat(indent + 1);
+        const targets = rel.targets.map((t) => `<${t}>`).join(", ");
+        lines.push(`${relInd}rel ${rel.name} = [${targets}]`);
+      }
+    }
+    if (prim.children) {
+      for (const child of prim.children) {
+        lines.push("");
+        this.serializePrim(child, lines, indent + 1);
+      }
+    }
+    lines.push(`${ind}}`);
+  }
+  serializeAttribute(attr, lines, indent) {
+    const ind = "    ".repeat(indent);
+    if (attr.timeSamples && attr.timeSamples.size > 0) {
+      lines.push(`${ind}${attr.type} ${attr.name}.timeSamples = {`);
+      for (const [time, sample] of Array.from(attr.timeSamples.entries())) {
+        const serializedSample = this.serializeValue(sample, attr.type);
+        lines.push(`${ind}    ${time}: ${serializedSample},`);
+      }
+      lines.push(`${ind}}`);
+    } else {
+      const value = this.serializeValue(attr.value, attr.type);
+      lines.push(`${ind}${attr.type} ${attr.name} = ${value}`);
+    }
+  }
+  serializeValue(value, type) {
+    if (Array.isArray(value)) {
+      if (type.includes("[]")) {
+        return `[${value.map((v) => this.serializeScalar(v, type.replace("[]", ""))).join(", ")}]`;
+      } else {
+        return `(${value.join(", ")})`;
+      }
+    } else if (typeof value === "string") {
+      return `"${value}"`;
+    } else if (typeof value === "object" && value !== null && "path" in value) {
+      return `@${value.path}@`;
+    } else {
+      return String(value);
+    }
+  }
+  serializeScalar(value, _type) {
+    if (typeof value === "string") {
+      return `"${value}"`;
+    }
+    return String(value);
+  }
+  async createZipArchive(package_) {
+    const files = [package_.mainFile, ...package_.files];
+    let totalSize = 0;
+    const fileEntries = [];
+    const localHeaderSize = 30;
+    const centralHeaderSize = 46;
+    const endCentralSize = 22;
+    for (const file of files) {
+      const nameBytes = new TextEncoder().encode(file.path);
+      fileEntries.push({
+        name: file.path,
+        data: file.data,
+        offset: totalSize
+      });
+      totalSize += localHeaderSize + nameBytes.length + file.data.byteLength;
+    }
+    const centralDirOffset = totalSize;
+    let centralDirSize = 0;
+    for (const entry of fileEntries) {
+      const nameBytes = new TextEncoder().encode(entry.name);
+      centralDirSize += centralHeaderSize + nameBytes.length;
+    }
+    totalSize += centralDirSize + endCentralSize;
+    const buffer = new ArrayBuffer(totalSize);
+    const view = new DataView(buffer);
+    const bytes = new Uint8Array(buffer);
+    let offset = 0;
+    for (const entry of fileEntries) {
+      const nameBytes = new TextEncoder().encode(entry.name);
+      view.setUint32(offset, 67324752, true);
+      view.setUint16(offset + 4, 20, true);
+      view.setUint16(offset + 6, 0, true);
+      view.setUint16(offset + 8, 0, true);
+      view.setUint16(offset + 10, 0, true);
+      view.setUint16(offset + 12, 0, true);
+      view.setUint32(offset + 14, 0, true);
+      view.setUint32(offset + 18, entry.data.byteLength, true);
+      view.setUint32(offset + 22, entry.data.byteLength, true);
+      view.setUint16(offset + 26, nameBytes.length, true);
+      view.setUint16(offset + 28, 0, true);
+      offset += 30;
+      bytes.set(nameBytes, offset);
+      offset += nameBytes.length;
+      bytes.set(new Uint8Array(entry.data), offset);
+      offset += entry.data.byteLength;
+    }
+    for (const entry of fileEntries) {
+      const nameBytes = new TextEncoder().encode(entry.name);
+      view.setUint32(offset, 33639248, true);
+      view.setUint16(offset + 4, 20, true);
+      view.setUint16(offset + 6, 20, true);
+      view.setUint16(offset + 8, 0, true);
+      view.setUint16(offset + 10, 0, true);
+      view.setUint16(offset + 12, 0, true);
+      view.setUint16(offset + 14, 0, true);
+      view.setUint32(offset + 16, 0, true);
+      view.setUint32(offset + 20, entry.data.byteLength, true);
+      view.setUint32(offset + 24, entry.data.byteLength, true);
+      view.setUint16(offset + 28, nameBytes.length, true);
+      view.setUint16(offset + 30, 0, true);
+      view.setUint16(offset + 32, 0, true);
+      view.setUint16(offset + 34, 0, true);
+      view.setUint16(offset + 36, 0, true);
+      view.setUint32(offset + 38, 0, true);
+      view.setUint32(offset + 42, entry.offset, true);
+      offset += 46;
+      bytes.set(nameBytes, offset);
+      offset += nameBytes.length;
+    }
+    view.setUint32(offset, 101010256, true);
+    view.setUint16(offset + 4, 0, true);
+    view.setUint16(offset + 6, 0, true);
+    view.setUint16(offset + 8, fileEntries.length, true);
+    view.setUint16(offset + 10, fileEntries.length, true);
+    view.setUint32(offset + 12, centralDirSize, true);
+    view.setUint32(offset + 16, centralDirOffset, true);
+    view.setUint16(offset + 20, 0, true);
+    return buffer;
+  }
+  // ========================================================================
+  // Private Methods - Utilities
+  // ========================================================================
+  reset() {
+    this.primCounter = 0;
+    this.materialMap.clear();
+    this.meshMap.clear();
+    this.nodePrimMap.clear();
+    this.sceneGraphAccessorData.clear();
+    this.textureFiles = [];
+  }
+  calculateStats(usdzSize, exportTime) {
+    let primCount = 0;
+    let meshCount = 0;
+    let materialCount = 0;
+    const countPrims = (prim) => {
+      primCount++;
+      if (prim.type === "Mesh") meshCount++;
+      if (prim.type === "Material") materialCount++;
+      if (prim.children) {
+        for (const child of prim.children) countPrims(child);
+      }
+    };
+    for (const prim of this.stage.prims) {
+      countPrims(prim);
+    }
+    return {
+      primCount,
+      meshCount,
+      materialCount,
+      textureCount: this.textureFiles.length,
+      fileCount: 1 + this.textureFiles.length,
+      usdzSize,
+      exportTime
+    };
+  }
+};
+_USDZExporter.DEFAULT_OPTIONS = {
+  includeAudio: false,
+  lookAtCamera: false,
+  placementMode: "floor",
+  materialQuality: "standard",
+  includeAnimations: true,
+  realityComposerMode: false,
+  metersPerUnit: 1,
+  upAxis: "Y",
+  enableOcclusion: true,
+  allowContentScaling: true,
+  canonicalCameraDistance: 2.5
+};
+var USDZExporter = _USDZExporter;
+
+export { USDZExporter };
+//# sourceMappingURL=USDZExporter-D2HQLQYK.js.map
+//# sourceMappingURL=USDZExporter-D2HQLQYK.js.map