@origingame/engine 0.2.0 → 0.3.0

package/src/index.ts

@@ -25,10 +25,16 @@ import {
   type FieldSpec,
 } from "./runtime.ts";
 import { cameras } from "./systems/cameras.ts";
-import { ai, i18n, nav, platform } from "./e6.ts";
-import { stream, terrain } from "./p2.ts";
+import { ai, i18n, nav, net, platform } from "./e6.ts";
+import { path, stream, terrain, timeline } from "./p2.ts";
+import { debug, depthRender } from "./depth.ts";
+import { targetsLoad, targetsRender } from "./targets.ts";
+import { lightRender } from "./light.ts";
 import { uiKit } from "./ui-kit/index.ts";
 
+// The math layer (IDL `math`): three.js's methods as pure functions over the plain structs.
+export { vec3, vec2, quat, mat4, box3, sphere, plane, frustum, ray, color } from "./math.ts";
+
 const spec = (kind: string, value: unknown, options: unknown): FieldSpec =>
   Object.freeze({ kind, default: value, options: Object.freeze({ ...((options as object | undefined) ?? {}) }) });
 
@@ -57,7 +63,9 @@ export const Lut = ((value = 0 as Api.Lut, options) => spec("Lut", value, option
 export const EnvironmentMap = ((value = 0 as Api.EnvironmentMap, options) => spec("EnvironmentMap", value, options)) as typeof Api.EnvironmentMap;
 export const ParticleEmitter = ((value = 0 as Api.ParticleEmitter, options) => spec("ParticleEmitter", value, options)) as typeof Api.ParticleEmitter;
 export const AoMethod = ((value = "auto" as Api.AoMethod, options) => spec("AoMethod", value, options)) as typeof Api.AoMethod;
+export const LineMode = ((value = "strip" as Api.LineMode, options) => spec("LineMode", value, options)) as typeof Api.LineMode;
 export const DofQuality = ((value = "low" as Api.DofQuality, options) => spec("DofQuality", value, options)) as typeof Api.DofQuality;
+export const ReflectionProbeMode = ((value = "baked" as Api.ReflectionProbeMode, options) => spec("ReflectionProbeMode", value, options)) as typeof Api.ReflectionProbeMode;
 export const SpriteBlend = ((value = "alpha" as Api.SpriteBlend, options) => spec("SpriteBlend", value, options)) as typeof Api.SpriteBlend;
 export const StripBlend = ((value = "additive" as Api.StripBlend, options) => spec("StripBlend", value, options)) as typeof Api.StripBlend;
 export const Palette = ((value = 0 as Api.Palette, options) => spec("Palette", value, options)) as typeof Api.Palette;
@@ -71,6 +79,14 @@ export const ClipAsset = ((value = 0 as Api.ClipAsset, options) => spec("ClipAss
 export const GraphAsset = ((value = 0 as Api.GraphAsset, options) => spec("GraphAsset", value, options)) as typeof Api.GraphAsset;
 export const FlipbookSheet = ((value = 0 as Api.FlipbookSheet, options) => spec("FlipbookSheet", value, options)) as typeof Api.FlipbookSheet;
 export const Tween = ((value = 0 as Api.Tween, options) => spec("Tween", value, options)) as typeof Api.Tween;
+export const Video = ((value = 0 as Api.Video, options) => spec("Video", value, options)) as typeof Api.Video;
+export const Path = ((value = 0 as Api.Path, options) => spec("Path", value, options)) as typeof Api.Path;
+export const PathKind = ((value = "catmullRom" as Api.PathKind, options) => spec("PathKind", value, options)) as typeof Api.PathKind;
+export const TimelineAsset = ((value = 0 as Api.TimelineAsset, options) => spec("TimelineAsset", value, options)) as typeof Api.TimelineAsset;
+export const Rig2D = ((value = 0 as Api.Rig2D, options) => spec("Rig2D", value, options)) as typeof Api.Rig2D;
+export const RenderTargetFormat = ((value = "ldr" as Api.RenderTargetFormat, options) => spec("RenderTargetFormat", value, options)) as typeof Api.RenderTargetFormat;
+export const RenderTarget = ((value = 0 as Api.RenderTarget, options) => spec("RenderTarget", value, options)) as typeof Api.RenderTarget;
+export const Post = ((value = 0 as Api.Post, options) => spec("Post", value, options)) as typeof Api.Post;
 export const TilemapAsset = ((value = 0 as Api.TilemapAsset, options) => spec("TilemapAsset", value, options)) as typeof Api.TilemapAsset;
 export const TerrainData = ((value = 0 as Api.TerrainData, options) => spec("TerrainData", value, options)) as typeof Api.TerrainData;
 export const RootMotion = ((value = "off" as Api.RootMotion, options) => spec("RootMotion", value, options)) as typeof Api.RootMotion;
@@ -100,6 +116,7 @@ export const MAX_POINTERS: typeof Api.MAX_POINTERS = 5;
 export const MAX_GAMEPADS: typeof Api.MAX_GAMEPADS = 4;
 export const MAX_LIGHTS: typeof Api.MAX_LIGHTS = 256;
 export const MAX_CLUSTER_LIGHTS: typeof Api.MAX_CLUSTER_LIGHTS = 64;
+export const MAX_REFLECTION_PROBES: typeof Api.MAX_REFLECTION_PROBES = 8;
 export const PARTICLES_ARMED: typeof Api.PARTICLES_ARMED = 4294967295;
 export const UI_LAYER: typeof Api.UI_LAYER = 1000;
 export const BODY_DYNAMIC: typeof Api.BODY_DYNAMIC = 0;
@@ -172,8 +189,8 @@ export const og: typeof Api.og = Object.freeze({
   ...BUILTINS,
   game: (desc?: Api.GameDesc) => defineGame(desc as never),
   transform,
-  render,
-  load,
+  render: Object.freeze({ ...render, ...depthRender, ...targetsRender, ...lightRender }),
+  load: Object.freeze({ ...load, ...targetsLoad }),
   commands,
   physics,
   atmosphere,
@@ -187,8 +204,12 @@ export const og: typeof Api.og = Object.freeze({
   ai,
   platform,
   i18n,
+  net,
   terrain,
   stream,
+  debug,
+  path,
+  timeline,
   ui: Object.freeze({ ...ui, ...uiKit }),
   systems: Object.freeze({ cameras }),
 }) as unknown as typeof Api.og;

package/src/light.ts

@@ -0,0 +1,18 @@
+// The depth wave's baked lighting (IDL `render`: bakedLighting): a thin
+// call into the host's binding symbol, typed by the generated declarations
+// through index.ts.
+
+import type { HostAbi } from "./generated/abi.ts";
+import { boundHost } from "./runtime.ts";
+
+type W = { readonly id: number };
+
+function abi(): HostAbi<Uint32Array, unknown> {
+  const h = boundHost();
+  if (!h) throw new Error("no engine host is loaded: start the game through @origingame/engine's web or node loader");
+  return h.abi;
+}
+
+export const lightRender = Object.freeze({
+  bakedLighting: (world: W) => JSON.parse(abi().og_render_baked_lighting(world.id)) as unknown,
+});