@zephyr3d/scene 0.9.25 → 0.9.27

package/dist/asset/loaders/zhair/zhair_format.js

@@ -0,0 +1,288 @@
+/**
+ * The `.zhair` container: strand geometry, ready to upload.
+ *
+ * @remarks
+ * Hair reaches the engine as an Alembic curve archive or a `.hair` model, and
+ * neither is cheap to open: the sample XGen archive is 84 MB of Ogawa container
+ * holding two million control points, and parsing it means walking an object
+ * tree and cross-checking property blocks before a single strand appears. Doing
+ * that every time a scene loads is not viable, so the editor converts once and
+ * writes this instead.
+ *
+ * The layout follows `.zabc`, the geometry cache container already in the tree:
+ * a magic, a version, a JSON manifest, and then every large array concatenated
+ * into one payload the manifest points into. The manifest stays readable for
+ * debugging while the arrays are copied out by offset rather than decoded.
+ *
+ * What is stored is {@link StrandCurveSet} - the format-neutral shape both
+ * importers already converge on - at **full authored density**. Thinning is a
+ * property of the node that draws the hair, not of the file, so an artist can
+ * pull strand count down for a distant character and back up for a close-up
+ * without returning to the source archive.
+ */ /** The only version this module writes. @public */ const ZHAIR_VERSION = 1;
+/** Bytes before the manifest: magic, version, manifest length. @internal */ const ZHAIR_HEADER_SIZE = 12;
+/**
+ * Packs strand sets into a `.zhair` file.
+ *
+ * @param sets - Strand sets to write, one per source curve object.
+ * @param options - Unit scale and source provenance.
+ * @returns The complete file.
+ *
+ * @public
+ */ function encodeZHair(sets, options) {
+    if (sets.length === 0) {
+        throw new Error('encodeZHair: no strand sets given');
+    }
+    // Two passes: the manifest has to carry the offset of every array, so the
+    // payload is laid out first and the arrays are copied only once the total size
+    // is known.
+    const chunks = [];
+    let payloadLength = 0;
+    const place = (data)=>{
+        // Each array starts on a 4-byte boundary so a reader may view the payload
+        // in place rather than copying, should it ever want to.
+        payloadLength = payloadLength + 3 & -4;
+        const ref = {
+            offset: payloadLength,
+            length: data.byteLength
+        };
+        chunks.push({
+            data,
+            ref
+        });
+        payloadLength += data.byteLength;
+        return ref;
+    };
+    const strandSets = sets.map((set, index)=>{
+        const counts = set.pointCounts;
+        const strandCount = counts.length;
+        let pointCount = 0;
+        for(let i = 0; i < strandCount; i++){
+            pointCount += counts[i];
+        }
+        if (strandCount === 0 || pointCount === 0) {
+            throw new Error(`encodeZHair: strand set ${index} is empty`);
+        }
+        if (set.positions.length < pointCount * 3) {
+            throw new Error(`encodeZHair: strand set ${index} holds ${set.positions.length / 3} points but its topology needs ${pointCount}`);
+        }
+        const json = {
+            name: set.name || `Strands${index}`,
+            strandCount,
+            pointCount,
+            bounds: computeBounds(set.positions, pointCount),
+            // Counts are stored as uint32 whatever the source used, so a reader has
+            // one type to handle.
+            positions: place(exactFloat32(set.positions, pointCount * 3)),
+            pointCounts: place(toUint32(counts))
+        };
+        if (set.widths && set.widths.length > 0) {
+            const expected = set.widthPerStrand ? strandCount : pointCount;
+            json.widths = place(exactFloat32(set.widths, expected));
+            if (set.widthPerStrand) {
+                json.widthPerStrand = true;
+            }
+        }
+        if (set.uv && set.uv.length > 0) {
+            const perPoint = !!set.uvPerPoint;
+            const expected = (perPoint ? pointCount : strandCount) * 2;
+            json.uv = place(exactFloat32(set.uv, expected));
+            if (perPoint) {
+                json.uvPerPoint = true;
+            }
+        }
+        if (set.colors && set.colors.length > 0) {
+            json.colors = place(exactFloat32(set.colors, pointCount * 3));
+        }
+        if (set.transparency && set.transparency.length > 0) {
+            json.transparency = place(exactFloat32(set.transparency, pointCount));
+        }
+        return json;
+    });
+    const manifest = {
+        version: ZHAIR_VERSION,
+        unitScale: options?.unitScale ?? 1,
+        strandSets
+    };
+    if (options?.sourcePath) {
+        manifest.sourcePath = options.sourcePath;
+    }
+    if (options?.sourceFormat) {
+        manifest.sourceFormat = options.sourceFormat;
+    }
+    const manifestBytes = new TextEncoder().encode(JSON.stringify(manifest));
+    // The payload is aligned too, so every array inside it keeps the alignment the
+    // layout pass gave it.
+    const payloadOffset = ZHAIR_HEADER_SIZE + manifestBytes.byteLength + 3 & -4;
+    const buffer = new ArrayBuffer(payloadOffset + payloadLength);
+    const view = new DataView(buffer);
+    const bytes = new Uint8Array(buffer);
+    bytes[0] = 0x5a; // 'Z'
+    bytes[1] = 0x48; // 'H'
+    bytes[2] = 0x52; // 'R'
+    bytes[3] = 0x00;
+    view.setUint32(4, ZHAIR_VERSION, true);
+    view.setUint32(8, manifestBytes.byteLength, true);
+    bytes.set(manifestBytes, ZHAIR_HEADER_SIZE);
+    for (const chunk of chunks){
+        bytes.set(new Uint8Array(chunk.data.buffer, chunk.data.byteOffset, chunk.data.byteLength), payloadOffset + chunk.ref.offset);
+    }
+    return buffer;
+}
+/**
+ * Opens a `.zhair` file.
+ *
+ * @remarks
+ * Reads the manifest and keeps the buffer; the arrays themselves are not touched
+ * until {@link readZHairPositions} and its siblings are called for them.
+ *
+ * @param buffer - The complete file.
+ * @returns The manifest and the payload it indexes into.
+ *
+ * @public
+ */ function parseZHair(buffer) {
+    if (!isZHair(buffer)) {
+        throw new Error('parseZHair: not a zhair file');
+    }
+    const view = new DataView(buffer);
+    const version = view.getUint32(4, true);
+    if (version !== ZHAIR_VERSION) {
+        throw new Error(`parseZHair: unsupported zhair version ${version}`);
+    }
+    const manifestLength = view.getUint32(8, true);
+    const manifestEnd = ZHAIR_HEADER_SIZE + manifestLength;
+    if (manifestEnd > buffer.byteLength) {
+        throw new Error('parseZHair: truncated manifest');
+    }
+    const manifestText = new TextDecoder().decode(new Uint8Array(buffer, ZHAIR_HEADER_SIZE, manifestLength));
+    const content = JSON.parse(manifestText);
+    if (!Array.isArray(content.strandSets) || content.strandSets.length === 0) {
+        throw new Error('parseZHair: manifest holds no strand sets');
+    }
+    return {
+        content,
+        payload: buffer,
+        payloadOffset: manifestEnd + 3 & -4
+    };
+}
+/**
+ * Whether a buffer starts with the `.zhair` magic.
+ *
+ * @param buffer - Bytes to test.
+ * @returns True when the buffer looks like a `.zhair` file.
+ *
+ * @public
+ */ function isZHair(buffer) {
+    if (buffer.byteLength < ZHAIR_HEADER_SIZE) {
+        return false;
+    }
+    const magic = new Uint8Array(buffer, 0, 4);
+    return magic[0] === 0x5a && magic[1] === 0x48 && magic[2] === 0x52 && magic[3] === 0x00;
+}
+/**
+ * Copies a float32 array out of the payload.
+ *
+ * @param parsed - The opened file.
+ * @param ref - Where the array sits, from the manifest.
+ * @returns A copy of the array, or null when `ref` is absent.
+ *
+ * @public
+ */ function readZHairFloats(parsed, ref) {
+    if (!ref) {
+        return null;
+    }
+    const start = parsed.payloadOffset + ref.offset;
+    const end = start + ref.length;
+    if (end > parsed.payload.byteLength) {
+        throw new Error('readZHairFloats: buffer reference runs past the end of the file');
+    }
+    return new Float32Array(parsed.payload.slice(start, end));
+}
+/**
+ * Copies a uint32 array out of the payload.
+ *
+ * @param parsed - The opened file.
+ * @param ref - Where the array sits, from the manifest.
+ * @returns A copy of the array.
+ *
+ * @public
+ */ function readZHairUints(parsed, ref) {
+    const start = parsed.payloadOffset + ref.offset;
+    const end = start + ref.length;
+    if (end > parsed.payload.byteLength) {
+        throw new Error('readZHairUints: buffer reference runs past the end of the file');
+    }
+    return new Uint32Array(parsed.payload.slice(start, end));
+}
+/** Bounds of the first `pointCount` points. @internal */ function computeBounds(positions, pointCount) {
+    let minX = Infinity;
+    let minY = Infinity;
+    let minZ = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    let maxZ = -Infinity;
+    for(let i = 0; i < pointCount; i++){
+        const x = positions[i * 3];
+        const y = positions[i * 3 + 1];
+        const z = positions[i * 3 + 2];
+        if (x < minX) {
+            minX = x;
+        }
+        if (y < minY) {
+            minY = y;
+        }
+        if (z < minZ) {
+            minZ = z;
+        }
+        if (x > maxX) {
+            maxX = x;
+        }
+        if (y > maxY) {
+            maxY = y;
+        }
+        if (z > maxZ) {
+            maxZ = z;
+        }
+    }
+    return [
+        minX,
+        minY,
+        minZ,
+        maxX,
+        maxY,
+        maxZ
+    ];
+}
+/**
+ * Narrows a float array to exactly `length` values.
+ *
+ * @remarks
+ * Sources routinely hand over arrays longer than the topology needs - a view
+ * into a larger buffer, or trailing values a container padded. Writing the
+ * excess would make the file disagree with its own point count.
+ * @internal
+ */ function exactFloat32(data, length) {
+    if (data.length === length && data.byteOffset === 0 && data.buffer.byteLength === data.byteLength) {
+        return data;
+    }
+    if (data.length < length) {
+        throw new Error(`encodeZHair: expected ${length} floats but the source holds ${data.length}`);
+    }
+    return data.slice(0, length);
+}
+/** Converts a count array to uint32, copying only when the type differs. @internal */ function toUint32(counts) {
+    if (counts instanceof Uint32Array && counts.byteOffset === 0) {
+        return counts;
+    }
+    const out = new Uint32Array(counts.length);
+    for(let i = 0; i < counts.length; i++){
+        if (counts[i] < 0) {
+            throw new Error(`encodeZHair: strand ${i} has a negative point count`);
+        }
+        out[i] = counts[i];
+    }
+    return out;
+}
+
+export { ZHAIR_VERSION, encodeZHair, isZHair, parseZHair, readZHairFloats, readZHairUints };
+//# sourceMappingURL=zhair_format.js.map

package/dist/asset/loaders/zhair/zhair_format.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"zhair_format.js","sources":["../../../../src/asset/loaders/zhair/zhair_format.ts"],"sourcesContent":["/**\r\n * The `.zhair` container: strand geometry, ready to upload.\r\n *\r\n * @remarks\r\n * Hair reaches the engine as an Alembic curve archive or a `.hair` model, and\r\n * neither is cheap to open: the sample XGen archive is 84 MB of Ogawa container\r\n * holding two million control points, and parsing it means walking an object\r\n * tree and cross-checking property blocks before a single strand appears. Doing\r\n * that every time a scene loads is not viable, so the editor converts once and\r\n * writes this instead.\r\n *\r\n * The layout follows `.zabc`, the geometry cache container already in the tree:\r\n * a magic, a version, a JSON manifest, and then every large array concatenated\r\n * into one payload the manifest points into. The manifest stays readable for\r\n * debugging while the arrays are copied out by offset rather than decoded.\r\n *\r\n * What is stored is {@link StrandCurveSet} - the format-neutral shape both\r\n * importers already converge on - at **full authored density**. Thinning is a\r\n * property of the node that draws the hair, not of the file, so an artist can\r\n * pull strand count down for a distant character and back up for a close-up\r\n * without returning to the source archive.\r\n */\r\nimport type { Nullable } from '@zephyr3d/base';\r\n\r\n/** The only version this module writes. @public */\r\nexport const ZHAIR_VERSION = 1;\r\n/** Bytes before the manifest: magic, version, manifest length. @internal */\r\nconst ZHAIR_HEADER_SIZE = 12;\r\n\r\n/**\r\n * Where one array sits inside the binary payload.\r\n *\r\n * @remarks\r\n * Both fields are byte counts, and `offset` is relative to the start of the\r\n * payload rather than the file, so the manifest does not have to be rewritten\r\n * if the header ever grows.\r\n * @public\r\n */\r\nexport type ZHairBufferRef = {\r\n  /** Byte offset from the start of the payload. */\r\n  offset: number;\r\n  /** Length in bytes. */\r\n  length: number;\r\n};\r\n\r\n/**\r\n * One strand set as described by the manifest.\r\n *\r\n * @remarks\r\n * Mirrors {@link StrandCurveSet}, with the per-point colour and transparency\r\n * channels a `.hair` file may carry. Control points are contiguous: strand `i`\r\n * owns the `pointCounts[i]` points following the running sum of the counts\r\n * before it.\r\n * @public\r\n */\r\nexport type ZHairStrandSetJSON = {\r\n  /** Name carried over from the source object. */\r\n  name: string;\r\n  /** Number of strands. */\r\n  strandCount: number;\r\n  /** Total control points across all strands. */\r\n  pointCount: number;\r\n  /**\r\n   * Axis-aligned bounds of the control points, as `[minX, minY, minZ, maxX,\r\n   * maxY, maxZ]`.\r\n   *\r\n   * @remarks\r\n   * In the file's own units, before `unitScale` is applied, so that a reader\r\n   * can size a node without touching the payload.\r\n   */\r\n  bounds: [number, number, number, number, number, number];\r\n  /** Control point positions, 3 float32 per point. */\r\n  positions: ZHairBufferRef;\r\n  /** Control point count per strand, 1 uint32 each. */\r\n  pointCounts: ZHairBufferRef;\r\n  /** Strand width as a diameter, in the same unit as `positions`. */\r\n  widths?: ZHairBufferRef;\r\n  /** True when `widths` holds one value per strand rather than per point. */\r\n  widthPerStrand?: boolean;\r\n  /** Root UV, 2 float32 each. */\r\n  uv?: ZHairBufferRef;\r\n  /** True when `uv` holds one pair per point rather than per strand. */\r\n  uvPerPoint?: boolean;\r\n  /** Per-point colour, 3 float32 each. Only `.hair` sources carry this. */\r\n  colors?: ZHairBufferRef;\r\n  /** Per-point transparency, 1 float32 each. Only `.hair` sources carry this. */\r\n  transparency?: ZHairBufferRef;\r\n};\r\n\r\n/**\r\n * The manifest at the head of a `.zhair` file.\r\n * @public\r\n */\r\nexport type ZHairFileJSON = {\r\n  /** Format version; {@link ZHAIR_VERSION} is the only one written. */\r\n  version: number;\r\n  /** Path of the archive this was converted from, for reimport. */\r\n  sourcePath?: string;\r\n  /** Container the strands came out of. */\r\n  sourceFormat?: 'alembic' | 'hair';\r\n  /**\r\n   * Scale that converts the stored units to metres.\r\n   *\r\n   * @remarks\r\n   * Decided at conversion time, because only the importer knows what the source\r\n   * meant: Alembic from Maya is authored in centimetres, while `.hair` records\r\n   * no unit at all and gets a scale fitted from its bounds. Positions are stored\r\n   * unscaled so the number stays visible and adjustable.\r\n   */\r\n  unitScale: number;\r\n  /** Strand sets, one per source curve object. */\r\n  strandSets: ZHairStrandSetJSON[];\r\n};\r\n\r\n/**\r\n * A `.zhair` file, opened.\r\n * @public\r\n */\r\nexport type ParsedZHair = {\r\n  /** The decoded manifest. */\r\n  content: ZHairFileJSON;\r\n  /** The whole file, which the buffer refs index into. */\r\n  payload: ArrayBuffer;\r\n  /** Byte offset of the payload within {@link ParsedZHair.payload}. */\r\n  payloadOffset: number;\r\n};\r\n\r\n/**\r\n * One strand set on its way into a file.\r\n *\r\n * @remarks\r\n * Structurally a `StrandCurveSet` plus the two optional `.hair` channels, but\r\n * declared here rather than imported so this module stays free of a dependency\r\n * on the loaders package.\r\n * @public\r\n */\r\nexport type ZHairStrandSetSource = {\r\n  /** Name for the strand set. */\r\n  name?: string;\r\n  /** Control point positions, 3 floats per point. */\r\n  positions: Float32Array;\r\n  /** Control point count per strand. */\r\n  pointCounts: Int32Array | Uint32Array;\r\n  /** Strand width as a diameter, or null when the source has none. */\r\n  widths?: Nullable<Float32Array>;\r\n  /** True when `widths` holds one value per strand. */\r\n  widthPerStrand?: boolean;\r\n  /** Root UV, 2 floats each, or null when absent. */\r\n  uv?: Nullable<Float32Array>;\r\n  /** True when `uv` holds one pair per point. */\r\n  uvPerPoint?: boolean;\r\n  /** Per-point colour, 3 floats each. */\r\n  colors?: Nullable<Float32Array>;\r\n  /** Per-point transparency. */\r\n  transparency?: Nullable<Float32Array>;\r\n};\r\n\r\n/**\r\n * File-level facts that are not derivable from the strands themselves.\r\n * @public\r\n */\r\nexport type ZHairEncodeOptions = {\r\n  /** Scale converting the stored units to metres. Defaults to 1. */\r\n  unitScale?: number;\r\n  /** Path of the source archive, recorded for reimport. */\r\n  sourcePath?: string;\r\n  /** Container the strands came from. */\r\n  sourceFormat?: 'alembic' | 'hair';\r\n};\r\n\r\n/**\r\n * Packs strand sets into a `.zhair` file.\r\n *\r\n * @param sets - Strand sets to write, one per source curve object.\r\n * @param options - Unit scale and source provenance.\r\n * @returns The complete file.\r\n *\r\n * @public\r\n */\r\nexport function encodeZHair(sets: ZHairStrandSetSource[], options?: ZHairEncodeOptions): ArrayBuffer {\r\n  if (sets.length === 0) {\r\n    throw new Error('encodeZHair: no strand sets given');\r\n  }\r\n  // Two passes: the manifest has to carry the offset of every array, so the\r\n  // payload is laid out first and the arrays are copied only once the total size\r\n  // is known.\r\n  const chunks: { data: ArrayBufferView; ref: ZHairBufferRef }[] = [];\r\n  let payloadLength = 0;\r\n  const place = (data: ArrayBufferView): ZHairBufferRef => {\r\n    // Each array starts on a 4-byte boundary so a reader may view the payload\r\n    // in place rather than copying, should it ever want to.\r\n    payloadLength = (payloadLength + 3) & ~3;\r\n    const ref: ZHairBufferRef = { offset: payloadLength, length: data.byteLength };\r\n    chunks.push({ data, ref });\r\n    payloadLength += data.byteLength;\r\n    return ref;\r\n  };\r\n\r\n  const strandSets: ZHairStrandSetJSON[] = sets.map((set, index) => {\r\n    const counts = set.pointCounts;\r\n    const strandCount = counts.length;\r\n    let pointCount = 0;\r\n    for (let i = 0; i < strandCount; i++) {\r\n      pointCount += counts[i];\r\n    }\r\n    if (strandCount === 0 || pointCount === 0) {\r\n      throw new Error(`encodeZHair: strand set ${index} is empty`);\r\n    }\r\n    if (set.positions.length < pointCount * 3) {\r\n      throw new Error(\r\n        `encodeZHair: strand set ${index} holds ${\r\n          set.positions.length / 3\r\n        } points but its topology needs ${pointCount}`\r\n      );\r\n    }\r\n    const json: ZHairStrandSetJSON = {\r\n      name: set.name || `Strands${index}`,\r\n      strandCount,\r\n      pointCount,\r\n      bounds: computeBounds(set.positions, pointCount),\r\n      // Counts are stored as uint32 whatever the source used, so a reader has\r\n      // one type to handle.\r\n      positions: place(exactFloat32(set.positions, pointCount * 3)),\r\n      pointCounts: place(toUint32(counts))\r\n    };\r\n    if (set.widths && set.widths.length > 0) {\r\n      const expected = set.widthPerStrand ? strandCount : pointCount;\r\n      json.widths = place(exactFloat32(set.widths, expected));\r\n      if (set.widthPerStrand) {\r\n        json.widthPerStrand = true;\r\n      }\r\n    }\r\n    if (set.uv && set.uv.length > 0) {\r\n      const perPoint = !!set.uvPerPoint;\r\n      const expected = (perPoint ? pointCount : strandCount) * 2;\r\n      json.uv = place(exactFloat32(set.uv, expected));\r\n      if (perPoint) {\r\n        json.uvPerPoint = true;\r\n      }\r\n    }\r\n    if (set.colors && set.colors.length > 0) {\r\n      json.colors = place(exactFloat32(set.colors, pointCount * 3));\r\n    }\r\n    if (set.transparency && set.transparency.length > 0) {\r\n      json.transparency = place(exactFloat32(set.transparency, pointCount));\r\n    }\r\n    return json;\r\n  });\r\n\r\n  const manifest: ZHairFileJSON = {\r\n    version: ZHAIR_VERSION,\r\n    unitScale: options?.unitScale ?? 1,\r\n    strandSets\r\n  };\r\n  if (options?.sourcePath) {\r\n    manifest.sourcePath = options.sourcePath;\r\n  }\r\n  if (options?.sourceFormat) {\r\n    manifest.sourceFormat = options.sourceFormat;\r\n  }\r\n  const manifestBytes = new TextEncoder().encode(JSON.stringify(manifest));\r\n  // The payload is aligned too, so every array inside it keeps the alignment the\r\n  // layout pass gave it.\r\n  const payloadOffset = (ZHAIR_HEADER_SIZE + manifestBytes.byteLength + 3) & ~3;\r\n  const buffer = new ArrayBuffer(payloadOffset + payloadLength);\r\n  const view = new DataView(buffer);\r\n  const bytes = new Uint8Array(buffer);\r\n  bytes[0] = 0x5a; // 'Z'\r\n  bytes[1] = 0x48; // 'H'\r\n  bytes[2] = 0x52; // 'R'\r\n  bytes[3] = 0x00;\r\n  view.setUint32(4, ZHAIR_VERSION, true);\r\n  view.setUint32(8, manifestBytes.byteLength, true);\r\n  bytes.set(manifestBytes, ZHAIR_HEADER_SIZE);\r\n  for (const chunk of chunks) {\r\n    bytes.set(\r\n      new Uint8Array(chunk.data.buffer, chunk.data.byteOffset, chunk.data.byteLength),\r\n      payloadOffset + chunk.ref.offset\r\n    );\r\n  }\r\n  return buffer;\r\n}\r\n\r\n/**\r\n * Opens a `.zhair` file.\r\n *\r\n * @remarks\r\n * Reads the manifest and keeps the buffer; the arrays themselves are not touched\r\n * until {@link readZHairPositions} and its siblings are called for them.\r\n *\r\n * @param buffer - The complete file.\r\n * @returns The manifest and the payload it indexes into.\r\n *\r\n * @public\r\n */\r\nexport function parseZHair(buffer: ArrayBuffer): ParsedZHair {\r\n  if (!isZHair(buffer)) {\r\n    throw new Error('parseZHair: not a zhair file');\r\n  }\r\n  const view = new DataView(buffer);\r\n  const version = view.getUint32(4, true);\r\n  if (version !== ZHAIR_VERSION) {\r\n    throw new Error(`parseZHair: unsupported zhair version ${version}`);\r\n  }\r\n  const manifestLength = view.getUint32(8, true);\r\n  const manifestEnd = ZHAIR_HEADER_SIZE + manifestLength;\r\n  if (manifestEnd > buffer.byteLength) {\r\n    throw new Error('parseZHair: truncated manifest');\r\n  }\r\n  const manifestText = new TextDecoder().decode(new Uint8Array(buffer, ZHAIR_HEADER_SIZE, manifestLength));\r\n  const content = JSON.parse(manifestText) as ZHairFileJSON;\r\n  if (!Array.isArray(content.strandSets) || content.strandSets.length === 0) {\r\n    throw new Error('parseZHair: manifest holds no strand sets');\r\n  }\r\n  return {\r\n    content,\r\n    payload: buffer,\r\n    payloadOffset: (manifestEnd + 3) & ~3\r\n  };\r\n}\r\n\r\n/**\r\n * Whether a buffer starts with the `.zhair` magic.\r\n *\r\n * @param buffer - Bytes to test.\r\n * @returns True when the buffer looks like a `.zhair` file.\r\n *\r\n * @public\r\n */\r\nexport function isZHair(buffer: ArrayBuffer): boolean {\r\n  if (buffer.byteLength < ZHAIR_HEADER_SIZE) {\r\n    return false;\r\n  }\r\n  const magic = new Uint8Array(buffer, 0, 4);\r\n  return magic[0] === 0x5a && magic[1] === 0x48 && magic[2] === 0x52 && magic[3] === 0x00;\r\n}\r\n\r\n/**\r\n * Copies a float32 array out of the payload.\r\n *\r\n * @param parsed - The opened file.\r\n * @param ref - Where the array sits, from the manifest.\r\n * @returns A copy of the array, or null when `ref` is absent.\r\n *\r\n * @public\r\n */\r\nexport function readZHairFloats(\r\n  parsed: ParsedZHair,\r\n  ref: Nullable<ZHairBufferRef> | undefined\r\n): Nullable<Float32Array> {\r\n  if (!ref) {\r\n    return null;\r\n  }\r\n  const start = parsed.payloadOffset + ref.offset;\r\n  const end = start + ref.length;\r\n  if (end > parsed.payload.byteLength) {\r\n    throw new Error('readZHairFloats: buffer reference runs past the end of the file');\r\n  }\r\n  return new Float32Array(parsed.payload.slice(start, end));\r\n}\r\n\r\n/**\r\n * Copies a uint32 array out of the payload.\r\n *\r\n * @param parsed - The opened file.\r\n * @param ref - Where the array sits, from the manifest.\r\n * @returns A copy of the array.\r\n *\r\n * @public\r\n */\r\nexport function readZHairUints(parsed: ParsedZHair, ref: ZHairBufferRef): Uint32Array {\r\n  const start = parsed.payloadOffset + ref.offset;\r\n  const end = start + ref.length;\r\n  if (end > parsed.payload.byteLength) {\r\n    throw new Error('readZHairUints: buffer reference runs past the end of the file');\r\n  }\r\n  return new Uint32Array(parsed.payload.slice(start, end));\r\n}\r\n\r\n/** Bounds of the first `pointCount` points. @internal */\r\nfunction computeBounds(\r\n  positions: Float32Array,\r\n  pointCount: number\r\n): [number, number, number, number, number, number] {\r\n  let minX = Infinity;\r\n  let minY = Infinity;\r\n  let minZ = Infinity;\r\n  let maxX = -Infinity;\r\n  let maxY = -Infinity;\r\n  let maxZ = -Infinity;\r\n  for (let i = 0; i < pointCount; i++) {\r\n    const x = positions[i * 3];\r\n    const y = positions[i * 3 + 1];\r\n    const z = positions[i * 3 + 2];\r\n    if (x < minX) {\r\n      minX = x;\r\n    }\r\n    if (y < minY) {\r\n      minY = y;\r\n    }\r\n    if (z < minZ) {\r\n      minZ = z;\r\n    }\r\n    if (x > maxX) {\r\n      maxX = x;\r\n    }\r\n    if (y > maxY) {\r\n      maxY = y;\r\n    }\r\n    if (z > maxZ) {\r\n      maxZ = z;\r\n    }\r\n  }\r\n  return [minX, minY, minZ, maxX, maxY, maxZ];\r\n}\r\n\r\n/**\r\n * Narrows a float array to exactly `length` values.\r\n *\r\n * @remarks\r\n * Sources routinely hand over arrays longer than the topology needs - a view\r\n * into a larger buffer, or trailing values a container padded. Writing the\r\n * excess would make the file disagree with its own point count.\r\n * @internal\r\n */\r\nfunction exactFloat32(data: Float32Array, length: number): Float32Array {\r\n  if (data.length === length && data.byteOffset === 0 && data.buffer.byteLength === data.byteLength) {\r\n    return data;\r\n  }\r\n  if (data.length < length) {\r\n    throw new Error(`encodeZHair: expected ${length} floats but the source holds ${data.length}`);\r\n  }\r\n  return data.slice(0, length);\r\n}\r\n\r\n/** Converts a count array to uint32, copying only when the type differs. @internal */\r\nfunction toUint32(counts: Int32Array | Uint32Array): Uint32Array {\r\n  if (counts instanceof Uint32Array && counts.byteOffset === 0) {\r\n    return counts;\r\n  }\r\n  const out = new Uint32Array(counts.length);\r\n  for (let i = 0; i < counts.length; i++) {\r\n    if (counts[i] < 0) {\r\n      throw new Error(`encodeZHair: strand ${i} has a negative point count`);\r\n    }\r\n    out[i] = counts[i];\r\n  }\r\n  return out;\r\n}\r\n"],"names":["ZHAIR_VERSION","ZHAIR_HEADER_SIZE","encodeZHair","sets","options","length","Error","chunks","payloadLength","place","data","ref","offset","byteLength","push","strandSets","map","set","index","counts","pointCounts","strandCount","pointCount","i","positions","json","name","bounds","computeBounds","exactFloat32","toUint32","widths","expected","widthPerStrand","uv","perPoint","uvPerPoint","colors","transparency","manifest","version","unitScale","sourcePath","sourceFormat","manifestBytes","TextEncoder","encode","JSON","stringify","payloadOffset","buffer","ArrayBuffer","view","DataView","bytes","Uint8Array","setUint32","chunk","byteOffset","parseZHair","isZHair","getUint32","manifestLength","manifestEnd","manifestText","TextDecoder","decode","content","parse","Array","isArray","payload","magic","readZHairFloats","parsed","start","end","Float32Array","slice","readZHairUints","Uint32Array","minX","Infinity","minY","minZ","maxX","maxY","maxZ","x","y","z","out"],"mappings":"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"}

package/dist/asset/loaders/zhair/zhair_loader.js

@@ -0,0 +1,221 @@
+import { readZHairUints, readZHairFloats } from './zhair_format.js';
+
+/**
+ * Decodes a `.zhair` file into strand sources.
+ *
+ * @param parsed - The opened file.
+ * @param options - Decimation and scaling.
+ * @returns One source per strand set, ready for `HairStrandData`.
+ *
+ * @public
+ */ function loadZHairStrandSources(parsed, options) {
+    const sets = parsed.content.strandSets;
+    const scale = options?.scale ?? parsed.content.unitScale ?? 1;
+    const widthScale = options?.widthScale ?? 1;
+    const stride = resolveStride(sets, options);
+    const sources = [];
+    for (const set of sets){
+        const source = decodeStrandSet(parsed, set, stride, scale, widthScale);
+        if (source) {
+            sources.push(source);
+        }
+    }
+    return sources;
+}
+/**
+ * Merges strand sets into one source.
+ *
+ * @remarks
+ * A `.zhair` file holds one set per source curve object, and an XGen archive
+ * routinely exports several spline descriptions for a single hairstyle. They
+ * share a material and differ only in which patch of scalp they grew from, so
+ * merging lets the whole head draw in one call.
+ *
+ * @param sources - Sources to merge.
+ * @returns A single source, or null when there is nothing to merge.
+ *
+ * @public
+ */ function mergeHairStrandSources(sources) {
+    if (sources.length === 0) {
+        return null;
+    }
+    if (sources.length === 1) {
+        return sources[0];
+    }
+    let strandCount = 0;
+    let pointCount = 0;
+    for (const source of sources){
+        strandCount += source.pointCounts.length;
+        for(let i = 0; i < source.pointCounts.length; i++){
+            pointCount += source.pointCounts[i];
+        }
+    }
+    const positions = new Float32Array(pointCount * 3);
+    const pointCounts = new Uint32Array(strandCount);
+    // A channel is only carried into the merge if every set has it: a partially
+    // filled width or UV array would read as zero for the sets that lacked it,
+    // which is worse than falling back to the defaults uniformly.
+    const hasWidths = sources.every((s)=>!!s.widths);
+    const hasUV = sources.every((s)=>!!s.uv);
+    // Per-point width and UV are the general case; a per-strand array is expanded
+    // rather than tracked, so the merged source has one layout to describe.
+    const widths = hasWidths ? new Float32Array(pointCount) : null;
+    const uv = hasUV ? new Float32Array(pointCount * 2) : null;
+    let strandOffset = 0;
+    let pointOffset = 0;
+    for (const source of sources){
+        const counts = source.pointCounts;
+        const scale = source.scale ?? 1;
+        const sourceWidthScale = source.widthScale ?? 1;
+        let sourcePoints = 0;
+        for(let i = 0; i < counts.length; i++){
+            sourcePoints += counts[i];
+        }
+        // `HairStrandSource` carries no per-point UV flag; it is inferred from the
+        // array length, and the inference has to match the one `HairStrandData`
+        // makes or the merged UVs would be read against a different layout.
+        const sourceUVPerPoint = !!source.uv && source.uv.length >= sourcePoints * 2;
+        let localPoint = 0;
+        for(let s = 0; s < counts.length; s++){
+            const count = counts[s];
+            pointCounts[strandOffset + s] = count;
+            for(let i = 0; i < count; i++){
+                const src = (localPoint + i) * 3;
+                const dst = (pointOffset + i) * 3;
+                // Per-source scale is baked in here, because the merged source carries a
+                // single scale and the sets may have come from files with different units.
+                positions[dst] = source.positions[src] * scale;
+                positions[dst + 1] = source.positions[src + 1] * scale;
+                positions[dst + 2] = source.positions[src + 2] * scale;
+                if (widths) {
+                    const w = source.widthPerStrand ? source.widths[s] : source.widths[localPoint + i];
+                    widths[pointOffset + i] = w * scale * sourceWidthScale;
+                }
+                if (uv) {
+                    const uvSrc = source.uv;
+                    // Expanding a per-strand UV to per-point costs a little memory and
+                    // removes a flag from everything downstream.
+                    const o = sourceUVPerPoint ? (localPoint + i) * 2 : s * 2;
+                    uv[(pointOffset + i) * 2] = uvSrc[o];
+                    uv[(pointOffset + i) * 2 + 1] = uvSrc[o + 1];
+                }
+            }
+            localPoint += count;
+            pointOffset += count;
+        }
+        strandOffset += counts.length;
+    }
+    return {
+        positions,
+        pointCounts,
+        widths,
+        widthPerStrand: false,
+        uv,
+        // Everything has been converted already, so the merged source must not be
+        // scaled a second time.
+        scale: 1,
+        widthScale: 1,
+        defaultWidth: sources[0].defaultWidth
+    };
+}
+/**
+ * Picks a stride that honours both `strandStride` and `maxStrands`.
+ * @internal
+ */ function resolveStride(sets, options) {
+    let stride = Math.max(1, Math.floor(options?.strandStride ?? 1));
+    const maxStrands = options?.maxStrands ?? 0;
+    if (maxStrands > 0) {
+        let total = 0;
+        for (const set of sets){
+            total += Math.ceil(set.strandCount / stride);
+        }
+        if (total > maxStrands) {
+            let authored = 0;
+            for (const set of sets){
+                authored += set.strandCount;
+            }
+            stride = Math.max(stride, Math.ceil(authored / maxStrands));
+        }
+    }
+    return stride;
+}
+/**
+ * Decodes one strand set, keeping one strand in every `stride`.
+ * @internal
+ */ function decodeStrandSet(parsed, set, stride, scale, widthScale) {
+    const allCounts = readZHairUints(parsed, set.pointCounts);
+    const allPositions = readZHairFloats(parsed, set.positions);
+    const allWidths = readZHairFloats(parsed, set.widths);
+    const allUV = readZHairFloats(parsed, set.uv);
+    const widthPerStrand = !!set.widthPerStrand;
+    const uvPerPoint = !!set.uvPerPoint;
+    if (stride <= 1) {
+        return {
+            positions: allPositions,
+            pointCounts: allCounts,
+            widths: allWidths,
+            widthPerStrand,
+            uv: allUV,
+            scale,
+            widthScale
+        };
+    }
+    // Walking the whole count array is unavoidable even when most strands are
+    // dropped, because a strand's first point index is the sum of all counts
+    // before it and the file stores no index.
+    const keptStrands = [];
+    const firstPoints = [];
+    let first = 0;
+    let keptPoints = 0;
+    for(let s = 0; s < allCounts.length; s++){
+        if (s % stride === 0) {
+            keptStrands.push(s);
+            firstPoints.push(first);
+            keptPoints += allCounts[s];
+        }
+        first += allCounts[s];
+    }
+    if (keptStrands.length === 0 || keptPoints === 0) {
+        return null;
+    }
+    const positions = new Float32Array(keptPoints * 3);
+    const pointCounts = new Uint32Array(keptStrands.length);
+    const widths = allWidths ? new Float32Array(widthPerStrand ? keptStrands.length : keptPoints) : null;
+    const uv = allUV ? new Float32Array((uvPerPoint ? keptPoints : keptStrands.length) * 2) : null;
+    let dstPoint = 0;
+    for(let k = 0; k < keptStrands.length; k++){
+        const s = keptStrands[k];
+        const count = allCounts[s];
+        const srcFirst = firstPoints[k];
+        pointCounts[k] = count;
+        positions.set(allPositions.subarray(srcFirst * 3, (srcFirst + count) * 3), dstPoint * 3);
+        if (widths) {
+            if (widthPerStrand) {
+                widths[k] = allWidths[s];
+            } else {
+                widths.set(allWidths.subarray(srcFirst, srcFirst + count), dstPoint);
+            }
+        }
+        if (uv) {
+            if (uvPerPoint) {
+                uv.set(allUV.subarray(srcFirst * 2, (srcFirst + count) * 2), dstPoint * 2);
+            } else {
+                uv[k * 2] = allUV[s * 2];
+                uv[k * 2 + 1] = allUV[s * 2 + 1];
+            }
+        }
+        dstPoint += count;
+    }
+    return {
+        positions,
+        pointCounts,
+        widths,
+        widthPerStrand,
+        uv,
+        scale,
+        widthScale
+    };
+}
+
+export { loadZHairStrandSources, mergeHairStrandSources };
+//# sourceMappingURL=zhair_loader.js.map

package/dist/asset/loaders/zhair/zhair_loader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"zhair_loader.js","sources":["../../../../src/asset/loaders/zhair/zhair_loader.ts"],"sourcesContent":["/**\r\n * Turns a parsed `.zhair` file into strand sources ready for the GPU.\r\n *\r\n * @remarks\r\n * The file stores hair at full authored density, which for a production groom is\r\n * around 69,000 strands of 30 control points. Drawing all of them is not always\r\n * wanted, so decimation happens here rather than at conversion time: the node\r\n * owning the hair exposes the knobs, and turning one re-runs this against the\r\n * same file. Going back to the source archive is never required.\r\n */\r\nimport type { Nullable } from '@zephyr3d/base';\r\nimport type { HairStrandSource } from '../../../material/hairstrand_data';\r\nimport type { ParsedZHair, ZHairStrandSetJSON } from './zhair_format';\r\nimport { readZHairFloats, readZHairUints } from './zhair_format';\r\n\r\n/**\r\n * How much of a `.zhair` file to keep.\r\n *\r\n * @public\r\n */\r\nexport type ZHairLoadOptions = {\r\n  /**\r\n   * Keep one strand in every `strandStride`.\r\n   *\r\n   * @remarks\r\n   * Decimating by a stride rather than by taking a leading slice keeps the kept\r\n   * strands spread over the whole scalp; a slice would leave a bald patch,\r\n   * because strands are stored in the order the groom generated them.\r\n   * Defaults to 1, which keeps everything.\r\n   */\r\n  strandStride?: number;\r\n  /**\r\n   * Upper bound on the number of strands kept, across all sets.\r\n   *\r\n   * @remarks\r\n   * Applied on top of `strandStride` by widening the stride further, so the\r\n   * result stays evenly spread instead of stopping partway through the groom.\r\n   */\r\n  maxStrands?: number;\r\n  /**\r\n   * Scale applied to positions and widths alike.\r\n   *\r\n   * @remarks\r\n   * Defaults to the file's own `unitScale`. Width is a length in the same unit\r\n   * as position, so the two must convert together - leaving width unscaled makes\r\n   * strands a hundred times too thick and they read as ribbons rather than hair.\r\n   */\r\n  scale?: number;\r\n  /** Extra multiplier on width only, for art direction. Defaults to 1. */\r\n  widthScale?: number;\r\n};\r\n\r\n/**\r\n * Decodes a `.zhair` file into strand sources.\r\n *\r\n * @param parsed - The opened file.\r\n * @param options - Decimation and scaling.\r\n * @returns One source per strand set, ready for `HairStrandData`.\r\n *\r\n * @public\r\n */\r\nexport function loadZHairStrandSources(parsed: ParsedZHair, options?: ZHairLoadOptions): HairStrandSource[] {\r\n  const sets = parsed.content.strandSets;\r\n  const scale = options?.scale ?? parsed.content.unitScale ?? 1;\r\n  const widthScale = options?.widthScale ?? 1;\r\n  const stride = resolveStride(sets, options);\r\n  const sources: HairStrandSource[] = [];\r\n  for (const set of sets) {\r\n    const source = decodeStrandSet(parsed, set, stride, scale, widthScale);\r\n    if (source) {\r\n      sources.push(source);\r\n    }\r\n  }\r\n  return sources;\r\n}\r\n\r\n/**\r\n * Merges strand sets into one source.\r\n *\r\n * @remarks\r\n * A `.zhair` file holds one set per source curve object, and an XGen archive\r\n * routinely exports several spline descriptions for a single hairstyle. They\r\n * share a material and differ only in which patch of scalp they grew from, so\r\n * merging lets the whole head draw in one call.\r\n *\r\n * @param sources - Sources to merge.\r\n * @returns A single source, or null when there is nothing to merge.\r\n *\r\n * @public\r\n */\r\nexport function mergeHairStrandSources(sources: HairStrandSource[]): Nullable<HairStrandSource> {\r\n  if (sources.length === 0) {\r\n    return null;\r\n  }\r\n  if (sources.length === 1) {\r\n    return sources[0];\r\n  }\r\n  let strandCount = 0;\r\n  let pointCount = 0;\r\n  for (const source of sources) {\r\n    strandCount += source.pointCounts.length;\r\n    for (let i = 0; i < source.pointCounts.length; i++) {\r\n      pointCount += source.pointCounts[i];\r\n    }\r\n  }\r\n  const positions = new Float32Array(pointCount * 3);\r\n  const pointCounts = new Uint32Array(strandCount);\r\n  // A channel is only carried into the merge if every set has it: a partially\r\n  // filled width or UV array would read as zero for the sets that lacked it,\r\n  // which is worse than falling back to the defaults uniformly.\r\n  const hasWidths = sources.every((s) => !!s.widths);\r\n  const hasUV = sources.every((s) => !!s.uv);\r\n  // Per-point width and UV are the general case; a per-strand array is expanded\r\n  // rather than tracked, so the merged source has one layout to describe.\r\n  const widths = hasWidths ? new Float32Array(pointCount) : null;\r\n  const uv = hasUV ? new Float32Array(pointCount * 2) : null;\r\n  let strandOffset = 0;\r\n  let pointOffset = 0;\r\n  for (const source of sources) {\r\n    const counts = source.pointCounts;\r\n    const scale = source.scale ?? 1;\r\n    const sourceWidthScale = source.widthScale ?? 1;\r\n    let sourcePoints = 0;\r\n    for (let i = 0; i < counts.length; i++) {\r\n      sourcePoints += counts[i];\r\n    }\r\n    // `HairStrandSource` carries no per-point UV flag; it is inferred from the\r\n    // array length, and the inference has to match the one `HairStrandData`\r\n    // makes or the merged UVs would be read against a different layout.\r\n    const sourceUVPerPoint = !!source.uv && source.uv.length >= sourcePoints * 2;\r\n    let localPoint = 0;\r\n    for (let s = 0; s < counts.length; s++) {\r\n      const count = counts[s];\r\n      pointCounts[strandOffset + s] = count;\r\n      for (let i = 0; i < count; i++) {\r\n        const src = (localPoint + i) * 3;\r\n        const dst = (pointOffset + i) * 3;\r\n        // Per-source scale is baked in here, because the merged source carries a\r\n        // single scale and the sets may have come from files with different units.\r\n        positions[dst] = source.positions[src] * scale;\r\n        positions[dst + 1] = source.positions[src + 1] * scale;\r\n        positions[dst + 2] = source.positions[src + 2] * scale;\r\n        if (widths) {\r\n          const w = source.widthPerStrand ? source.widths![s] : source.widths![localPoint + i];\r\n          widths[pointOffset + i] = w * scale * sourceWidthScale;\r\n        }\r\n        if (uv) {\r\n          const uvSrc = source.uv!;\r\n          // Expanding a per-strand UV to per-point costs a little memory and\r\n          // removes a flag from everything downstream.\r\n          const o = sourceUVPerPoint ? (localPoint + i) * 2 : s * 2;\r\n          uv[(pointOffset + i) * 2] = uvSrc[o];\r\n          uv[(pointOffset + i) * 2 + 1] = uvSrc[o + 1];\r\n        }\r\n      }\r\n      localPoint += count;\r\n      pointOffset += count;\r\n    }\r\n    strandOffset += counts.length;\r\n  }\r\n  return {\r\n    positions,\r\n    pointCounts,\r\n    widths,\r\n    widthPerStrand: false,\r\n    uv,\r\n    // Everything has been converted already, so the merged source must not be\r\n    // scaled a second time.\r\n    scale: 1,\r\n    widthScale: 1,\r\n    defaultWidth: sources[0].defaultWidth\r\n  };\r\n}\r\n\r\n/**\r\n * Picks a stride that honours both `strandStride` and `maxStrands`.\r\n * @internal\r\n */\r\nfunction resolveStride(sets: ZHairStrandSetJSON[], options?: ZHairLoadOptions): number {\r\n  let stride = Math.max(1, Math.floor(options?.strandStride ?? 1));\r\n  const maxStrands = options?.maxStrands ?? 0;\r\n  if (maxStrands > 0) {\r\n    let total = 0;\r\n    for (const set of sets) {\r\n      total += Math.ceil(set.strandCount / stride);\r\n    }\r\n    if (total > maxStrands) {\r\n      let authored = 0;\r\n      for (const set of sets) {\r\n        authored += set.strandCount;\r\n      }\r\n      stride = Math.max(stride, Math.ceil(authored / maxStrands));\r\n    }\r\n  }\r\n  return stride;\r\n}\r\n\r\n/**\r\n * Decodes one strand set, keeping one strand in every `stride`.\r\n * @internal\r\n */\r\nfunction decodeStrandSet(\r\n  parsed: ParsedZHair,\r\n  set: ZHairStrandSetJSON,\r\n  stride: number,\r\n  scale: number,\r\n  widthScale: number\r\n): Nullable<HairStrandSource> {\r\n  const allCounts = readZHairUints(parsed, set.pointCounts);\r\n  const allPositions = readZHairFloats(parsed, set.positions)!;\r\n  const allWidths = readZHairFloats(parsed, set.widths);\r\n  const allUV = readZHairFloats(parsed, set.uv);\r\n  const widthPerStrand = !!set.widthPerStrand;\r\n  const uvPerPoint = !!set.uvPerPoint;\r\n\r\n  if (stride <= 1) {\r\n    return {\r\n      positions: allPositions,\r\n      pointCounts: allCounts,\r\n      widths: allWidths,\r\n      widthPerStrand,\r\n      uv: allUV,\r\n      scale,\r\n      widthScale\r\n    };\r\n  }\r\n\r\n  // Walking the whole count array is unavoidable even when most strands are\r\n  // dropped, because a strand's first point index is the sum of all counts\r\n  // before it and the file stores no index.\r\n  const keptStrands: number[] = [];\r\n  const firstPoints: number[] = [];\r\n  let first = 0;\r\n  let keptPoints = 0;\r\n  for (let s = 0; s < allCounts.length; s++) {\r\n    if (s % stride === 0) {\r\n      keptStrands.push(s);\r\n      firstPoints.push(first);\r\n      keptPoints += allCounts[s];\r\n    }\r\n    first += allCounts[s];\r\n  }\r\n  if (keptStrands.length === 0 || keptPoints === 0) {\r\n    return null;\r\n  }\r\n\r\n  const positions = new Float32Array(keptPoints * 3);\r\n  const pointCounts = new Uint32Array(keptStrands.length);\r\n  const widths = allWidths ? new Float32Array(widthPerStrand ? keptStrands.length : keptPoints) : null;\r\n  const uv = allUV ? new Float32Array((uvPerPoint ? keptPoints : keptStrands.length) * 2) : null;\r\n  let dstPoint = 0;\r\n  for (let k = 0; k < keptStrands.length; k++) {\r\n    const s = keptStrands[k];\r\n    const count = allCounts[s];\r\n    const srcFirst = firstPoints[k];\r\n    pointCounts[k] = count;\r\n    positions.set(allPositions.subarray(srcFirst * 3, (srcFirst + count) * 3), dstPoint * 3);\r\n    if (widths) {\r\n      if (widthPerStrand) {\r\n        widths[k] = allWidths![s];\r\n      } else {\r\n        widths.set(allWidths!.subarray(srcFirst, srcFirst + count), dstPoint);\r\n      }\r\n    }\r\n    if (uv) {\r\n      if (uvPerPoint) {\r\n        uv.set(allUV!.subarray(srcFirst * 2, (srcFirst + count) * 2), dstPoint * 2);\r\n      } else {\r\n        uv[k * 2] = allUV![s * 2];\r\n        uv[k * 2 + 1] = allUV![s * 2 + 1];\r\n      }\r\n    }\r\n    dstPoint += count;\r\n  }\r\n  return {\r\n    positions,\r\n    pointCounts,\r\n    widths,\r\n    widthPerStrand,\r\n    uv,\r\n    scale,\r\n    widthScale\r\n  };\r\n}\r\n"],"names":["loadZHairStrandSources","parsed","options","sets","content","strandSets","scale","unitScale","widthScale","stride","resolveStride","sources","set","source","decodeStrandSet","push","mergeHairStrandSources","length","strandCount","pointCount","pointCounts","i","positions","Float32Array","Uint32Array","hasWidths","every","s","widths","hasUV","uv","strandOffset","pointOffset","counts","sourceWidthScale","sourcePoints","sourceUVPerPoint","localPoint","count","src","dst","w","widthPerStrand","uvSrc","o","defaultWidth","Math","max","floor","strandStride","maxStrands","total","ceil","authored","allCounts","readZHairUints","allPositions","readZHairFloats","allWidths","allUV","uvPerPoint","keptStrands","firstPoints","first","keptPoints","dstPoint","k","srcFirst","subarray"],"mappings":"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"}