@ignifx/particles 0.0.0-stage → 0.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/package.json CHANGED
@@ -1,6 +1,70 @@
1
1
  {
2
2
  "name": "@ignifx/particles",
3
- "version": "0.0.0-stage",
4
- "stub": true,
5
- "description": "Temporary package placeholder for staged publishing"
6
- }
3
+ "version": "0.3.0",
4
+ "description": "ignifx particles: stateless GPU particle systems driven by declarative .particles.json definitions.",
5
+ "keywords": [
6
+ "ignifx",
7
+ "ignifx-extension"
8
+ ],
9
+ "homepage": "https://ignifx.com",
10
+ "license": "Apache-2.0",
11
+ "author": "Astrum Forge Studios",
12
+ "repository": {
13
+ "type": "git",
14
+ "url": "git+https://github.com/astrum-forge/ignifx.git",
15
+ "directory": "packages/particles"
16
+ },
17
+ "files": [
18
+ "dist",
19
+ "skills"
20
+ ],
21
+ "type": "module",
22
+ "sideEffects": false,
23
+ "exports": {
24
+ ".": {
25
+ "types": "./dist/index.d.ts",
26
+ "import": "./dist/index.js"
27
+ },
28
+ "./package.json": "./package.json"
29
+ },
30
+ "publishConfig": {
31
+ "access": "public",
32
+ "provenance": false
33
+ },
34
+ "scripts": {
35
+ "build": "tsdown",
36
+ "typecheck": "tsc --build tsconfig.json tsconfig.test.json",
37
+ "test": "vitest run --project node --project node-isolated --root ../.. packages/particles",
38
+ "api-report": "api-extractor run --verbose",
39
+ "docs:api": "typedoc",
40
+ "api-report:update": "api-extractor run --local --verbose",
41
+ "pack-check": "publint && attw --pack . --profile esm-only"
42
+ },
43
+ "devDependencies": {
44
+ "@arethetypeswrong/cli": "catalog:",
45
+ "@babylonjs/lite": "catalog:",
46
+ "@ignifx/core": "workspace:*",
47
+ "@microsoft/api-extractor": "catalog:",
48
+ "@types/webxr": "catalog:",
49
+ "@webgpu/types": "catalog:",
50
+ "publint": "catalog:",
51
+ "tsdown": "catalog:",
52
+ "typedoc": "catalog:",
53
+ "typedoc-plugin-markdown": "catalog:",
54
+ "typescript-native": "catalog:",
55
+ "vitest": "catalog:",
56
+ "wgsl_reflect": "catalog:"
57
+ },
58
+ "peerDependencies": {
59
+ "@babylonjs/lite": "catalog:",
60
+ "@ignifx/core": "workspace:*"
61
+ },
62
+ "ignifx": {
63
+ "extension": true,
64
+ "engine": ">=0.0.0 <1.0.0",
65
+ "requires": [],
66
+ "optional": [],
67
+ "capabilities": [],
68
+ "skill": "./skills/particles/SKILL.md"
69
+ }
70
+ }
@@ -0,0 +1,367 @@
1
+ ---
2
+ name: particles
3
+ description: Builds GPU particle effects in ignifx with @ignifx/particles: fire, smoke, sparks, explosions, weather and magic, declared in .particles.json and evaluated on the GPU from CPU-written spawn records. Use when adding or editing a particle effect, an emitter, or a .particles.json document in an ignifx project, or when the user mentions @ignifx/particles, ParticleSystem, particleDefinition, or app.particles.
4
+ license: Apache-2.0
5
+ metadata:
6
+ ignifx-version: "0.3.0"
7
+ ---
8
+
9
+ # @ignifx/particles
10
+
11
+ ## What this is / when to use
12
+
13
+ `@ignifx/particles` draws effects: fire, smoke, sparks, explosions, rain, snow, dust, glints and
14
+ falling leaves. An effect is a **document** — a `.particles.json`, or the same object built in code —
15
+ and a `ParticleSystem` component plays it.
16
+
17
+ Use it for anything made of many small, short-lived, non-interacting pieces. Do not use it for
18
+ things that must collide, chain into one another, or be sorted against each other; the design
19
+ trades those away, and "Gotchas" below says what to do instead. For 2D sprite particles use
20
+ `@ignifx/particles-2d`, which reads the same documents.
21
+
22
+ ## Environment
23
+
24
+ - Engine: ignifx `0.3.0`; this package targets `@ignifx/core` `>=0.0.0 <1.0.0`.
25
+ - Requires nothing but `@ignifx/core`. `@ignifx/physics` is optional: when it is registered, an
26
+ effect that asks for "the world's gravity" reads the `physics` settings section.
27
+ - WebGPU only, browser and Electron. Babylon Lite `1.27.0` is a peer dependency, and this package
28
+ imports none of it.
29
+ - Everything except the GPU upload runs under `createApp({ headless: true })`.
30
+ - Nothing happens at import time.
31
+
32
+ ```ts
33
+ import { createApp } from "@ignifx/core";
34
+ import { particles } from "@ignifx/particles";
35
+
36
+ const canvas = document.querySelector("canvas");
37
+ if (canvas instanceof HTMLCanvasElement) {
38
+ const app = await createApp({ canvas, extensions: [particles({ maxParticles: 50_000 })] });
39
+ await app.start();
40
+ }
41
+ ```
42
+
43
+ ## Mental model
44
+
45
+ A particle is **stateless**. The CPU writes one 48-byte _spawn record_ when the particle is born —
46
+ its birth time, lifetime, seed, start position, size, velocity and rotation — and never touches it
47
+ again. Every frame the vertex shader reads the record, subtracts the birth time from the system
48
+ clock, and computes the whole particle from closed formulas. A particle whose age has passed its
49
+ lifetime collapses to a point behind the far plane.
50
+
51
+ ```
52
+ emit() ──▶ spawn record ──▶ ring buffer (capacity records)
53
+ │
54
+ one updateStorageBuffer of the new records per frame
55
+ ▼
56
+ vertex shader: state(t) = f(record, clock) ──▶ one instanced draw
57
+ ```
58
+
59
+ | Thing | Phase | Order | Why there |
60
+ | -------------------------------------------- | ----------- | ----- | ------------------------------------------------------------------------- |
61
+ | Emission (`ParticleUpdateSystem`) | `Update` | `900` | After every script's `update`, so `emit()` from a script draws this frame |
62
+ | Upload and uniforms (`ParticleRenderSystem`) | `PreRender` | `880` | Before core's shader-uniform and render-sync systems |
63
+
64
+ What follows from being stateless:
65
+
66
+ - **Pause is exact.** The system clock advances by the frame delta only while the app is not paused
67
+ and the system is playing; freeze it and every particle freezes where it is.
68
+ - **The seed is the simulation.** Two systems with one seed, fed the same frame deltas, write
69
+ identical records.
70
+ - **The frame rate does not change the result.** A particle's state is a function of its age.
71
+ - **Fast-forward is free.** `simulate(5)` is the same arithmetic as five seconds of frames.
72
+ - **Nothing is freed.** A record is overwritten by a newer one; `capacity` is the whole budget.
73
+
74
+ ## First app
75
+
76
+ A campfire on a headless app: load a preset, play it, step the frame loop, count the flames.
77
+
78
+ ```ts run
79
+ import { Camera, createApp } from "@ignifx/core";
80
+ import { ParticleSystem, particleAssetFromDefinition, particleDefinition, particles } from "@ignifx/particles";
81
+
82
+ const app = await createApp({ headless: true, extensions: [particles()] });
83
+
84
+ const eye = app.world.createEntity("Main Camera", { position: { x: 0, y: 1.5, z: -4 } });
85
+ eye.transform.lookAt({ x: 0, y: 0.5, z: 0 });
86
+ eye.addComponent(Camera);
87
+
88
+ await app.start();
89
+
90
+ // The third argument is a diagnostics label, not an address: in-code assets get a generated `memory:` address.
91
+ const fire = particleAssetFromDefinition(app, particleDefinition("fire"), "campfire");
92
+ const campfire = app.world.createEntity("Campfire", { position: { x: 0, y: 0.2, z: 0 } });
93
+ const system = campfire.addComponent(ParticleSystem, { definition: fire, seed: 7 });
94
+
95
+ for (let frame = 0; frame < 60; frame += 1) {
96
+ app.step(1 / 60);
97
+ }
98
+
99
+ app.log.info(`alive: ${String(system.aliveCount)} of ${String(system.capacity)}`);
100
+ system.emit(20);
101
+ app.step(1 / 60);
102
+ app.log.info(`after a burst: ${String(system.aliveCount)}`);
103
+
104
+ app.dispose();
105
+ ```
106
+
107
+ ## Core APIs
108
+
109
+ ### `ParticleSystem`
110
+
111
+ | Member | What it does |
112
+ | ------------------------ | ------------------------------------------------------------------------------------------------------ |
113
+ | `definition` | The `.particles.json` handle it plays. Assigning a different one rebuilds the effect. |
114
+ | `playOnAwake` | Play the first frame the component is enabled. The document's own `main.playOnAwake` must agree. |
115
+ | `seed` | The emission seed. `0` uses the document's, and `0` there picks one at random on `play()`. |
116
+ | `play()` | Start, or resume after `stop()`. A `prewarm` document fast-forwards one cycle first. |
117
+ | `stop({ clear })` | Stop emitting. Live particles finish their lives unless `clear` is `true`. |
118
+ | `pause()` / `resume()` | Hold and release the system clock. Everything freezes in place. |
119
+ | `emit(count)` | Spawn `count` particles at the current clock, playing or not. `qualityScale` does not apply. |
120
+ | `simulate(seconds)` | Fast-forward in sixtieths, emitting as it goes. What `prewarm` uses. |
121
+ | `isPlaying` / `isPaused` | Playback state. |
122
+ | `aliveCount` | How many particles are alive. Exact, on the CPU, headless too. |
123
+ | `drawCount` | How many records the GPU draws: the newest back to the oldest still alive. |
124
+ | `droppedCount` | Spawns that displaced a particle that was still alive, because the capacity is too small for the rate. |
125
+ | `time` | The system's own clock, in seconds. `app.time` is never read. |
126
+ | `capacity` | The records it holds, after `app.particles.maxParticles` clamped the document's. |
127
+ | `onStopped` | Emitted once when a non-looping system runs out of cycle and particles. |
128
+ | `evaluate(slot, out)` | The CPU twin of the shader: one record's world state at the current clock. `@beta`, for tools. |
129
+
130
+ Several effects may share one entity: `ParticleSystem` is `allowMultiple`.
131
+
132
+ ### `app.particles`
133
+
134
+ | Member | What it does |
135
+ | --------------- | --------------------------------------------------------------------------------------------------- |
136
+ | `maxParticles` | The budget every system's `capacity` is counted against. Default `100_000`. |
137
+ | `qualityScale` | A `0`–`1` multiplier on every emission rate and burst count, read each frame. For settings screens. |
138
+ | `gravity` | The world gravity a document's `forces.gravityMultiplier` scales. Defaults to `(0, -9.81, 0)`. |
139
+ | `systems` | Every attached `ParticleSystem`, in attach order. |
140
+ | `capacityInUse` | How much of the budget the attached systems hold. |
141
+ | `counters` | The `particles` diagnostics group: `systems`, `alive`, `emitted`, `uploadBytes`, `drawCalls`. |
142
+
143
+ ### Presets
144
+
145
+ `particleDefinition(name, overrides?)` returns a complete document. The nine names are `fire`,
146
+ `smoke`, `sparks`, `explosion`, `dust`, `sparkle`, `rain`, `snow` and `leaves`. An object override
147
+ merges key by key; an array or a primitive replaces the whole value.
148
+
149
+ ```ts
150
+ import { particleDefinition } from "@ignifx/particles";
151
+
152
+ export const bigFire = particleDefinition("fire", {
153
+ main: { capacity: 512 },
154
+ start: { size: { min: 0.6, max: 1 } },
155
+ });
156
+ ```
157
+
158
+ ### The module set
159
+
160
+ | Module | Fields |
161
+ | -------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
162
+ | `main` | `capacity`, `duration`, `looping`, `prewarm`, `startDelay`, `simulationSpace`, `seed`, `playOnAwake`, `timeScale`, `renderOrder` |
163
+ | `emission` | `rateOverTime`, `rateOverDistance`, `bursts: [{ time, count, cycles, interval, probability }]` |
164
+ | `shape` | `kind` (`point`, `sphere`, `hemisphere`, `cone`, `box`, `circle`, `edge`, `mesh`), `radius`, `thickness`, `arc`, `angle`, `length`, `size`, `emitFrom`, `randomDirection`, `spherizeDirection`, `vertices` |
165
+ | `start` | `lifetime`, `speed`, `size`, `size3D`, `rotation`, `color` |
166
+ | `forces` | `gravity`, `gravityMultiplier`, `drag`, `constantForce`, `orbit: { axis, speed }`, `noise: { strength, frequency, scroll, octaves, influenceOverLife }` |
167
+ | `overLifetime` | `color` (gradient), `size`, `sizeY`, `sizeZ`, `rotation` (angular speed) |
168
+ | `renderer` | `mode` (`billboard`, `stretched`, `horizontal`, `vertical`, `mesh`), `mesh`, `texture`, `sheet`, `blend`, `lit`, `pivot`, `speedScale`, `lengthScale` |
169
+
170
+ A **value** is a number, `{ "min": a, "max": b }` (rolled once per particle), or
171
+ `{ "curve": { "keys": [[t, v, inTangent, outTangent], …] } }` (read at the particle's age). A
172
+ **colour value** is `[r, g, b, a]`, `{ "min": …, "max": … }`, or `{ "gradient": [[t, r, g, b, a], …] }`.
173
+ Colours are sRGB in `0`–`1`; curves and gradients are baked into 64-sample rows both the CPU and the
174
+ GPU read the same way.
175
+
176
+ **Which way a shape faces.** Every shape is authored in the emitter's local space, and a directional
177
+ one sends particles along local `+Y`. Rotate the entity to aim it; a negative `start.speed` reverses
178
+ it. Two of them lie flat in the ground plane, which is the usual surprise:
179
+
180
+ | Shape | Spread | Direction |
181
+ | ---------------------- | ------------------------------------ | ------------------------------------------------------------ |
182
+ | `circle` | X and Z, nothing in Y | Radially outward in the XZ plane — a ring seen from above |
183
+ | `edge` | X only | `+Y` |
184
+ | `box` | X, Y and Z by `size` | `+Y` |
185
+ | `cone` | X and Z on the base disc by `radius` | `+Y`, opening out by `angle` — a wide `angle` spreads in X/Z |
186
+ | `sphere`, `hemisphere` | X, Y and Z by `radius` | Radially outward (`hemisphere` keeps `y >= 0`) |
187
+ | `point` | Nothing | `+Y` |
188
+ | `mesh` | The triangles you supply | Along each face normal |
189
+
190
+ A camera looking down `-Z` at a scene laid out in X and Y therefore sees a `circle` edge-on, as a
191
+ horizontal line, and sees a wide `cone` spread sideways while it travels up. For a fan in the camera
192
+ plane, use a `cone` with a small `angle` and let `shape.randomDirection` widen it, or rotate the
193
+ emitter ninety degrees about X so the circle faces the camera.
194
+
195
+ ### Choosing a blend
196
+
197
+ | Blend | Use it for | Why |
198
+ | --------------- | ------------------------------------ | ------------------------------------------------------------------------------ |
199
+ | `premultiplied` | Smoke, dust, mixed effects (default) | Fire and smoke can share one draw and still composite front to back correctly. |
200
+ | `additive` | Fire, sparks, glints, magic | Light adds; overlapping particles get brighter, and black is transparent. |
201
+ | `alpha` | Rain, leaves, anything with an edge | Straight alpha over the background, with no brightening. |
202
+
203
+ Particles never write depth and are never depth-sorted against each other. `main.renderOrder` orders
204
+ whole systems within the transparent phase; lower draws first.
205
+
206
+ ## Recipes
207
+
208
+ ### A muzzle flash a script fires
209
+
210
+ `emit()` runs before this frame's upload, so the flash appears on the frame the shot happens.
211
+
212
+ ```ts
213
+ import { Script } from "@ignifx/core";
214
+ import { ParticleSystem } from "@ignifx/particles";
215
+
216
+ /** Fires one burst of sparks per shot. */
217
+ export class Muzzle extends Script {
218
+ static typeId = "game/Muzzle";
219
+
220
+ #sparks: ParticleSystem | null = null;
221
+
222
+ awake(): void {
223
+ this.#sparks = this.entity.getComponent(ParticleSystem);
224
+ }
225
+
226
+ fire(): void {
227
+ this.#sparks?.emit(24);
228
+ }
229
+ }
230
+ ```
231
+
232
+ ### A one-shot explosion that cleans itself up
233
+
234
+ ```ts
235
+ import { Entity } from "@ignifx/core";
236
+ import { ParticleSystem, particleAssetFromDefinition, particleDefinition } from "@ignifx/particles";
237
+ import type { App } from "@ignifx/core";
238
+
239
+ /**
240
+ * Spawns an explosion that destroys its own entity when the last ember dies.
241
+ *
242
+ * @param app - The running app.
243
+ * @param at - Where to put it.
244
+ * @returns The entity, which destroys itself.
245
+ */
246
+ export function explodeAt(app: App, at: { x: number; y: number; z: number }): Entity {
247
+ const asset = particleAssetFromDefinition(app, particleDefinition("explosion"), "explosion");
248
+ const entity = app.world.createEntity("Explosion", { position: at });
249
+ const system = entity.addComponent(ParticleSystem, { definition: asset });
250
+ system.onStopped.connect(
251
+ () => {
252
+ entity.destroy();
253
+ },
254
+ { owner: entity },
255
+ );
256
+ return entity;
257
+ }
258
+ ```
259
+
260
+ `onStopped` fires once, when a non-looping document has run out of cycle **and** its last particle
261
+ has died. A looping document never stops on its own.
262
+
263
+ ### A rain document, as a file
264
+
265
+ ```json
266
+ {
267
+ "format": "ignifx.particles",
268
+ "formatVersion": 1,
269
+ "main": { "capacity": 2000, "duration": 2, "looping": true, "prewarm": true, "simulationSpace": "world" },
270
+ "emission": { "rateOverTime": 600 },
271
+ "shape": { "kind": "box", "size": { "x": 12, "y": 0.1, "z": 12 } },
272
+ "start": { "lifetime": 1.2, "speed": { "min": -9, "max": -11 }, "size": 0.02, "color": [0.7, 0.8, 1, 0.5] },
273
+ "forces": { "gravityMultiplier": 1 },
274
+ "renderer": { "mode": "stretched", "blend": "alpha", "speedScale": 0.03 }
275
+ }
276
+ ```
277
+
278
+ Load it the way any asset loads, and hand the handle to the component:
279
+
280
+ ```ts
281
+ import { createApp } from "@ignifx/core";
282
+ import { ParticleSystem, particles } from "@ignifx/particles";
283
+ import type { ParticleAsset } from "@ignifx/particles";
284
+
285
+ const app = await createApp({ headless: true, extensions: [particles()] });
286
+ await app.start();
287
+ const weather = app.assets.load<ParticleAsset>("fx/rain.particles.json");
288
+ app.world.createEntity("Weather", { position: { x: 0, y: 10, z: 0 } }).addComponent(ParticleSystem, {
289
+ definition: weather,
290
+ });
291
+ ```
292
+
293
+ A negative `start.speed` on a `box` shape emits downward: directional shapes emit along the
294
+ emitter's local `+Y`, so a negative speed reverses it. `simulationSpace: "world"` leaves each drop
295
+ where it was emitted, so moving the emitter does not drag the storm with it.
296
+
297
+ ### A quality setting
298
+
299
+ ```ts
300
+ import type { App } from "@ignifx/core";
301
+
302
+ /**
303
+ * Applies a three-step effects quality setting.
304
+ *
305
+ * @param app - The running app.
306
+ * @param level - `"low"`, `"medium"` or `"high"`.
307
+ */
308
+ export function setEffectsQuality(app: App, level: "low" | "medium" | "high"): void {
309
+ app.particles.qualityScale = level === "low" ? 0.25 : level === "medium" ? 0.6 : 1;
310
+ }
311
+ ```
312
+
313
+ `qualityScale` multiplies every rate and burst count on the next frame. It does not touch `emit()`,
314
+ because a script that asked for twenty-four sparks meant twenty-four.
315
+
316
+ ### A trail that follows a moving emitter
317
+
318
+ ```ts
319
+ import { particleDefinition } from "@ignifx/particles";
320
+
321
+ export const exhaust = particleDefinition("smoke", {
322
+ main: { simulationSpace: "world", capacity: 256 },
323
+ emission: { rateOverTime: 0, rateOverDistance: 12 },
324
+ start: { lifetime: { min: 0.6, max: 1.2 }, size: { min: 0.1, max: 0.25 }, speed: 0.2 },
325
+ });
326
+ ```
327
+
328
+ `rateOverDistance` emits per metre the emitter's entity moves, so a stationary ship makes no smoke.
329
+
330
+ ## File formats
331
+
332
+ | Format | Extension | Reference |
333
+ | ------------------ | ----------------- | ----------------------------------- |
334
+ | `ignifx.particles` | `.particles.json` | `skills/ignifx/references/formats/` |
335
+
336
+ Every module and every field is optional; `defineParticles` fills in the defaults and refuses a
337
+ document it cannot read with `IGX-1701`, naming the exact path — `start.lifetime.min`, not "invalid
338
+ document". A misspelled key is an error, not a silent no-op.
339
+
340
+ ## Gotchas
341
+
342
+ | Trap | What happens | Do this instead |
343
+ | ---------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
344
+ | Expecting particles to collide, or to spawn more particles | Neither is a function of the particle's age, so the shader cannot compute it. There is no collision module and no sub-emitter. | Hit an effect at the point your own code decides: play a second `ParticleSystem` there, or drive a `Rigidbody` for the few pieces that matter. |
345
+ | Expecting particles to sort against each other | They never write depth and are never depth-sorted, so two overlapping systems composite in draw order. | Use `additive` (order-independent), or set `main.renderOrder` to order whole systems. |
346
+ | A looping effect that starts empty and fills in | Without `prewarm` the first cycle is the effect filling up; a campfire the player walks up to should already be burning. | `"main": { "prewarm": true }` on a looping document, or call `system.simulate(seconds)` after `play()`. |
347
+ | A rate the capacity cannot hold | The ring overwrites the oldest live particle, so the effect visibly thins out. `droppedCount` counts each one. | `capacity` at least `rateOverTime × the longest lifetime`. Check `system.droppedCount` after a few seconds. |
348
+ | A system that draws nothing after a while | `app.particles.maxParticles` ran out and the system was clamped; `IGX-1702` was logged once, naming the entity. | Raise `maxParticles` in `ignifx.config.ts`, or give the document a smaller `capacity`. |
349
+ | `app.pause()` and an effect that keeps moving | It cannot: the system clock advances only while `time.paused` is false. An effect that _should_ keep moving while paused has no switch. | Nothing to do — pause is exact. For a menu background, keep it in its own app or run it with `main.timeScale` and your own `simulate()`. |
350
+ | `emit()` before the definition has loaded | `IGX-1705`: the system has no document, so it cannot spawn anything. | Await the handle, or emit from `update` and let the first frames pass; `aliveCount` stays `0` until the document arrives. |
351
+ | The first frames of a new effect drawing nothing | The generated program is loaded as an asset and compiled on first draw, which takes a few frames. | Expect it, or warm the effect up during a loading screen by adding the system while the screen is still showing. |
352
+ | Reading `app.time.time` to age particles | A system's clock is its own: `timeScale`, `pause()` and `simulate()` all move it independently. | Read `system.time`. |
353
+ | A gradient authored in linear colour | Document colours are sRGB in `0`–`1`, decoded on the way to the GPU, so linear values come out dark. | Author the numbers you would type into a colour picker. |
354
+ | Expecting `stop()` to clear the screen | It stops emission; the live particles finish their lives, which is what a torch being put out looks like. | `stop({ clear: true })` to drop them all at once. |
355
+
356
+ - `simulate(seconds)` advances the records at once, but `aliveCount` and the draw count refresh in the next `app.step()`, when the update system runs its census.
357
+
358
+ ## Deprecated (current window)
359
+
360
+ None (pre-1.0: no deprecation window; breaking changes are listed in the changelog).
361
+
362
+ ## Where to look next
363
+
364
+ `skills/ignifx/SKILL.md` for the engine entry skill · `skills/ignifx/references/api/particles.md` for
365
+ the generated API · `docs/plan/2026-09-terrain-particles-shaders.md` §4 for the design ·
366
+ `docs/adr/0025-stateless-gpu-particles.md` for why particles are stateless and what that costs ·
367
+ `packages/particles-2d/skills/particles-2d/SKILL.md` for the same documents drawn as sprites.
package/README.md DELETED
@@ -1,3 +0,0 @@
1
- # Temporary Holding Version
2
-
3
- This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.