@woosh/meep-engine 3.68.0 → 3.69.0

package/src/engine/graphics3/Trail3DSystem.d.ts

@@ -1,48 +1,43 @@
 /**
- * Draws {@link Trail3D}'s tubes under Shade, as dynamic geometry inside the transparency pipeline.
+ * Copy a component onto runtime parameters.
  *
- * **A trail is dynamic content by definition** — every knot of it is rewritten as the entity moves
- * and every knot's opacity as it ages — so its geometry is a {@link DynamicMesh} (D5/I-10), not a
- * meshlet build, the same as paths and debug shapes.
- *
- * **It is drawn through AVBOIT, not over it.** The batch is a transparency channel
- * ({@link DynamicMeshAVBOITChannel}, registered with the facade): its fragments go into the same
- * extinction volume and accumulators as the transparent meshes and the GPU particles, so a trail
- * behind glass is seen through the glass, a trail inside smoke is hidden by the smoke in front of it
- * and hides the smoke behind it, and two trails crossing composite by depth, not by the order they
- * were linked in. Everything drawn at `AfterTransparency` runs after the transparency resolve they
- * are part of, so path display and the selection highlight land over a trail rather than under it.
- * Under MBOIT, the legacy transparency mode, trails are not drawn — as the particles are not.
+ * @param {TrailParameters} parameters
+ * @param {Trail3D} trail
+ * @param {Trail3DEntry} entry
+ */
+export function apply_trail3d(parameters: TrailParameters, trail: Trail3D, entry: Trail3DEntry): void;
+/**
+ * Draws every {@link Trail3D}: simulated on the GPU, its head following the entity's `transforms` row,
+ * its knots seeded and committed in compute and its tube extruded in the vertex stage, drawn inside the
+ * transparency pipeline (AVBOIT), so a trail behind glass or smoke composites with them by depth.
+ * Nothing per knot happens on the CPU.
  *
- * **The simulation is not this system's, and that is deliberate.** {@link seed_trail_tube} and
- * {@link advance_trail} are what the legacy `Trail3DSystem` runs too: the knots a trail lays down
- * are a property of the trail, not of the renderer drawing it, and two implementations of them
- * would be two trails that age differently. What is this system's is turning those knots into
- * vertices, once a frame, per trail.
+ * **What is the CPU's:** registering a trail with the scene context's {@link GPUTrailSystem} — a row, a
+ * knot run, the entity's transform row held through {@link EntityRowHold} — comparing each component's
+ * fields once a tick with what was staged and restaging what differs, and moving the clock by the
+ * simulation time it is given. A game writes `trail.color` or `trail.maxAge` from code that never heard
+ * of this system; there is no change signal to send.
  *
- * **Every trail is rewritten every frame it exists**, moving or not, because the simulator ages
- * every knot on every tick and the age is what the vertex opacity carries. There is no quiet trail
- * — a trail that has stopped is a trail fading out.
+ * **The head follows announced transforms.** A trail reads where its entity is from the GPU row, which a
+ * transform write reaches when it is announced (`TRANSFORM64_EVENT_CHANGE`), as meshes and particle
+ * emitters do.
  *
- * **What the tube material had and this does not**: a texture, lighting, and per-trail depth
- * writing. The dynamic path has one vertex layout — position and colour — and a trail is drawn as
- * unlit straight alpha, depth tested against the opaque scene and never written, which is what a
- * trail wants and what the game's trails are authored as. `Trail3D.textureURL` therefore draws
- * untinted here; nothing in the game's own effects sets it to anything a flat colour does not
- * carry.
+ * A trail's knot count (from its `maxAge`, or its authored layout's) and its `radialSegments` are fixed
+ * when it registers; a replaced authored layout brings its own count.
  */
 export class Trail3DSystem extends System<any> {
     /**
-     * @param {GraphicsEngine} graphics
+     * @param {import("./GraphicsEngine.js").GraphicsEngine} graphics
+     * @param {import("../../shade/renderer/scene/Scene.js").Scene} scene the scene the trails' entities are in
      */
-    constructor(graphics: GraphicsEngine);
+    constructor(graphics: import("./GraphicsEngine.js").GraphicsEngine, scene: import("../../shade/renderer/scene/Scene.js").Scene);
     dependencies: (typeof Transform64 | typeof Trail3D)[];
     /**
-     * What the transparency channel draws. Read-only — the meshes follow the entities.
+     * The runtime the scene's trails are registered with, or null while there is no scene context.
      *
-     * @returns {DynamicMeshBatch}
+     * @returns {GPUTrailSystem|null}
      */
-    get batch(): DynamicMeshBatch;
+    get runtime(): GPUTrailSystem;
     startup(entityManager: any): Promise<void>;
     shutdown(entityManager: any): Promise<void>;
     /**
@@ -57,7 +52,19 @@ export class Trail3DSystem extends System<any> {
      * @param {number} entity
      */
     unlink(trail: Trail3D, transform: Transform64, entity: number): void;
-    update(timeDelta: any): void;
+    /**
+     * Move the clock by the simulation time given, register what is waiting, and restage every trail
+     * whose component changed.
+     *
+     * @param {number} [time_delta_seconds]
+     */
+    update(time_delta_seconds?: number): void;
+    /**
+     * Record the frame's trail work — called by the frame extension.
+     *
+     * @param {import("../../shade/renderer/extension/FrameContext.js").FrameContext} frame
+     */
+    record(frame: import("../../shade/renderer/extension/FrameContext.js").FrameContext): void;
     #private;
 }
 /**
@@ -73,9 +80,36 @@ export class Trail3DSystem extends System<any> {
 export class TrailExtension extends RenderExtension {
     record(frame: any): void;
 }
+export type Trail3DEntry = {
+    entity: number;
+    trail: Trail3D;
+    /**
+     * the entity's row, kept current as it moves
+     */
+    hold: EntityRowHold;
+    /**
+     * the
+     * trail in the runtime, or null while it is not registered
+     */
+    context: import("../../shade/renderer/trails/GPUTrailSystem.js").GPUTrailContext | null;
+    /**
+     * knots of the trail's ring, fixed when it is built
+     */
+    knot_count: number;
+    /**
+     * radial segments, fixed when it is built
+     */
+    radial: number;
+    /**
+     * the component's `clearCount` as last seen
+     */
+    clears: number;
+};
+import { TrailParameters } from "../../shade/renderer/trails/runtime/TrailParameters.js";
+import Trail3D from "../graphics/ecs/trail3d/Trail3D.js";
 import { System } from "../ecs/System.js";
 import { Transform64 } from "../ecs/transform/Transform64.js";
-import Trail3D from "../graphics/ecs/trail3d/Trail3D.js";
-import { DynamicMeshBatch } from "../../shade/renderer/scene/DynamicMeshBatch.js";
+import { GPUTrailSystem } from "../../shade/renderer/trails/GPUTrailSystem.js";
 import { RenderExtension } from "../../shade/renderer/extension/RenderExtension.js";
+import { EntityRowHold } from "./EntityRowHold.js";
 //# sourceMappingURL=Trail3DSystem.d.ts.map

package/src/engine/graphics3/Trail3DSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Trail3DSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/Trail3DSystem.js"],"names":[],"mappings":"AAkBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH;IAuCI;;OAEG;IACH,sCAMC;IA/CD,sDAAsC;IA6BtC;;;;OAIG;IACH,8BAEC;IAaD,2CAIC;IAED,4CAQC;IAED;;;;OAIG;IACH,YAJW,OAAO,aACP,WAAW,UACX,MAAM,QAgBhB;IAED;;;;OAIG;IACH,cAJW,OAAO,aACP,WAAW,UACX,MAAM,QAiBhB;IAED,6BAaC;;CACJ;AAQD;;;;;;;;;GASG;AACH;IAeI,yBAEC;CACJ;uBA3MsB,kBAAkB;4BACb,iCAAiC;oBAGzC,oCAAoC;iCALvB,gDAAgD;gCAHjD,mDAAmD"}
+{"version":3,"file":"Trail3DSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/Trail3DSystem.js"],"names":[],"mappings":"AAsCA;;;;;;GAMG;AACH,0CAJW,eAAe,SACf,OAAO,SACP,YAAY,QA8BtB;AA8BD;;;;;;;;;;;;;;;;;;GAkBG;AACH;IAuDI;;;OAGG;IACH,sBAHW,OAAO,qBAAqB,EAAE,cAAc,SAC5C,OAAO,qCAAqC,EAAE,KAAK,EAW7D;IAnED,sDAAsC;IAqEtC;;;;OAIG;IACH,8BAEC;IAED,2CAOC;IAED,4CAWC;IA4BD;;;;OAIG;IACH,YAJW,OAAO,aACP,WAAW,UACX,MAAM,QAqBhB;IAED;;;;OAIG;IACH,cAJW,OAAO,aACP,WAAW,UACX,MAAM,QAIhB;IAED;;;;;OAKG;IACH,4BAFW,MAAM,QAchB;IAED;;;;OAIG;IACH,cAFW,OAAO,gDAAgD,EAAE,YAAY,QA2B/E;;CA2IJ;AAQD;;;;;;;;;GASG;AACH;IAeI,yBAEC;CACJ;;YA3ea,MAAM;WACN,OAAO;;;;UACP,aAAa;;;;;aACb,OAAO,+CAA+C,EAAE,eAAe,GAAC,IAAI;;;;gBAE5E,MAAM;;;;YACN,MAAM;;;;YACN,MAAM;;gCAlBY,wDAAwD;oBAIpE,oCAAoC;uBAHjC,kBAAkB;4BACb,iCAAiC;+BAH9B,+CAA+C;gCAJ9C,mDAAmD;8BAYrD,oBAAoB"}