@forgeax/engine-render 0.1.3 → 0.1.6

package/src/record/material-payload.ts

@@ -1,292 +0,0 @@
-import type { DerivedMaterialInterface, ParamSchemaEntry } from '@forgeax/engine-types';
-import {
-  createMaterialError,
-  type derive,
-  err,
-  type MaterialError,
-  ok,
-  type Result,
-  resolveMaterialTextureCoordinates,
-} from '@forgeax/engine-types';
-import {
-  deriveParamSchemaForCensus,
-  type ParamSchemaProjectionCensus,
-} from '../param-schema-projection-census';
-import type { MaterialSnapshot } from '../render-system-extract';
-
-export type MaterialUboPayload = ArrayBuffer | Uint8Array | Float32Array;
-
-export function materialUboFloatView(payload: MaterialUboPayload): Float32Array {
-  if (payload instanceof Float32Array) return payload;
-  return payload instanceof Uint8Array
-    ? new Float32Array(payload.buffer, payload.byteOffset, payload.byteLength / 4)
-    : new Float32Array(payload);
-}
-
-export function derivedParamSchema(
-  schema: readonly ParamSchemaEntry[],
-  paramSchemaProjectionCensus?: ParamSchemaProjectionCensus,
-): ReturnType<typeof derive> {
-  return deriveParamSchemaForCensus(schema, paramSchemaProjectionCensus, 'record-payload');
-}
-
-export function materialBindingByteLength(
-  schema: readonly ParamSchemaEntry[] | undefined,
-  fallbackBytes: number,
-  paramSchemaProjectionCensus?: ParamSchemaProjectionCensus,
-): number {
-  if (schema === undefined) return fallbackBytes;
-  return derivedParamSchema(schema, paramSchemaProjectionCensus).totalBytes || fallbackBytes;
-}
-
-export interface DerivedMaterialPayloadCoordinate {
-  readonly set?: number;
-  readonly transform?: {
-    readonly offset?: readonly [number, number];
-    readonly scale?: readonly [number, number];
-    readonly rotation?: number;
-  };
-  readonly physicalUvScale?: readonly [number, number];
-}
-
-export interface DerivedMaterialSlotPlan {
-  readonly layout: ReturnType<typeof derive>['uboLayout'];
-  readonly numericMembers: ReturnType<typeof derive>['numericMembers'];
-  readonly coordinateRecords: ReturnType<typeof derive>['coordinateRecords'];
-  readonly layoutIdentity: string;
-  readonly totalBytes: number;
-}
-
-export interface DerivedMaterialPayloadInput {
-  readonly material: string;
-  readonly schema: readonly ParamSchemaEntry[] | undefined;
-  readonly projection?: DerivedMaterialInterface;
-  readonly values: Readonly<Record<string, number | readonly number[] | string | undefined>>;
-  readonly coordinates:
-    | Readonly<Record<string, DerivedMaterialPayloadCoordinate>>
-    | ReadonlyMap<string, DerivedMaterialPayloadCoordinate>;
-  readonly capacityBytes?: number;
-  readonly paramSchemaProjectionCensus?: ParamSchemaProjectionCensus;
-}
-
-export function createDerivedMaterialSlotPlan(
-  schema: readonly ParamSchemaEntry[],
-): DerivedMaterialSlotPlan {
-  const derived = derivedParamSchema(schema);
-  return {
-    layout: derived.uboLayout,
-    numericMembers: derived.numericMembers,
-    coordinateRecords: derived.coordinateRecords,
-    layoutIdentity: derived.layoutIdentity,
-    totalBytes: derived.totalBytes,
-  };
-}
-
-export function writeDerivedMaterialPayload(
-  input: DerivedMaterialPayloadInput,
-): Result<Uint8Array, MaterialError> {
-  if (input.schema === undefined) {
-    return err(
-      createMaterialError('material-derived-interface-mismatch', {
-        code: 'material-derived-interface-mismatch',
-        stage: 'record',
-        material: input.material,
-        layoutIdentity: 'unknown',
-        action: 'recook',
-      }),
-    );
-  }
-  let derived: ReturnType<typeof derive>;
-  try {
-    derived =
-      input.projection ?? derivedParamSchema(input.schema, input.paramSchemaProjectionCensus);
-  } catch {
-    return err(
-      createMaterialError('material-derived-interface-mismatch', {
-        code: 'material-derived-interface-mismatch',
-        stage: 'record',
-        material: input.material,
-        layoutIdentity: 'unknown',
-        action: 'recook',
-      }),
-    );
-  }
-  const capacityBytes = input.capacityBytes ?? derived.totalBytes;
-  if (capacityBytes < derived.totalBytes) {
-    return err(
-      createMaterialError('material-payload-bounds', {
-        code: 'material-payload-bounds',
-        stage: 'record',
-        material: input.material,
-        layoutIdentity: derived.layoutIdentity,
-        slot: input.material,
-        byteOffset: 0,
-        byteLength: derived.totalBytes,
-        payloadBytes: capacityBytes,
-        action: 'stop-draw',
-      }),
-    );
-  }
-  const payload = new Uint8Array(derived.totalBytes);
-  const view = new DataView(payload.buffer, payload.byteOffset, payload.byteLength);
-  const defaults = new Map(input.schema.map((entry) => [entry.name, entry.default]));
-  for (const member of derived.numericMembers) {
-    const defaultValue = defaults.get(member.name);
-    const value =
-      input.values[member.name] ??
-      (typeof defaultValue === 'number' ||
-      typeof defaultValue === 'string' ||
-      (Array.isArray(defaultValue) && defaultValue.every((item) => typeof item === 'number'))
-        ? defaultValue
-        : undefined);
-    if (value === undefined) continue;
-    if (value === null) continue;
-    const valueWithDefaultLanes = mergeNumericValueWithDefault(value, defaultValue);
-    if (!writeNumericValue(view, member, valueWithDefaultLanes)) {
-      return err(
-        createMaterialError('material-payload-bounds', {
-          code: 'material-payload-bounds',
-          stage: 'record',
-          material: input.material,
-          layoutIdentity: derived.layoutIdentity,
-          slot: input.material,
-          byteOffset: member.offset,
-          byteLength: member.size,
-          payloadBytes: payload.byteLength,
-          action: 'stop-draw',
-        }),
-      );
-    }
-  }
-  for (const record of derived.coordinateRecords) {
-    const coordinates = coordinateFor(input.coordinates, record.parameter);
-    const resolved = resolveMaterialTextureCoordinates(coordinates);
-    const values = [
-      resolved.transform.offset[0],
-      resolved.transform.offset[1],
-      resolved.transform.scale[0],
-      resolved.transform.scale[1],
-      resolved.set,
-      resolved.transform.rotation,
-      coordinates?.physicalUvScale?.[0] ?? 1,
-      coordinates?.physicalUvScale?.[1] ?? 1,
-    ];
-    const reason = values.every(Number.isFinite) === false ? 'non-finite' : undefined;
-    if (reason !== undefined) {
-      return err(
-        createMaterialError('material-texture-coordinate-invalid', {
-          code: 'material-texture-coordinate-invalid',
-          stage: 'record',
-          material: input.material,
-          layoutIdentity: derived.layoutIdentity,
-          parameter: record.parameter,
-          slot: input.material,
-          reason,
-          action: 'recook',
-        }),
-      );
-    }
-    for (const [index, value] of values.entries()) {
-      view.setFloat32(record.offset + index * 4, value as number, true);
-    }
-  }
-  return ok(payload);
-}
-
-function mergeNumericValueWithDefault(
-  value: number | readonly number[] | string,
-  defaultValue: unknown,
-): number | readonly number[] | string {
-  if (
-    !Array.isArray(value) ||
-    value.length === 0 ||
-    !Array.isArray(defaultValue) ||
-    defaultValue.some((item) => typeof item !== 'number')
-  ) {
-    return value;
-  }
-  return defaultValue.map((fallback, index) => value[index] ?? fallback);
-}
-
-/**
- * Build one record-stage payload from the typed extract projection. The record
- * path does not reconstruct authored values or texture coordinates: the
- * projection is the only input that can satisfy the derived interface.
- */
-export function writeMaterialSnapshotPayload(
-  material: MaterialSnapshot,
-  capacityBytes?: number,
-  paramSchemaProjectionCensus?: ParamSchemaProjectionCensus,
-): Result<Uint8Array, MaterialError> {
-  if (material.derivedMaterialError !== undefined) return err(material.derivedMaterialError);
-  const projection = material.derivedMaterialSlot;
-  return writeDerivedMaterialPayload({
-    material: String(material.materialHandle ?? material.materialShaderId ?? 'material'),
-    schema: material.materialParamSchema,
-    ...(projection === undefined ? {} : { projection: projection.derivedInterface }),
-    values: projection?.numericValues ?? material.paramSnapshot ?? {},
-    coordinates: projection?.coordinates ?? material.textureCoordinates ?? new Map(),
-    ...(paramSchemaProjectionCensus === undefined ? {} : { paramSchemaProjectionCensus }),
-    ...(capacityBytes === undefined ? {} : { capacityBytes }),
-  });
-}
-
-function coordinateFor(
-  coordinates: DerivedMaterialPayloadInput['coordinates'],
-  parameter: string,
-): DerivedMaterialPayloadCoordinate | undefined {
-  if (
-    typeof (coordinates as ReadonlyMap<string, DerivedMaterialPayloadCoordinate>).get === 'function'
-  ) {
-    return (coordinates as ReadonlyMap<string, DerivedMaterialPayloadCoordinate>).get(parameter);
-  }
-  return (coordinates as Readonly<Record<string, DerivedMaterialPayloadCoordinate>>)[parameter];
-}
-
-function writeNumericValue(
-  view: DataView,
-  member: ReturnType<typeof derive>['numericMembers'][number],
-  value: number | readonly number[] | string,
-): boolean {
-  const values = typeof value === 'number' ? [value] : Array.isArray(value) ? value : [];
-  if (values.length === 0 || values.some((item) => !Number.isFinite(item))) return false;
-  if (member.type === 'i32') view.setInt32(member.offset, values[0] ?? 0, true);
-  else if (member.type === 'u32') view.setUint32(member.offset, values[0] ?? 0, true);
-  else {
-    for (const [index, item] of values.entries()) {
-      if (index * 4 >= member.size) break;
-      view.setFloat32(member.offset + index * 4, item, true);
-    }
-  }
-  return true;
-}
-
-export function applyParamSnapshotToUbo(
-  payload: MaterialUboPayload,
-  paramSchema: readonly ParamSchemaEntry[] | undefined,
-  paramSnapshot:
-    | Readonly<Record<string, number | readonly number[] | string | undefined>>
-    | undefined,
-  paramSchemaProjectionCensus?: ParamSchemaProjectionCensus,
-): void {
-  if (paramSchema === undefined || paramSnapshot === undefined) return;
-  const f32 = materialUboFloatView(payload);
-  const { uboLayout } = derivedParamSchema(paramSchema, paramSchemaProjectionCensus);
-  for (const entry of uboLayout.entries) {
-    const value = paramSnapshot[entry.name];
-    if (value === undefined) continue;
-    const f32Offset = entry.offset / 4;
-    const f32Width = entry.size / 4;
-    if (typeof value === 'number') {
-      if (f32Width >= 1) f32[f32Offset] = value;
-      continue;
-    }
-    if (Array.isArray(value)) {
-      const writeCount = Math.min(value.length, f32Width);
-      for (let index = 0; index < writeCount; index++) {
-        const item = value[index];
-        if (typeof item === 'number') f32[f32Offset + index] = item;
-      }
-    }
-  }
-}

package/src/record/material-slot-plan.ts

@@ -1,68 +0,0 @@
-/**
- * A frame-local material table. Repeated snapshot objects share one UBO slot;
- * each renderable keeps only the slot index used by each authored material.
- */
-export interface MaterialSlotPlan<T extends object> {
-  readonly slotIndices: readonly (readonly number[])[];
-  readonly slots: readonly T[];
-  /** Index of the first renderable that referenced each slot. */
-  readonly slotOwners: readonly number[];
-}
-
-/**
- * Intern identical material snapshots into one frame-local slot table.
- * Snapshot identity is the extract layer's invalidation token, so this keeps
- * the same correctness boundary while avoiding duplicate payload assembly and
- * upload for repeated scene instances.
- */
-export function buildMaterialSlotPlan<T extends object>(
-  materialGroups: readonly (readonly T[])[],
-): MaterialSlotPlan<T> {
-  const slotByMaterial = new Map<T, number>();
-  const slots: T[] = [];
-  const slotOwners: number[] = [];
-  const slotIndices = materialGroups.map((materials, ownerIndex) =>
-    materials.map((material) => {
-      const cached = slotByMaterial.get(material);
-      if (cached !== undefined) return cached;
-      const slot = slots.length;
-      slots.push(material);
-      slotOwners.push(ownerIndex);
-      slotByMaterial.set(material, slot);
-      return slot;
-    }),
-  );
-  return { slotIndices, slots, slotOwners };
-}
-
-/**
- * Return the largest complete renderable prefix supported by a shared
- * mesh/material capacity. Mesh rows consume one slot per renderable; material
- * rows use the deduplicated slot indices assigned in first-seen order.
- */
-export function findRenderablePrefixForSlotCapacity(
-  materialSlotIndices: readonly (readonly number[])[],
-  slotCapacity: number,
-): number {
-  const capacity = Math.max(0, Math.floor(slotCapacity));
-  const maxRenderableCount = Math.min(materialSlotIndices.length, capacity);
-  let renderableCount = 0;
-  while (renderableCount < maxRenderableCount) {
-    const slots = materialSlotIndices[renderableCount] ?? [];
-    if (slots.some((slot) => slot >= capacity)) break;
-    renderableCount += 1;
-  }
-  return renderableCount;
-}
-
-/** Count material slots reachable from a prefix of a first-seen slot plan. */
-export function materialSlotCountForPrefix(
-  materialSlotIndices: readonly (readonly number[])[],
-  renderableCount: number,
-): number {
-  let maxSlot = -1;
-  for (let index = 0; index < renderableCount; index += 1) {
-    for (const slot of materialSlotIndices[index] ?? []) maxSlot = Math.max(maxSlot, slot);
-  }
-  return maxSlot + 1;
-}