lecodes-sdk 2.3.1 → 2.4.1

package/dist/global.d.ts

@@ -105,6 +105,7 @@ declare global {
   const Replicated: typeof SDK.Replicated
   const Router: typeof SDK.Router
   const RpcError: typeof SDK.RpcError
+  const Scatter: typeof SDK.Scatter
   const Scene: typeof SDK.Scene
   const Scene2D: typeof SDK.Scene2D
   const Scene2dHandle: typeof SDK.Scene2dHandle
@@ -527,6 +528,9 @@ declare global {
   type RibbonOptions = SDK.RibbonOptions
   type Rolloff = SDK.Rolloff
   type RpcError = SDK.RpcError
+  type Scatter = SDK.Scatter
+  type ScatterOptions = SDK.ScatterOptions
+  type ScatterPlacement = SDK.ScatterPlacement
   type Scene = SDK.Scene
   type Scene2D = SDK.Scene2D
   type Scene2dDef = SDK.Scene2dDef

package/dist/types/gl/Foliage.d.ts

@@ -48,6 +48,11 @@ export type FoliageOptions = {
     /** Coverage held over distance: the cards' alpha × (1 + coverage × mip level), so a far crown does not thin out as its
      *  atlas mips away. Default 0.25, 0 = none; past ~0.5 a crown turns into a solid mass. */
     coverage?: number;
+    /** THE PLANTS' CASTER DISTANCE, metres: a plant casts the sun's shadow only this close to the camera (the LOD pass takes
+     *  the farther ones out of the shadow map; 3 m of hysteresis). Meant for a level with a BAKED ground, which keeps the
+     *  far shadows while the shadow map holds a fraction of the casters (the Forest's Radeon frame: 6 ms of 39 at 25 m).
+     *  Default 0 = every plant casts. */
+    castDistance?: number;
 };
 export declare const Foliage: {
     /** Level-wide options; each field given replaces the current value (a scene file's `env.foliage`

package/dist/types/gl/Lightmap.d.ts

@@ -77,9 +77,11 @@ export declare class Lightmap {
     private static warned;
     /** The bake bound last (`load`): what `probe` reads rects from. */
     private static bound;
-    /** Register static geometry — a Model, a Mesh, or any node whose subtree holds them. Statics are
-     *  both receivers and occluders in the bake. `key` names the entry in the .bake (default:
-     *  the node's name + a running number, `container#3`); pass one when names are not stable. */
+    /** Register static geometry — a Model, a Mesh, a Terrain's node, or any node whose subtree holds them. Statics are
+     *  both receivers and occluders in the bake (a model without lightmap UVs, or with materials the lightmap shader
+     *  declines — alpha cards — is an occluder alone; a terrain is ONE rect, built with `Material.terrainLightmap()`).
+     *  `key` names the entry in the .bake (default: the node's name + a running number, `container#3`); pass one when
+     *  names are not stable. */
     static add(node: Node, key?: string): Node;
     private static next;
     private static movers;

package/dist/types/gl/Material.d.ts

@@ -199,6 +199,12 @@ export declare class Material {
     private static _glbDefaults;
     private static _lightmapDefaults;
     private static _folTemplate;
+    /** Which material a foliage model's CARDS (its alpha-MASK materials) take: `"full"` = `foliage-masked`, the
+     *  shader with the card's own plane, normal map, edge fade and the ground's baked light; `"lean"` =
+     *  `foliage-cards`, the same wind with the lighting moved to the vertex (one texture read, the sun's shadow
+     *  kept) — a third of a forest frame less on a phone-class GPU (2026-10-18). Read when the first foliage
+     *  model loads; set it before. */
+    static foliageCards: "full" | "lean";
     static _foliageMaskedTemplate(): Material | null;
     private static _folMaskedTemplate;
     private static _glbTemplate;

package/dist/types/gl/Scatter.d.ts

@@ -0,0 +1,25 @@
+import { Node } from "./Node";
+import type { Model } from "./Model";
+import { type Vec3Like } from "../math/vec";
+/** One placement: where the kind's origin stands, its yaw about +Y in degrees, its uniform scale. */
+export type ScatterPlacement = {
+    position: Vec3Like;
+    /** Degrees, default 0. */
+    yaw?: number;
+    /** Uniform, default 1. */
+    scale?: number;
+};
+export type ScatterOptions = {
+    /** The cell edge in metres the placements are bucketed by (one draw per 64 placements of a cell). Default 16. */
+    cell?: number;
+    /** Whether the copies cast the sun's shadow. Default false: ground cover never does. */
+    castShadows?: boolean;
+    name?: string;
+};
+export declare class Scatter extends Node {
+    /** Placements given. */
+    readonly count: number;
+    /** Renderables the engine made (0 on a host that cloned instead). */
+    readonly draws: number;
+    constructor(kind: Model, placements: readonly ScatterPlacement[], options?: ScatterOptions);
+}

package/dist/types/gl/terrain/Terrain.d.ts

@@ -19,6 +19,9 @@ export type TerrainLayer = {
     /** Sample this layer triplanar in world space (cliff rock): no stretching on steep slopes; its
      *  normal map is then skipped. Default false. */
     triplanar?: boolean;
+    /** The layer's MEAN COLOUR, for the plants: a grass blade's base takes the colour of the soil it stands in (the
+     *  vegetation tier's cards read the control map and these four colours). Unset on every layer = no tint. */
+    color?: ColorInput;
 };
 export type TerrainOptions = {
     /** Samples per side (square). 257 / 513 / 1025 are the usual sizes. Default 129. */
@@ -274,6 +277,8 @@ export declare class Terrain {
     private _rebuildFallbackChunks;
     private _applyShadows;
     private _uploadControl;
+    /** The layers' colours to the vegetation tier (TerrainLayer.color), once the control map exists. */
+    private _pushGroundTint;
     private _applyLayers;
     /** Re-push layer scalars after editing `layers` (textures given as Texture apply too). */
     applyLayers(): Promise<void>;

package/dist/types/inject.d.ts

@@ -143,6 +143,8 @@ export type { LocomotionSet, LocomotionClip, LocomotionTuning, LocomotionState,
 export { Material } from "./gl/Material";
 export { Geometry } from "./gl/Geometry";
 export { InstancedMesh } from "./gl/InstancedMesh";
+export { Scatter } from "./gl/Scatter";
+export type { ScatterPlacement, ScatterOptions } from "./gl/Scatter";
 export type { InstanceTransform } from "./gl/InstancedMesh";
 export { Texture } from "./gl/Texture";
 export type { TextureLoadOptions } from "./gl/Texture";

package/dist/types/runtime/device.d.ts

@@ -63,6 +63,26 @@ export declare const device: {
      *  what it measures. It belongs to the host, not to the project: it stays on when another project
      *  is opened. Reads `false`, and writing does nothing, on hosts without one (web, headless). */
     statsOverlay: boolean;
+    /** Cap the frame rate: the host runs the frame — the tick, the 3D scene — at most `fps` times a
+     *  second. `0` removes the cap: the display's own rate (120 on a 120 Hz phone), or, with vsync
+     *  off, as fast as the host renders. A REQUEST, not a state the app owns: a phone asks its panel
+     *  for the rate (a 120 Hz panel at 60 shows every frame for a full period — even, cooler) and an
+     *  OEM may refuse the switch, in which case the host renders every second refresh instead; the
+     *  screen's own maximum always wins. The tick IS the frame here, so a cap of 30 is 30 Hz of game
+     *  logic and input sampling too — raise it for gameplay. Host state: it stays through a project
+     *  swap. A no-op on hosts whose loop has no pacing of its own (web, headless). */
+    setFrameRate(fps: number): void;
+    /** Vertical sync: `false` presents without waiting for the display's refresh — the lowest input
+     *  latency, tearing possible, and with no cap set (`setFrameRate(0)`) the loop renders as fast as
+     *  it can. Set a cap unless you are measuring. Desktop only: a mobile compositor never presents
+     *  outside the refresh. Returns whether the host took the request (`false` on a host without
+     *  the switch), so a settings menu can hide the toggle. */
+    setVsync(enabled: boolean): boolean;
+    /** The display's refresh rate in Hz: the fastest the screen offers the app — 120 on a 120 Hz
+     *  phone whatever mode a cap has put it in (an iPhone's 60 unless the app's Info.plist lifts the
+     *  floor), the monitor's current mode on desktop. The sensible choices of a frame-rate menu are
+     *  its divisors. 0 where the host cannot tell (web). */
+    readonly displayRefreshRate: number;
     /** Device-orientation sensor (gyro + accelerometer, fused) for tilt/steering and magic-window /
      *  360° panoramas. Poll `attitude` / `gravity` inside setLoop; they return the freshest fused
      *  sample, so the sensor rate need not match your frame rate. Host-gated: a no-op with no sensor. */

package/dist/types/version.d.ts

@@ -1,4 +1,4 @@
-export declare const SDK_VERSION = "2.3.1";
+export declare const SDK_VERSION = "2.4.1";
 /** The major of a semver string, or null when it is not one. */
 export declare const sdkMajor: (version: string | null | undefined) => number | null;
 /** The `// sdk: <version>` line of a compiled bundle's header (sdk/src/compile/header.ts), read from