@forgeax/engine-render 0.1.4 → 0.1.6

package/dist/components/skylight.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Skylight ambient environment light.
+ *
+ * A single Skylight entity provides ambient lighting for all StandardMaterial
+ * surfaces. Two modes share one component:
+ *
+ * - **Solid-color ambient (no equirect).** Omit `equirect` for a constant
+ *   ambient = `color` * `intensity` applied immediately, with no async GPU
+ *   precompute. The engine samples a built-in 1x1 white irradiance cube, so a
+ *   freshly-loaded scene is lit on its first frame instead of being black
+ *   until an IBL upload finishes.
+ * - **Image-based lighting (with equirect).** Supply `equirect` to upgrade to
+ *   diffuse irradiance + specular prefilter IBL. The engine runs the full
+ *   precompute (equirect->cubemap, irradiance convolution, prefilter mip
+ *   chain, BRDF LUT) transparently inside the render-system record arm;
+ *   `color` * `intensity` then scale the IBL ambient.
+ *
+ * `equirect` is an OPTIONAL `Handle<EquirectAsset>` resolved from a vite
+ * pack-index GUID via `engine.assets.loadByGuid<EquirectAsset>(guid)`. The
+ * cubemap projection is internal and idempotent: the same equirect source
+ * always resolves to the same GPU cubemap (no user upload call).
+ *
+ * `color` is the linear-space ambient tint (default white [1, 1, 1]).
+ * `intensity` is a linear multiplier (default 1.0; 0 disables ambient). Both
+ * are read every frame, so they are live dynamic dials.
+ *
+ * `rotation` is an environment-space quaternion in `[x, y, z, w]` order.
+ * The default identity quaternion leaves the source orientation unchanged;
+ * changing it rotates the IBL at sample time without rebaking the source.
+ *
+ * @example Instant white ambient (no asset, no async):
+ *   world.spawn({ component: Skylight, data: {} });
+ *
+ * @example Dim warm ambient:
+ *   world.spawn({ component: Skylight, data: { color: [1, 0.9, 0.8], intensity: 0.3 } }); // color is [r, g, b]
+ *
+ * @example Full IBL from an HDR equirect (declarative -- no upload call):
+ *   // 1. resolve GUID from vite pack-index (see forgeax-engine-vite-plugin-pack)
+ *   import { AssetGuid } from '@forgeax/engine-pack/guid';
+ *   const guidRes = AssetGuid.parse('019e4a26-3c29-7420-af5d-20f2724a16b0');
+ *   if (!guidRes.ok) throw guidRes.error;
+ *   // 2. load the HDR equirect via the GUID-addressed pack route
+ *   const hdrRes = await engine.assets.loadByGuid<EquirectAsset>(guidRes.value);
+ *   if (!hdrRes.ok) throw hdrRes.error;
+ *   // 3. spawn the Skylight — the equirect handle activates the full IBL path;
+ *   //    the cubemap + IBL precompute happen lazily inside the record arm.
+ *   world.spawn({ component: Skylight, data: { equirect: hdrRes.value } });
+ */
+export declare const Skylight: import("@forgeax/engine-ecs").Component<"Skylight", {
+    readonly equirect: "shared<EquirectAsset>";
+    readonly color: "array<f32, 3>";
+    readonly intensity: "f32";
+    readonly rotation: "array<f32, 4>";
+}>;
+//# sourceMappingURL=skylight.d.ts.map

package/dist/components/skylight.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skylight.d.ts","sourceRoot":"","sources":["../../src/components/skylight.ts"],"names":[],"mappings":"AAsCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,eAAO,MAAM,QAAQ;;;;;EAUnB,CAAC"}

package/dist/components/sprite-animation.d.ts

@@ -27,8 +27,7 @@
  *     SpriteAnimation, SpriteRegionOverride, SPRITE_PLAYBACK_MODE_LOOP,
  *   } from '@forgeax/engine-render/authoring';
  *   import { Transform } from '@forgeax/engine-scene';
- *   import { createPrimitiveMesh } from '@forgeax/engine-geometry';
- *   const quadMesh = world.internSharedRef(createPrimitiveMesh('quad').unwrap());
+ *   import { HANDLE_QUAD } from '@forgeax/engine-assets-runtime';
  *
  *   // 4 frames packed in an atlas, each 64x64 inside a 256x64 row:
  *   const regions = new Float32Array([
@@ -40,7 +39,7 @@
  *   world.spawn(
  *     { component: Transform, data: { pos: [0, 0, 0],
  *       quat: [0, 0, 0, 1], scale: [1, 1, 1] } },
- *     { component: MeshFilter, data: { assetHandle: quadMesh } },
+ *     { component: MeshFilter, data: { assetHandle: HANDLE_QUAD } },
  *     { component: MeshRenderer, data: { materials: [spriteMaterial] } },
  *     { component: SpriteAnimation,
  *       data: {

package/dist/components/sprite-animation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sprite-animation.d.ts","sourceRoot":"","sources":["../../src/components/sprite-animation.ts"],"names":[],"mappings":"AA+FA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiEG;AACH,eAAO,MAAM,eAAe;;;;;;;EAO1B,CAAC"}
+{"version":3,"file":"sprite-animation.d.ts","sourceRoot":"","sources":["../../src/components/sprite-animation.ts"],"names":[],"mappings":"AA+FA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgEG;AACH,eAAO,MAAM,eAAe;;;;;;;EAO1B,CAAC"}

package/dist/components/sprite-instances.d.ts

@@ -18,7 +18,7 @@
  *   const regions    = new Float32Array(10000 * 4);
  *   // ... fill mat4 columns + [uMin, vMin, uW, vH] ...
  *   world.spawn(
- *     { component: MeshFilter,      data: { assetHandle: quadMesh } },
+ *     { component: MeshFilter,      data: { assetHandle: HANDLE_QUAD } },
  *     { component: MeshRenderer,    data: { ... } },
  *     { component: SpriteInstances, data: { transforms, regions } },
  *   );

package/dist/components/sprite-playback-mode.d.ts

@@ -20,10 +20,15 @@ export type SpritePlaybackMode = 'loop' | 'clamp';
 export declare const SPRITE_PLAYBACK_MODE_LOOP: 0;
 /** Numeric encoding of the clamp playback mode (schema value for `playbackMode`). */
 export declare const SPRITE_PLAYBACK_MODE_CLAMP: 1;
+/** Grouped authoring values; the numeric ECS encoding stays owner-local. */
+export declare const SpritePlayback: Readonly<{
+    readonly loop: 0;
+    readonly clamp: 1;
+}>;
 /**
  * Map a `SpriteAnimation.playbackMode` numeric column value to the closed
  * `SpritePlaybackMode` string-literal union. The defensive fallback mirrors
- * `cameraProjectionFromF32` / `tonemapFromF32` precedent — any value other
+ * `cameraProjectionFromF32` / `tonemapFromF32` precedent — a value other
  * than `SPRITE_PLAYBACK_MODE_CLAMP` (1) maps to `'loop'`, so stale or
  * uninitialised entities surface a predictable playback shape through the
  * tick-system query (rather than throwing or returning `undefined`).

package/dist/components/sprite-playback-mode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sprite-playback-mode.d.ts","sourceRoot":"","sources":["../../src/components/sprite-playback-mode.ts"],"names":[],"mappings":"AAgCA;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,kBAAkB,GAAG,MAAM,GAAG,OAAO,CAAC;AAElD,oFAAoF;AACpF,eAAO,MAAM,yBAAyB,EAAG,CAAU,CAAC;AAEpD,qFAAqF;AACrF,eAAO,MAAM,0BAA0B,EAAG,CAAU,CAAC;AAErD;;;;;;;;;;;;GAYG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,MAAM,GAAG,kBAAkB,CAE3E"}
+{"version":3,"file":"sprite-playback-mode.d.ts","sourceRoot":"","sources":["../../src/components/sprite-playback-mode.ts"],"names":[],"mappings":"AAgCA;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,kBAAkB,GAAG,MAAM,GAAG,OAAO,CAAC;AAElD,oFAAoF;AACpF,eAAO,MAAM,yBAAyB,EAAG,CAAU,CAAC;AAEpD,qFAAqF;AACrF,eAAO,MAAM,0BAA0B,EAAG,CAAU,CAAC;AAErD,4EAA4E;AAC5E,eAAO,MAAM,cAAc;;;EAGhB,CAAC;AAEZ;;;;;;;;;;;;GAYG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,MAAM,GAAG,kBAAkB,CAE3E"}

package/dist/components/sprite-region-override.d.ts

@@ -25,13 +25,12 @@
  *   import { MeshFilter, MeshRenderer } from '@forgeax/engine-render';
  *   import { SpriteRegionOverride } from '@forgeax/engine-render/authoring';
  *   import { Transform } from '@forgeax/engine-scene';
- *   import { createPrimitiveMesh } from '@forgeax/engine-geometry';
- *   const quadMesh = world.internSharedRef(createPrimitiveMesh('quad').unwrap());
+ *   import { HANDLE_QUAD } from '@forgeax/engine-assets-runtime';
  *
  *   world.spawn(
  *     { component: Transform, data: { pos: [0, 0, 0],
  *       quat: [0, 0, 0, 1], scale: [1, 1, 1] } },
- *     { component: MeshFilter, data: { assetHandle: quadMesh } },
+ *     { component: MeshFilter, data: { assetHandle: HANDLE_QUAD } },
  *     { component: MeshRenderer, data: { materials: [spriteMaterial] } },
  *     { component: SpriteRegionOverride,
  *       data: { region: new Float32Array([0.5, 0, 0.5, 1]) } },

package/dist/components/sprite-region-override.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sprite-region-override.d.ts","sourceRoot":"","sources":["../../src/components/sprite-region-override.ts"],"names":[],"mappings":"AA4DA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,eAAO,MAAM,oBAAoB;;EAE/B,CAAC"}
+{"version":3,"file":"sprite-region-override.d.ts","sourceRoot":"","sources":["../../src/components/sprite-region-override.ts"],"names":[],"mappings":"AA4DA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,eAAO,MAAM,oBAAoB;;EAE/B,CAAC"}

package/dist/components/tile-layer.d.ts

@@ -13,6 +13,11 @@ import type { Result } from '@forgeax/engine-types';
  *                  player sprite riding the same SPRITE_LAYER_VALUE).
  */
 export type SortScope = 'layer' | 'per-cell';
+/** Compact authoring values for the stored u8 sort-scope field. */
+export declare const TilemapSort: Readonly<{
+    layer: 0;
+    perCell: 1;
+}>;
 /**
  * Bridge: `SortScope` -> on-disk u8. SSOT for the encoding (`'layer'` -> 0,
  * `'per-cell'` -> 1). The compile-time exhaustive switch guards against

package/dist/components/tile-layer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tile-layer.d.ts","sourceRoot":"","sources":["../../src/components/tile-layer.ts"],"names":[],"mappings":"AAyCA,OAAO,EAAmB,KAAK,QAAQ,EAAE,KAAK,YAAY,EAAE,KAAK,KAAK,EAAE,MAAM,qBAAqB,CAAC;AACpG,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAEpD;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,SAAS,GAAG,OAAO,GAAG,UAAU,CAAC;AAE7C;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,SAAS,GAAG,CAAC,GAAG,CAAC,CAOvD;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,CAElE;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,CAAC;CAChC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,eAAO,MAAM,SAAS;;;;;EAKpB,CAAC;AAEH;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,KAAK,EACZ,WAAW,EAAE,YAAY,GACxB,MAAM,CAAC,IAAI,EAAE,QAAQ,CAAC,CAExB"}
+{"version":3,"file":"tile-layer.d.ts","sourceRoot":"","sources":["../../src/components/tile-layer.ts"],"names":[],"mappings":"AAyCA,OAAO,EAAmB,KAAK,QAAQ,EAAE,KAAK,YAAY,EAAE,KAAK,KAAK,EAAE,MAAM,qBAAqB,CAAC;AACpG,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAEpD;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,SAAS,GAAG,OAAO,GAAG,UAAU,CAAC;AAE7C,mEAAmE;AACnE,eAAO,MAAM,WAAW;;;EAGtB,CAAC;AAEH;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,SAAS,GAAG,CAAC,GAAG,CAAC,CAOvD;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,CAElE;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,CAAC;CAChC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,eAAO,MAAM,SAAS;;;;;EAKpB,CAAC;AAEH;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,KAAK,EACZ,WAAW,EAAE,YAAY,GACxB,MAAM,CAAC,IAAI,EAAE,QAAQ,CAAC,CAExB"}

package/dist/construct-renderer.d.ts

@@ -1,2 +1,19 @@
-export { type BundlerOptions, createRenderer as constructRenderer, } from './renderer/renderer-factory';
+import type { AssetRegistry } from '@forgeax/engine-assets-runtime';
+import type { RhiBackendPack } from './assembly/backend-contract';
+import type { BundlerOptions } from './assembly/factory';
+import type { RendererHostImplementation, RendererLegacyHostAdapter } from './assembly/host-contract';
+import { type RenderError } from './errors/render';
+import type { Renderer, RendererOptions, RenderResult } from './render-contract';
+export type { EngineEnvironmentErrorDetail, RhiBackendInstrumentation, RhiBackendPack, } from './assembly/backend-contract';
+export { EngineEnvironmentError } from './assembly/backend-contract';
+export type { RendererLegacyHostAdapter } from './assembly/host-contract';
+export type { BundlerOptions };
+export type RendererFeatureAssemblyHost = Pick<RendererLegacyHostAdapter, 'installRenderFeature' | 'uninstallRenderFeature'>;
+export interface RendererHostAssembly {
+    readonly renderer: Renderer;
+    readonly debugDrawHost: RendererHostImplementation;
+    readonly featureHost: RendererFeatureAssemblyHost;
+    readonly assets: AssetRegistry;
+}
+export declare function constructRendererHost(canvas: unknown, options?: RendererOptions, bundler?: BundlerOptions, backend?: RhiBackendPack): Promise<RenderResult<RendererHostAssembly, RenderError>>;
 //# sourceMappingURL=construct-renderer.d.ts.map

package/dist/construct-renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"construct-renderer.d.ts","sourceRoot":"","sources":["../src/construct-renderer.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,cAAc,EACnB,cAAc,IAAI,iBAAiB,GACpC,MAAM,6BAA6B,CAAC"}
+{"version":3,"file":"construct-renderer.d.ts","sourceRoot":"","sources":["../src/construct-renderer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AACpE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAClE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEzD,OAAO,KAAK,EACV,0BAA0B,EAC1B,yBAAyB,EAC1B,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,KAAK,WAAW,EAAgC,MAAM,iBAAiB,CAAC;AACjF,OAAO,KAAK,EAAE,QAAQ,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEjF,YAAY,EACV,4BAA4B,EAC5B,yBAAyB,EACzB,cAAc,GACf,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AACrE,YAAY,EAAE,yBAAyB,EAAE,MAAM,0BAA0B,CAAC;AAC1E,YAAY,EAAE,cAAc,EAAE,CAAC;AAE/B,MAAM,MAAM,2BAA2B,GAAG,IAAI,CAC5C,yBAAyB,EACzB,sBAAsB,GAAG,wBAAwB,CAClD,CAAC;AAEF,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B,QAAQ,CAAC,aAAa,EAAE,0BAA0B,CAAC;IACnD,QAAQ,CAAC,WAAW,EAAE,2BAA2B,CAAC;IAClD,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;CAChC;AAED,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,OAAO,EACf,OAAO,CAAC,EAAE,eAAe,EACzB,OAAO,CAAC,EAAE,cAAc,EACxB,OAAO,CAAC,EAAE,cAAc,GACvB,OAAO,CAAC,YAAY,CAAC,oBAAoB,EAAE,WAAW,CAAC,CAAC,CA6B1D"}