lecodes-sdk 0.20.2 → 1.0.0

package/src/gl/Lightmap.ts

@@ -71,6 +71,13 @@ export type LightmapLoadOptions = {
    *  and its underside does not — the same shading the atlas gives the statics. Before that the volume
    *  was one flat 0.5·E on every face and this knob was the workaround. Kept as a trim. */
   volumeBoost?: number
+  /** What an OCCLUDER-only static (a prop without lightmap UVs — traced into the receivers' atlas but
+   *  carrying no rect of its own) does in real time. `"baked"` (default): its shadow is in the bake, so
+   *  it stops casting and the shadow pass draws only the movers — on a level of thousands of foliage
+   *  cards that is a third of the GPU frame. `"realtime"`: it keeps casting, which is the only way its
+   *  shadow reaches OTHER non-receiver props (a rock under a tree); the honest fix for that is lightmap
+   *  UVs on the props (`lecodes assets doctor --lightmap-uv`), which makes them receivers. */
+  occluderShadows?: "baked" | "realtime"
 }
 
 export type LightmapInfo = {
@@ -87,6 +94,8 @@ export type LightmapInfo = {
   applied: number
   total: number
   missing: string[]
+  /** Occluder-only statics whose real-time shadow was switched off (`occluderShadows: "baked"`). */
+  occluders: number
 }
 
 export type LightmapFiles = {
@@ -98,7 +107,7 @@ export type LightmapFiles = {
   volume?: string
 }
 
-import type { Terrain } from "./Terrain"
+import type { Terrain } from "./terrain/Terrain"
 
 type Entry = { key: string, model?: Model, mesh?: Mesh, terrain?: Terrain }
 
@@ -274,12 +283,29 @@ export class Lightmap {
     // the light volume next: it claims every lightmap-material instance, the atlas rects below win back the statics
     const volume = files.volume ? await Lightmap.loadVolume(files.volume, volumeScale, lightGamma, ambientScale, strength, aoStrength) : null
     const rects = new Map<string, { st: number[], page: number }>()
-    for (const inst of data.instances) if (inst.receiver && inst.st) rects.set(inst.key, { st: inst.st, page: inst.page ?? 0 })
-    let applied = 0
+    // an OCCLUDER-only static (no lightmap UVs): the bake traced its shadow onto every receiver, so it
+    // has nothing left to cast in real time — the shadow pass then draws only the movers. Twig & Twine's
+    // 9 441 props (5 M alpha-masked spruce cards) cost the GPU a third of the frame as live casters.
+    const occluders = new Set<string>()
+    for (const inst of data.instances) {
+      if (inst.receiver && inst.st) rects.set(inst.key, { st: inst.st, page: inst.page ?? 0 })
+      else if (!inst.receiver) occluders.add(inst.key)
+    }
+    const bakedOccluders = (options.occluderShadows ?? "baked") === "baked"
+    let applied = 0, shadowless = 0
     const missing: string[] = []
     for (const e of Lightmap.entries) {
       const r = rects.get(e.key)
-      if (!r || r.page >= textures.length) { missing.push(e.key); continue }
+      if (!r || r.page >= textures.length) {
+        if (occluders.has(e.key)) {
+          if (bakedOccluders) {
+            if (e.model) e.model.castShadows = false
+            else if (e.mesh) e.mesh.castShadows = false
+            shadowless++
+          }
+        } else missing.push(e.key)
+        continue
+      }
       const st = r.st
       const texture = textures[r.page]
       const light = r.page < lightTextures.length ? lightTextures[r.page] : null
@@ -304,7 +330,8 @@ export class Lightmap {
     // the lights the bake carries go dark: the atlas holds them for the statics, the volume for the movers
     let lights = 0
     if (lightTextures.length > 0 && data.lights?.length) lights = Lightmap.switchOffBaked(data.lights)
-    const info: LightmapInfo = { size: data.size, texel: data.texel, pages, applied, total: rects.size, missing, lights }
+    if (shadowless > 0) console.log(`[lightmap] ${shadowless} occluder-only static(s) cast no real-time shadow (baked); the shadow pass draws the movers only`)
+    const info: LightmapInfo = { size: data.size, texel: data.texel, pages, applied, total: rects.size, missing, lights, occluders: shadowless }
     if (volume) info.volume = { dims: volume.dims, cell: volume.cell }
     return info
   }

package/src/gl/Material.ts

@@ -349,6 +349,22 @@ export class Material {
     return m
   }
 
+  /** `Material.lightmap()`'s masked twin (`blending: masked`, same shader and parameters): what the engine
+   *  gives a lightmapped model's alpha-MASK materials. The cutoff comes from the glTF material. */
+  static lightmapMasked(): Material {
+    const id = Material.lightmapShading === "baked"
+      ? _creatorUtils.fetchLocal("lightmap-baked-masked.filamat")
+      : Material.lightmapShading === "baked-lite"
+        ? _creatorUtils.fetchLocal("lightmap-baked-lite-masked.filamat")
+        : _creatorUtils.fetchLocal("lightmap-masked.filamat")
+    const m = new Material({ _id: id } as any)
+    m.set("baseColorFactor", "#ffffffff").set("roughnessFactor", 1).set("metallicFactor", 0)
+    m.set("lightmapST", [ 1, 1, 0, 0 ]).set("ambientScale", 1).set("sunStrength", 1).set("hasNormalMap", 0)
+    m.set("bakedAo", 1).set("lightScale", 0)
+    m.set("probeMin", [ 0, 0, 0, 0 ]).set("probeInvSize", [ 0, 0, 0, 0 ])
+    return m
+  }
+
   /** The terrain splat material (docs/terrain-plan.md §1.5): four albedo (+ normal-map) layers blended by
    *  a control map on the terrain's own grid, per-layer `tiling` (metres per repeat) / `roughness` /
    *  `normalScale` / `triplanar`, lightmap-aware (the same `lightmap` / `lightmapST` block as
@@ -367,6 +383,10 @@ export class Material {
    *  the GLB provider instantiates; the template itself never draws). */
   static _lightmapTemplate(): Material { return (Material._lmTemplate ??= Material.lightmap()) }
   private static _lmTemplate: Material | undefined
+  /** @internal The tier's MASKED twin, handed to the engine next to the template: a model's glTF MASK
+   *  materials (foliage cards) take it instead of falling back to the ubershader's full lit path. */
+  static _lightmapMaskedTemplate(): Material { return (Material._lmMaskedTemplate ??= Material.lightmapMasked()) }
+  private static _lmMaskedTemplate: Material | undefined
 
   static _lightmapShading: LightmapShading = "full"
   /** Which shader lightmapped models take — a graphics-quality tier, engine-wide. `"full"` is filament's
@@ -381,6 +401,7 @@ export class Material {
     if (mode === Material._lightmapShading) return
     Material._lightmapShading = mode
     Material._lmTemplate = undefined   // the next load builds a template on the new shader
+    Material._lmMaskedTemplate = undefined
   }
 
   /** Shadow-catcher material (transparent except where shadows fall). */

package/src/gl/Mesh.ts

@@ -1,102 +1,120 @@
-// A renderable 3D node from raw geometry — the primitive shapes (box/sphere/cylinder/plane) and
-// Mesh.from for a custom Geometry. A GLB import is a different kind: see Model.load.
-
-import { cx, cy, cz, type Vec3Like } from "../math/vec"
-import {
-  Geometry,
-  type CylinderOptions,
-  type PlaneOptions,
-  type SphereOptions,
-} from "./Geometry"
-import { Material } from "./Material"
-import { Node } from "./Node"
-
-/** Common transform/render options every primitive factory accepts. */
-export type MeshOptions = {
-  material?: Material
-  position?: Vec3Like
-  eulerAngles?: Vec3Like
-  scale?: Vec3Like | number
-  name?: string
-  castShadows?: boolean
-  receiveShadows?: boolean
-  /** Coarse draw order, 0 (first) … 7 (last); default 4. See `Mesh.renderPriority`. */
-  renderPriority?: number
-}
-
-export class Mesh extends Node {
-  private _geometry?: Geometry
-
-  constructor(geometry?: Geometry, material?: Material) {
-    super()
-    if (geometry) {
-      const mat = material ?? Material.unlit()
-      this._geometry = geometry
-      this._materials = [ mat ]
-      _creator.setMesh(this.id, Material.idOf(mat), geometry.vertices, geometry.normals, geometry.indices, geometry.uv, geometry._meshKind, geometry.uv1, geometry.colors)
-    }
-  }
-
-  override get geometry(): Geometry | undefined { return this._geometry }
-  /** Replace the geometry in place — the node, its transform and its material stay, the vertex and
-   *  index buffers are rebuilt. What an editor overlay or a debug drawer redraws with. */
-  setGeometry(geometry: Geometry): this {
-    this._geometry = geometry
-    _creator.setMesh(this.id, Material.idOf(this._materials![0]!), geometry.vertices, geometry.normals, geometry.indices, geometry.uv, geometry._meshKind, geometry.uv1, geometry.colors)
-    return this
-  }
-
-  /** A Mesh always carries a material (slot 0) — see Node.setMaterial for the slot API. */
-  override get material(): Material { return this._materials![0]! }
-  override set material(m: Material) { this.setMaterial(m, 0) }
-
-  set culling(v: boolean) { _creator.setCulling(this.id, v) }
-  /** Coarse draw order within the frame: 0 draws first, 7 last, 4 is the default (Filament's
-   *  renderable priority; within one priority opaque draws sort front-to-back, blended back-to-front).
-   *  Something drawn over the scene with `Material.depthTest = false` goes in 7, so nothing drawn
-   *  after it can cover it. Write-only; a host that predates the call ignores it. */
-  set renderPriority(v: number) {
-    if (_creator.setRenderPriority) _creator.setRenderPriority(this.id, Math.max(0, Math.min(7, Math.round(v))))
-    else if (!Mesh._warnedPriority) { Mesh._warnedPriority = true; console.warn("[mesh] this host has no setRenderPriority — renderPriority ignored") }
-  }
-  private static _warnedPriority = false
-  set castShadows(v: boolean) { _creator.setCastShadows(this.id, v) }
-  set receiveShadows(v: boolean) { _creator.setReceiveShadows(this.id, v) }
-
-  // --- factories ---
-
-  static box(options: MeshOptions & { size?: Vec3Like | number } = {}): Mesh {
-    // the size goes into the geometry (not a scale after): the lightmap chart is laid out per face area
-    return apply(new Mesh(Geometry.box(options.size ?? 1), options.material), options)
-  }
-
-  static sphere(options: MeshOptions & SphereOptions = {}): Mesh {
-    return apply(new Mesh(Geometry.sphere(options), options.material), options)
-  }
-
-  static cylinder(options: MeshOptions & CylinderOptions = {}): Mesh {
-    return apply(new Mesh(Geometry.cylinder(options), options.material), options)
-  }
-
-  static plane(options: MeshOptions & PlaneOptions = {}): Mesh {
-    return apply(new Mesh(Geometry.plane(options), options.material), options)
-  }
-
-  /** Wrap a custom Geometry. */
-  static from(geometry: Geometry, options: MeshOptions = {}): Mesh {
-    return apply(new Mesh(geometry, options.material), options)
-  }
-}
-
-const sizeToVec = (s: Vec3Like | number): [number, number, number] => (typeof s === "number" ? [ s, s, s ] : [ cx(s), cy(s), cz(s) ])
-
-const apply = (mesh: Mesh, o: MeshOptions): Mesh => {
-  if (o.position) mesh.position = o.position
-  if (o.eulerAngles) mesh.eulerAngles = o.eulerAngles
-  if (o.scale !== undefined) mesh.scale = typeof o.scale === "number" ? [ o.scale, o.scale, o.scale ] : o.scale
-  if (o.name !== undefined) mesh.name = o.name
-  if (o.castShadows !== undefined) mesh.castShadows = o.castShadows
-  if (o.receiveShadows !== undefined) mesh.receiveShadows = o.receiveShadows
-  if (o.renderPriority !== undefined) mesh.renderPriority = o.renderPriority
-  return mesh
-}
+// A renderable 3D node from raw geometry — the primitive shapes (box/sphere/cylinder/capsule/plane) and
+// Mesh.from for a custom Geometry. A GLB import is a different kind: see Model.load.
+
+import { cx, cy, cz, type Vec3Like } from "../math/vec"
+import {
+  Geometry,
+  type CapsuleOptions,
+  type CylinderOptions,
+  type PlaneOptions,
+  type SphereOptions,
+} from "./Geometry"
+import { Material } from "./Material"
+import { Node } from "./Node"
+
+/** Common transform/render options every primitive factory accepts. */
+export type MeshOptions = {
+  material?: Material
+  position?: Vec3Like
+  eulerAngles?: Vec3Like
+  scale?: Vec3Like | number
+  name?: string
+  castShadows?: boolean
+  receiveShadows?: boolean
+  /** Coarse draw order, 0 (first) … 7 (last); default 4. See `Mesh.renderPriority`. */
+  renderPriority?: number
+}
+
+export class Mesh extends Node {
+  private _geometry?: Geometry
+
+  constructor(geometry?: Geometry, material?: Material) {
+    super()
+    if (geometry) {
+      const mat = material ?? Material.unlit()
+      this._geometry = geometry
+      this._materials = [ mat ]
+      _creator.setMesh(this.id, Material.idOf(mat), geometry.vertices, geometry.normals, geometry.indices, geometry.uv, geometry._meshKind, geometry.uv1, geometry.colors)
+    }
+  }
+
+  override get geometry(): Geometry | undefined { return this._geometry }
+  /** Replace the geometry in place — the node, its transform and its material stay, the vertex and
+   *  index buffers are rebuilt. What an editor overlay or a debug drawer redraws with. */
+  setGeometry(geometry: Geometry): this {
+    this._geometry = geometry
+    _creator.setMesh(this.id, Material.idOf(this._materials![0]!), geometry.vertices, geometry.normals, geometry.indices, geometry.uv, geometry._meshKind, geometry.uv1, geometry.colors)
+    // the host rebuilds the renderable for a new geometry (creator-gl createMesh destroys + builds), which
+    // resets its priority / culling / shadow flags to the defaults — an overlay redrawn every frame lost its
+    // renderPriority 7 after one frame and hid inside the model. What was set on this mesh is set again.
+    if (this._renderPriority !== undefined) this.renderPriority = this._renderPriority
+    if (this._culling !== undefined) this.culling = this._culling
+    if (this._castShadows !== undefined) this.castShadows = this._castShadows
+    if (this._receiveShadows !== undefined) this.receiveShadows = this._receiveShadows
+    return this
+  }
+  private _renderPriority?: number
+  private _culling?: boolean
+  private _castShadows?: boolean
+  private _receiveShadows?: boolean
+
+  /** A Mesh always carries a material (slot 0) — see Node.setMaterial for the slot API. */
+  override get material(): Material { return this._materials![0]! }
+  override set material(m: Material) { this.setMaterial(m, 0) }
+
+  set culling(v: boolean) { this._culling = v; _creator.setCulling(this.id, v) }
+  /** Coarse draw order within the frame: 0 draws first, 7 last, 4 is the default (Filament's
+   *  renderable priority; within one priority opaque draws sort front-to-back, blended back-to-front).
+   *  Something drawn over the scene with `Material.depthTest = false` goes in 7, so nothing drawn
+   *  after it can cover it. Write-only; a host that predates the call ignores it. */
+  set renderPriority(v: number) {
+    this._renderPriority = v
+    if (_creator.setRenderPriority) _creator.setRenderPriority(this.id, Math.max(0, Math.min(7, Math.round(v))))
+    else if (!Mesh._warnedPriority) { Mesh._warnedPriority = true; console.warn("[mesh] this host has no setRenderPriority — renderPriority ignored") }
+  }
+  private static _warnedPriority = false
+  set castShadows(v: boolean) { this._castShadows = v; _creator.setCastShadows(this.id, v) }
+  set receiveShadows(v: boolean) { this._receiveShadows = v; _creator.setReceiveShadows(this.id, v) }
+
+  // --- factories ---
+
+  static box(options: MeshOptions & { size?: Vec3Like | number } = {}): Mesh {
+    // the size goes into the geometry (not a scale after): the lightmap chart is laid out per face area
+    return apply(new Mesh(Geometry.box(options.size ?? 1), options.material), options)
+  }
+
+  static sphere(options: MeshOptions & SphereOptions = {}): Mesh {
+    return apply(new Mesh(Geometry.sphere(options), options.material), options)
+  }
+
+  static cylinder(options: MeshOptions & CylinderOptions = {}): Mesh {
+    return apply(new Mesh(Geometry.cylinder(options), options.material), options)
+  }
+
+  /** A capsule along Y (`radius`, `length` between the cap centres) — a character's or a collider's shape in one mesh. */
+  static capsule(options: MeshOptions & CapsuleOptions = {}): Mesh {
+    return apply(new Mesh(Geometry.capsule(options), options.material), options)
+  }
+
+  static plane(options: MeshOptions & PlaneOptions = {}): Mesh {
+    return apply(new Mesh(Geometry.plane(options), options.material), options)
+  }
+
+  /** Wrap a custom Geometry. */
+  static from(geometry: Geometry, options: MeshOptions = {}): Mesh {
+    return apply(new Mesh(geometry, options.material), options)
+  }
+}
+
+const sizeToVec = (s: Vec3Like | number): [number, number, number] => (typeof s === "number" ? [ s, s, s ] : [ cx(s), cy(s), cz(s) ])
+
+const apply = (mesh: Mesh, o: MeshOptions): Mesh => {
+  if (o.position) mesh.position = o.position
+  if (o.eulerAngles) mesh.eulerAngles = o.eulerAngles
+  if (o.scale !== undefined) mesh.scale = typeof o.scale === "number" ? [ o.scale, o.scale, o.scale ] : o.scale
+  if (o.name !== undefined) mesh.name = o.name
+  if (o.castShadows !== undefined) mesh.castShadows = o.castShadows
+  if (o.receiveShadows !== undefined) mesh.receiveShadows = o.receiveShadows
+  if (o.renderPriority !== undefined) mesh.renderPriority = o.renderPriority
+  return mesh
+}

package/src/gl/Model.ts

@@ -9,6 +9,27 @@ import { Node } from "./Node"
 import { Animator, _pushLod, type LodMode } from "./animation/Animator"
 import { Material } from "./Material"
 
+/** One polygon under a screen point — what `Model.pickTriangle` returns. `bones` are the vertex's raw
+ *  JOINTS_0 / WEIGHTS_0 pairs (weight > 0; empty = unweighted), `bind` its position in mesh space,
+ *  `world` its skinned position this frame. */
+export interface TrianglePick {
+  /** the Model's root entity, and the mesh node's own entity (0 when the host has no entity for it) */
+  entity: number
+  node: number
+  nodeName: string
+  mesh: string
+  primitive: number
+  material: string
+  /** triangle index within the primitive (index-buffer order), and whether the ray came from behind */
+  triangle: number
+  backface: boolean
+  distance: number
+  point: [number, number, number]
+  bary: [number, number, number]
+  skin: string
+  vertices: { index: number, bind: [number, number, number], world: [number, number, number], bones: { name: string, weight: number }[] }[]
+}
+
 export class Model extends Node {
   /** The model's Animator — always present, its clip table = the GLB's embedded clips. Configure
    *  more (external clips, blend spaces, layers) with `model.aspect(Animator, {...})`. */
@@ -69,6 +90,16 @@ export class Model extends Node {
   /** @internal both flags travel together — the bridge walks the instance once. */
   _applyShadows(): void { _creator.setGlbShadows?.(this.id, this._castShadows, this._receiveShadows) }
 
+  /** DEBUG: the closest polygon of this model under a screen point (logical px — `Input.mouse.position`,
+   *  a touch event's clientX/Y), tested against the CPU-skinned CURRENT pose, both faces. Names the
+   *  triangle, its three vertices (bind + skinned positions) and their raw bone weights, so a stretched
+   *  or misbound polygon can be traced to its binding. One full CPU skin of the model per call: click-rate
+   *  only. null = miss, or a host without the pick (desktop today). */
+  pickTriangle(screenX: number, screenY: number): TrianglePick | null {
+    const json = _creator.pickTriangle?.(this.id, screenX, screenY)
+    return json ? JSON.parse(json) as TrianglePick : null
+  }
+
   /** Duplicate this model — a deep copy of the GLB (meshes, skeleton, animation clips), attached to
    *  the same parent and scene and sharing this model's current transform. The clone has its own
    *  independent animation state (reach it via clone.anim). Mirrors this model's culling flag. */
@@ -110,7 +141,8 @@ export class Model extends Node {
     return new Promise<Model>((resolve, reject) => {
       const mode = options.lightmap ?? Model._lightmapDefault
       const lightmapped = !!mode && !!_creator.setNextGlbLightmapped
-      if (lightmapped) _creator.setNextGlbLightmapped!(Material.idOf(Material._lightmapTemplate()))
+      // the tier + its masked twin (alpha-MASK materials — foliage — take the lightmap shader too, 2026-09-11)
+      if (lightmapped) _creator.setNextGlbLightmapped!(Material.idOf(Material._lightmapTemplate()), Material.idOf(Material._lightmapMaskedTemplate()))
       _creator.createGlb((source as unknown as { _id: number })._id, (entityId: number) => {
         if (entityId === 0) { reject(new Error("Failed to load GLB")); return }
         const model = new Model(entityId)

package/src/gl/Node.ts

@@ -12,7 +12,7 @@ import { Quat, cw, type QuatLike } from "../math/quat"
 import { Mat4, type Mat4Like } from "../math/mat4"
 import type { Geometry } from "./Geometry"
 import { registerTouchEndEvent, registerTouchStartEvent } from "./touch"
-import { ensurePhysicsEvents } from "./physicsEvents"
+import { ensurePhysicsEvents } from "./physics/physicsEvents"
 import { Material } from "./Material"
 import type { CompAxis, CompWriter } from "../core/compWrite"
 import type { ClickEvent, TouchStartEvent } from "../runtime/touch"

package/src/gl/Particles.ts

@@ -231,7 +231,15 @@ type Shape =
  *  birth direction (a burst that decays: `curve(4).to(0)`), `x`/`y`/`z` drift in the simulation
  *  space (rising smoke: `y: curve(2).from(0).to(1)`). Unity's velocityOverLifetime. */
 export type VelocityOverLife = { radial?: ParticleValue, x?: ParticleValue, y?: ParticleValue, z?: ParticleValue }
-type Noise = { strength?: number, frequency?: number, speed?: number }
+type Noise = {
+  strength?: number, frequency?: number, speed?: number,
+  /** How much of the displacement a particle earns with AGE (default 0 = all of it from birth).
+   *  The field is sampled by position, so at 0 every particle born at the same spot is pushed the
+   *  same way and a plume's root wanders off its emitter by up to `strength` metres; at 1 a particle
+   *  is born exactly where the emitter put it and drifts into the field over its life — what you
+   *  want whenever the source is visible (an exhaust pipe, a contact patch, a muzzle). */
+  ramp?: number,
+}
 
 /** Ground plane for bouncing particles (all render modes). `height` is in the simulation space:
  *  world y with `space: 'world'`, emitter-local y otherwise. */
@@ -283,6 +291,11 @@ export type ParticlesOptions = ParticlesMaterialOptions & {
    *  without this the engine picks who covers whom per frame (smoke popping over a fireball).
    *  Default 0; a fireball wants 2, its smoke 1, a smoke trail -1. */
   order?: number
+  /** Coarse draw order among ALL blended draws, 0 (first) … 7 (last) — see `Mesh.renderPriority`.
+   *  Default 5: meshes sit at 4 and decals at 3, so smoke covers a car's glass and its skid marks
+   *  whatever the camera does (the engine's depth sort compares object centres, and an emitter's
+   *  centre says nothing about where its cloud is). `order` breaks ties inside one priority. */
+  renderPriority?: number
   shape?: Shape
   /** Extra velocity over life (radial burst that decays, axis drift) — see `VelocityOverLife`. */
   velocityOverLife?: VelocityOverLife
@@ -437,6 +450,7 @@ export class Particles extends Node {
     super()
     this._material = options.material ?? (options.mesh ? Material.lit() : Material.particles(options))
     _creator.createParticleSystem(this.id, Material.idOf(this._material), options.maxParticles ?? 0)
+    this.renderPriority = options.renderPriority ?? 5
 
     const id = this.id
     this.custom = new Proxy([] as ParticleValue[], {
@@ -496,7 +510,7 @@ export class Particles extends Node {
     }
     if (options.noise !== undefined) {
       const n = options.noise
-      out.push(TAG_NOISE, 3, n ? n.strength ?? 1 : 0, n ? n.frequency ?? 1 : 0, n ? n.speed ?? 1 : 0)
+      out.push(TAG_NOISE, 4, n ? n.strength ?? 1 : 0, n ? n.frequency ?? 1 : 0, n ? n.speed ?? 1 : 0, n ? n.ramp ?? 0 : 0)
     }
     if (options.seed !== undefined) out.push(TAG_SEED, 1, options.seed)
 
@@ -517,6 +531,10 @@ export class Particles extends Node {
   set inheritVelocity(val: number) { this._send([ TAG_INHERIT_VELOCITY, 1, val ]) }
   set rateOverDistance(val: number) { this._send([ TAG_RATE_DISTANCE, 1, val ]) }
   set order(val: number) { this._send([ TAG_ORDER, 1, val ]) }
+  /** Coarse draw order, 0 … 7 — see `Mesh.renderPriority`. Write-only. */
+  set renderPriority(v: number) {
+    if (_creator.setRenderPriority) _creator.setRenderPriority(this.id, Math.max(0, Math.min(7, Math.round(v))))
+  }
 
   set velocityOverLife(v: VelocityOverLife) {
     const out: number[] = []
@@ -585,7 +603,7 @@ export class Particles extends Node {
 
   set noise(noise: Noise | null) {
     this._send(noise
-      ? [ TAG_NOISE, 3, noise.strength ?? 1, noise.frequency ?? 1, noise.speed ?? 1 ]
+      ? [ TAG_NOISE, 4, noise.strength ?? 1, noise.frequency ?? 1, noise.speed ?? 1, noise.ramp ?? 0 ]
       : [ TAG_NOISE, 3, 0, 0, 0 ])
   }
 }

package/src/gl/Scene.ts

@@ -13,7 +13,7 @@ import type { ClickEvent, TouchStartEvent } from "../runtime/touch"
 import type { FetchResponse } from "../runtime/fetch"
 import { _requestCameraPermission } from "../plugins/permission"
 import { Camera } from "./Camera"
-import { SceneAudio } from "./SceneAudio"
+import { SceneAudio } from "./audio/SceneAudio"
 import { attachControls, type ControlsHandle, type ControlsOptions } from "./controls"
 import { Material } from "./Material"
 import { Texture } from "./Texture"