@threenative/core 0.3.11 → 0.3.12

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.
Files changed (157) hide show
  1. package/capabilities.json +1096 -26
  2. package/dist/camera-shake-CZKOfGn4.d.ts +46 -0
  3. package/dist/{canvas-layer-vCtanIeB.d.ts → canvas-layer-CWuFRT7G.d.ts} +1 -1
  4. package/dist/chunk-2Z44XSI2.js +35 -0
  5. package/dist/chunk-5O73CDMR.js +1849 -0
  6. package/dist/chunk-6KLNISRJ.js +153 -0
  7. package/dist/chunk-7UUT3TY5.js +133 -0
  8. package/dist/chunk-CFGTPFUH.js +231 -0
  9. package/dist/chunk-DBELTTTM.js +615 -0
  10. package/dist/chunk-GMHATRPW.js +7701 -0
  11. package/dist/chunk-GXY7B3JG.js +46 -0
  12. package/dist/chunk-KIRUKTBQ.js +187 -0
  13. package/dist/chunk-N5LRP4BR.js +220 -0
  14. package/dist/chunk-OKXUCASC.js +2238 -0
  15. package/dist/chunk-QWJEMUUT.js +94 -0
  16. package/dist/chunk-VAZM36TV.js +497 -0
  17. package/dist/{game-DzMcitDO.d.ts → game-D7pAzZUY.d.ts} +15 -3
  18. package/dist/hot.d.ts +3 -3
  19. package/dist/hot.js +2 -46
  20. package/dist/index.d.ts +329 -302
  21. package/dist/index.js +10566 -22552
  22. package/dist/{model-lod-CTpZ6imz.d.ts → model-lod-B6BMqS1r.d.ts} +33 -3
  23. package/dist/playtest.d.ts +3 -3
  24. package/dist/playtest.js +24 -75
  25. package/dist/react-css.js +1 -215
  26. package/dist/react.d.ts +2 -2
  27. package/dist/{renderer-rZm0hVqq.d.ts → renderer-DvFVoAgj.d.ts} +13 -4
  28. package/dist/spells/index.d.ts +643 -0
  29. package/dist/spells/index.js +1558 -0
  30. package/dist/spells/ultra/index.d.ts +1600 -0
  31. package/dist/spells/ultra/index.js +6804 -0
  32. package/dist/terrain-jobs-worker.js +1 -123
  33. package/dist/two-sided-foliage-W523J3UM.js +1 -0
  34. package/dist/ui-layer.js +5 -384
  35. package/dist/worker.js +4 -41
  36. package/dist/world.d.ts +725 -259
  37. package/dist/world.js +16714 -18284
  38. package/mcp/animation-server.mjs +1 -1
  39. package/mcp/animation.mjs +2 -3
  40. package/mcp/engine-server.mjs +142 -47
  41. package/mcp/servers.mjs +9 -2
  42. package/mcp/terrain.mjs +8 -0
  43. package/package.json +14 -6
  44. package/patches/three@0.187.0-prd269-upgrade.patch +2102 -0
  45. package/patches/three@0.187.0.patch +2004 -407
  46. package/src/assets.ts +9 -2
  47. package/src/card-lod.ts +152 -0
  48. package/src/compressed-texture-preparation.ts +1008 -0
  49. package/src/frame-budget.ts +31 -20
  50. package/src/game-dev-tools.ts +93 -0
  51. package/src/game-frame-loop.ts +995 -0
  52. package/src/game-renderer-metrics.ts +77 -0
  53. package/src/game-startup.ts +1001 -0
  54. package/src/game-validate.ts +70 -0
  55. package/src/game.ts +253 -1935
  56. package/src/index.ts +27 -2
  57. package/src/launch-diagnostics.ts +22 -12
  58. package/src/look/ao-admission.ts +24 -0
  59. package/src/look/filmic-tone-mapping.ts +15 -13
  60. package/src/look/look-diagnostics.ts +3 -3
  61. package/src/look/quality.ts +10 -5
  62. package/src/look/world-environment.ts +76 -9
  63. package/src/loop.ts +29 -0
  64. package/src/model-lod.ts +42 -3
  65. package/src/particle-kinds.ts +515 -0
  66. package/src/picking.ts +17 -3
  67. package/src/playtest.ts +27 -1
  68. package/src/projection-apply.ts +4 -1
  69. package/src/projection-plan.ts +9 -6
  70. package/src/render/mesh-pool.ts +1 -1
  71. package/src/render/resolution-subrect.ts +2 -0
  72. package/src/render/rough-diffuse.ts +46 -12
  73. package/src/render/soft-shadow.ts +27 -12
  74. package/src/render/virtual-shadow-adaptive.ts +55 -0
  75. package/src/render/virtual-shadow-casters.ts +175 -0
  76. package/src/render/virtual-shadow-layers.ts +76 -0
  77. package/src/render/virtual-shadow-level.ts +224 -0
  78. package/src/render/virtual-shadow-markers.ts +193 -0
  79. package/src/render/virtual-shadow-options.ts +370 -0
  80. package/src/render/virtual-shadow-pages.ts +5 -0
  81. package/src/render/virtual-shadow.ts +213 -992
  82. package/src/render/world-impostor-surface.ts +293 -34
  83. package/src/render-pass-budget.ts +34 -7
  84. package/src/renderProjection.ts +22 -0
  85. package/src/renderer.ts +92 -37
  86. package/src/snow-field.ts +1 -1
  87. package/src/spells/cast-pool.ts +361 -0
  88. package/src/spells/index.ts +177 -0
  89. package/src/spells/mechanisms.ts +295 -0
  90. package/src/spells/reaction-field.ts +415 -0
  91. package/src/spells/spell-lights.ts +139 -0
  92. package/src/spells/spell-world.ts +187 -0
  93. package/src/spells/spell.ts +397 -0
  94. package/src/spells/spells.ts +283 -0
  95. package/src/spells/ultra/engine/camera.ts +184 -0
  96. package/src/spells/ultra/engine/quality.ts +96 -0
  97. package/src/spells/ultra/index.ts +52 -0
  98. package/src/spells/ultra/main.ts +305 -0
  99. package/src/spells/ultra/scene/arenaMaterial.ts +325 -0
  100. package/src/spells/ultra/spells/cast.ts +233 -0
  101. package/src/spells/ultra/spells/fire.ts +1267 -0
  102. package/src/spells/ultra/vfx/FluidVolume.ts +816 -0
  103. package/src/spells/ultra/vfx/FluidVolume.tsl.ts +855 -0
  104. package/src/spells/ultra/vfx/FxTarget.ts +61 -0
  105. package/src/spells/ultra/vfx/GroundField.ts +1399 -0
  106. package/src/spells/ultra/vfx/Particles.ts +1475 -0
  107. package/src/spells/ultra/vfx/Ribbons.ts +645 -0
  108. package/src/spells/ultra/vfx/Shockwaves.ts +286 -0
  109. package/src/spells/ultra/vfx/Volumes.ts +489 -0
  110. package/src/spells/ultra/vfx/common.ts +1195 -0
  111. package/src/spells/ultra/vfx/noise.ts +441 -0
  112. package/src/startup-readiness.ts +128 -34
  113. package/src/version.ts +1 -1
  114. package/src/warmup.ts +56 -8
  115. package/src/water-surface.ts +9 -3
  116. package/src/world-bundle-safety.ts +401 -0
  117. package/src/world-cell-batches.ts +1216 -0
  118. package/src/world-cell-chunks.ts +1132 -0
  119. package/src/world-cell-data.ts +995 -0
  120. package/src/world-cell-impostors.ts +1449 -0
  121. package/src/world-cell-lod-bias.ts +151 -0
  122. package/src/world-cell-models.ts +1074 -0
  123. package/src/world-cell-options.ts +189 -0
  124. package/src/world-cell-placements.ts +694 -0
  125. package/src/world-cell-prewarm.ts +557 -0
  126. package/src/world-cell-readiness.ts +357 -0
  127. package/src/world-cell-render-bundles.ts +459 -0
  128. package/src/world-cell-render-gpu-dress.ts +714 -0
  129. package/src/world-cell-render-main-cull.ts +484 -0
  130. package/src/world-cell-render-shadow-claims.ts +198 -0
  131. package/src/world-cell-render-util.ts +246 -0
  132. package/src/world-cell-render.ts +1493 -0
  133. package/src/world-cell-residency.ts +745 -0
  134. package/src/world-cells.ts +1318 -10418
  135. package/src/world-chunk-shadow.ts +308 -0
  136. package/src/world-collar.ts +315 -0
  137. package/src/world-gpu-flags.ts +163 -0
  138. package/src/world-gpu-readback.ts +881 -0
  139. package/src/world-gpu-reference.ts +510 -0
  140. package/src/world-gpu-scene.ts +214 -2264
  141. package/src/world-gpu-shadow.ts +190 -0
  142. package/src/world-gpu-types.ts +381 -0
  143. package/src/world-gpu-validation.ts +518 -0
  144. package/src/world-heightfield.ts +802 -0
  145. package/src/world-load-limiter.ts +106 -0
  146. package/src/world-noise.ts +241 -0
  147. package/src/world-package.ts +42 -0
  148. package/src/world-region.ts +1 -1
  149. package/src/world-terrain-splat.ts +365 -149
  150. package/src/world-tile-budget.ts +256 -0
  151. package/src/world-tile-geometry.ts +469 -0
  152. package/src/world-tile-lod.ts +408 -0
  153. package/src/world-tile-observation.ts +566 -0
  154. package/src/world-tile-stitch.ts +166 -0
  155. package/src/world-tiles.ts +170 -1745
  156. package/src/world-water-bodies.ts +359 -0
  157. package/src/world.ts +35 -741
@@ -0,0 +1,1600 @@
1
+ import * as three_webgpu from 'three/webgpu';
2
+ import { WebGPURenderer, Group, Camera, Vector3 as Vector3$1, Vector2 as Vector2$1, Vector4 as Vector4$1, QuadMesh, Node, RenderTarget, Color, Mesh, MeshBasicNodeMaterial, NodeMaterial, ColorRepresentation, DataTexture as DataTexture$1, Quaternion, BufferGeometry } from 'three/webgpu';
3
+ import * as three from 'three';
4
+ import { Vector3, Vector2, DataTexture, Vector4, Data3DTexture, Group as Group$1, RenderTarget as RenderTarget$1, Camera as Camera$1, Color as Color$1, Texture, Scene, OrthographicCamera, Object3D, PointLight } from 'three';
5
+ import { texture } from 'three/tsl';
6
+
7
+ declare const TIERS: {
8
+ low: {
9
+ resolution: number;
10
+ msaa: number;
11
+ fxScale: number;
12
+ particles: number[];
13
+ debris: number;
14
+ volumeSteps: number;
15
+ noiseSize: number;
16
+ groundSize: number;
17
+ reflections: boolean;
18
+ reflectionScale: number;
19
+ reflectFx: boolean;
20
+ maxLights: number;
21
+ shadowLights: number;
22
+ bloomLevels: number;
23
+ emission: number;
24
+ fluidIterations: number;
25
+ };
26
+ medium: {
27
+ resolution: number;
28
+ msaa: number;
29
+ fxScale: number;
30
+ particles: number[];
31
+ debris: number;
32
+ volumeSteps: number;
33
+ noiseSize: number;
34
+ groundSize: number;
35
+ reflections: boolean;
36
+ reflectionScale: number;
37
+ reflectFx: boolean;
38
+ maxLights: number;
39
+ shadowLights: number;
40
+ bloomLevels: number;
41
+ emission: number;
42
+ };
43
+ high: {
44
+ resolution: number;
45
+ msaa: number;
46
+ fxScale: number;
47
+ particles: number[];
48
+ debris: number;
49
+ volumeSteps: number;
50
+ noiseSize: number;
51
+ groundSize: number;
52
+ reflections: boolean;
53
+ reflectionScale: number;
54
+ reflectFx: boolean;
55
+ maxLights: number;
56
+ shadowLights: number;
57
+ bloomLevels: number;
58
+ emission: number;
59
+ };
60
+ ultra: {
61
+ resolution: number;
62
+ msaa: number;
63
+ fxScale: number;
64
+ particles: number[];
65
+ debris: number;
66
+ volumeSteps: number;
67
+ noiseSize: number;
68
+ groundSize: number;
69
+ reflections: boolean;
70
+ reflectionScale: number;
71
+ reflectFx: boolean;
72
+ maxLights: number;
73
+ shadowLights: number;
74
+ bloomLevels: number;
75
+ emission: number;
76
+ fluid: boolean;
77
+ anamorphic: boolean;
78
+ };
79
+ };
80
+ declare const Q: {
81
+ autoResolution: boolean;
82
+ auto: {
83
+ emission: number;
84
+ steps: number;
85
+ };
86
+ resolution: number;
87
+ msaa: number;
88
+ fxScale: number;
89
+ particles: number[];
90
+ debris: number;
91
+ volumeSteps: number;
92
+ noiseSize: number;
93
+ groundSize: number;
94
+ reflections: boolean;
95
+ reflectionScale: number;
96
+ reflectFx: boolean;
97
+ maxLights: number;
98
+ shadowLights: number;
99
+ bloomLevels: number;
100
+ emission: number;
101
+ fluidIterations: number;
102
+ tier: "low" | "medium" | "high" | "ultra";
103
+ mobile: boolean;
104
+ } | {
105
+ autoResolution: boolean;
106
+ auto: {
107
+ emission: number;
108
+ steps: number;
109
+ };
110
+ resolution: number;
111
+ msaa: number;
112
+ fxScale: number;
113
+ particles: number[];
114
+ debris: number;
115
+ volumeSteps: number;
116
+ noiseSize: number;
117
+ groundSize: number;
118
+ reflections: boolean;
119
+ reflectionScale: number;
120
+ reflectFx: boolean;
121
+ maxLights: number;
122
+ shadowLights: number;
123
+ bloomLevels: number;
124
+ emission: number;
125
+ tier: "low" | "medium" | "high" | "ultra";
126
+ mobile: boolean;
127
+ } | {
128
+ autoResolution: boolean;
129
+ auto: {
130
+ emission: number;
131
+ steps: number;
132
+ };
133
+ resolution: number;
134
+ msaa: number;
135
+ fxScale: number;
136
+ particles: number[];
137
+ debris: number;
138
+ volumeSteps: number;
139
+ noiseSize: number;
140
+ groundSize: number;
141
+ reflections: boolean;
142
+ reflectionScale: number;
143
+ reflectFx: boolean;
144
+ maxLights: number;
145
+ shadowLights: number;
146
+ bloomLevels: number;
147
+ emission: number;
148
+ tier: "low" | "medium" | "high" | "ultra";
149
+ mobile: boolean;
150
+ } | {
151
+ autoResolution: boolean;
152
+ auto: {
153
+ emission: number;
154
+ steps: number;
155
+ };
156
+ resolution: number;
157
+ msaa: number;
158
+ fxScale: number;
159
+ particles: number[];
160
+ debris: number;
161
+ volumeSteps: number;
162
+ noiseSize: number;
163
+ groundSize: number;
164
+ reflections: boolean;
165
+ reflectionScale: number;
166
+ reflectFx: boolean;
167
+ maxLights: number;
168
+ shadowLights: number;
169
+ bloomLevels: number;
170
+ emission: number;
171
+ fluid: boolean;
172
+ anamorphic: boolean;
173
+ tier: "low" | "medium" | "high" | "ultra";
174
+ mobile: boolean;
175
+ };
176
+
177
+ declare const ARENA: {
178
+ radius: number;
179
+ wallThickness: number;
180
+ wallHeight: number;
181
+ pillarRing: number;
182
+ pillarRadius: number;
183
+ pillarHeight: number;
184
+ pillars: Vector3[];
185
+ focus: Vector3;
186
+ pedestal: {
187
+ pos: Vector3;
188
+ radius: number;
189
+ height: number;
190
+ };
191
+ dummies: Vector3[];
192
+ dummyRadius: number;
193
+ dummyHeight: number;
194
+ pool: {
195
+ center: Vector2;
196
+ half: Vector2;
197
+ depth: number;
198
+ water: number;
199
+ };
200
+ ground: {
201
+ min: Vector2;
202
+ size: number;
203
+ };
204
+ };
205
+ declare const U: {
206
+ uTime: three_webgpu.UniformNode<"float", number>;
207
+ uDt: three_webgpu.UniformNode<"float", number>;
208
+ uFrame: three_webgpu.UniformNode<"float", number>;
209
+ uWorld: {
210
+ value: DataTexture;
211
+ };
212
+ uWorldCounts: three_webgpu.UniformNode<"vec4", Vector4>;
213
+ uNoise3D: {
214
+ value: Data3DTexture;
215
+ };
216
+ uCurl3D: {
217
+ value: Data3DTexture;
218
+ };
219
+ uBlackbody: {
220
+ value: DataTexture;
221
+ };
222
+ uGroundA: {
223
+ value: DataTexture;
224
+ };
225
+ uGroundB: {
226
+ value: DataTexture;
227
+ };
228
+ uGroundRect: three_webgpu.UniformNode<"vec4", Vector4>;
229
+ uSceneDepth: {
230
+ value: null;
231
+ };
232
+ uSceneColor: {
233
+ value: null;
234
+ };
235
+ uResolution: three_webgpu.UniformNode<"vec2", Vector2>;
236
+ uFxResolution: three_webgpu.UniformNode<"vec2", Vector2>;
237
+ uNearFar: three_webgpu.UniformNode<"vec2", Vector2>;
238
+ uSunDir: three_webgpu.UniformNode<"vec3", Vector3>;
239
+ uSunColor: three_webgpu.UniformNode<"vec3", Vector3>;
240
+ uAmbient: three_webgpu.UniformNode<"vec3", Vector3>;
241
+ uSkyCube: {
242
+ value: null;
243
+ };
244
+ uDebug: three_webgpu.UniformNode<"float", number>;
245
+ uFxParams: three_webgpu.UniformNode<"vec4", Vector4>;
246
+ };
247
+ interface IPoolItem {
248
+ index: number;
249
+ active: boolean;
250
+ }
251
+ interface IOccluder {
252
+ a: Vector3;
253
+ b: Vector3;
254
+ radius: number;
255
+ kind: number;
256
+ release(): void;
257
+ }
258
+ declare const vec3Uniform: (v: Vector3) => three_webgpu.UniformNode<"vec3", Vector3>;
259
+ type Vec3Uniform = ReturnType<typeof vec3Uniform>;
260
+ interface IMat3Rows {
261
+ x: Vec3Uniform;
262
+ y: Vec3Uniform;
263
+ z: Vec3Uniform;
264
+ }
265
+
266
+ type Phase = "charge" | "release" | "travel" | "impact" | "linger" | "done";
267
+ interface ISpellInstance {
268
+ phase?(c: ICast, name: Phase): void;
269
+ update?(c: ICast, dt: number): void;
270
+ travel?(c: ICast, dt: number): boolean;
271
+ onParam?(k: string): void;
272
+ }
273
+ interface ISpell {
274
+ id: string;
275
+ name: string;
276
+ shape?: string;
277
+ forms?: string[];
278
+ formShapes?: Record<string, string>;
279
+ radius?: number;
280
+ speed?: number;
281
+ lob?: number;
282
+ params?: Record<string, number | string>;
283
+ timing?: {
284
+ charge?: number;
285
+ impact?: number;
286
+ linger?: number;
287
+ sustain?: number;
288
+ };
289
+ inst?: ISpellInstance;
290
+ }
291
+ interface ICast {
292
+ index: number;
293
+ alive: boolean;
294
+ spell: ISpell | null;
295
+ inst: ISpellInstance | null;
296
+ form: string;
297
+ shape: string;
298
+ phase: Phase;
299
+ t: number;
300
+ age: number;
301
+ seed: number;
302
+ from: Vector3;
303
+ to: Vector3;
304
+ pos: Vector3;
305
+ vel: Vector3;
306
+ dir: Vector3;
307
+ held: boolean;
308
+ travelled: number;
309
+ target: number;
310
+ data: Record<string, unknown>;
311
+ durations: {
312
+ charge: number;
313
+ travel: number;
314
+ impact: number;
315
+ linger: number;
316
+ };
317
+ }
318
+ declare class Casts {
319
+ fx: {
320
+ rand(): number;
321
+ };
322
+ list: ICast[];
323
+ last: ICast | null;
324
+ constructor(fx: {
325
+ rand(): number;
326
+ });
327
+ cast(spell: ISpell, to: Vector3, { form, from, target, held, seed, }?: {
328
+ form?: string;
329
+ from?: Vector3;
330
+ target?: number;
331
+ held?: boolean;
332
+ seed?: number;
333
+ }): ICast;
334
+ enter(c: ICast, phase: Phase): void;
335
+ releaseHeld(): void;
336
+ clear(): void;
337
+ update(dt: number): void;
338
+ active(): ICast | null;
339
+ count(): number;
340
+ }
341
+
342
+ type TexNode = ReturnType<typeof texture>;
343
+
344
+ interface IFluidSource {
345
+ pos: Vector3$1;
346
+ radius?: number;
347
+ fuel?: number;
348
+ temp?: number;
349
+ soot?: number;
350
+ vel?: Vector3$1;
351
+ radial?: number;
352
+ noise?: number;
353
+ noiseScale?: number;
354
+ seed?: number;
355
+ coupling?: number;
356
+ burst?: boolean;
357
+ }
358
+ type U4 = Node<"vec4"> & {
359
+ value: Vector4$1;
360
+ };
361
+ type U3 = Node<"vec3"> & {
362
+ value: Vector3$1;
363
+ };
364
+ type U2 = Node<"vec2"> & {
365
+ value: Vector2$1;
366
+ };
367
+ type U1 = Node<"float"> & {
368
+ value: number;
369
+ };
370
+ type Tex$1 = TexNode;
371
+ interface IRenderUniforms {
372
+ uS: Tex$1;
373
+ uL0: Tex$1;
374
+ uDim: U3;
375
+ uTiles: U2;
376
+ uInv: U2;
377
+ uCDim: U3;
378
+ uCTiles: U2;
379
+ uCInv: U2;
380
+ uOrigin: U3;
381
+ uH: U1;
382
+ uMarch: U4;
383
+ uMarch2: U4;
384
+ uLit: U4;
385
+ uSootColor: U3;
386
+ uDetail: U4;
387
+ uDetailC: U3;
388
+ uLook0: U4;
389
+ uLook1: U4;
390
+ uTint: U3;
391
+ }
392
+ declare class FluidDomain {
393
+ [field: string]: unknown;
394
+ sys: FluidVolume;
395
+ W: number;
396
+ H: number;
397
+ cW: number;
398
+ cH: number;
399
+ state: RenderTarget[];
400
+ tmp: RenderTarget;
401
+ curl: RenderTarget;
402
+ press: RenderTarget[];
403
+ light: RenderTarget;
404
+ all: RenderTarget[];
405
+ dim: Vector3$1;
406
+ tiles: Vector2$1;
407
+ cdim: Vector3$1;
408
+ ctiles: Vector2$1;
409
+ h: number;
410
+ size: Vector3$1;
411
+ position: Vector3$1;
412
+ origin: Vector3$1;
413
+ lastOrigin: Vector3$1;
414
+ tint: Color;
415
+ sootColor: Color;
416
+ detailCenter: Vector3$1;
417
+ obstacle: Vector4$1;
418
+ srcP: Vector4$1[];
419
+ srcA: Vector4$1[];
420
+ srcV: Vector4$1[];
421
+ srcB: Vector4$1[];
422
+ nSrc: number;
423
+ active: boolean;
424
+ cur: number;
425
+ pc: number;
426
+ fresh: boolean;
427
+ heat: number;
428
+ fuelPool: number;
429
+ mesh: Mesh;
430
+ material: MeshBasicNodeMaterial;
431
+ uniforms: IRenderUniforms;
432
+ ignition: number;
433
+ burnRate: number;
434
+ heatPerFuel: number;
435
+ sootYield: number;
436
+ expansion: number;
437
+ cooling: number;
438
+ radiative: number;
439
+ sootDecay: number;
440
+ fuelDecay: number;
441
+ buoyancy: number;
442
+ sootWeight: number;
443
+ vorticity: number;
444
+ forceCoupling: number;
445
+ damping: number;
446
+ emission: number;
447
+ temperature: number;
448
+ sootDensity: number;
449
+ flameDensity: number;
450
+ fuelDensity: number;
451
+ absorb: number;
452
+ g: number;
453
+ sun: number;
454
+ sky: number;
455
+ fireLight: number;
456
+ upres: number;
457
+ upresScale: number;
458
+ edgeFade: number;
459
+ visible: boolean;
460
+ turbulence: number;
461
+ turbulenceFreq: number;
462
+ sootCool: number;
463
+ sootErode: number;
464
+ detailFreq: number;
465
+ detailErode: number;
466
+ detailHeat: number;
467
+ nearFade: number;
468
+ emptyBelow: number;
469
+ stepScale: number;
470
+ chroma: number;
471
+ constructor(sys: FluidVolume, W: number, H: number, cW: number, cH: number);
472
+ setGrid(nx: number, ny: number, nz: number, tiles: number[], cn: number[], ctiles: number[], h: number): void;
473
+ emit(s: IFluidSource): void;
474
+ clear(): void;
475
+ release(): void;
476
+ }
477
+ declare class FullscreenPass<O extends object> {
478
+ readonly uniforms: O;
479
+ readonly quad: QuadMesh;
480
+ constructor(uniforms: O, outputs: Node<"vec4">[]);
481
+ render(renderer: WebGPURenderer, out: RenderTarget): void;
482
+ }
483
+ interface IFluidFx {
484
+ renderer?: WebGPURenderer;
485
+ scenes: {
486
+ fx: Group;
487
+ };
488
+ systems: {
489
+ update(dt: number, camera: Camera): void;
490
+ }[];
491
+ fluidVolume?: FluidVolume;
492
+ }
493
+ declare class FluidVolume {
494
+ static get(fx: IFluidFx): FluidVolume;
495
+ fx: IFluidFx;
496
+ renderer: WebGPURenderer;
497
+ res: number;
498
+ iterations: number;
499
+ stepVox: number;
500
+ maxSteps: number;
501
+ dt: number;
502
+ pending: number;
503
+ lastFrame: number | undefined;
504
+ su: {
505
+ uDim: three_webgpu.UniformNode<"vec3", Vector3$1>;
506
+ uTiles: three_webgpu.UniformNode<"vec2", Vector2$1>;
507
+ uInv: three_webgpu.UniformNode<"vec2", Vector2$1>;
508
+ uOrigin: three_webgpu.UniformNode<"vec3", Vector3$1>;
509
+ uH: three_webgpu.UniformNode<"float", number>;
510
+ uSimDt: three_webgpu.UniformNode<"float", number>;
511
+ uShift: three_webgpu.UniformNode<"vec3", Vector3$1>;
512
+ uObst: three_webgpu.UniformNode<"vec4", Vector4$1>;
513
+ };
514
+ look: {
515
+ uLook0: three_webgpu.UniformNode<"vec4", Vector4$1>;
516
+ uLook1: three_webgpu.UniformNode<"vec4", Vector4$1>;
517
+ uTint: three_webgpu.UniformNode<"vec3", Vector3$1>;
518
+ };
519
+ passes: {
520
+ advect: FullscreenPass<{
521
+ uV: three_webgpu.TextureNode<"vec4">;
522
+ uS: three_webgpu.TextureNode<"vec4">;
523
+ }>;
524
+ correct: FullscreenPass<{
525
+ uV: three_webgpu.TextureNode<"vec4">;
526
+ uS: three_webgpu.TextureNode<"vec4">;
527
+ uVf: three_webgpu.TextureNode<"vec4">;
528
+ uSf: three_webgpu.TextureNode<"vec4">;
529
+ uMacCormack: three_webgpu.UniformNode<"float", number>;
530
+ }>;
531
+ curl: FullscreenPass<{
532
+ uV: three_webgpu.TextureNode<"vec4">;
533
+ }>;
534
+ react: FullscreenPass<{
535
+ uV: three_webgpu.TextureNode<"vec4">;
536
+ uS: three_webgpu.TextureNode<"vec4">;
537
+ uC: three_webgpu.TextureNode<"vec4">;
538
+ uSrcP: three_webgpu.UniformNode<"vec4", Vector4$1>[];
539
+ uSrcA: three_webgpu.UniformNode<"vec4", Vector4$1>[];
540
+ uSrcV: three_webgpu.UniformNode<"vec4", Vector4$1>[];
541
+ uSrcB: three_webgpu.UniformNode<"vec4", Vector4$1>[];
542
+ uSrcN: three_webgpu.UniformNode<"int", number>;
543
+ uBurn: three_webgpu.UniformNode<"vec4", Vector4$1>;
544
+ uDecay: three_webgpu.UniformNode<"vec4", Vector4$1>;
545
+ uForce: three_webgpu.UniformNode<"vec4", Vector4$1>;
546
+ uFlow: three_webgpu.UniformNode<"vec4", Vector4$1>;
547
+ uTurb: three_webgpu.UniformNode<"vec4", Vector4$1>;
548
+ }>;
549
+ diverge: FullscreenPass<{
550
+ uV: three_webgpu.TextureNode<"vec4">;
551
+ uS: three_webgpu.TextureNode<"vec4">;
552
+ uP: three_webgpu.TextureNode<"vec4">;
553
+ uWarm: three_webgpu.UniformNode<"float", number>;
554
+ }>;
555
+ jacobi: FullscreenPass<{
556
+ uP: three_webgpu.TextureNode<"vec4">;
557
+ }>;
558
+ project: FullscreenPass<{
559
+ uV: three_webgpu.TextureNode<"vec4">;
560
+ uS: three_webgpu.TextureNode<"vec4">;
561
+ uP: three_webgpu.TextureNode<"vec4">;
562
+ }>;
563
+ light: FullscreenPass<{
564
+ uS: three_webgpu.TextureNode<"vec4">;
565
+ uC: three_webgpu.TextureNode<"vec4">;
566
+ uCDim: three_webgpu.UniformNode<"vec3", Vector3$1>;
567
+ uCTiles: three_webgpu.UniformNode<"vec2", Vector2$1>;
568
+ uCInv: three_webgpu.UniformNode<"vec2", Vector2$1>;
569
+ uLightP: three_webgpu.UniformNode<"vec4", Vector4$1>;
570
+ uLook0: three_webgpu.UniformNode<"vec4", Vector4$1>;
571
+ uLook1: three_webgpu.UniformNode<"vec4", Vector4$1>;
572
+ uTint: three_webgpu.UniformNode<"vec3", Vector3$1>;
573
+ }>;
574
+ };
575
+ domains: FluidDomain[];
576
+ constructor(fx: IFluidFx);
577
+ layout(d: FluidDomain, size: number[], res: number): boolean;
578
+ acquire({ size, res, position, }?: {
579
+ size?: number[];
580
+ res?: number;
581
+ position?: Vector3$1 | null;
582
+ }): FluidDomain | null;
583
+ get active(): boolean;
584
+ clearDomain(d: FluidDomain): void;
585
+ draw(name: keyof FluidVolume["passes"], out: RenderTarget): {
586
+ uV: three_webgpu.TextureNode<"vec4">;
587
+ uS: three_webgpu.TextureNode<"vec4">;
588
+ } | {
589
+ uV: three_webgpu.TextureNode<"vec4">;
590
+ uS: three_webgpu.TextureNode<"vec4">;
591
+ uVf: three_webgpu.TextureNode<"vec4">;
592
+ uSf: three_webgpu.TextureNode<"vec4">;
593
+ uMacCormack: three_webgpu.UniformNode<"float", number>;
594
+ } | {
595
+ uV: three_webgpu.TextureNode<"vec4">;
596
+ } | {
597
+ uV: three_webgpu.TextureNode<"vec4">;
598
+ uS: three_webgpu.TextureNode<"vec4">;
599
+ uC: three_webgpu.TextureNode<"vec4">;
600
+ uSrcP: three_webgpu.UniformNode<"vec4", Vector4$1>[];
601
+ uSrcA: three_webgpu.UniformNode<"vec4", Vector4$1>[];
602
+ uSrcV: three_webgpu.UniformNode<"vec4", Vector4$1>[];
603
+ uSrcB: three_webgpu.UniformNode<"vec4", Vector4$1>[];
604
+ uSrcN: three_webgpu.UniformNode<"int", number>;
605
+ uBurn: three_webgpu.UniformNode<"vec4", Vector4$1>;
606
+ uDecay: three_webgpu.UniformNode<"vec4", Vector4$1>;
607
+ uForce: three_webgpu.UniformNode<"vec4", Vector4$1>;
608
+ uFlow: three_webgpu.UniformNode<"vec4", Vector4$1>;
609
+ uTurb: three_webgpu.UniformNode<"vec4", Vector4$1>;
610
+ } | {
611
+ uV: three_webgpu.TextureNode<"vec4">;
612
+ uS: three_webgpu.TextureNode<"vec4">;
613
+ uP: three_webgpu.TextureNode<"vec4">;
614
+ uWarm: three_webgpu.UniformNode<"float", number>;
615
+ } | {
616
+ uP: three_webgpu.TextureNode<"vec4">;
617
+ } | {
618
+ uV: three_webgpu.TextureNode<"vec4">;
619
+ uS: three_webgpu.TextureNode<"vec4">;
620
+ uP: three_webgpu.TextureNode<"vec4">;
621
+ } | {
622
+ uS: three_webgpu.TextureNode<"vec4">;
623
+ uC: three_webgpu.TextureNode<"vec4">;
624
+ uCDim: three_webgpu.UniformNode<"vec3", Vector3$1>;
625
+ uCTiles: three_webgpu.UniformNode<"vec2", Vector2$1>;
626
+ uCInv: three_webgpu.UniformNode<"vec2", Vector2$1>;
627
+ uLightP: three_webgpu.UniformNode<"vec4", Vector4$1>;
628
+ uLook0: three_webgpu.UniformNode<"vec4", Vector4$1>;
629
+ uLook1: three_webgpu.UniformNode<"vec4", Vector4$1>;
630
+ uTint: three_webgpu.UniformNode<"vec3", Vector3$1>;
631
+ };
632
+ step(d: FluidDomain, dt: number): void;
633
+ setLook(d: FluidDomain, u: {
634
+ uLook0: U4;
635
+ uLook1: U4;
636
+ uTint: U3;
637
+ }): void;
638
+ update(dt0: number, camera: Camera): void;
639
+ }
640
+
641
+ declare class FxTarget {
642
+ readonly scene: Group$1<three.Object3DEventMap>;
643
+ readonly params: {
644
+ smokeOccludesGlow: number;
645
+ distortion: number;
646
+ ca: number;
647
+ };
648
+ readonly invert: Vector4;
649
+ readonly ratio: {
650
+ x: number;
651
+ y: number;
652
+ };
653
+ constructor();
654
+ setSize(w: number, h: number, scale: number): void;
655
+ render(): void;
656
+ }
657
+
658
+ interface IFieldRenderer {
659
+ setRenderTarget(target: RenderTarget$1 | null): void;
660
+ getRenderTarget(): RenderTarget$1 | null;
661
+ render(scene: object, camera: Camera$1): void;
662
+ getClearColor(target: Color$1): Color$1;
663
+ getClearAlpha(): number;
664
+ setClearColor(color: Color$1 | number, alpha?: number): void;
665
+ readRenderTargetPixelsAsync(target: RenderTarget$1, x: number, y: number, w: number, h: number): Promise<ArrayLike<number>>;
666
+ info?: {
667
+ engine?: {
668
+ frameGateSkips?: number;
669
+ };
670
+ };
671
+ }
672
+ interface IFieldTarget {
673
+ a: RenderTarget$1;
674
+ b: RenderTarget$1;
675
+ textures: [Texture, Texture];
676
+ }
677
+ interface IRegion {
678
+ x0: number;
679
+ z0: number;
680
+ x1: number;
681
+ z1: number;
682
+ until: number;
683
+ }
684
+ interface ISplat {
685
+ x?: number;
686
+ z?: number;
687
+ radius?: number;
688
+ heat?: number;
689
+ char?: number;
690
+ wet?: number;
691
+ frost?: number;
692
+ crack?: number;
693
+ acid?: number;
694
+ corruption?: number;
695
+ glow?: number;
696
+ pattern?: string;
697
+ seed?: number;
698
+ angle?: number;
699
+ x2?: number;
700
+ z2?: number;
701
+ width?: number;
702
+ lobe?: number;
703
+ }
704
+ declare class GroundField {
705
+ readonly renderer: IFieldRenderer;
706
+ readonly size: number;
707
+ readonly partial: boolean;
708
+ readonly targets: [IFieldTarget, IFieldTarget];
709
+ parity: number;
710
+ params: {
711
+ heatTau: number;
712
+ heatDiffusion: number;
713
+ charRate: number;
714
+ charTau: number;
715
+ evaporation: number;
716
+ wetTau: number;
717
+ melt: number;
718
+ frostTau: number;
719
+ frostSpeed: number;
720
+ frostDrop: number;
721
+ frostThreshold: number;
722
+ frostWaterDrop: number;
723
+ crackSpeed: number;
724
+ crackDrop: number;
725
+ crackTau: number;
726
+ corruptionSpeed: number;
727
+ corruptionDrop: number;
728
+ corruptionTau: number;
729
+ acidTau: number;
730
+ acidSpread: number;
731
+ glowTau: number;
732
+ poolQuench: number;
733
+ cleanse: number;
734
+ };
735
+ readonly mask: RenderTarget$1;
736
+ readonly splatVecs: Vector4[];
737
+ splatCount: number;
738
+ seed: number;
739
+ fp16Truncates: boolean;
740
+ time: number;
741
+ readonly regions: IRegion[];
742
+ readonly boxes: Vector4[];
743
+ boxCount: number;
744
+ band: number;
745
+ readonly bandDt: Float32Array;
746
+ private _full;
747
+ private _q;
748
+ private _u;
749
+ private readonly _k;
750
+ private readonly _bandRect;
751
+ private readonly _splatData;
752
+ private readonly _splatTex;
753
+ private readonly _uni;
754
+ private readonly _srcA;
755
+ private readonly _srcB;
756
+ private readonly _simA;
757
+ private readonly _simB;
758
+ private readonly _zero;
759
+ private readonly _quad;
760
+ readonly paintTargetA: RenderTarget$1;
761
+ readonly paintTargetB: RenderTarget$1;
762
+ private readonly _clearColor;
763
+ readonly paintScene: Scene<three.Object3DEventMap>;
764
+ readonly paintSceneB: Scene<three.Object3DEventMap>;
765
+ readonly paintCamera: OrthographicCamera;
766
+ readonly probes: Float32Array<ArrayBuffer>;
767
+ probeCount: number;
768
+ private _probeN;
769
+ private readonly _probeXZ;
770
+ private readonly _probeData;
771
+ private readonly _probeTex;
772
+ readonly probeRT: RenderTarget$1;
773
+ private readonly _probeMat;
774
+ private _probeReading;
775
+ private _maskMat;
776
+ constructor(renderer: IFieldRenderer, size?: number, { partial }?: {
777
+ partial?: boolean | undefined;
778
+ });
779
+ get current(): IFieldTarget;
780
+ splat({ x, z, radius, heat, char, wet, frost, crack, acid, corruption, glow, pattern, seed, angle, x2, z2, width, lobe, }?: ISplat): boolean;
781
+ touch(x: number, z: number, radius: number, seconds?: number): void;
782
+ _region(x0: number, z0: number, x1: number, z1: number, seconds: number): void;
783
+ update(dt: number): void;
784
+ _cluster(): void;
785
+ _factors(k: Vector4[], o: number, dt: number, band: boolean): void;
786
+ _skips(): number;
787
+ _bakeMask(): void;
788
+ _step(): void;
789
+ _draw(material: NodeMaterial, target: RenderTarget$1): void;
790
+ clear(): void;
791
+ setProbes(points: readonly (readonly [number, number] | number[])[]): void;
792
+ _readProbes(): void;
793
+ dispose(): void;
794
+ }
795
+
796
+ declare const STYLES: readonly ["glow", "media", "debris"];
797
+ type Style = (typeof STYLES)[number];
798
+ declare const SHAPES$1: {
799
+ sphere: number;
800
+ shell: number;
801
+ disk: number;
802
+ ring: number;
803
+ line: number;
804
+ cone: number;
805
+ };
806
+ declare const KIND_DEFAULTS: {
807
+ style: Style;
808
+ flicker: number;
809
+ drag: number;
810
+ gravity: number;
811
+ buoyancy: number;
812
+ curl: number;
813
+ curlScale: number;
814
+ forceResponse: number;
815
+ restitution: number;
816
+ friction: number;
817
+ life: number[];
818
+ size: number[];
819
+ stretch: number;
820
+ emissive: number;
821
+ temp: number[] | null;
822
+ color: ColorRepresentation[];
823
+ alpha: number[];
824
+ paints: string | null;
825
+ paintAmount: number;
826
+ morph: string | number | null;
827
+ killOnCollide: boolean;
828
+ absorbing: boolean;
829
+ toSmokeAt: number;
830
+ smokeAlbedo: number;
831
+ density: number;
832
+ distortion: number;
833
+ fadeIn: number;
834
+ fadeOut: number;
835
+ spin: number;
836
+ sizePow: number;
837
+ softness: number;
838
+ lightResponse: number;
839
+ mesh: string;
840
+ erosion: number;
841
+ orbit: boolean;
842
+ };
843
+ type KindDef = typeof KIND_DEFAULTS;
844
+ declare const storageOf: (n: number) => three_webgpu.StorageBufferNode<"vec4">;
845
+ type Storage = ReturnType<typeof storageOf>;
846
+ declare const floatU: (v: number) => three_webgpu.UniformNode<"float", number>;
847
+ type UF = ReturnType<typeof floatU>;
848
+ declare const vec2U: (v: Vector2$1) => three_webgpu.UniformNode<"vec2", Vector2$1>;
849
+ type UV2 = ReturnType<typeof vec2U>;
850
+ declare const texOf: (t: DataTexture$1) => three_webgpu.TextureNode<"vec4">;
851
+ type Tex = ReturnType<typeof texOf>;
852
+ interface IState {
853
+ uS0: Storage;
854
+ uS1: Storage;
855
+ uS2: Storage;
856
+ uKinds: Tex;
857
+ }
858
+ interface IStyleU {
859
+ uStyleStart: UF;
860
+ uStyleCount: UF;
861
+ uFieldCount: UF;
862
+ uRingBase: UF;
863
+ }
864
+ interface ISimU {
865
+ uEmitTex: Tex;
866
+ uEmitCount: UF;
867
+ uSpan: UV2[];
868
+ uSpanCount: UF;
869
+ uFieldTex: Tex;
870
+ uFieldCount: UF;
871
+ uSimDt: UF;
872
+ uGroundA: Tex;
873
+ uGroundB: Tex;
874
+ }
875
+ interface IKind {
876
+ name: string;
877
+ id: number;
878
+ def: KindDef;
879
+ }
880
+ interface IStyleRange {
881
+ start: number;
882
+ count: number;
883
+ field: number;
884
+ cursor: number;
885
+ log: Float64Array;
886
+ head: number;
887
+ tail: number;
888
+ base: number;
889
+ window: number;
890
+ first: number;
891
+ }
892
+ interface IFieldDef {
893
+ kind: number;
894
+ count: number;
895
+ wa: number[];
896
+ wb: number[];
897
+ threshold: number;
898
+ rate: number;
899
+ lifeScale: number;
900
+ sizeScale: number;
901
+ up: number;
902
+ }
903
+ /** what the particle pool calls on the ground field (GroundField.js): touch() widens its live area */
904
+ interface IParticleGround {
905
+ touch?(x: number, z: number, reach: number, life: number): void;
906
+ }
907
+ /** what the particle pool needs of the renderer: `compute` runs the sim kernel */
908
+ interface IParticleRenderer {
909
+ compute(node: unknown): unknown;
910
+ }
911
+ interface IEmitterOptions {
912
+ shape?: keyof typeof SHAPES$1;
913
+ radius?: number;
914
+ spread?: number;
915
+ radial?: number;
916
+ size?: number;
917
+ life?: number;
918
+ cone?: number;
919
+ }
920
+ type IEmitter = ReturnType<Particles["emitter"]>;
921
+ declare class Particles {
922
+ renderer: IParticleRenderer | null;
923
+ ground: IParticleGround | null;
924
+ W: number;
925
+ H: number;
926
+ kinds: IKind[];
927
+ kindIndex: Map<string, number>;
928
+ fieldDefs: IFieldDef[];
929
+ kindData: Float32Array;
930
+ kindTex: DataTexture$1;
931
+ emitData: Float32Array;
932
+ emitTex: DataTexture$1;
933
+ fieldData: Float32Array;
934
+ fieldTex: DataTexture$1;
935
+ recCount: number;
936
+ built: boolean;
937
+ time: number;
938
+ alive: number;
939
+ seed: number;
940
+ glow: Mesh;
941
+ media: Mesh;
942
+ debris: Mesh[];
943
+ paint: Mesh[];
944
+ style: Record<Style, IStyleRange>;
945
+ fieldCount: number;
946
+ spans: UV2[];
947
+ stateU: IState | null;
948
+ simU: ISimU | null;
949
+ sim: unknown;
950
+ clear: unknown;
951
+ styleU: Record<Style, IStyleU>;
952
+ constructor(renderer: IParticleRenderer | null, { ground }?: {
953
+ ground?: IParticleGround | null;
954
+ });
955
+ rand(): number;
956
+ reseed(n: number): void;
957
+ addKind(name: string, def: Partial<KindDef>): number;
958
+ kind(name: string): number | undefined;
959
+ setKind(id: string | number, patch: object): void;
960
+ fieldEmitter(kind: string | number, { slots, a, b, threshold, rate, lifeScale, sizeScale, up, }?: {
961
+ slots?: number | undefined;
962
+ a?: number[] | undefined;
963
+ b?: number[] | undefined;
964
+ threshold?: number | undefined;
965
+ rate?: number | undefined;
966
+ lifeScale?: number | undefined;
967
+ sizeScale?: number | undefined;
968
+ up?: number | undefined;
969
+ }): void;
970
+ writeKind(k: IKind): void;
971
+ build(): void;
972
+ clearState(dispatch?: boolean): void;
973
+ emitter(kind: string | number, opts?: IEmitterOptions): {
974
+ kind: number;
975
+ shape: number;
976
+ pos: Vector3$1;
977
+ radius: number;
978
+ vel: Vector3$1;
979
+ spread: number;
980
+ p: Vector3$1;
981
+ radial: number;
982
+ size: number;
983
+ life: number;
984
+ cone: number;
985
+ acc: number;
986
+ burst(count: number): void;
987
+ rate(perSecond: number, dt: number): void;
988
+ setShape(name: keyof typeof SHAPES$1): /*elided*/ any;
989
+ };
990
+ emit(e: IEmitter, count: number, prescaled?: boolean): void;
991
+ update(dt: number, time: number): void;
992
+ setDraw(s: Style, base: number, n: number): void;
993
+ warm(on: boolean): void;
994
+ }
995
+
996
+ type F$1 = Node<"float">;
997
+ type V3$1 = Node<"vec3">;
998
+ declare const ownUniforms: () => {
999
+ uVolCenter: three_webgpu.UniformNode<"vec3", Vector3$1>;
1000
+ uVolRot: IMat3Rows;
1001
+ uVolScale: three_webgpu.UniformNode<"vec3", Vector3$1>;
1002
+ uVolSteps: three_webgpu.UniformNode<"float", number>;
1003
+ uVolLight: three_webgpu.UniformNode<"vec4", Vector4$1>;
1004
+ };
1005
+ type IOwnUniforms = ReturnType<typeof ownUniforms>;
1006
+ interface IVolumeScope extends IOwnUniforms {
1007
+ readonly gVolDt: F$1;
1008
+ readonly [uniform: string]: unknown;
1009
+ }
1010
+ type VolumeSample = (pw: V3$1, pl: V3$1, sigma: F$1, albedo: V3$1, emission: V3$1, V: IVolumeScope) => void;
1011
+ declare const SHAPES: {
1012
+ sphere: number;
1013
+ box: number;
1014
+ capsule: number;
1015
+ };
1016
+ interface IVolumeHandle {
1017
+ mesh: Mesh;
1018
+ position: Vector3$1;
1019
+ scale: Vector3$1;
1020
+ quaternion: Quaternion;
1021
+ uniforms: Record<string, unknown> & IOwnUniforms;
1022
+ visible: boolean;
1023
+ maxSteps: number;
1024
+ g: number;
1025
+ shadowTap: number;
1026
+ ambient: number;
1027
+ sun: number;
1028
+ }
1029
+ declare class Volumes {
1030
+ readonly group: Group<three.Object3DEventMap>;
1031
+ readonly list: IVolumeHandle[];
1032
+ readonly proxies: Record<keyof typeof SHAPES, BufferGeometry>;
1033
+ constructor();
1034
+ add({ shape, tsl, uniforms, maxSteps, }: {
1035
+ shape?: keyof typeof SHAPES;
1036
+ tsl: VolumeSample;
1037
+ uniforms?: Record<string, unknown>;
1038
+ maxSteps?: number;
1039
+ }): IVolumeHandle;
1040
+ update(camera: Camera): void;
1041
+ }
1042
+
1043
+ interface ITrail {
1044
+ width: number;
1045
+ intensity: number;
1046
+ glow: number;
1047
+ glowIntensity: number;
1048
+ fadeTime: number;
1049
+ distortion: number;
1050
+ color: Color$1;
1051
+ push(p: Vector3): void;
1052
+ release(): void;
1053
+ }
1054
+ interface ITrails {
1055
+ acquire(): ITrail | null;
1056
+ }
1057
+ interface IShocks {
1058
+ spawn(shock: object): void;
1059
+ }
1060
+ interface IGround {
1061
+ splat(splat: object): void;
1062
+ }
1063
+ interface IFluidDomain {
1064
+ position: Vector3;
1065
+ size: Vector3;
1066
+ h: number;
1067
+ heat: number;
1068
+ tint: Color$1;
1069
+ sootColor: Color$1;
1070
+ detailCenter: Vector3;
1071
+ obstacle: {
1072
+ set(x: number, y: number, z: number, r: number): void;
1073
+ };
1074
+ emit(source: object): void;
1075
+ release(): void;
1076
+ [field: string]: unknown;
1077
+ }
1078
+ interface IFluid {
1079
+ res: number;
1080
+ acquire(options: {
1081
+ size: number[];
1082
+ res?: number;
1083
+ }): IFluidDomain | null;
1084
+ }
1085
+ interface IRig {
1086
+ shake(amount: number, frequency: number): void;
1087
+ punch(amount: number, seconds: number): void;
1088
+ hitstop(seconds: number): void;
1089
+ /** main multiplies the simulation dt by this (hitstop) */
1090
+ readonly timeScale: number;
1091
+ /** after the game's camera update: adds the shake and FOV punch; restore() takes them back */
1092
+ apply(camera: Camera$1, dt: number): void;
1093
+ restore(camera: Camera$1): void;
1094
+ }
1095
+ interface IArena {
1096
+ focus: {
1097
+ color: Color$1;
1098
+ };
1099
+ setFocus(color: Color$1, intensity: number): void;
1100
+ }
1101
+ interface IDummy {
1102
+ pos: Vector3;
1103
+ status: {
1104
+ burn: number;
1105
+ };
1106
+ hit(dir: Vector3, amount: number): void;
1107
+ }
1108
+ interface IFxOptions {
1109
+ camera: Camera$1;
1110
+ /** compiles each spell's pipelines before its first cast (warmSpell); upstream: renderer.compileAsync */
1111
+ renderer?: {
1112
+ compileAsync(object: Object3D, camera: Camera$1, scene?: Scene): Promise<unknown>;
1113
+ compute(node: unknown): unknown;
1114
+ };
1115
+ /** drawing-buffer size in pixels (upstream: renderer.getDrawingBufferSize) */
1116
+ size: () => {
1117
+ width: number;
1118
+ height: number;
1119
+ };
1120
+ seed?: number;
1121
+ /** PointLights the spell lights drive (common.ts mirrorLights); parked at 0 when idle */
1122
+ pointLights?: number;
1123
+ trails?: ITrails;
1124
+ ground?: IGround;
1125
+ shocks?: IShocks;
1126
+ fluid?: IFluid;
1127
+ rig?: IRig;
1128
+ arena?: IArena;
1129
+ dummies?: IDummy[];
1130
+ }
1131
+ declare function createFx(o: IFxOptions): {
1132
+ fx: {
1133
+ camera: Camera$1;
1134
+ scenes: {
1135
+ fx: three.Group<three.Object3DEventMap>;
1136
+ };
1137
+ U: {
1138
+ uTime: three_webgpu.UniformNode<"float", number>;
1139
+ uDt: three_webgpu.UniformNode<"float", number>;
1140
+ uFrame: three_webgpu.UniformNode<"float", number>;
1141
+ uWorld: {
1142
+ value: three.DataTexture;
1143
+ };
1144
+ uWorldCounts: three_webgpu.UniformNode<"vec4", three.Vector4>;
1145
+ uNoise3D: {
1146
+ value: three.Data3DTexture;
1147
+ };
1148
+ uCurl3D: {
1149
+ value: three.Data3DTexture;
1150
+ };
1151
+ uBlackbody: {
1152
+ value: three.DataTexture;
1153
+ };
1154
+ uGroundA: {
1155
+ value: three.DataTexture;
1156
+ };
1157
+ uGroundB: {
1158
+ value: three.DataTexture;
1159
+ };
1160
+ uGroundRect: three_webgpu.UniformNode<"vec4", three.Vector4>;
1161
+ uSceneDepth: {
1162
+ value: null;
1163
+ };
1164
+ uSceneColor: {
1165
+ value: null;
1166
+ };
1167
+ uResolution: three_webgpu.UniformNode<"vec2", three.Vector2>;
1168
+ uFxResolution: three_webgpu.UniformNode<"vec2", three.Vector2>;
1169
+ uNearFar: three_webgpu.UniformNode<"vec2", three.Vector2>;
1170
+ uSunDir: three_webgpu.UniformNode<"vec3", Vector3>;
1171
+ uSunColor: three_webgpu.UniformNode<"vec3", Vector3>;
1172
+ uAmbient: three_webgpu.UniformNode<"vec3", Vector3>;
1173
+ uSkyCube: {
1174
+ value: null;
1175
+ };
1176
+ uDebug: three_webgpu.UniformNode<"float", number>;
1177
+ uFxParams: three_webgpu.UniformNode<"vec4", three.Vector4>;
1178
+ };
1179
+ Q: {
1180
+ autoResolution: boolean;
1181
+ auto: {
1182
+ emission: number;
1183
+ steps: number;
1184
+ };
1185
+ resolution: number;
1186
+ msaa: number;
1187
+ fxScale: number;
1188
+ particles: number[];
1189
+ debris: number;
1190
+ volumeSteps: number;
1191
+ noiseSize: number;
1192
+ groundSize: number;
1193
+ reflections: boolean;
1194
+ reflectionScale: number;
1195
+ reflectFx: boolean;
1196
+ maxLights: number;
1197
+ shadowLights: number;
1198
+ bloomLevels: number;
1199
+ emission: number;
1200
+ fluidIterations: number;
1201
+ tier: "low" | "medium" | "high" | "ultra";
1202
+ mobile: boolean;
1203
+ } | {
1204
+ autoResolution: boolean;
1205
+ auto: {
1206
+ emission: number;
1207
+ steps: number;
1208
+ };
1209
+ resolution: number;
1210
+ msaa: number;
1211
+ fxScale: number;
1212
+ particles: number[];
1213
+ debris: number;
1214
+ volumeSteps: number;
1215
+ noiseSize: number;
1216
+ groundSize: number;
1217
+ reflections: boolean;
1218
+ reflectionScale: number;
1219
+ reflectFx: boolean;
1220
+ maxLights: number;
1221
+ shadowLights: number;
1222
+ bloomLevels: number;
1223
+ emission: number;
1224
+ tier: "low" | "medium" | "high" | "ultra";
1225
+ mobile: boolean;
1226
+ } | {
1227
+ autoResolution: boolean;
1228
+ auto: {
1229
+ emission: number;
1230
+ steps: number;
1231
+ };
1232
+ resolution: number;
1233
+ msaa: number;
1234
+ fxScale: number;
1235
+ particles: number[];
1236
+ debris: number;
1237
+ volumeSteps: number;
1238
+ noiseSize: number;
1239
+ groundSize: number;
1240
+ reflections: boolean;
1241
+ reflectionScale: number;
1242
+ reflectFx: boolean;
1243
+ maxLights: number;
1244
+ shadowLights: number;
1245
+ bloomLevels: number;
1246
+ emission: number;
1247
+ tier: "low" | "medium" | "high" | "ultra";
1248
+ mobile: boolean;
1249
+ } | {
1250
+ autoResolution: boolean;
1251
+ auto: {
1252
+ emission: number;
1253
+ steps: number;
1254
+ };
1255
+ resolution: number;
1256
+ msaa: number;
1257
+ fxScale: number;
1258
+ particles: number[];
1259
+ debris: number;
1260
+ volumeSteps: number;
1261
+ noiseSize: number;
1262
+ groundSize: number;
1263
+ reflections: boolean;
1264
+ reflectionScale: number;
1265
+ reflectFx: boolean;
1266
+ maxLights: number;
1267
+ shadowLights: number;
1268
+ bloomLevels: number;
1269
+ emission: number;
1270
+ fluid: boolean;
1271
+ anamorphic: boolean;
1272
+ tier: "low" | "medium" | "high" | "ultra";
1273
+ mobile: boolean;
1274
+ };
1275
+ ARENA: {
1276
+ radius: number;
1277
+ wallThickness: number;
1278
+ wallHeight: number;
1279
+ pillarRing: number;
1280
+ pillarRadius: number;
1281
+ pillarHeight: number;
1282
+ pillars: Vector3[];
1283
+ focus: Vector3;
1284
+ pedestal: {
1285
+ pos: Vector3;
1286
+ radius: number;
1287
+ height: number;
1288
+ };
1289
+ dummies: Vector3[];
1290
+ dummyRadius: number;
1291
+ dummyHeight: number;
1292
+ pool: {
1293
+ center: three.Vector2;
1294
+ half: three.Vector2;
1295
+ depth: number;
1296
+ water: number;
1297
+ };
1298
+ ground: {
1299
+ min: three.Vector2;
1300
+ size: number;
1301
+ };
1302
+ };
1303
+ arena: IArena;
1304
+ ground: GroundField | IGround;
1305
+ particles: Particles;
1306
+ trails: ITrails;
1307
+ volumes: Volumes;
1308
+ shocks: IShocks | undefined;
1309
+ readonly fluid: IFluid;
1310
+ fluidVolume: FluidVolume | undefined;
1311
+ renderer: ConstructorParameters<typeof FluidVolume>[0]["renderer"] | undefined;
1312
+ rig: IRig;
1313
+ lights: {
1314
+ items: ({
1315
+ pos: Vector3;
1316
+ range: number;
1317
+ color: Color$1;
1318
+ intensity: number;
1319
+ type: number;
1320
+ end: Vector3;
1321
+ shadow: boolean;
1322
+ cookie: number[];
1323
+ release(this: {
1324
+ active: boolean;
1325
+ }): void;
1326
+ } & IPoolItem)[];
1327
+ acquire(): ({
1328
+ pos: Vector3;
1329
+ range: number;
1330
+ color: Color$1;
1331
+ intensity: number;
1332
+ type: number;
1333
+ end: Vector3;
1334
+ shadow: boolean;
1335
+ cookie: number[];
1336
+ release(this: {
1337
+ active: boolean;
1338
+ }): void;
1339
+ } & IPoolItem) | null;
1340
+ };
1341
+ forces: {
1342
+ items: ({
1343
+ pos: Vector3;
1344
+ type: number;
1345
+ p: number[];
1346
+ dir: Vector3;
1347
+ w: number;
1348
+ release(this: {
1349
+ active: boolean;
1350
+ }): void;
1351
+ } & IPoolItem)[];
1352
+ acquire(): ({
1353
+ pos: Vector3;
1354
+ type: number;
1355
+ p: number[];
1356
+ dir: Vector3;
1357
+ w: number;
1358
+ release(this: {
1359
+ active: boolean;
1360
+ }): void;
1361
+ } & IPoolItem) | null;
1362
+ };
1363
+ impacts: {
1364
+ types: Record<string, number>;
1365
+ add(type: string | number, pos: Vector3, radius: number, amount?: number, life?: number, color?: Color$1 | null): {
1366
+ pos: Vector3;
1367
+ radius: number;
1368
+ type: number;
1369
+ age: number;
1370
+ life: number;
1371
+ amount: number;
1372
+ color: Color$1;
1373
+ };
1374
+ clear(): void;
1375
+ };
1376
+ occluders: {
1377
+ list: IOccluder[];
1378
+ add(a: Vector3, b: Vector3, radius: number, kind?: number): IOccluder | null;
1379
+ };
1380
+ fxTarget: FxTarget;
1381
+ dummies: IDummy[];
1382
+ spells: Record<string, ISpell>;
1383
+ reduced: boolean;
1384
+ systems: {
1385
+ update(dt: number, camera: Camera$1): void;
1386
+ }[];
1387
+ flashAmount: number;
1388
+ rand(): number;
1389
+ flash(amount: number): void;
1390
+ casts: Casts;
1391
+ };
1392
+ casts: Casts;
1393
+ renderFrame: (realDt: number) => void;
1394
+ addSpell: <S extends ISpell & {
1395
+ create(fx: Fx): NonNullable<ISpell["inst"]>;
1396
+ }>(s: S) => S;
1397
+ warmSpell: (s: ISpell) => Promise<void>;
1398
+ pointLights: PointLight[];
1399
+ };
1400
+ type Fx = ReturnType<typeof createFx>["fx"];
1401
+
1402
+ declare const _default: {
1403
+ id: string;
1404
+ name: string;
1405
+ key: string;
1406
+ hue: string;
1407
+ shape: string;
1408
+ forms: string[];
1409
+ radius: number;
1410
+ params: {
1411
+ size: number;
1412
+ speed: number;
1413
+ temperature: number;
1414
+ intensity: number;
1415
+ soot: number;
1416
+ embers: number;
1417
+ smoke: number;
1418
+ haze: number;
1419
+ scorch: number;
1420
+ height: number;
1421
+ tint: string;
1422
+ };
1423
+ ranges: {
1424
+ size: number[];
1425
+ speed: number[];
1426
+ temperature: number[];
1427
+ intensity: number[];
1428
+ soot: number[];
1429
+ embers: number[];
1430
+ smoke: number[];
1431
+ haze: number[];
1432
+ scorch: number[];
1433
+ height: number[];
1434
+ };
1435
+ presets: {
1436
+ hellfire: {
1437
+ temperature: number;
1438
+ tint: string;
1439
+ smoke: number;
1440
+ soot: number;
1441
+ intensity: number;
1442
+ };
1443
+ "blue flame": {
1444
+ temperature: number;
1445
+ tint: string;
1446
+ smoke: number;
1447
+ soot: number;
1448
+ };
1449
+ soulfire: {
1450
+ temperature: number;
1451
+ tint: string;
1452
+ smoke: number;
1453
+ soot: number;
1454
+ };
1455
+ };
1456
+ timing: {
1457
+ charge: number;
1458
+ impact: number;
1459
+ linger: number;
1460
+ sustain: number;
1461
+ };
1462
+ kinds: {
1463
+ flame: {
1464
+ style: string;
1465
+ drag: number;
1466
+ buoyancy: number;
1467
+ curl: number;
1468
+ curlScale: number;
1469
+ life: number[];
1470
+ size: number[];
1471
+ sizePow: number;
1472
+ emissive: number;
1473
+ temp: number[];
1474
+ toSmokeAt: number;
1475
+ smokeAlbedo: number;
1476
+ alpha: number[];
1477
+ density: number;
1478
+ distortion: number;
1479
+ erosion: number;
1480
+ fadeIn: number;
1481
+ fadeOut: number;
1482
+ };
1483
+ ember: {
1484
+ style: string;
1485
+ drag: number;
1486
+ buoyancy: number;
1487
+ gravity: number;
1488
+ curl: number;
1489
+ curlScale: number;
1490
+ life: number[];
1491
+ size: number[];
1492
+ stretch: number;
1493
+ emissive: number;
1494
+ temp: number[];
1495
+ restitution: number;
1496
+ friction: number;
1497
+ paints: string;
1498
+ paintAmount: number;
1499
+ };
1500
+ spark: {
1501
+ style: string;
1502
+ drag: number;
1503
+ gravity: number;
1504
+ restitution: number;
1505
+ friction: number;
1506
+ life: number[];
1507
+ size: number[];
1508
+ stretch: number;
1509
+ emissive: number;
1510
+ temp: number[];
1511
+ paints: string;
1512
+ paintAmount: number;
1513
+ };
1514
+ smoke: {
1515
+ style: string;
1516
+ emissive: number;
1517
+ drag: number;
1518
+ buoyancy: number;
1519
+ curl: number;
1520
+ curlScale: number;
1521
+ life: number[];
1522
+ size: number[];
1523
+ sizePow: number;
1524
+ color: string[];
1525
+ alpha: number[];
1526
+ density: number;
1527
+ erosion: number;
1528
+ fadeIn: number;
1529
+ fadeOut: number;
1530
+ };
1531
+ dust: {
1532
+ style: string;
1533
+ emissive: number;
1534
+ drag: number;
1535
+ buoyancy: number;
1536
+ curl: number;
1537
+ life: number[];
1538
+ size: number[];
1539
+ color: string[];
1540
+ alpha: number[];
1541
+ density: number;
1542
+ erosion: number;
1543
+ };
1544
+ debris: {
1545
+ style: string;
1546
+ mesh: string;
1547
+ drag: number;
1548
+ gravity: number;
1549
+ restitution: number;
1550
+ friction: number;
1551
+ life: number[];
1552
+ size: number[];
1553
+ color: string[];
1554
+ alpha: number[];
1555
+ spin: number;
1556
+ fadeOut: number;
1557
+ paints: string;
1558
+ paintAmount: number;
1559
+ };
1560
+ };
1561
+ create(fx: Fx): {
1562
+ onParam(k: string): void;
1563
+ travel(c: ICast, dt: number): boolean;
1564
+ phase(c: ICast, name: Phase): void;
1565
+ update(c: ICast, dt: number): void;
1566
+ };
1567
+ };
1568
+
1569
+ type F = Node<"float">;
1570
+ type V3 = Node<"vec3">;
1571
+ interface IGroundSurface {
1572
+ albedo: V3;
1573
+ rough: F;
1574
+ metal: F;
1575
+ /** 0..1: grout, grooves, cracks the heat glows through */
1576
+ crevice?: F;
1577
+ }
1578
+ /**
1579
+ * The arena floor's response to the ground field and the impacts, for a game's own floor material:
1580
+ * `{ color, roughness, metalness, emissive }` nodes from the surface's own albedo / roughness /
1581
+ * metalness, at world position `wp`. Build the GroundField first (common.ts setGroundTexture).
1582
+ */
1583
+ declare function groundShade(wp: V3, surface: IGroundSurface): {
1584
+ color: Node<"vec3">;
1585
+ roughness: Node<"float">;
1586
+ metalness: Node<"float">;
1587
+ emissive: Node<"vec3">;
1588
+ };
1589
+
1590
+ interface IBakedNoise {
1591
+ noise3D: Data3DTexture;
1592
+ curl3D: Data3DTexture;
1593
+ blackbody: DataTexture;
1594
+ ms: number;
1595
+ }
1596
+ declare function bakeNoise({ noiseSize }?: {
1597
+ noiseSize?: number;
1598
+ }): IBakedNoise;
1599
+
1600
+ export { ARENA, type Fx, type IArena, type IBakedNoise, type ICast, type IDummy, type IEmitter, type IFluid, type IFluidDomain, type IFxOptions, type IGround, type IGroundSurface, type IRig, type IShocks, type ISpell, type ISpellInstance, type ITrail, type ITrails, type KindDef, Particles, type Phase, Q, TIERS, U, bakeNoise, createFx, _default as fire, groundShade };