melonjs 20.3.0 → 20.4.0

package/build/renderable/mesh.d.ts

@@ -57,11 +57,14 @@ export default class Mesh extends Renderable {
      * @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 {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).
+     * @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
@@ -127,11 +130,14 @@ export default class Mesh extends Renderable {
         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;
     });
@@ -150,7 +156,6 @@ export default class Mesh extends Renderable {
      * @type {number}
      */
     vertexCount: number;
-    _indicesOriginal: number[];
     /**
      * the projected vertex positions.
      *
@@ -268,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
@@ -293,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}
@@ -377,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
@@ -430,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.
@@ -463,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
@@ -552,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,
@@ -608,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

@@ -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
@@ -664,12 +626,7 @@ 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. Receives whatever

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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"}

package/build/renderable/sprite.d.ts

@@ -66,7 +66,6 @@ export default class Sprite extends Renderable {
         } | undefined;
         normalMap?: string | ImageBitmap | HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | Texture2d | undefined;
     });
-    _frameAnim: FrameAnimation;
     /**
      * global offset for the position to draw from on the source image.
      * @type {Vector2d}
@@ -89,22 +88,6 @@ export default class Sprite extends Renderable {
      * @type {TextureAtlas}
      */
     source: TextureAtlas;
-    /**
-     * backing field for the `normalMap` accessor — see the getter/setter
-     * defined on the class for the public API and validation rules.
-     * @ignore
-     */
-    _normalMap: ImageBitmap | HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | null;
-    /**
-     * flicker settings
-     * @ignore
-     */
-    _flicker: {
-        isFlickering: boolean;
-        duration: number;
-        callback: null;
-        elapsed: number;
-    };
     image: any;
     textureAtlas: any;
     width: any;
@@ -116,13 +99,6 @@ export default class Sprite extends Renderable {
      * @default false
      */
     get animationpause(): boolean;
-    /**
-     * pause the video when losing focus
-     * @ignore
-     */
-    removeStatePauseListener: (() => void) | undefined;
-    _lastVideoFrameVersion: number | undefined;
-    _videoFrameHandle: any;
     set normalMap(value: HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | ImageBitmap | null);
     /**
      * The optional normal-map image paired with this sprite's color
@@ -312,14 +288,6 @@ export default class Sprite extends Renderable {
      * mySprite.setRegion(mytexture.getRegion("shadedDark13.png"));
      */
     setRegion(region: object): Sprite;
-    /**
-     * Apply the current frame's texture region to this sprite's geometry: swap
-     * the source sub-texture, then resolve size / anchor (honoring trimming).
-     * Invoked by the shared {@link FrameAnimation} engine via `setRegion`.
-     * @param {object} region - the texture region object
-     * @ignore
-     */
-    _applyFrame(region: object): void;
     /**
      * force the current animation frame index.
      * @param {number} [index=0] - animation frame index
@@ -334,13 +302,6 @@ export default class Sprite extends Renderable {
      * @returns {number} current animation frame index
      */
     getCurrentAnimationFrame(): number;
-    /**
-     * Returns the frame object by the index.
-     * @ignore
-     * @param {number} id - the frame id
-     * @returns {number} if using number indices. Returns {object} containing frame data if using texture atlas
-     */
-    getAnimationFrameObjectByIndex(id: number): number;
     /**
      * Prepare the rendering context before drawing this sprite (automatically called by melonJS).
      * Extends `Renderable.preDraw` to publish this sprite's `normalMap` (if any)
@@ -357,14 +318,8 @@ export default class Sprite extends Renderable {
     /**
      * draw this sprite (automatically called by melonJS)
      * @param {Renderer} renderer - a renderer instance
-     * @param {Camera2d} [viewport] - the viewport to (re)draw
      */
     draw(renderer: Renderer): void;
-    /**
-     * Destroy function<br>
-     * @ignore
-     */
-    destroy(): void;
 }
 import Renderable from "./renderable.js";
 import FrameAnimation from "./frameAnimation.js";

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

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