three-stdlib 2.22.7 → 2.22.9

package/dist/exporters/USDZExporter.mjs

@@ -0,0 +1,340 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+import { strToU8, zipSync } from "fflate";
+import { Mesh, MeshPhysicalMaterial } from "three";
+class USDZExporter {
+  constructor() {
+    __publicField(this, "PRECISION", 7);
+    __publicField(this, "materials");
+    __publicField(this, "textures");
+    __publicField(this, "files");
+    this.materials = {};
+    this.textures = {};
+    this.files = {};
+  }
+  async parse(scene) {
+    const modelFileName = "model.usda";
+    this.files[modelFileName] = null;
+    let output = this.buildHeader();
+    scene.traverseVisible((object) => {
+      if (object instanceof Mesh && object.isMesh && object.material.isMeshStandardMaterial) {
+        const geometry = object.geometry;
+        const material = object.material;
+        const geometryFileName = "geometries/Geometry_" + geometry.id + ".usd";
+        if (!(geometryFileName in this.files)) {
+          const meshObject = this.buildMeshObject(geometry);
+          this.files[geometryFileName] = this.buildUSDFileAsString(meshObject);
+        }
+        if (!(material.uuid in this.materials)) {
+          this.materials[material.uuid] = material;
+        }
+        output += this.buildXform(object, geometry, material);
+      }
+    });
+    output += this.buildMaterials(this.materials);
+    this.files[modelFileName] = strToU8(output);
+    output = null;
+    for (const id in this.textures) {
+      const texture = this.textures[id];
+      const color = id.split("_")[1];
+      const isRGBA = texture.format === 1023;
+      const canvas = this.imageToCanvas(texture.image, color);
+      const blob = await new Promise(
+        (resolve) => canvas == null ? void 0 : canvas.toBlob(resolve, isRGBA ? "image/png" : "image/jpeg", 1)
+      );
+      if (blob) {
+        this.files[`textures/Texture_${id}.${isRGBA ? "png" : "jpg"}`] = new Uint8Array(await blob.arrayBuffer());
+      }
+    }
+    let offset = 0;
+    for (const filename in this.files) {
+      const file = this.files[filename];
+      const headerSize = 34 + filename.length;
+      offset += headerSize;
+      const offsetMod64 = offset & 63;
+      if (offsetMod64 !== 4 && file !== null && file instanceof Uint8Array) {
+        const padLength = 64 - offsetMod64;
+        const padding = new Uint8Array(padLength);
+        this.files[filename] = [file, { extra: { 12345: padding } }];
+      }
+      if (file && typeof file.length === "number") {
+        offset = file.length;
+      }
+    }
+    return zipSync(this.files, { level: 0 });
+  }
+  imageToCanvas(image, color) {
+    if (typeof HTMLImageElement !== "undefined" && image instanceof HTMLImageElement || typeof HTMLCanvasElement !== "undefined" && image instanceof HTMLCanvasElement || typeof OffscreenCanvas !== "undefined" && image instanceof OffscreenCanvas || typeof ImageBitmap !== "undefined" && image instanceof ImageBitmap) {
+      const scale = 1024 / Math.max(image.width, image.height);
+      const canvas = document.createElement("canvas");
+      canvas.width = image.width * Math.min(1, scale);
+      canvas.height = image.height * Math.min(1, scale);
+      const context = canvas.getContext("2d");
+      context == null ? void 0 : context.drawImage(image, 0, 0, canvas.width, canvas.height);
+      if (color !== void 0) {
+        const hex = parseInt(color, 16);
+        const r = (hex >> 16 & 255) / 255;
+        const g = (hex >> 8 & 255) / 255;
+        const b = (hex & 255) / 255;
+        const imagedata = context == null ? void 0 : context.getImageData(0, 0, canvas.width, canvas.height);
+        if (imagedata) {
+          const data = imagedata == null ? void 0 : imagedata.data;
+          for (let i = 0; i < data.length; i += 4) {
+            data[i + 0] = data[i + 0] * r;
+            data[i + 1] = data[i + 1] * g;
+            data[i + 2] = data[i + 2] * b;
+          }
+          context == null ? void 0 : context.putImageData(imagedata, 0, 0);
+        }
+      }
+      return canvas;
+    }
+  }
+  buildHeader() {
+    return `#usda 1.0
+(
+    customLayerData = {
+        string creator = "Three.js USDZExporter"
+    }
+    metersPerUnit = 1
+    upAxis = "Y"
+)
+`;
+  }
+  buildUSDFileAsString(dataToInsert) {
+    let output = this.buildHeader();
+    output += dataToInsert;
+    return strToU8(output);
+  }
+  // Xform
+  buildXform(object, geometry, material) {
+    const name = "Object_" + object.id;
+    const transform = this.buildMatrix(object.matrixWorld);
+    if (object.matrixWorld.determinant() < 0) {
+      console.warn("THREE.USDZExporter: USDZ does not support negative scales", object);
+    }
+    return `def Xform "${name}" (
+    prepend references = @./geometries/Geometry_${geometry.id}.usd@</Geometry>
+)
+{
+    matrix4d xformOp:transform = ${transform}
+    uniform token[] xformOpOrder = ["xformOp:transform"]
+    rel material:binding = </Materials/Material_${material.id}>
+}
+`;
+  }
+  buildMatrix(matrix) {
+    const array = matrix.elements;
+    return `( ${this.buildMatrixRow(array, 0)}, ${this.buildMatrixRow(array, 4)}, ${this.buildMatrixRow(
+      array,
+      8
+    )}, ${this.buildMatrixRow(array, 12)} )`;
+  }
+  buildMatrixRow(array, offset) {
+    return `(${array[offset + 0]}, ${array[offset + 1]}, ${array[offset + 2]}, ${array[offset + 3]})`;
+  }
+  // Mesh
+  buildMeshObject(geometry) {
+    const mesh = this.buildMesh(geometry);
+    return `
+def "Geometry"
+{
+  ${mesh}
+}
+`;
+  }
+  buildMesh(geometry) {
+    const name = "Geometry";
+    const attributes = geometry.attributes;
+    const count = attributes.position.count;
+    return `
+    def Mesh "${name}"
+    {
+        int[] faceVertexCounts = [${this.buildMeshVertexCount(geometry)}]
+        int[] faceVertexIndices = [${this.buildMeshVertexIndices(geometry)}]
+        normal3f[] normals = [${this.buildVector3Array(attributes.normal, count)}] (
+            interpolation = "vertex"
+        )
+        point3f[] points = [${this.buildVector3Array(attributes.position, count)}]
+        float2[] primvars:st = [${this.buildVector2Array(attributes.uv, count)}] (
+            interpolation = "vertex"
+        )
+        uniform token subdivisionScheme = "none"
+    }
+`;
+  }
+  buildMeshVertexCount(geometry) {
+    const count = geometry.index !== null ? geometry.index.array.length : geometry.attributes.position.count;
+    return Array(count / 3).fill(3).join(", ");
+  }
+  buildMeshVertexIndices(geometry) {
+    if (geometry.index !== null) {
+      return geometry.index.array.join(", ");
+    }
+    const array = [];
+    const length = geometry.attributes.position.count;
+    for (let i = 0; i < length; i++) {
+      array.push(i);
+    }
+    return array.join(", ");
+  }
+  buildVector3Array(attribute, count) {
+    if (attribute === void 0) {
+      console.warn("USDZExporter: Normals missing.");
+      return Array(count).fill("(0, 0, 0)").join(", ");
+    }
+    const array = [];
+    const data = attribute.array;
+    for (let i = 0; i < data.length; i += 3) {
+      array.push(
+        `(${data[i + 0].toPrecision(this.PRECISION)}, ${data[i + 1].toPrecision(this.PRECISION)}, ${data[i + 2].toPrecision(this.PRECISION)})`
+      );
+    }
+    return array.join(", ");
+  }
+  buildVector2Array(attribute, count) {
+    if (attribute === void 0) {
+      console.warn("USDZExporter: UVs missing.");
+      return Array(count).fill("(0, 0)").join(", ");
+    }
+    const array = [];
+    const data = attribute.array;
+    for (let i = 0; i < data.length; i += 2) {
+      array.push(`(${data[i + 0].toPrecision(this.PRECISION)}, ${1 - data[i + 1].toPrecision(this.PRECISION)})`);
+    }
+    return array.join(", ");
+  }
+  // Materials
+  buildMaterials(materials) {
+    const array = [];
+    for (const uuid in materials) {
+      const material = materials[uuid];
+      array.push(this.buildMaterial(material));
+    }
+    return `def "Materials"
+{
+${array.join("")}
+}
+`;
+  }
+  buildMaterial(material) {
+    const pad = "            ";
+    const inputs = [];
+    const samplers = [];
+    if (material.map !== null) {
+      inputs.push(
+        `${pad}color3f inputs:diffuseColor.connect = </Materials/Material_${material.id}/Texture_${material.map.id}_diffuse.outputs:rgb>`
+      );
+      samplers.push(this.buildTexture(material, material.map, "diffuse", material.color));
+    } else {
+      inputs.push(`${pad}color3f inputs:diffuseColor = ${this.buildColor(material.color)}`);
+    }
+    if (material.emissiveMap !== null) {
+      inputs.push(
+        `${pad}color3f inputs:emissiveColor.connect = </Materials/Material_${material.id}/Texture_${material.emissiveMap.id}_emissive.outputs:rgb>`
+      );
+      samplers.push(this.buildTexture(material, material.emissiveMap, "emissive"));
+    } else if (material.emissive.getHex() > 0) {
+      inputs.push(`${pad}color3f inputs:emissiveColor = ${this.buildColor(material.emissive)}`);
+    }
+    if (material.normalMap !== null) {
+      inputs.push(
+        `${pad}normal3f inputs:normal.connect = </Materials/Material_${material.id}/Texture_${material.normalMap.id}_normal.outputs:rgb>`
+      );
+      samplers.push(this.buildTexture(material, material.normalMap, "normal"));
+    }
+    if (material.aoMap !== null) {
+      inputs.push(
+        `${pad}float inputs:occlusion.connect = </Materials/Material_${material.id}/Texture_${material.aoMap.id}_occlusion.outputs:r>`
+      );
+      samplers.push(this.buildTexture(material, material.aoMap, "occlusion"));
+    }
+    if (material.roughnessMap !== null && material.roughness === 1) {
+      inputs.push(
+        `${pad}float inputs:roughness.connect = </Materials/Material_${material.id}/Texture_${material.roughnessMap.id}_roughness.outputs:g>`
+      );
+      samplers.push(this.buildTexture(material, material.roughnessMap, "roughness"));
+    } else {
+      inputs.push(`${pad}float inputs:roughness = ${material.roughness}`);
+    }
+    if (material.metalnessMap !== null && material.metalness === 1) {
+      inputs.push(
+        `${pad}float inputs:metallic.connect = </Materials/Material_${material.id}/Texture_${material.metalnessMap.id}_metallic.outputs:b>`
+      );
+      samplers.push(this.buildTexture(material, material.metalnessMap, "metallic"));
+    } else {
+      inputs.push(`${pad}float inputs:metallic = ${material.metalness}`);
+    }
+    inputs.push(`${pad}float inputs:opacity = ${material.opacity}`);
+    if (material instanceof MeshPhysicalMaterial) {
+      inputs.push(`${pad}float inputs:clearcoat = ${material.clearcoat}`);
+      inputs.push(`${pad}float inputs:clearcoatRoughness = ${material.clearcoatRoughness}`);
+      inputs.push(`${pad}float inputs:ior = ${material.ior}`);
+    }
+    return `
+    def Material "Material_${material.id}"
+    {
+        def Shader "PreviewSurface"
+        {
+            uniform token info:id = "UsdPreviewSurface"
+${inputs.join("\n")}
+            int inputs:useSpecularWorkflow = 0
+            token outputs:surface
+        }
+        token outputs:surface.connect = </Materials/Material_${material.id}/PreviewSurface.outputs:surface>
+        token inputs:frame:stPrimvarName = "st"
+        def Shader "uvReader_st"
+        {
+            uniform token info:id = "UsdPrimvarReader_float2"
+            token inputs:varname.connect = </Materials/Material_${material.id}.inputs:frame:stPrimvarName>
+            float2 inputs:fallback = (0.0, 0.0)
+            float2 outputs:result
+        }
+${samplers.join("\n")}
+    }
+`;
+  }
+  buildTexture(material, texture, mapType, color) {
+    const id = texture.id + (color ? "_" + color.getHexString() : "");
+    const isRGBA = texture.format === 1023;
+    this.textures[id] = texture;
+    return `
+      def Shader "Transform2d_${mapType}" (
+          sdrMetadata = {
+              string role = "math"
+          }
+      )
+      {
+          uniform token info:id = "UsdTransform2d"
+          float2 inputs:in.connect = </Materials/Material_${material.id}/uvReader_st.outputs:result>
+          float2 inputs:scale = ${this.buildVector2(texture.repeat)}
+          float2 inputs:translation = ${this.buildVector2(texture.offset)}
+          float2 outputs:result
+      }
+      def Shader "Texture_${texture.id}_${mapType}"
+      {
+          uniform token info:id = "UsdUVTexture"
+          asset inputs:file = @textures/Texture_${id}.${isRGBA ? "png" : "jpg"}@
+          float2 inputs:st.connect = </Materials/Material_${material.id}/Transform2d_${mapType}.outputs:result>
+          token inputs:wrapS = "repeat"
+          token inputs:wrapT = "repeat"
+          float outputs:r
+          float outputs:g
+          float outputs:b
+          float3 outputs:rgb
+      }`;
+  }
+  buildColor(color) {
+    return `(${color.r}, ${color.g}, ${color.b})`;
+  }
+  buildVector2(vector) {
+    return `(${vector.x}, ${vector.y})`;
+  }
+}
+export {
+  USDZExporter
+};

package/dist/geometries/BoxLineGeometry.d.ts

@@ -0,0 +1,12 @@
+import { BufferGeometry } from 'three'
+
+export class BoxLineGeometry extends BufferGeometry {
+  constructor(
+    width?: number,
+    height?: number,
+    depth?: number,
+    widthSegments?: number,
+    heightSegments?: number,
+    depthSegments?: number,
+  )
+}

package/dist/geometries/BoxLineGeometry.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+class BoxLineGeometry extends THREE.BufferGeometry {
+  constructor(width, height, depth, widthSegments, heightSegments, depthSegments) {
+    super();
+    width = width || 1;
+    height = height || 1;
+    depth = depth || 1;
+    widthSegments = Math.floor(widthSegments) || 1;
+    heightSegments = Math.floor(heightSegments) || 1;
+    depthSegments = Math.floor(depthSegments) || 1;
+    const widthHalf = width / 2;
+    const heightHalf = height / 2;
+    const depthHalf = depth / 2;
+    const segmentWidth = width / widthSegments;
+    const segmentHeight = height / heightSegments;
+    const segmentDepth = depth / depthSegments;
+    const vertices = [];
+    let x = -widthHalf, y = -heightHalf, z = -depthHalf;
+    for (let i = 0; i <= widthSegments; i++) {
+      vertices.push(x, -heightHalf, -depthHalf, x, heightHalf, -depthHalf);
+      vertices.push(x, heightHalf, -depthHalf, x, heightHalf, depthHalf);
+      vertices.push(x, heightHalf, depthHalf, x, -heightHalf, depthHalf);
+      vertices.push(x, -heightHalf, depthHalf, x, -heightHalf, -depthHalf);
+      x += segmentWidth;
+    }
+    for (let i = 0; i <= heightSegments; i++) {
+      vertices.push(-widthHalf, y, -depthHalf, widthHalf, y, -depthHalf);
+      vertices.push(widthHalf, y, -depthHalf, widthHalf, y, depthHalf);
+      vertices.push(widthHalf, y, depthHalf, -widthHalf, y, depthHalf);
+      vertices.push(-widthHalf, y, depthHalf, -widthHalf, y, -depthHalf);
+      y += segmentHeight;
+    }
+    for (let i = 0; i <= depthSegments; i++) {
+      vertices.push(-widthHalf, -heightHalf, z, -widthHalf, heightHalf, z);
+      vertices.push(-widthHalf, heightHalf, z, widthHalf, heightHalf, z);
+      vertices.push(widthHalf, heightHalf, z, widthHalf, -heightHalf, z);
+      vertices.push(widthHalf, -heightHalf, z, -widthHalf, -heightHalf, z);
+      z += segmentDepth;
+    }
+    this.setAttribute("position", new THREE.Float32BufferAttribute(vertices, 3));
+  }
+}
+exports.BoxLineGeometry = BoxLineGeometry;

package/dist/geometries/BoxLineGeometry.mjs

@@ -0,0 +1,45 @@
+import { BufferGeometry, Float32BufferAttribute } from "three";
+class BoxLineGeometry extends BufferGeometry {
+  constructor(width, height, depth, widthSegments, heightSegments, depthSegments) {
+    super();
+    width = width || 1;
+    height = height || 1;
+    depth = depth || 1;
+    widthSegments = Math.floor(widthSegments) || 1;
+    heightSegments = Math.floor(heightSegments) || 1;
+    depthSegments = Math.floor(depthSegments) || 1;
+    const widthHalf = width / 2;
+    const heightHalf = height / 2;
+    const depthHalf = depth / 2;
+    const segmentWidth = width / widthSegments;
+    const segmentHeight = height / heightSegments;
+    const segmentDepth = depth / depthSegments;
+    const vertices = [];
+    let x = -widthHalf, y = -heightHalf, z = -depthHalf;
+    for (let i = 0; i <= widthSegments; i++) {
+      vertices.push(x, -heightHalf, -depthHalf, x, heightHalf, -depthHalf);
+      vertices.push(x, heightHalf, -depthHalf, x, heightHalf, depthHalf);
+      vertices.push(x, heightHalf, depthHalf, x, -heightHalf, depthHalf);
+      vertices.push(x, -heightHalf, depthHalf, x, -heightHalf, -depthHalf);
+      x += segmentWidth;
+    }
+    for (let i = 0; i <= heightSegments; i++) {
+      vertices.push(-widthHalf, y, -depthHalf, widthHalf, y, -depthHalf);
+      vertices.push(widthHalf, y, -depthHalf, widthHalf, y, depthHalf);
+      vertices.push(widthHalf, y, depthHalf, -widthHalf, y, depthHalf);
+      vertices.push(-widthHalf, y, depthHalf, -widthHalf, y, -depthHalf);
+      y += segmentHeight;
+    }
+    for (let i = 0; i <= depthSegments; i++) {
+      vertices.push(-widthHalf, -heightHalf, z, -widthHalf, heightHalf, z);
+      vertices.push(-widthHalf, heightHalf, z, widthHalf, heightHalf, z);
+      vertices.push(widthHalf, heightHalf, z, widthHalf, -heightHalf, z);
+      vertices.push(widthHalf, -heightHalf, z, -widthHalf, -heightHalf, z);
+      z += segmentDepth;
+    }
+    this.setAttribute("position", new Float32BufferAttribute(vertices, 3));
+  }
+}
+export {
+  BoxLineGeometry
+};

package/dist/geometries/ConvexGeometry.d.ts

@@ -0,0 +1,5 @@
+import { BufferGeometry, Vector3 } from 'three'
+
+export class ConvexGeometry extends BufferGeometry {
+  constructor(points?: Vector3[])
+}

package/dist/geometries/ConvexGeometry.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+const ConvexHull = require("../math/ConvexHull.js");
+class ConvexGeometry extends THREE.BufferGeometry {
+  constructor(points = []) {
+    super();
+    const vertices = [];
+    const normals = [];
+    if (ConvexHull.ConvexHull === void 0) {
+      console.error("THREE.ConvexGeometry: ConvexGeometry relies on ConvexHull");
+    }
+    const convexHull = new ConvexHull.ConvexHull().setFromPoints(points);
+    const faces = convexHull.faces;
+    for (let i = 0; i < faces.length; i++) {
+      const face = faces[i];
+      let edge = face.edge;
+      do {
+        const point = edge.head().point;
+        vertices.push(point.x, point.y, point.z);
+        normals.push(face.normal.x, face.normal.y, face.normal.z);
+        edge = edge.next;
+      } while (edge !== face.edge);
+    }
+    this.setAttribute("position", new THREE.Float32BufferAttribute(vertices, 3));
+    this.setAttribute("normal", new THREE.Float32BufferAttribute(normals, 3));
+  }
+}
+exports.ConvexGeometry = ConvexGeometry;

package/dist/geometries/ConvexGeometry.mjs

@@ -0,0 +1,29 @@
+import { BufferGeometry, Float32BufferAttribute } from "three";
+import { ConvexHull } from "../math/ConvexHull.mjs";
+class ConvexGeometry extends BufferGeometry {
+  constructor(points = []) {
+    super();
+    const vertices = [];
+    const normals = [];
+    if (ConvexHull === void 0) {
+      console.error("THREE.ConvexGeometry: ConvexGeometry relies on ConvexHull");
+    }
+    const convexHull = new ConvexHull().setFromPoints(points);
+    const faces = convexHull.faces;
+    for (let i = 0; i < faces.length; i++) {
+      const face = faces[i];
+      let edge = face.edge;
+      do {
+        const point = edge.head().point;
+        vertices.push(point.x, point.y, point.z);
+        normals.push(face.normal.x, face.normal.y, face.normal.z);
+        edge = edge.next;
+      } while (edge !== face.edge);
+    }
+    this.setAttribute("position", new Float32BufferAttribute(vertices, 3));
+    this.setAttribute("normal", new Float32BufferAttribute(normals, 3));
+  }
+}
+export {
+  ConvexGeometry
+};

package/dist/geometries/DecalGeometry.d.ts

@@ -0,0 +1,10 @@
+import { BufferGeometry, Euler, Mesh, Vector3 } from 'three'
+
+export class DecalGeometry extends BufferGeometry {
+  constructor(mesh: Mesh, position: Vector3, orientation: Euler, size: Vector3)
+}
+
+export class DecalVertex {
+  constructor(position: Vector3, normal: Vector3)
+  clone(): this
+}