melonjs 20.2.0 → 20.4.0

package/build/renderable/mesh.d.ts

@@ -56,6 +56,17 @@ export default class Mesh extends Renderable {
      * @param {string} [settings.textureFilter] - texture magnification filter (`"nearest"` for crisp pixel-art upscaling, `"linear"` for smooth) applied to the resolved texture. Omit to keep the renderer's global `antiAlias` default. On the mesh path, linear filtering also samples a generated mip chain with trilinear minification and 4× anisotropy (distant geometry stops shimmering) — `"nearest"` opts out, keeping crisp pixel-art models on hard level-0 sampling. GPU backends only (ignored by the Canvas renderer).
      * @param {number} [settings.alphaCutoff=0] - alpha cutout threshold. Fragments whose final alpha is below this value are discarded (hard-edged cutout — foliage, fences, decals — with no blending or sorting). `0` disables the cutout. Set automatically by the glTF loader from a material's `alphaMode: "MASK"`. GPU mesh path only (WebGL and WebGPU; the Canvas renderer ignores it).
      * @param {number[]|Float32Array} [settings.emissive] - emissive (self-illumination) color `[r, g, b]` (0..1, may exceed 1 for HDR glow) added on top of the lit/unlit color so the surface glows regardless of scene lights (neon, lava, screens). Omit / all-zero for no emission. Set automatically by the glTF loader (`emissiveFactor`) and OBJ loader (MTL `Ke`). GPU mesh path only (WebGL and WebGPU; the Canvas renderer ignores it).
+     * @param {boolean} [settings.lit=false] - shade this mesh with the scene's {@link Light3d} lights (the lit mesh pipeline) instead of rendering fullbright. Set automatically by the glTF importer when the scene carries a directional, point or spot light. With `lit` on and no lights present the batcher uploads a white ambient, so the result is indistinguishable from unlit.
+     * @param {Uint32Array|Color[]|number[]} [settings.vertexColors] - per-vertex colour, one entry per vertex, multiplied into {@link Mesh#tint}. Either packed RGBA8 (`Uint32Array`, the form the batchers read — no conversion) or one {@link Color} per vertex. Omit for plain white. Lets a single mesh carry a gradient — fading a terrain toward the sky with distance, darkening a crease — which a per-object `tint` cannot express. An explicit value wins over the colours a multi-material OBJ bakes from its MTL.
+     * @param {number[]|Float32Array} [settings.normals] - per-vertex normals for the lit path. An explicit value wins over the ones an OBJ or glTF source supplies; omit it and they are taken from the model, or generated from the geometry when the mesh is `lit`. Generated normals average per vertex where faces share vertices (smooth shading) and equal the face normal where they do not (flat shading) — the geometry decides, not a flag.
+     * @param {number[]|Float32Array} [settings.specular] - specular color `[r, g, b]` (0..1) for the lit path. Set by the OBJ loader from MTL `Ks`, and derived from glTF metallic/roughness.
+     * @param {number} [settings.shininess=0] - specular exponent for the lit path (MTL `Ns`). `0` for a fully diffuse surface.
+     * @param {string|TextureAtlas|HTMLImageElement} [settings.alphaMap] - per-texel opacity map, sampled in addition to the diffuse texture (MTL `map_d`).
+     * @param {boolean} [settings.castGroundShadow] - give this mesh a blob ground shadow, overriding the application's `castGroundShadow` setting in both directions. Omit to inherit. Needs a GPU backend and a `Camera3d`.
+     * @param {boolean} [settings.transparent] - draw in the transparent pass (blended, back-to-front, no depth write). Omit and a mesh goes transparent whenever its draw alpha is fractional; `true` for soft-alpha textures; `false` to stay opaque however faded
+     * @param {boolean} [settings.fog] - set `false` to exempt this mesh from the camera's distance fog ({@link Camera3d#setFog}); omit to fog whenever the camera does
+     * @param {number} [settings.shadowGroundY] - world Y of the floor the shadow lands on. Omit and the blob sits at the object's own base at full strength; set it and the blob shrinks and fades as the object rises. Render space is Y-down, so the floor is a **greater** Y than the object above it.
+     * @param {number} [settings.shadowOpacity=0.45] - opacity of the shadow directly beneath the object, before any height fade.
      * @example
      * // create from OBJ + MTL (texture auto-resolved from material)
      * let mesh = new me.Mesh(0, 0, {
@@ -118,6 +129,17 @@ export default class Mesh extends Renderable {
         textureFilter?: string | undefined;
         alphaCutoff?: number | undefined;
         emissive?: number[] | Float32Array<ArrayBufferLike> | undefined;
+        lit?: boolean | undefined;
+        vertexColors?: number[] | Uint32Array<ArrayBufferLike> | Color[] | undefined;
+        normals?: number[] | Float32Array<ArrayBufferLike> | undefined;
+        specular?: number[] | Float32Array<ArrayBufferLike> | undefined;
+        shininess?: number | undefined;
+        alphaMap?: string | HTMLImageElement | TextureAtlas | undefined;
+        castGroundShadow?: boolean | undefined;
+        transparent?: boolean | undefined;
+        fog?: boolean | undefined;
+        shadowGroundY?: number | undefined;
+        shadowOpacity?: number | undefined;
     });
     /**
      * the original (untransformed) vertex positions as x,y,z triplets
@@ -134,7 +156,6 @@ export default class Mesh extends Renderable {
      * @type {number}
      */
     vertexCount: number;
-    _indicesOriginal: number[];
     /**
      * the projected vertex positions.
      *
@@ -252,6 +273,102 @@ export default class Mesh extends Renderable {
      * @see Mesh#shadowGroundY
      */
     castGroundShadow: boolean | undefined;
+    /**
+     * Whether this mesh is affected by the camera's distance fog
+     * ({@link Camera3d#setFog}).
+     *
+     * Left **unset** (`undefined`, the default) the mesh fogs whenever the
+     * camera drawing it has fog — which for a scene that never enables fog
+     * means never. Set it to `false` and this mesh is never fogged, however
+     * far away it is: the escape hatch for something that has to stay
+     * readable at any distance, such as an objective marker or a waypoint.
+     * `true` is accepted for symmetry and behaves as the default.
+     *
+     * It exempts the **mesh**, not the ground shadow it casts. A blob is a
+     * mark on the floor and fogs with the floor it lies on — one staying
+     * crisp under an object whose surroundings had dissolved would read as
+     * a fault rather than as emphasis. The blob quad is also shared by
+     * every caster in the scene, so it carries no per-object state to read.
+     *
+     * Emissive surfaces fog too — light travelling through fog is
+     * attenuated like anything else — so a neon sign that should punch
+     * through wants `fog: false` rather than a brighter emissive.
+     * @type {boolean|undefined}
+     * @default undefined
+     * @see Camera3d#setFog
+     * @example
+     * // the world fogs; this waypoint stays readable at any distance
+     * camera.setFog({ near: 1200, far: 7000 });
+     *
+     * const marker = new Mesh(0, 0, {
+     *   ...beaconGeometry,
+     *   emissive: [1, 0.6, 0],
+     *   fog: false,
+     * });
+     * // or afterwards, on anything already built
+     * marker.fog = false;
+     */
+    fog: boolean | undefined;
+    /**
+     * Whether this mesh draws in the **transparent pass** — blended,
+     * back-to-front, writing no depth — instead of the opaque one.
+     *
+     * Left **unset** (`undefined`, the default) the mesh goes transparent
+     * whenever the draw resolves to fractional alpha, so `setOpacity(0.5)`
+     * simply fades it. That is the useful default because the opaque path
+     * writes premultiplied colour with blending off: a faded mesh comes out
+     * *darkened toward black* rather than see-through, which is a defect
+     * rather than a contract — the fully transparent end of the same range
+     * used to paint an opaque black silhouette until it was fixed.
+     *
+     * Set it **`true`** when the transparency lives in the TEXTURE rather
+     * than in the opacity — a soft-edged glow, smoke, a glTF material with
+     * `alphaMode: "BLEND"`. The automatic check reads the draw's alpha and
+     * cannot see into the texture. The glTF loader does not set this for
+     * you: one loaded mesh can merge several materials, and this flag
+     * routes the whole mesh, so a `"BLEND"` material sharing geometry with
+     * an opaque one would drag the opaque half into the transparent pass.
+     * Note that `alphaCutoff` discards texels before blending sees them, so
+     * a soft edge needs a low cutoff (see {@link Sprite3d}, which lowers
+     * its default for exactly this). The cutoff thresholds the MATERIAL's
+     * alpha, not the drawn alpha, so a fading cutout mesh keeps its shape
+     * rather than disappearing at its own threshold.
+     *
+     * The pass composites premultiplied, which is what the mesh vertex
+     * stage always emits. A texture uploaded with straight alpha and drawn
+     * with `transparent: true` therefore reads slightly bright at its soft
+     * texels; upload it premultiplied (the default) and it is exact.
+     *
+     * {@link Renderable#blendMode} is honoured per entry, with one limit:
+     * the advanced modes (`"overlay"`, `"difference"`, and the rest that
+     * need a compositing pass) fall back to `"normal"` here on both
+     * backends, since the pass rasterizes directly into the target.
+     *
+     * Set it **`false`** to keep a mesh in the opaque pass however it is
+     * faded — it will darken rather than fade, and it will keep writing
+     * depth.
+     *
+     * Sorting is **per object**, by distance from the camera, so two
+     * intersecting or mutually enclosing transparent meshes may pop as the
+     * camera moves; split them, or accept it. Needs a GPU backend and a
+     * {@link Camera3d} — the 2D-camera path is unaffected.
+     * @type {boolean|undefined}
+     * @default undefined
+     * @see Renderable#blendMode
+     * @example
+     * // a ghost that fades in — nothing else needed
+     * ghost.setOpacity(0.4);
+     *
+     * // a glow that blends at full opacity, and additively
+     * const glow = new Mesh(0, 0, {
+     *   ...quad,
+     *   texture: glowTexture,
+     *   transparent: true,
+     *   blendMode: "additive",
+     *   alphaCutoff: 0,
+     * });
+     */
+    transparent: boolean | undefined;
     /**
      * World Y of the floor the shadow lands on, or `undefined` (the
      * default) to mean "this object is standing on the ground" — the
@@ -277,17 +394,6 @@ export default class Mesh extends Renderable {
      * @default 0.45
      */
     shadowOpacity: number;
-    /**
-     * Cached horizontal half-extent used to size the shadow, resolved on
-     * first shadowed draw. Cached because the alternative is a
-     * `getBounds3d()` per frame per shadow, which re-bounds every source
-     * vertex through the model matrix.
-     * @ignore
-     */
-    _shadowHalfX: number;
-    _shadowHalfZ: number;
-    _shadowGeomVersion: number;
-    _shadowHasHeight: boolean;
     /**
      * whether to cull back-facing triangles
      * @type {boolean}
@@ -361,9 +467,15 @@ export default class Mesh extends Renderable {
      * material has its own dedup scope in the OBJ parser), so
      * every vertex belongs to exactly one material group and
      * carries that group's color unambiguously.
-     * @type {Uint32Array}
+     *
+     * This is also what `settings.vertexColors` and
+     * {@link Mesh#setVertexColor} populate, so procedural geometry
+     * can carry a gradient a per-object `tint` cannot express.
+     * `undefined` when every vertex is plain white.
+     * @type {Uint32Array|undefined}
+     * @see Mesh#setVertexColor
      */
-    vertexColors: Uint32Array;
+    vertexColors: Uint32Array | undefined;
     texture: any;
     /**
      * Index ranges that each need their own diffuse texture bound, for a
@@ -414,23 +526,6 @@ export default class Mesh extends Renderable {
      * @type {Matrix3d}
      */
     projectionMatrix: Matrix3d;
-    /** @ignore */
-    _anchorBaked: boolean;
-    /** @ignore */
-    _hullPoints: Vector2d[];
-    /** @ignore */
-    _hullPolygon: Polygon | null;
-    /** @ignore */
-    _geometryVersion: number;
-    /**
-     * Project all vertices through projectionMatrix × currentTransform
-     * and store the results in `this.vertices`.
-     * @param {number} [offsetX=0] - x offset added to each projected vertex
-     * @param {number} [offsetY=0] - y offset added to each projected vertex
-     * @param {number} [zScale=0] - scale factor for Z output (0 = skip Z, 1000 = depth buffer range)
-     * @ignore
-     */
-    _projectVertices(offsetX?: number, offsetY?: number, zScale?: number): void;
     /**
      * Signal that this mesh's geometry itself has changed — its vertices, UVs,
      * indices, normals or per-vertex colours were edited in place.
@@ -447,80 +542,29 @@ export default class Mesh extends Renderable {
      */
     set needsUpdate(value: any);
     /**
-     * Compose this mesh's placement into a single matrix: where its model-space
-     * geometry sits in the world.
+     * Set one vertex's colour, multiplied into {@link Mesh#tint}.
      *
-     * This is the matrix form of {@link Mesh#_projectVerticesWorld} — the same
-     * transform, scale and axis bridge, expressed once instead of applied to
-     * every vertex:
+     * The mesh starts carrying per-vertex colour on the first call — every
+     * other vertex is white until coloured, so a mesh built without
+     * `settings.vertexColors` looks unchanged until you touch it.
      *
-     *   `translate(pos, depth) · scale(s, -s, ±s) · currentTransform`
+     * Out-of-range indices are ignored rather than throwing, matching
+     * {@link InstancedMesh#setInstanceColor}.
      *
-     * The Y negation bridges Y-up geometry to the engine's Y-down world; Z is
-     * negated too for right-handed (glTF) sources, which makes the bridge a
-     * rotation rather than a reflection and so preserves triangle winding.
-     * @returns {Matrix3d} the mesh's model matrix (reused instance)
-     * @ignore
-     */
-    _composeModelMatrix(): Matrix3d;
-    /** @ignore */
-    _modelMatrix: Matrix3d | undefined;
-    /**
-     * Project vertices into **world space** for the Camera3d render path.
-     * Bypasses {@link Mesh#projectionMatrix} (the self-contained
-     * perspective that's meaningful only under Camera2d) and emits
-     * vertices that the active 3D camera then projects via its own
-     * view + projection matrices, the same way it does for Sprites.
-     *
-     * Per-vertex math: `currentTransform × originalVertex`, then a uniform
-     * scale by `this.width`, the Y-up→Y-down bridge (negate Y, and also Z when
-     * {@link Mesh#rightHanded} is set so the bridge is a rotation rather than a
-     * mirror), and a translate to `(offsetX, offsetY, offsetZ)`.
-     *
-     * @param {number} offsetX - world X to place the mesh center at
-     * @param {number} offsetY - world Y to place the mesh center at
-     * @param {number} offsetZ - world Z to place the mesh center at
-     * @ignore
-     */
-    _projectVerticesWorld(offsetX: number, offsetY: number, offsetZ: number): void;
-    /**
-     * Project {@link Mesh#originalNormals} into world space for lit shading,
-     * storing the result in {@link Mesh#normals}. Applies the rotation/scale of
-     * {@link Renderable#currentTransform} (no translation), the same Y-down /
-     * `rightHanded` Y/Z bridge as {@link Mesh#_projectVerticesWorld}, then
-     * renormalizes. No-op when the mesh has no source normals.
-     *
-     * Note: uses the transform's rotation/scale columns directly rather than
-     * the inverse-transpose, so normals are exact under rotation + uniform
-     * scale (the common case); a strongly non-uniform scale would skew them
-     * slightly — acceptable for the diffuse lighting path.
-     * @ignore
-     */
-    _projectNormalsWorld(): void;
-    /**
-     * Build the winding-reversed indices buffer used by the Camera3d
-     * world-space path. Called once, lazily, the first time the mesh
-     * draws under Camera3d. Why: the world-space path Y-flips vertices
-     * on output (a reflection, det = -1), which inverts triangle
-     * winding in screen space. Without the swap, `cullBackFaces: true`
-     * would end up culling the front faces and the model would look
-     * hollow.
-     *
-     * Both buffers are kept alive — `_indicesOriginal` is the original
-     * OBJ-shared (or user-supplied) winding, `_indicesReversed` is the
-     * Camera3d-flipped copy. `draw()` swaps `this.indices` between them
-     * each frame based on the active camera, so a Mesh that was first
-     * drawn under Camera3d and later re-parented to a Camera2d stage
-     * (e.g. a level transition into a 2D minigame) gets its original
-     * winding back and stays correctly oriented under
-     * `cullBackFaces: true`.
-     * @param {boolean} [needsReversedIndices=true] - build the winding-reversed index copy. `false` on the retained path, which corrects winding with `frontFace` and would otherwise duplicate the index array for nothing.
-     * @ignore
+     * Bumps {@link Mesh#needsUpdate} for you: the retained `Camera3d` path
+     * uploads geometry once and compares the version, so a colour written
+     * without it would apply on the immediate path and silently not on the
+     * retained one.
+     * @param {number} index - the vertex to colour
+     * @param {Color} color - the vertex colour
+     * @example
+     * // fade a procedural terrain toward the sky with distance
+     * for (let i = 0; i < mesh.vertexCount; i++) {
+     *     const t = Math.min(1, mesh.originalVertices[i * 3 + 2] / 6000);
+     *     mesh.setVertexColor(i, haze.copy(ground).lerp(sky, t));
+     * }
      */
-    _setupWorldSpace(needsReversedIndices?: boolean): void;
-    _indicesReversed: any;
-    _worldSpace: boolean | undefined;
-    _useWorldSpace: boolean | undefined;
+    setVertexColor(index: number, color: Color): void;
     /**
      * The mesh's world-space 3D axis-aligned bounding box. This is the 3D analog
      * of {@link Renderable#getBounds} (which returns a flat 2D box from
@@ -536,39 +580,6 @@ export default class Mesh extends Renderable {
      * @returns {AABB3d} the world-space bounding box (reused instance)
      */
     getBounds3d(): AABB3d;
-    /** @ignore */
-    _bounds3d: AABB3d | undefined;
-    /**
-     * Whether this mesh casts a ground shadow on this draw (#1515).
-     *
-     * Precedence, most specific first: the mesh's own `castGroundShadow`, then
-     * the application's `castGroundShadow` setting. A per-mesh value is an
-     * explicit instruction and is obeyed as given; the application default is a
-     * blanket one, so it skips meshes with no vertical extent — which is what a
-     * ground plane is, and a flat plane lying on the floor has nothing to cast.
-     * Read off the renderer rather than the global application instance, the
-     * same way the `textureFilter` default is.
-     * @param {WebGLRenderer|WebGPURenderer} renderer - the active renderer
-     * @returns {boolean} true if a shadow should be drawn
-     * @ignore
-     */
-    _castsGroundShadow(renderer: WebGLRenderer | WebGPURenderer): boolean;
-    /**
-     * Measure the model-space footprint the blob is built from, and whether the
-     * geometry has any height at all — once per geometry version.
-     * @ignore
-     */
-    _measureShadowFootprint(): void;
-    /**
-     * Draw this mesh's ground shadow: the shared blob quad, flattened onto the
-     * ground plane beneath the object (#1515).
-     *
-     * The quad is shared by every shadow in the scene and its geometry is
-     * uploaded once, so this is one draw and no allocation.
-     * @param {WebGLRenderer} renderer - the active renderer
-     * @ignore
-     */
-    _drawGroundShadow(renderer: WebGLRenderer): void;
     /**
      * Render the mesh at its current state (transforms, projection, tint) to an offscreen canvas.
      * The returned canvas can be used with `renderer.drawImage()`, as a `Sprite` image source,
@@ -592,12 +603,6 @@ export default class Mesh extends Renderable {
      * const sprite = new me.Sprite(100, 100, { image: bitmap });
      */
     toImageBitmap(): Promise<ImageBitmap>;
-    /**
-     * Release this mesh's GPU-resident geometry, if a renderer is holding any,
-     * then destroy the renderable.
-     * @ignore
-     */
-    destroy(): void;
 }
 import Renderable from "./renderable.js";
 import { TextureAtlas } from "./../video/texture/atlas.js";

package/build/renderable/mesh.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mesh.d.ts","sourceRoot":"","sources":["../../src/renderable/mesh.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"mesh.d.ts","sourceRoot":"","sources":["../../src/renderable/mesh.js"],"names":[],"mappings":"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"}

package/build/renderable/nineslicesprite.d.ts

@@ -65,10 +65,6 @@ export default class NineSliceSprite extends Sprite {
     nss_height: number;
     insetx: number | undefined;
     insety: number | undefined;
-    /**
-     * @ignore
-     */
-    draw(renderer: any): void;
 }
 import Sprite from "./sprite.js";
 import type { TextureAtlas } from "./../video/texture/atlas.js";

package/build/renderable/nineslicesprite.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"nineslicesprite.d.ts","sourceRoot":"","sources":["../../src/renderable/nineslicesprite.js"],"names":[],"mappings":"AAkBA;;;;;;GAMG;AACH;IACC;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,eAxBW,MAAM,KACN,MAAM,YAEd;QAAyB,KAAK,EAAtB,MAAM;QACW,MAAM,EAAvB,MAAM;QACY,MAAM;QACN,MAAM;QACyD,KAAK,EAAtF,gBAAgB,GAAC,iBAAiB,GAAC,YAAY,GAAC,eAAe,GAAC,MAAM;QACpD,IAAI;QACJ,MAAM;QACN,UAAU;QACV,WAAW;QACL,IAAI;QACV,KAAK;QACL,KAAK;QACwB,WAAW,GAA1D,MAAM,GAAC,QAAQ,GAAC;YAAC,CAAC,EAAC,MAAM,CAAC;YAAA,CAAC,EAAC,MAAM,CAAA;SAAC;KAC3C,EA8BF;IASD,iBALU,MAAM,EAOf;IATD;;;OAGG;IACH,aAFU,MAAM,CAIf;IAYD,kBALU,MAAM,EAOf;IATD;;;OAGG;IACH,cAFU,MAAM,CAIf;IAxBA,kBAA2B;IAC3B,mBAA6B;IAE7B,2BAA6B;IAC7B,2BAA6B;IAkD9B;;OAEG;IACH,0BA6EC;CACD;mBA3MkB,aAAa;kCAKC,6BAA6B;2BADtC,oBAAoB"}
+{"version":3,"file":"nineslicesprite.d.ts","sourceRoot":"","sources":["../../src/renderable/nineslicesprite.js"],"names":[],"mappings":"AAkBA;;;;;;GAMG;AACH;IACC;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,eAxBW,MAAM,KACN,MAAM,YAEd;QAAyB,KAAK,EAAtB,MAAM;QACW,MAAM,EAAvB,MAAM;QACY,MAAM;QACN,MAAM;QACyD,KAAK,EAAtF,gBAAgB,GAAC,iBAAiB,GAAC,YAAY,GAAC,eAAe,GAAC,MAAM;QACpD,IAAI;QACJ,MAAM;QACN,UAAU;QACV,WAAW;QACL,IAAI;QACV,KAAK;QACL,KAAK;QACwB,WAAW,GAA1D,MAAM,GAAC,QAAQ,GAAC;YAAC,CAAC,EAAC,MAAM,CAAC;YAAA,CAAC,EAAC,MAAM,CAAA;SAAC;KAC3C,EA8BF;IASD,iBALU,MAAM,EAOf;IATD;;;OAGG;IACH,aAFU,MAAM,CAIf;IAYD,kBALU,MAAM,EAOf;IATD;;;OAGG;IACH,cAFU,MAAM,CAIf;IAxBA,kBAA2B;IAC3B,mBAA6B;IAE7B,2BAA6B;IAC7B,2BAA6B;IAmD9B;;;OAGG;IACH,0BA6EC;CACD;mBA7MkB,aAAa;kCAKC,6BAA6B;2BADtC,oBAAoB"}

package/build/renderable/renderable.d.ts

@@ -64,7 +64,7 @@ export default class Renderable extends Rect {
      *          this.isKinematic = false;
      *
      *          // set the display to follow our position on both axis
-     *          app.viewport.follow(this.pos, app.viewport.AXIS.BOTH);
+     *          app.viewport.follow(this, app.viewport.AXIS.BOTH);
      *      }
      *
      *      ...
@@ -241,11 +241,6 @@ export default class Renderable extends Rect {
      * mySprite.postEffects = [new SepiaEffect(renderer), new VignetteEffect(renderer)];
      */
     postEffects: Array<GLShader | ShaderEffect>;
-    /**
-     * whether this renderable manages its own FBO lifecycle (e.g. Camera2d)
-     * @ignore
-     */
-    _postEffectManaged: boolean;
     /**
      * the blend mode to be applied to this renderable — any of the modes
      * listed on {@link CanvasRenderer#setBlendMode}, honoured identically by
@@ -262,45 +257,12 @@ export default class Renderable extends Rect {
      * @default ""
      */
     name: string;
-    /**
-     * to identify the object as a renderable object
-     * @ignore
-     */
-    isRenderable: boolean;
     /**
      * If true then physic collision and input events will not impact this renderable
      * @type {boolean}
      * @default true
      */
     isKinematic: boolean;
-    /**
-     * cache the absolute position of the renderable
-     * @ignore
-     */
-    _absPos: import("../index.ts").Vector3d | undefined;
-    /**
-     * keep track of when we flip
-     * @ignore
-     */
-    _flip: {
-        x: boolean;
-        y: boolean;
-    };
-    /**
-     * viewport flag
-     * @ignore
-     */
-    _inViewport: boolean;
-    /**
-     * cache value for the parentApp
-     * @ignore
-     */
-    _parentApp: any;
-    /**
-     * renderable cache tint value used by the getter/setter
-     * @ignore
-     */
-    _tint: import("../index.ts").Color;
     /**
      * returns the parent application (or game) to which this renderable is attached to
      * @return {Application} the parent application or undefined if not attached to any container/app
@@ -610,8 +572,11 @@ export default class Renderable extends Rect {
      * to the position or transforms set or applied by the preDraw method.
      * The main draw loop will first call preDraw() to prepare the context for drawing the renderable,
      * then draw() to draw the renderable, and finally postDraw() to clear the context.
-     * If you override this method, be mindful about the drawing logic; for example if you draw a shape
-     * from the draw method, you should make sure that your draw it at the 0, 0 coordinates.
+     * If you override this method, be mindful about the drawing logic: `preDraw`
+     * applies this renderable's transforms, tint and anchor offset, but does
+     * **not** translate to `this.pos`. The renderer arrives positioned at the
+     * parent container's origin, so draw relative to `this.pos` — drawing at
+     * `(0, 0)` places the shape at the container's origin instead.
      * @see Renderable#preDraw
      * @see Renderable#postDraw
      * @param {CanvasRenderer|WebGLRenderer} renderer - a renderer instance
@@ -647,7 +612,7 @@ export default class Renderable extends Rect {
      * `onCollision` only when its every-frame, return-false, fixed-`a`/`b`
      * semantics are what you want.
      *
-     * @param {import("../physics/adapter.ts").CollisionResponse} response - the collision response object
+     * @param {import("../physics/response.js").default} response - the SAT response object; the legacy handler receives this, not the adapter's `CollisionResponse`, which is why `normal` and `depth` are absent from the table above
      * @param {Renderable} other - the other renderable touching this one (a reference to response.a or response.b)
      * @returns {boolean} true if the object should respond to the collision (its position and velocity will be corrected); the return value is only honored by the builtin SAT adapter.
      * @example
@@ -661,18 +626,14 @@ export default class Renderable extends Rect {
      *     return true;
      * }
      */
-    onCollision(_response: any, _other: any): boolean;
-    /**
-     * Destroy function<br>
-     * @ignore
-     */
-    destroy(...args: any[]): void;
+    onCollision(response: import("../physics/response.js").default, other: Renderable): boolean;
     /**
      * OnDestroy Notification function<br>
-     * Called by engine before deleting the object. `Stage.destroy(app)`
-     * forwards the active Application, so subclasses that wire teardown
-     * against the app object can override as `onDestroyEvent(app)`.
-     * @param {...*} _args - forwarded by `destroy(...args)`; Stage passes the Application instance
+     * Called by engine before deleting the object. Receives whatever
+     * `destroy(...args)` was called with — the production path
+     * (`Container.removeChildNow`) passes nothing. {@link Stage} has its own
+     * `onDestroyEvent`, which does forward the active Application.
+     * @param {...*} _args - forwarded by `destroy(...args)`; normally empty
      */
     onDestroyEvent(..._args: any[]): void;
     /**
@@ -681,7 +642,8 @@ export default class Renderable extends Rect {
      * Override to wire up input handlers, register external listeners,
      * or grab adapter references — `this.parentApp` is guaranteed to be
      * available here. Pair with {@link Renderable#onDeactivateEvent}.
-     * @param {...*} _args - forwarded by `Container.addChild`
+     * @param {...*} _args - the rest parameter exists for subclass-signature
+     * compatibility; `Container.addChild` currently forwards nothing
      */
     onActivateEvent(..._args: any[]): void;
     /**
@@ -689,7 +651,8 @@ export default class Renderable extends Rect {
      * removed from its container or its container is itself removed.
      * Override to release input handlers, unsubscribe from events, or
      * drop adapter references. Pair with {@link Renderable#onActivateEvent}.
-     * @param {...*} _args - forwarded by `Container.removeChildNow`
+     * @param {...*} _args - the rest parameter exists for subclass-signature
+     * compatibility; `Container.removeChildNow` currently forwards nothing
      */
     onDeactivateEvent(..._args: any[]): void;
 }

package/build/renderable/renderable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"renderable.d.ts","sourceRoot":"","sources":["../../src/renderable/renderable.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"renderable.d.ts","sourceRoot":"","sources":["../../src/renderable/renderable.js"],"names":[],"mappings":"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"}