reze-engine 0.68.15 → 0.68.17

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 (62) hide show
  1. package/dist/engine.d.ts +77 -6
  2. package/dist/engine.d.ts.map +1 -1
  3. package/dist/engine.js +129 -31
  4. package/dist/graph/presets/pool_floor.d.ts +3 -0
  5. package/dist/graph/presets/pool_floor.d.ts.map +1 -0
  6. package/dist/graph/presets/pool_floor.js +42 -0
  7. package/dist/graph/presets/water.d.ts +3 -0
  8. package/dist/graph/presets/water.d.ts.map +1 -0
  9. package/dist/graph/presets/water.js +31 -0
  10. package/dist/graph/registry.d.ts.map +1 -1
  11. package/dist/graph/registry.js +4 -1
  12. package/dist/index.d.ts +1 -1
  13. package/dist/index.d.ts.map +1 -1
  14. package/dist/physics/autofit.d.ts +147 -0
  15. package/dist/physics/autofit.d.ts.map +1 -0
  16. package/dist/physics/autofit.js +501 -0
  17. package/dist/shaders/agx-lut.d.ts +11 -0
  18. package/dist/shaders/agx-lut.d.ts.map +1 -0
  19. package/dist/shaders/agx-lut.js +29 -0
  20. package/dist/shaders/dfg_lut.d.ts +3 -0
  21. package/dist/shaders/dfg_lut.d.ts.map +1 -0
  22. package/dist/shaders/dfg_lut.js +129 -0
  23. package/dist/shaders/lights.d.ts +1 -1
  24. package/dist/shaders/lights.d.ts.map +1 -1
  25. package/dist/shaders/lights.js +89 -6
  26. package/dist/shaders/ltc_mag_lut.d.ts +3 -0
  27. package/dist/shaders/ltc_mag_lut.d.ts.map +1 -0
  28. package/dist/shaders/ltc_mag_lut.js +1033 -0
  29. package/dist/shaders/materials/common.d.ts.map +1 -1
  30. package/dist/shaders/materials/common.js +2 -1
  31. package/dist/shaders/materials/nodes.d.ts +1 -1
  32. package/dist/shaders/materials/nodes.d.ts.map +1 -1
  33. package/dist/shaders/materials/nodes.js +182 -13
  34. package/dist/shaders/passes/composite.d.ts.map +1 -1
  35. package/dist/shaders/passes/composite.js +59 -4
  36. package/dist/shaders/passes/field-blit.d.ts +26 -0
  37. package/dist/shaders/passes/field-blit.d.ts.map +1 -0
  38. package/dist/shaders/passes/field-blit.js +65 -0
  39. package/dist/shaders/passes/ghosts.d.ts +22 -0
  40. package/dist/shaders/passes/ghosts.d.ts.map +1 -0
  41. package/dist/shaders/passes/ghosts.js +75 -0
  42. package/dist/shaders/passes/ground-noise.d.ts +7 -0
  43. package/dist/shaders/passes/ground-noise.d.ts.map +1 -0
  44. package/dist/shaders/passes/ground-noise.js +88 -0
  45. package/dist/shaders/passes/sim.d.ts +34 -0
  46. package/dist/shaders/passes/sim.d.ts.map +1 -0
  47. package/dist/shaders/passes/sim.js +169 -0
  48. package/dist/shaders/score-api.d.ts +10 -0
  49. package/dist/shaders/score-api.d.ts.map +1 -0
  50. package/dist/shaders/score-api.js +114 -0
  51. package/dist/shaders/shadow-api.d.ts +29 -0
  52. package/dist/shaders/shadow-api.d.ts.map +1 -0
  53. package/dist/shaders/shadow-api.js +112 -0
  54. package/package.json +1 -1
  55. package/src/engine.ts +154 -31
  56. package/src/graph/registry.ts +4 -1
  57. package/src/index.ts +2 -0
  58. package/src/shaders/lights.ts +89 -6
  59. package/src/shaders/materials/common.ts +2 -1
  60. package/src/shaders/materials/nodes.ts +182 -13
  61. package/src/shaders/passes/composite.ts +59 -4
  62. package/dist/_dbg-loader.mjs +0 -1100
package/src/engine.ts CHANGED
@@ -491,6 +491,19 @@ export type SceneAovs = {
491
491
  exposure: number
492
492
  }
493
493
 
494
+ /** The shape of a renderer's pixel filter (Engine.setPixelFilter): Cycles'
495
+ * default Blackman-Harris, or its box. */
496
+ export type PixelFilterType = "blackman-harris" | "box"
497
+
498
+ /** A local reflection probe (Engine.setReflectionProbe): where it is captured
499
+ * from and the box it projects onto, world space (PMX units). A surface
500
+ * outside the box reflects the sky. */
501
+ export type ReflectionProbeRegion = {
502
+ center: readonly [number, number, number] | readonly number[]
503
+ min: readonly [number, number, number] | readonly number[]
504
+ max: readonly [number, number, number] | readonly number[]
505
+ }
506
+
494
507
  /** The light arriving at one point (Engine.probeLight). Colours are linear
495
508
  * light, before the surface's albedo: the sun's is its colour times strength,
496
509
  * unshadowed and unfaced — multiply by sunShadow and max(sunFacing, 0). */
@@ -1086,6 +1099,8 @@ interface ModelInstance {
1086
1099
  * hiddenMaterials so a morph switching a part off never clobbers the user's
1087
1100
  * own visibility toggle, and vice versa. */
1088
1101
  morphHiddenMaterials: Set<string>
1102
+ /** Materials the reflection probe leaves out (setMaterialInProbe). */
1103
+ probeHiddenMaterials: Set<string>
1089
1104
  /** Material-morph targets, or null when the model has no type-8 morphs. */
1090
1105
  materialMorphTargets: MaterialMorphTarget[] | null
1091
1106
  /** The same targets by PMX material index, so a named offset is one lookup. */
@@ -1970,6 +1985,16 @@ export type SceneLight = {
1970
1985
  * room without lighting up its shiny floor. Omitted or true: both.
1971
1986
  */
1972
1987
  specular?: boolean
1988
+ /**
1989
+ * A TUBE: the lamp is the segment position ± this half-axis (engine units)
1990
+ * rather than a point — a neon strip, a glowing line. Its light is the
1991
+ * segment's and its highlight a band along it; `near` is the tube's radius,
1992
+ * `radius` its reach from the segment. With an `aim` (square to the tube)
1993
+ * it is a glowing strip facing that way, Lambertian — the cosine exact, so
1994
+ * `angle`, `innerAngle` and `cookie` are not read; without one it glows every
1995
+ * way. Omitted or zero: a point (or spot).
1996
+ */
1997
+ tube?: XYZ
1973
1998
  }
1974
1999
 
1975
2000
  /**
@@ -2799,6 +2824,9 @@ export class Engine {
2799
2824
  /** Off: no capture, and every reader falls back to the sky — see
2800
2825
  * setReflectionProbe. */
2801
2826
  private probeEnabled = true
2827
+ /** A local probe's capture point and box, world space — see
2828
+ * setReflectionProbe. Null: the stage's middle and bounds. */
2829
+ private probeRegion: ReflectionProbeRegion | null = null
2802
2830
  private probeCapture: {
2803
2831
  msTargets: GPUTexture[]
2804
2832
  depth: GPUTexture
@@ -3339,6 +3367,58 @@ export class Engine {
3339
3367
  return this.grain
3340
3368
  }
3341
3369
 
3370
+ /** The pixel filter: its width in pixels (0 off) and the 1D weights of
3371
+ * offsets 0, ±1, ±2 it comes to — see setPixelFilter. */
3372
+ private pixelFilter = { width: 0, type: "blackman-harris" as PixelFilterType, weights: [1, 0, 0] as [number, number, number] }
3373
+
3374
+ /**
3375
+ * A renderer's pixel filter, over the rendered scene: how Cycles builds a
3376
+ * pixel from the light around it rather than from its own square alone.
3377
+ * Off (width 0) the engine's pixels are their own box, which is what it has
3378
+ * always drawn.
3379
+ *
3380
+ * Cycles samples each pixel through a Blackman-Harris window twice the
3381
+ * filter width across (1.5 px by default, so 3 px), or a box that width
3382
+ * across. It is invisible on ordinary surfaces and decides what a thing
3383
+ * smaller than a pixel and far brighter than white looks like: a 3 cm ember
3384
+ * glowing at twenty times white spreads into the pixels around it and reads
3385
+ * as a coloured square, and a neon edge gets its coloured fringe. The engine
3386
+ * resolves its samples to a box first, so the filter here is that window
3387
+ * integrated over each neighbour's square — the nearest staircase to it —
3388
+ * applied to the scene's HDR light before the view transform, coverage
3389
+ * alongside, so the sky behind it composites as before. Up to 2.5 px wide
3390
+ * (5×5 taps), one more pass of reads in the composite, none when off.
3391
+ */
3392
+ setPixelFilter(width: number, type: PixelFilterType = "blackman-harris"): void {
3393
+ const w = Number.isFinite(width) ? Math.min(Math.max(width, 0), 2.5) : 0
3394
+ // The window's full span in pixels and its shape over u in 0..1.
3395
+ const span = type === "box" ? w : w * 2
3396
+ const shape = (u: number) =>
3397
+ type === "box"
3398
+ ? 1
3399
+ : 0.35875 - 0.48829 * Math.cos(2 * Math.PI * u) + 0.14128 * Math.cos(4 * Math.PI * u) - 0.01168 * Math.cos(6 * Math.PI * u)
3400
+ const weights: [number, number, number] = [1, 0, 0]
3401
+ if (span > 1e-3) {
3402
+ // Each offset's square, [d − ½, d + ½], integrated over the window.
3403
+ const n = 64
3404
+ for (let d = 0; d < 3; d++) {
3405
+ let sum = 0
3406
+ for (let i = 0; i < n; i++) {
3407
+ const x = d - 0.5 + (i + 0.5) / n
3408
+ if (Math.abs(x) < span / 2) sum += shape(x / span + 0.5) / n
3409
+ }
3410
+ weights[d] = sum
3411
+ }
3412
+ const total = weights[0] + 2 * weights[1] + 2 * weights[2]
3413
+ for (let d = 0; d < 3; d++) weights[d] /= total
3414
+ }
3415
+ this.pixelFilter = { width: w, type, weights }
3416
+ if (this.device && this.compositeUniformBuffer) this.writeCompositeViewUniforms()
3417
+ }
3418
+ getPixelFilter(): Readonly<{ width: number; type: PixelFilterType }> {
3419
+ return { width: this.pixelFilter.width, type: this.pixelFilter.type }
3420
+ }
3421
+
3342
3422
  setViewTransformOptions(patch: Partial<ViewTransformOptions>): void {
3343
3423
  const v = this.viewTransform
3344
3424
  if (patch.exposure !== undefined) v.exposure = patch.exposure
@@ -3426,6 +3506,11 @@ export class Engine {
3426
3506
  // The soft curve's power (viewU[15].x), the scene's own (SceneSetting._contrast).
3427
3507
  // Its own vec4: viewU[11..14] are the cast's positions whenever an effect runs.
3428
3508
  u[60] = v.contrast
3509
+ // The pixel filter's 1D weights for offsets 0, ±1, ±2 (viewU[15].yzw);
3510
+ // 1, 0, 0 is off — see setPixelFilter.
3511
+ u[61] = this.pixelFilter.weights[0]
3512
+ u[62] = this.pixelFilter.weights[1]
3513
+ u[63] = this.pixelFilter.weights[2]
3429
3514
  // ── Grade (viewU[7..9]) ── The UI's three tonal COLORS map to ASC CDL here,
3430
3515
  // on the CPU, so the shader only ever sees slope/offset/power. Mid-gray is
3431
3516
  // neutral in all three; the signed distance from it is the amount.
@@ -11013,10 +11098,19 @@ export class Engine {
11013
11098
  /** Whether the stage reflects its own capture (the default) or the sky. Off
11014
11099
  * is for a stage whose sky was measured from inside it — a Blender export's
11015
11100
  * world — where a capture lit without the lamps' shadows comes out too
11016
- * bright on a shiny floor. */
11017
- setReflectionProbe(enabled: boolean): void {
11018
- if (this.probeEnabled === enabled) return
11101
+ * bright on a shiny floor.
11102
+ *
11103
+ * With a region the probe is LOCAL, as a room's box probe is in Unity:
11104
+ * captured from region.center, box-projected onto region.min..max, and a
11105
+ * surface outside that box reflects the sky — a tunnel's glossy walls
11106
+ * mirror its neon while the floor around it keeps the world. Null: the
11107
+ * stage's middle and bounds, every surface. */
11108
+ setReflectionProbe(enabled: boolean, region: ReflectionProbeRegion | null = null): void {
11109
+ const same = (a: ReflectionProbeRegion | null, b: ReflectionProbeRegion | null) =>
11110
+ a === b || (!!a && !!b && [0, 1, 2].every((k) => a.center[k] === b.center[k] && a.min[k] === b.min[k] && a.max[k] === b.max[k]))
11111
+ if (this.probeEnabled === enabled && same(this.probeRegion, region)) return
11019
11112
  this.probeEnabled = enabled
11113
+ this.probeRegion = region && [region.center, region.min, region.max].every((v) => v.length >= 3 && v.every(Number.isFinite)) ? region : null
11020
11114
  this.captureReflectionProbe()
11021
11115
  }
11022
11116
 
@@ -11056,7 +11150,8 @@ export class Engine {
11056
11150
  const settled = this.probeFrame - this.probeDirtyFrame >= Engine.PROBE_SETTLE_FRAMES
11057
11151
  if (!settled && this.probeFrame - this.probeAskedFrame < Engine.PROBE_MAX_WAIT_FRAMES) return
11058
11152
  this.probeDirty = false
11059
- const bounds = this.probeEnabled ? this.stageBounds() : null
11153
+ const region = this.probeRegion
11154
+ const bounds = !this.probeEnabled ? null : region ? { min: region.min, max: region.max } : this.stageBounds()
11060
11155
  if (!bounds) {
11061
11156
  // No stage, or the probe is off: it goes dark and every reader falls
11062
11157
  // back to the sky.
@@ -11065,7 +11160,7 @@ export class Engine {
11065
11160
  return
11066
11161
  }
11067
11162
  try {
11068
- this.renderProbe(bounds)
11163
+ this.renderProbe(bounds, region?.center ?? null)
11069
11164
  } catch (e) {
11070
11165
  console.warn("[reze-engine] reflection probe capture failed:", e)
11071
11166
  }
@@ -11193,19 +11288,25 @@ export class Engine {
11193
11288
  * the MMD convention, else their bottom) — where a game puts the probe of a
11194
11289
  * room the player stands in. The box it projects onto is the bounds.
11195
11290
  *
11291
+ * A LOCAL probe (setReflectionProbe's region) is captured from the point
11292
+ * it names and projects onto its own box; a surface outside that box
11293
+ * reflects the sky, as Unity's box probes fall back to the skybox past
11294
+ * their bounds.
11295
+ *
11196
11296
  * WHAT: the stage alone, in its own looks, lit by the scene's sun, lamps
11197
11297
  * and sky as they stand. The cast is not in it (a baked probe never holds
11198
11298
  * the characters), nor are effects.
11199
11299
  */
11200
- private renderProbe(bounds: { min: [number, number, number]; max: [number, number, number] }): void {
11300
+ private renderProbe(
11301
+ bounds: { min: readonly number[]; max: readonly number[] },
11302
+ at: readonly number[] | null,
11303
+ ): void {
11201
11304
  const cap = this.ensureProbeCapture()
11202
11305
  const { min, max } = bounds
11203
11306
  const floor = min[1] <= 0 && max[1] >= 0 ? 0 : min[1]
11204
- const eye: [number, number, number] = [
11205
- (min[0] + max[0]) * 0.5,
11206
- Math.min(floor + 12, (min[1] + max[1]) * 0.5),
11207
- (min[2] + max[2]) * 0.5,
11208
- ]
11307
+ const eye: [number, number, number] = at
11308
+ ? [at[0], at[1], at[2]]
11309
+ : [(min[0] + max[0]) * 0.5, Math.min(floor + 12, (min[1] + max[1]) * 0.5), (min[2] + max[2]) * 0.5]
11209
11310
  const span = Math.hypot(max[0] - min[0], max[1] - min[1], max[2] - min[2])
11210
11311
  const near = 0.25
11211
11312
  const far = Math.max(span * 2, 100)
@@ -11328,7 +11429,8 @@ export class Engine {
11328
11429
  for (let f = 0; f < 6; f++) run(face(this.probeTexture, m, f), cap.filterPipeline, cap.filterGroups[m * 6 + f])
11329
11430
  this.device.queue.submit([encoder.finish()])
11330
11431
 
11331
- this.probeData.set([eye[0], eye[1], eye[2], 1, min[0], min[1], min[2], 1, max[0], max[1], max[2], 0])
11432
+ // boxMax.w: 1 for a local probe, whose outside reflects the sky.
11433
+ this.probeData.set([eye[0], eye[1], eye[2], 1, min[0], min[1], min[2], 1, max[0], max[1], max[2], at ? 1 : 0])
11332
11434
  this.device.queue.writeBuffer(this.probeUniformBuffer, 0, this.probeData)
11333
11435
  }
11334
11436
 
@@ -11891,6 +11993,12 @@ export class Engine {
11891
11993
  // rewrites the lamps when it lands).
11892
11994
  const cookie = l.cookie !== undefined ? this.cookieLayers.get(l.cookie) : undefined
11893
11995
  this.lightsData[b + 15] = cookie !== undefined ? cookie + 1 : 0
11996
+ // A tube's half-axis; zero for a point (a non-finite one is a point too)
11997
+ const tube = l.tube && [l.tube.x, l.tube.y, l.tube.z].every(Number.isFinite) && l.kind !== "directional" ? l.tube : null
11998
+ this.lightsData[b + 16] = tube ? tube.x : 0
11999
+ this.lightsData[b + 17] = tube ? tube.y : 0
12000
+ this.lightsData[b + 18] = tube ? tube.z : 0
12001
+ this.lightsData[b + 19] = 0
11894
12002
  }
11895
12003
  // The grid, from the records as STORED — normalised aim, clamped reach, the
11896
12004
  // cosines in f32 — so it indexes exactly what the shader will evaluate.
@@ -11898,7 +12006,10 @@ export class Engine {
11898
12006
  list.map((_, i) => {
11899
12007
  const b = LIGHT_HEADER + i * LIGHT_STRIDE
11900
12008
  const d = this.lightsData
11901
- return { x: d[b], y: d[b + 1], z: d[b + 2], radius: d[b + 3], ax: d[b + 8], ay: d[b + 9], az: d[b + 10], cosOuter: d[b + 11] }
12009
+ // a tube reaches its radius from any point of its segment: past the
12010
+ // middle by its half-length, and a cone is no bound along it
12011
+ const half = Math.hypot(d[b + 16], d[b + 17], d[b + 18])
12012
+ return { x: d[b], y: d[b + 1], z: d[b + 2], radius: d[b + 3] + half, ax: d[b + 8], ay: d[b + 9], az: d[b + 10], cosOuter: half > 0 ? -1 : d[b + 11] }
11902
12013
  }),
11903
12014
  )
11904
12015
  this.lightHeader.set(grid.origin, 4)
@@ -13702,6 +13813,20 @@ export class Engine {
13702
13813
  else inst.hiddenMaterials.add(materialName)
13703
13814
  }
13704
13815
 
13816
+ /**
13817
+ * Whether the reflection probe captures a material. Off for a glowing strip
13818
+ * whose light a TUBE LAMP already carries (SceneLight.tube): the lamp draws
13819
+ * its reflection in every glossy surface, exactly, and the probe's picture
13820
+ * of the same strip would put it there a second time. Re-captures the probe.
13821
+ */
13822
+ setMaterialInProbe(modelName: string, materialName: string, inProbe: boolean): void {
13823
+ const inst = this.modelInstances.get(modelName)
13824
+ if (!inst || inst.probeHiddenMaterials.has(materialName) === !inProbe) return
13825
+ if (inProbe) inst.probeHiddenMaterials.delete(materialName)
13826
+ else inst.probeHiddenMaterials.add(materialName)
13827
+ this.captureReflectionProbe()
13828
+ }
13829
+
13705
13830
  toggleMaterialVisible(modelName: string, materialName: string): void {
13706
13831
  const inst = this.modelInstances.get(modelName)
13707
13832
  if (!inst) return
@@ -15371,6 +15496,7 @@ export class Engine {
15371
15496
  skinMatricesDirty: true,
15372
15497
  hiddenMaterials: new Set(),
15373
15498
  morphHiddenMaterials: new Set(),
15499
+ probeHiddenMaterials: new Set(),
15374
15500
  materialMorphTargets: null,
15375
15501
  materialMorphByIndex: null,
15376
15502
  physics,
@@ -18340,23 +18466,18 @@ export class Engine {
18340
18466
  return true
18341
18467
  }
18342
18468
 
18343
- /** The model at one cast slot — the subject rzSubject(index) reads. */
18344
- private castSubjectName(index: number, subjects: readonly string[] | null = null): string | null {
18469
+ /** The models an effect's rzSubject(i) reads, in its own index order: the
18470
+ * ones it is aimed at, or the whole cast when it is aimed at nobody. */
18471
+ private castSubjectNames(subjects: readonly string[] | null = null): string[] {
18472
+ const names: string[] = []
18345
18473
  let n = 0
18346
- let local = 0
18347
- let found: string | null = null
18348
18474
  this.forEachInstance((inst) => {
18349
- if (found !== null || n >= MAX_EFFECT_SUBJECTS || inst.isStage || inst.isPlane || inst.isProp || !inst.model.visible)
18350
- return
18475
+ if (n >= MAX_EFFECT_SUBJECTS || inst.isStage || inst.isPlane || inst.isProp || !inst.model.visible) return
18351
18476
  n++
18352
- // The effect's OWN index, which is what its shaders count in: an effect
18353
- // aimed at the third dancer finds her at 0, so a #dissolve on it takes HER
18354
- // apart rather than whoever stands at the head of the cast.
18355
18477
  if (subjects && !subjects.includes(inst.name)) return
18356
- if (local === index) found = inst.name
18357
- local++
18478
+ names.push(inst.name)
18358
18479
  })
18359
- return found
18480
+ return names
18360
18481
  }
18361
18482
 
18362
18483
  /** One effect's four durations: its dials where it declares them, the
@@ -18381,8 +18502,8 @@ export class Engine {
18381
18502
  *
18382
18503
  * Two things ask for one. A cycle set on a model (setModelDissolveCycle) runs
18383
18504
  * on the scene clock and repeats, as it always has. An effect declaring
18384
- * `#dissolve` takes ITS OWN subject 0 apart on its own terms — the first model
18385
- * it is aimed at, the head of the cast when it is aimed at nobody in
18505
+ * `#dissolve` takes every one of ITS subjects apart on its own terms — the
18506
+ * models it is aimed at, the whole cast when it is aimed at nobody in
18386
18507
  * particular: scheduled, the cycle on each clip's clock with her whole between
18387
18508
  * clips; unscheduled, the same repeating cycle as before. Where both ask, the more dissolved wins — two
18388
18509
  * answers about one body, and half a body is not one of them.
@@ -18395,14 +18516,15 @@ export class Engine {
18395
18516
  for (const fx of this.effects) {
18396
18517
  if (!fx.dissolve) continue
18397
18518
  const cycle = dissolveCycleOf(this.dissolveTimingsOf(fx, fx.dissolve))
18398
- const subject = this.castSubjectName(0, fx.subjects)
18399
- if (!cycle || !subject) continue
18519
+ if (!cycle) continue
18520
+ let v: number
18400
18521
  if (fx.window && fx.window.length > 0) {
18401
18522
  transport ??= this.transportTime()
18402
- put(subject, scheduledDissolve(fx.window, cycle, transport))
18523
+ v = scheduledDissolve(fx.window, cycle, transport)
18403
18524
  } else {
18404
- put(subject, sampleDissolveCycle(cycle, this.sceneClock))
18525
+ v = sampleDissolveCycle(cycle, this.sceneClock)
18405
18526
  }
18527
+ for (const subject of this.castSubjectNames(fx.subjects)) put(subject, v)
18406
18528
  }
18407
18529
  for (const name of this.dissolveTouched) if (!want.has(name)) this.setModelDissolve(name, 1)
18408
18530
  this.dissolveTouched = new Set(want.keys())
@@ -19135,6 +19257,7 @@ export class Engine {
19135
19257
  if (only && (only === "hair") !== this.isHairDraw(inst, draw)) continue
19136
19258
  // The probe draws directly, past the cull: honour the switches it holds.
19137
19259
  if (view.args === "probe" && !this.shouldRenderDrawCall(inst, draw)) continue
19260
+ if (view.args === "probe" && inst.probeHiddenMaterials.has(draw.materialName)) continue
19138
19261
  if (!bound) {
19139
19262
  pass.setBindGroup(0, view.perFrame)
19140
19263
  pass.setBindGroup(1, inst.mainPerInstanceBindGroup)
@@ -734,12 +734,15 @@ export const NODE_REGISTRY: Record<string, NodeSpec> = {
734
734
  occlusion: F(1),
735
735
  emission: C([0, 0, 0]),
736
736
  alpha: F(1),
737
+ /** 1: the lamps' and sun's highlights rise toward white at grazing
738
+ * (Schlick), as Blender's Principled; 0 is URP's fixed reflectance. */
739
+ fresnel: F(0),
737
740
  normal: { type: "vector", contextDefault: "n" },
738
741
  },
739
742
  outputs: { color: "color", alpha: "float" },
740
743
  outputSelect: { color: ".rgb", alpha: ".a" },
741
744
  emit: (a) =>
742
- `urp_lit(${a.base_color}, ${a.metallic}, ${a.smoothness}, ${a.specular}, ${a.occlusion}, ${a.emission}, ${a.alpha}, ` +
745
+ `urp_lit(${a.base_color}, ${a.metallic}, ${a.smoothness}, ${a.specular}, ${a.occlusion}, ${a.emission}, ${a.alpha}, ${a.fresnel}, ` +
743
746
  `${a.normal}, l, v, sun, amb, shadow, input.worldPos, true)`,
744
747
  takesLight: true,
745
748
  },
package/src/index.ts CHANGED
@@ -25,6 +25,8 @@ export {
25
25
  type ModelAttachment,
26
26
  type SceneAovs,
27
27
  type LightProbe,
28
+ type ReflectionProbeRegion,
29
+ type PixelFilterType,
28
30
  type GizmoDragEvent,
29
31
  type GizmoDragCallback,
30
32
  type GizmoDragKind,
@@ -23,7 +23,7 @@ import { subjectMaskApi } from "./cast-api"
23
23
  // [4..6] grid origin (f32) [7] 1 / cell edge (f32)
24
24
  // [8..10] grid dims (u32) [12..19] the OUTSIDE mask (u32 bits)
25
25
  //
26
- // then MAX_LIGHTS records of 16 floats — four vec4s:
26
+ // then MAX_LIGHTS records of 20 floats — five vec4s:
27
27
  //
28
28
  // [0..2] position, world space [3] radius
29
29
  // [4..6] colour PREMULTIPLIED by intensity [7] type: bits, 1 spot, 2 diffuse only
@@ -32,6 +32,8 @@ import { subjectMaskApi } from "./cast-api"
32
32
  // [13] the rendering layers it does NOT reach (u32 bits)
33
33
  // [14] its bulb: the distance inside which the inverse square is held flat
34
34
  // (0 = RZ_LAMP_NEAR) [15] its cookie: layer + 1, 0 none
35
+ // [16..18] a TUBE's half-axis, world space: the lamp is the segment
36
+ // position ± this, (0,0,0) for a point [19] unused
35
37
  //
36
38
  // then the grid: LIGHT_MASK_WORDS words of lamp bits per cell.
37
39
  //
@@ -64,7 +66,7 @@ import { textureApi } from "./texture-api"
64
66
  * outside mask, five vec4s — see the layout above. */
65
67
  export const LIGHT_HEADER = 20
66
68
  /** Floats per light — see the layout above. */
67
- export const LIGHT_STRIDE = 16
69
+ export const LIGHT_STRIDE = 20
68
70
  /**
69
71
  * The cap. The loop below runs per fragment over the lights a scene HAS, so
70
72
  * this bounds the worst case rather than the ordinary one, and the buffer is
@@ -252,6 +254,10 @@ fn lightEmitMain(@builtin(global_invocation_id) gid: vec3u) {
252
254
  _rzLightsOut[b + 13u] = 0.0;
253
255
  _rzLightsOut[b + 14u] = select(0.0, max(l.near, 0.0), finite && l.near == l.near);
254
256
  _rzLightsOut[b + 15u] = 0.0;
257
+ _rzLightsOut[b + 16u] = 0.0;
258
+ _rzLightsOut[b + 17u] = 0.0;
259
+ _rzLightsOut[b + 18u] = 0.0;
260
+ _rzLightsOut[b + 19u] = 0.0;
255
261
  }
256
262
  `
257
263
  }
@@ -299,9 +305,9 @@ fn rzLightPos(i: u32) -> vec3f { return _rzLightVec(i, 0u).xyz; }
299
305
  fn rzLightRadius(i: u32) -> f32 { return _rzLightVec(i, 0u).w; }
300
306
 
301
307
  /** Light i's colour, already multiplied by its intensity. */
302
- fn rzLightColor(i: u32) -> vec3f { return _rzLightVec(i, 1u).xyz; }
303
- /** 0 for a lamp that lights diffuse only (type bit 2), else 1 — the weight on
304
- * its highlight. */
308
+ fn rzLightColor(i: u32) -> vec3f { return _rzLightVec(i, 1u).xyz; }
309
+ /** 0 for a lamp that lights diffuse only (type bit 2), else 1 — the weight on
310
+ * its highlight. */
305
311
  fn rzLightSpecular(i: u32) -> f32 { return select(1.0, 0.0, (u32(max(_rzLightVec(i, 1u).w, 0.0)) & 2u) != 0u); }
306
312
 
307
313
  /** Where light i points, away from itself. The zero vector for a point light. */
@@ -335,6 +341,68 @@ fn rzLightCookie(i: u32, toLight: vec3f) -> vec3f {
335
341
  * a soft sphere, which a single global bulb cannot spell. */
336
342
  fn rzLightNear(i: u32) -> f32 { let r = _rzLightVec(i, 3u).z; return select(RZ_LAMP_NEAR, r, r > 0.0); }
337
343
 
344
+ /** A tube lamp's half-axis: the lamp is the segment rzLightPos ± this. The
345
+ * zero vector for a point or a spot, which is every lamp but a tube. */
346
+ fn rzLightTube(i: u32) -> vec3f { return _rzLightVec(i, 4u).xyz; }
347
+
348
+ /**
349
+ * A TUBE: a glowing strip, a neon line — light along a segment, not from a
350
+ * point. A row of points stood in for one puts a dot of highlight per point on
351
+ * a glossy wall where the strip's reflection is a band, and lights the panel
352
+ * beside the strip as if from half a metre away.
353
+ *
354
+ * Its irradiance is the segment's, its total intensity spread along it, per
355
+ * unit of that intensity (far off it is n·l/d², the point lamp's):
356
+ *
357
+ * - WITH AN AIM, a glowing strip facing it — Lambertian, cos θₑ at every
358
+ * point of it. Since the aim is square to the segment, cos θₑ/r is hₑ/r²
359
+ * all along it (hₑ the height of p over the strip's plane), and the
360
+ * integral of hₑ·n·(x − p)/r⁴ along it is closed: with t along the axis
361
+ * and D the distance off it, ∫(A + B·t)/(D² + t²)² dt =
362
+ * A·(t/(2D²(D² + t²)) + atan(t/D)/(2D³)) − B/(2(D² + t²)). Exact for a
363
+ * thin strip (within 0.4% of the integral over a 2 × 0.1 m face); a spot
364
+ * cone's fit to the cosine gave a quarter too much 30° off its axis.
365
+ * - Without one, a line glowing every way (Picott's, as Karis gives it):
366
+ * (n·L0/|L0| + n·L1/|L1|) / (|L0||L1| + L0·L1), the ends L0 and L1 from p;
367
+ * beside a long line at h it is 2/(h·length).
368
+ *
369
+ * The bulb floors D (2·bulb² the Picott denominator), as max(d², bulb²)
370
+ * floors a point. Clamped at zero: both assume the whole segment above p's
371
+ * horizon.
372
+ */
373
+ fn _rzTubeIrradiance(p: vec3f, n: vec3f, c: vec3f, h: vec3f, aim: vec3f, bulb: f32) -> f32 {
374
+ if (dot(aim, aim) > 0.5) {
375
+ let len = length(h);
376
+ let u = h / max(len, 1e-6);
377
+ let w = c - p;
378
+ let wu = dot(w, u);
379
+ let wp = w - u * wu;
380
+ let he = -dot(aim, w);
381
+ if (he <= 0.0) { return 0.0; }
382
+ let D2 = max(dot(wp, wp), bulb * bulb);
383
+ let D = sqrt(D2);
384
+ let A = dot(n, wp);
385
+ let B = dot(n, u);
386
+ let t1 = wu + len;
387
+ let t0 = wu - len;
388
+ let f1 = A * (t1 / (2.0 * D2 * (D2 + t1 * t1)) + atan(t1 / D) / (2.0 * D2 * D)) - B / (2.0 * (D2 + t1 * t1));
389
+ let f0 = A * (t0 / (2.0 * D2 * (D2 + t0 * t0)) + atan(t0 / D) / (2.0 * D2 * D)) - B / (2.0 * (D2 + t0 * t0));
390
+ return max(he * (f1 - f0) / max(2.0 * len, 1e-6), 0.0);
391
+ }
392
+ let L0 = c - h - p;
393
+ let L1 = c + h - p;
394
+ let l0 = max(length(L0), 1e-4);
395
+ let l1 = max(length(L1), 1e-4);
396
+ let e = (dot(n, L0) / l0 + dot(n, L1) / l1) / max(l0 * l1 + dot(L0, L1), 2.0 * bulb * bulb);
397
+ return max(e, 0.0);
398
+ }
399
+
400
+ /** The point of a tube nearest p: where its reach, cone and cookie are read. */
401
+ fn _rzTubeNearest(p: vec3f, c: vec3f, h: vec3f) -> vec3f {
402
+ let t = clamp(dot(p - c, h) / max(dot(h, h), 1e-8), -1.0, 1.0);
403
+ return c + h * t;
404
+ }
405
+
338
406
  /** The cosines a spot fades between: x its outer edge, y its inner one. A point
339
407
  * light stores (-1, -1), which saturates the cone term to 1. */
340
408
  fn rzLightCone(i: u32) -> vec2f { return vec2f(_rzLightVec(i, 2u).w, _rzLightVec(i, 3u).x); }
@@ -379,8 +447,23 @@ fn _rzLightOne(i: u32, p: vec3f, n: vec3f) -> vec3f {
379
447
  let dist = length(d);
380
448
  // Out of reach before anything else is computed. The grid is conservative —
381
449
  // a cell's bit means the lamp CAN reach part of it — so this still runs.
382
- if (dist >= pr.w) { return vec3f(0.0); }
450
+ // a tube's reach is from its segment: past it by its half-length
451
+ let h = rzLightTube(i);
452
+ if (dist >= pr.w + length(h)) { return vec3f(0.0); }
383
453
  let toLight = d / max(dist, 1e-4);
454
+ // A tube (see _rzTubeIrradiance): its reach from the point of it nearest
455
+ // p, its light the segment's whole — an aimed one's cosine included, so it
456
+ // takes no cone and no cookie.
457
+ if (dot(h, h) > 0.0) {
458
+ let q = _rzTubeNearest(p, pr.xyz, h);
459
+ let qd = length(q - p);
460
+ if (qd >= pr.w) { return vec3f(0.0); }
461
+ let qt = clamp(qd / max(pr.w, 1e-4), 0.0, 1.0);
462
+ let qt2 = qt * qt;
463
+ let qw = 1.0 - qt2 * qt2;
464
+ let e = _rzTubeIrradiance(p, n, pr.xyz, h, rzLightAim(i), rzLightNear(i));
465
+ return rzLightColor(i) * (e * qw * qw);
466
+ }
384
467
  // Facing the light, and nothing behind it. No wrap or half-lambert: this
385
468
  // layer adds light, and a wrapped term would lift the shadow side, which is
386
469
  // the ramp's business and not this one's.
@@ -241,7 +241,8 @@ struct LightVP { viewProj: array<mat4x4f, ${SHADOW_CASCADES.length}>, };
241
241
 
242
242
  /** The stage's reflection probe (Engine.captureReflectionProbe): where it was
243
243
  * captured (xyz) and its strength (w); the box it projects onto, min with the
244
- * on-flag in w, then max. Off (boxMin.w 0) the sky stands in. */
244
+ * on-flag in w, then max with the local flag in w (1: outside the box the
245
+ * sky stands in). Off (boxMin.w 0) the sky stands in everywhere. */
245
246
  struct ProbeUniforms {
246
247
  center: vec4f,
247
248
  boxMin: vec4f,