@forgeax/engine-geometry 0.1.20 → 0.1.21

package/dist/index.mjs

@@ -1114,6 +1114,9 @@ function normalizeMeshPayload(payload, refs) {
   if (payload === null || typeof payload !== "object" || Array.isArray(payload)) return void 0;
   const source = payload;
   if (source.kind !== "mesh") return void 0;
+  const sourceAttributes = source.attributes !== null && typeof source.attributes === "object" ? source.attributes : void 0;
+  const projection = sourceAttributes === void 0 ? void 0 : deriveVertexLayoutProjection(sourceAttributes);
+  const floatsPerVertex = projection === void 0 || projection.attributes.length === 0 ? PROCEDURAL_FLOATS_PER_VERTEX : projection.arrayStride / Float32Array.BYTES_PER_ELEMENT;
   return meshFromParts(
     {
       vertices: source.vertices,
@@ -1124,7 +1127,7 @@ function normalizeMeshPayload(payload, refs) {
       ...Array.isArray(source.materialSlots) ? { materialSlots: source.materialSlots } : {},
       ...source.morphTargets === void 0 ? {} : { morphTargets: source.morphTargets },
       ...source.morphWeights === void 0 ? {} : { morphWeights: source.morphWeights },
-      floatsPerVertex: PROCEDURAL_FLOATS_PER_VERTEX
+      floatsPerVertex
     },
     refs
   );
@@ -2325,6 +2328,367 @@ function createEdgesGeometry(source, thresholdAngleDegrees = DEFAULT_THRESHOLD_D
   );
   return lineMesh(edges.map(({ a, b }) => ({ a, b })));
 }
+var ATTRIBUTE_KEYS = [
+  "position",
+  "normal",
+  "uv",
+  "tangent",
+  "skinIndex",
+  "skinWeight",
+  "uv1",
+  "uv2",
+  "uv3",
+  "uv4",
+  "uv5",
+  "uv6",
+  "uv7",
+  "color"
+];
+var ATTRIBUTE_COMPONENTS = {
+  position: 3,
+  normal: 3,
+  uv: 2,
+  tangent: 4,
+  skinIndex: 4,
+  skinWeight: 4,
+  uv1: 2,
+  uv2: 2,
+  uv3: 2,
+  uv4: 2,
+  uv5: 2,
+  uv6: 2,
+  uv7: 2,
+  color: 4
+};
+var TOPOLOGIES = [
+  "point-list",
+  "line-list",
+  "line-strip",
+  "triangle-list",
+  "triangle-strip"
+];
+function failure(field, value, reason) {
+  return err(
+    new AssetError({
+      code: "asset-invalid-value",
+      expected: `valid MeshBuilder ${field}: ${reason}`,
+      hint: ASSET_ERROR_HINTS["asset-invalid-value"],
+      detail: { field, value, reason }
+    })
+  );
+}
+function sourceView(key, value) {
+  if (key === "skinIndex") {
+    if (value instanceof Uint16Array) return value;
+    if (value instanceof ArrayBuffer && value.byteLength % Uint16Array.BYTES_PER_ELEMENT === 0) {
+      return new Uint16Array(value);
+    }
+    return void 0;
+  }
+  if (value instanceof Float32Array) return value;
+  if (value instanceof ArrayBuffer && value.byteLength % Float32Array.BYTES_PER_ELEMENT === 0) {
+    return new Float32Array(value);
+  }
+  return void 0;
+}
+function cloneAttribute(key, value) {
+  const view = sourceView(key, value);
+  if (view === void 0) return void 0;
+  return view.slice();
+}
+function attributeKeys(attributes) {
+  return ATTRIBUTE_KEYS.filter((key) => attributes[key] !== void 0);
+}
+function appendArray(target, source) {
+  if (target instanceof Uint16Array && source instanceof Uint16Array) {
+    const output = new Uint16Array(target.length + source.length);
+    output.set(target, 0);
+    output.set(source, target.length);
+    return output;
+  }
+  if (target instanceof Float32Array && source instanceof Float32Array) {
+    const output = new Float32Array(target.length + source.length);
+    output.set(target, 0);
+    output.set(source, target.length);
+    return output;
+  }
+  return target;
+}
+function copySlots(slots) {
+  return (slots ?? [{ slotName: "Default" }]).map((slot) => ({
+    slotName: slot.slotName,
+    ...slot.sourceKey === void 0 ? {} : { sourceKey: slot.sourceKey },
+    ...slot.defaultMaterial === void 0 ? {} : { defaultMaterial: slot.defaultMaterial }
+  }));
+}
+function validateAttributeBatch(attributes) {
+  const keys = attributeKeys(attributes);
+  if (keys.length === 0)
+    return failure("attributes", [], "at least one canonical attribute is required");
+  const position = attributes.position;
+  if (position === void 0)
+    return failure("attributes.position", void 0, "position is required");
+  const positionView = sourceView("position", position);
+  if (positionView === void 0) {
+    return failure(
+      "attributes.position",
+      typeof position,
+      "position must use Float32Array or ArrayBuffer"
+    );
+  }
+  if (positionView.length === 0 || positionView.length % 3 !== 0) {
+    return failure(
+      "attributes.position",
+      positionView.length,
+      "position cardinality must be a non-zero multiple of 3"
+    );
+  }
+  const vertexCount = positionView.length / 3;
+  for (const key of keys) {
+    const value = attributes[key];
+    if (value === void 0) continue;
+    const view = sourceView(key, value);
+    if (view === void 0) {
+      return failure(
+        key,
+        typeof value,
+        key === "skinIndex" ? "storage must be Uint16Array" : "storage must be Float32Array"
+      );
+    }
+    const expectedLength = vertexCount * ATTRIBUTE_COMPONENTS[key];
+    if (view.length !== expectedLength) {
+      return failure(key, view.length, `cardinality must be ${expectedLength}`);
+    }
+    for (let elementIndex = 0; elementIndex < view.length; elementIndex += 1) {
+      const valueAt = view[elementIndex];
+      if (valueAt === void 0 || !Number.isFinite(valueAt)) {
+        return failure(key, valueAt, `${key}[${elementIndex}] must be finite`);
+      }
+      if (key === "skinIndex" && (!Number.isInteger(valueAt) || valueAt < 0 || valueAt > 65535)) {
+        return failure(key, valueAt, `${key}[${elementIndex}] must be an integer in [0, 65535]`);
+      }
+    }
+  }
+  return ok({ keys, vertexCount });
+}
+function validateSlots(slots) {
+  if (slots.length === 0)
+    return failure("materialSlots", slots.length, "at least one material slot is required");
+  const names = /* @__PURE__ */ new Set();
+  for (let index = 0; index < slots.length; index += 1) {
+    const slot = slots[index];
+    const name = slot?.slotName.trim() ?? "";
+    if (name.length === 0 || names.has(name)) {
+      return failure(`materialSlots[${index}].slotName`, name, "must be non-empty and unique");
+    }
+    names.add(name);
+  }
+  return ok(void 0);
+}
+function completedSubmeshes(requested, vertexCount, indexCount, materialSlotCount) {
+  const source = requested.length === 0 ? [
+    {
+      indexOffset: 0,
+      indexCount,
+      vertexCount,
+      topology: "triangle-list",
+      materialSlot: 0
+    }
+  ] : requested;
+  const output = [];
+  for (let index = 0; index < source.length; index += 1) {
+    const candidate = source[index];
+    if (candidate === void 0)
+      return failure(`submeshes[${index}]`, void 0, "entry is required");
+    const indexOffset = candidate.indexOffset ?? 0;
+    const submeshIndexCount = candidate.indexCount ?? (indexCount > 0 ? indexCount : 0);
+    const submeshVertexCount = candidate.vertexCount ?? vertexCount;
+    const topology = candidate.topology ?? "triangle-list";
+    const materialSlot = candidate.materialSlot ?? index;
+    if (!TOPOLOGIES.includes(topology)) {
+      return failure(
+        `submeshes[${index}].topology`,
+        topology,
+        "must be a WebGPU primitive topology"
+      );
+    }
+    if (!Number.isInteger(indexOffset) || indexOffset < 0 || !Number.isInteger(submeshIndexCount) || submeshIndexCount < 0 || !Number.isInteger(submeshVertexCount) || submeshVertexCount < 0 || submeshVertexCount > vertexCount || !Number.isInteger(materialSlot) || materialSlot < 0 || materialSlot >= materialSlotCount) {
+      return failure(
+        `submeshes[${index}]`,
+        JSON.stringify(candidate),
+        "range and material slot are invalid"
+      );
+    }
+    if (indexCount === 0 && (indexOffset !== 0 || submeshIndexCount !== 0)) {
+      return failure(
+        `submeshes[${index}]`,
+        JSON.stringify(candidate),
+        "non-indexed meshes use indexOffset=0 and indexCount=0"
+      );
+    }
+    if (indexCount > 0 && indexOffset + submeshIndexCount > indexCount) {
+      return failure(
+        `submeshes[${index}]`,
+        JSON.stringify(candidate),
+        "index range exceeds the accumulated index buffer"
+      );
+    }
+    if (indexCount === 0 && (topology === "line-strip" || topology === "triangle-strip")) {
+      return failure(
+        `submeshes[${index}].topology`,
+        topology,
+        "strip topology requires an index buffer"
+      );
+    }
+    output.push({
+      indexOffset,
+      indexCount: submeshIndexCount,
+      vertexCount: submeshVertexCount,
+      topology,
+      materialSlot
+    });
+  }
+  return ok(Object.freeze(output));
+}
+function createMeshBuilder(options = {}) {
+  const attributes = {};
+  const indices = [];
+  const submeshes = [];
+  const materialSlots = copySlots(options.materialSlots);
+  const appendVertices = (batch) => {
+    const checked = validateAttributeBatch(batch);
+    if (!checked.ok) return checked;
+    const incomingKeys = checked.value.keys;
+    const existingKeys = ATTRIBUTE_KEYS.filter((key) => attributes[key] !== void 0);
+    if (existingKeys.length > 0 && existingKeys.join("|") !== incomingKeys.join("|")) {
+      return failure(
+        "attributes",
+        incomingKeys.join(","),
+        "every appended batch must carry the same canonical keys"
+      );
+    }
+    for (const key of incomingKeys) {
+      const value = batch[key];
+      if (value === void 0) continue;
+      const cloned = cloneAttribute(key, value);
+      if (cloned === void 0) return failure(key, typeof value, "storage could not be cloned");
+      const previous = attributes[key];
+      attributes[key] = previous === void 0 ? cloned : appendArray(previous, cloned);
+    }
+    return ok(void 0);
+  };
+  const appendIndices = (batch) => {
+    for (let index = 0; index < batch.length; index += 1) {
+      const value = Number(batch[index]);
+      if (!Number.isInteger(value) || value < 0 || value > 4294967295) {
+        return failure("indices", value, `indices[${index}] must be an integer in [0, 2^32-1]`);
+      }
+      indices.push(value);
+    }
+    return ok(void 0);
+  };
+  const addSubmesh = (submesh) => {
+    if (submesh === null || typeof submesh !== "object") {
+      return failure("submeshes", submesh, "entry must be an object");
+    }
+    submeshes.push({ ...submesh });
+    return ok(void 0);
+  };
+  const build = () => {
+    const source = attributes;
+    const checked = validateAttributeBatch(source);
+    if (!checked.ok) return checked;
+    const slotCheck = validateSlots(materialSlots);
+    if (!slotCheck.ok) return slotCheck;
+    const vertexCount = checked.value.vertexCount;
+    const position = source.position;
+    if (position === void 0)
+      return failure("attributes.position", void 0, "position is required");
+    const positionView = sourceView("position", position);
+    if (!(positionView instanceof Float32Array)) {
+      return failure("attributes.position", typeof position, "position storage is invalid");
+    }
+    let maxIndex = 0;
+    for (const value of indices) maxIndex = Math.max(maxIndex, value);
+    const indexArray2 = indices.length === 0 ? void 0 : maxIndex <= 65535 ? new Uint16Array(indices) : new Uint32Array(indices);
+    if (indexArray2 !== void 0) {
+      for (let index = 0; index < indexArray2.length; index += 1) {
+        const value = indexArray2[index];
+        if (value === void 0 || value >= vertexCount) {
+          return failure(
+            "indices",
+            value ?? -1,
+            `indices[${index}] must be less than vertexCount (${vertexCount})`
+          );
+        }
+      }
+    }
+    const packed = packInterleavedVertexAttributes(source, vertexCount);
+    if (!packed.ok) return packed;
+    const ranges = completedSubmeshes(
+      submeshes,
+      vertexCount,
+      indexArray2?.length ?? 0,
+      materialSlots.length
+    );
+    if (!ranges.ok) return ranges;
+    const aabb = box3.fromPositions(box3.create(), positionView);
+    const copiedAttributes = {};
+    for (const key of checked.value.keys) {
+      const value = source[key];
+      if (value === void 0) continue;
+      const cloned = cloneAttribute(key, value);
+      if (cloned === void 0) return failure(key, typeof value, "storage could not be cloned");
+      if (key === "skinIndex") {
+        if (!(cloned instanceof Uint16Array)) {
+          return failure(key, typeof value, "skinIndex storage must be Uint16Array");
+        }
+        copiedAttributes.skinIndex = cloned;
+      } else {
+        if (!(cloned instanceof Float32Array)) {
+          return failure(key, typeof value, `${key} storage must be Float32Array`);
+        }
+        copiedAttributes[key] = cloned;
+      }
+    }
+    const mesh = {
+      kind: "mesh",
+      vertices: packed.value.vertices.slice(),
+      ...indexArray2 === void 0 ? {} : { indices: indexArray2.slice() },
+      attributes: copiedAttributes,
+      aabb: Float32Array.from(aabb),
+      submeshes: ranges.value,
+      materialSlots: Object.freeze(materialSlots.map((slot) => ({ ...slot })))
+    };
+    return ok(Object.freeze(mesh));
+  };
+  if (options.attributes !== void 0) {
+    const result = appendVertices(options.attributes);
+    if (!result.ok) {
+      const constructionError = result.error;
+      return {
+        appendVertices,
+        appendIndices,
+        addSubmesh,
+        build: () => err(constructionError)
+      };
+    }
+  }
+  if (options.indices !== void 0) {
+    const result = appendIndices(options.indices);
+    if (!result.ok) {
+      const constructionError = result.error;
+      return {
+        appendVertices,
+        appendIndices,
+        addSubmesh,
+        build: () => err(constructionError)
+      };
+    }
+  }
+  for (const submesh of options.submeshes ?? []) submeshes.push({ ...submesh });
+  return { appendVertices, appendIndices, addSubmesh, build };
+}
 var PATCHES = new Uint16Array([
   0,
   1,
@@ -3901,6 +4265,6 @@ function createTorusGeometry(radius, tube, radialSegments = 8, tubularSegments =
   return meshFromInterleaved(vertices, indices);
 }
 
-export { PROCEDURAL_FLOATS_PER_VERTEX, VertexAttributePackError, buildMeshAttributeMapForUvSets, compute2dBounds, computeTangentVec4, create2dGeometry, create2dRingGeometry, createBoxGeometry, createCapsuleGeometry, createConeGeometry, createCylinderGeometry, createEdgesGeometry, createPlaneGeometry, createPrimitiveMesh, createSphereGeometry, createTeapotGeometry, createTorusGeometry, createWireframeGeometry, deriveVertexBufferLayout, deriveVertexBufferLayoutFromProjection, deriveVertexLayoutProjection, deriveVertexLayoutProjectionFromMask, meshAssetContribution, meshAssetDecoder, meshAssetKind, meshFromInterleaved, packInterleavedVertexAttributes };
+export { PROCEDURAL_FLOATS_PER_VERTEX, VertexAttributePackError, buildMeshAttributeMapForUvSets, compute2dBounds, computeTangentVec4, create2dGeometry, create2dRingGeometry, createBoxGeometry, createCapsuleGeometry, createConeGeometry, createCylinderGeometry, createEdgesGeometry, createMeshBuilder, createPlaneGeometry, createPrimitiveMesh, createSphereGeometry, createTeapotGeometry, createTorusGeometry, createWireframeGeometry, deriveVertexBufferLayout, deriveVertexBufferLayoutFromProjection, deriveVertexLayoutProjection, deriveVertexLayoutProjectionFromMask, meshAssetContribution, meshAssetDecoder, meshAssetKind, meshFromInterleaved, packInterleavedVertexAttributes };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map