/**
 * A base class for renderable objects.
 * @category Game Objects
 */
export default class Renderable extends Rect {
    isDirty: boolean;
    /**
     * The anchor point is used for attachment behavior, and/or when applying transformations.<br>
     * The coordinate system places the origin at the top left corner of the frame (0, 0) and (1, 1) means the bottom-right corner<br>
     * <img src="images/anchor_point.png"/><br>
     * a Renderable's anchor point defaults to (0.5,0.5), which corresponds to the center position.<br>
     * <br>
     * <i><b>Note:</b> Object created through Tiled will have their anchorPoint set to (0, 0) to match Tiled Level editor implementation.
     * To specify a value through Tiled, use a json expression like `json:{"x":0.5,"y":0.5}`, or (since 19.9) a plain string preset such as `bottom`. </i>
     * <br>
     * At construction time, `settings.anchorPoint` also accepts the named presets
     * `"center"`, `"top"`, `"bottom"`, `"left"`, `"right"`, `"top-left"`, `"top-right"`,
     * `"bottom-left"`, `"bottom-right"` on every renderable that consumes it
     * (Sprite, Entity, Collectable, ImageLayer, Text, BitmapText, Sprite3d and subclasses).
     * @type {ObservablePoint}
     * @default <0.5,0.5>
     */
    anchorPoint: ObservablePoint;
    /**
     * the renderable transformation matrix (4x4).
     * For standard 2D use, only the 2D components are used (rotate around Z, scale X/Y, translate X/Y).
     * For 3D use (e.g. Mesh), the full 4x4 matrix supports rotation around any axis,
     * 3D translation, and perspective projection.
     * Use the `rotate()`, `scale()`, and `translate()` methods rather than modifying this directly.
     * @type {Matrix3d}
     */
    currentTransform: Matrix3d;
    /**
     * the renderable physics body — the handle returned by the
     * active {@link PhysicsAdapter}'s `addBody` (or constructed
     * imperatively via `new Body(...)`). Typed as the portable
     * {@link PhysicsBody} interface; cast to the adapter-specific
     * concrete type (`MatterAdapter.Body`, `BuiltinAdapter.Body`, or
     * the legacy {@link Body} class) to reach native fields.
     * @type {PhysicsBody}
     * @example
     *  // define a new Player Class
     *  class PlayerEntity extends me.Sprite {
     *      // constructor
     *      constructor(x, y, settings) {
     *          // call the parent constructor
     *          super(x, y , settings);
     *
     *          // define a basic walking animation
     *          this.addAnimation("walk",  [...]);
     *          // define a standing animation (using the first frame)
     *          this.addAnimation("stand",  [...]);
     *          // set the standing animation as default
     *          this.setCurrentAnimation("stand");
     *
     *          // add a physic body
     *          this.body = new me.Body(this);
     *          // add a default collision shape
     *          this.body.addShape(new me.Rect(0, 0, this.width, this.height));
     *          // configure max speed, friction, and initial force to be applied
     *          this.body.setMaxVelocity(3, 15);
     *          this.body.setFriction(0.4, 0);
     *          this.body.force.set(3, 0);
     *          this.isKinematic = false;
     *
     *          // set the display to follow our position on both axis
     *          app.viewport.follow(this, app.viewport.AXIS.BOTH);
     *      }
     *
     *      ...
     *
     * }
     */
    body: PhysicsBody;
    /**
     * Declarative body definition consumed by the active
     * {@link PhysicsAdapter} when this renderable is added to a
     * container. **Adapter API only** — leave `undefined` if you
     * build a body imperatively via `this.body = new Body(...)`.
     *
     * When set, the parent container forwards it to
     * `world.adapter.addBody(this, this.bodyDef)`, which constructs
     * the underlying physics body (matter, builtin SAT, …) and
     * assigns the engine-portable wrapper to `this.body`. This is
     * the engine-portable path: the same `bodyDef` produces an
     * equivalent body under any adapter.
     *
     * Typical fields: `type` (`"static"`/`"dynamic"`/`"kinematic"`),
     * `shapes`, `collisionType`, `collisionMask`, `restitution`,
     * `frictionAir`, `density`, `gravityScale`, `isSensor`,
     * `maxVelocity`, `fixedRotation`. See {@link BodyDefinition}.
     * @type {object|undefined}
     * @default undefined
     */
    bodyDef: object | undefined;
    /**
     * (G)ame (U)nique (Id)entifier" <br>
     * a GUID will be allocated for any renderable object added <br>
     * to an object container (including the `app.world` container)
     * @type {string}
     */
    GUID: string;
    /**
     * an event handler that is called when the renderable leave or enter a camera viewport
     * @type {Function}
     * @default undefined
     * @example
     * this.onVisibilityChange = function(inViewport) {
     *     if (inViewport === true) {
     *         console.log("object has entered the in a camera viewport!");
     *     }
     * };
     */
    onVisibilityChange: Function;
    /**
     * Whether the renderable object will always update, even when outside of the viewport<br>
     * @type {boolean}
     * @default false
     */
    alwaysUpdate: boolean;
    /**
     * Whether to update this object when the game is paused.
     * @type {boolean}
     * @default false
     */
    updateWhenPaused: boolean;
    /**
     * make the renderable object persistent over level changes<br>
     * @type {boolean}
     * @default false
     */
    isPersistent: boolean;
    /**
     * If true, this renderable will be rendered using screen coordinates,
     * as opposed to world coordinates. Use this, for example, to define UI elements.
     * @type {boolean}
     * @default false
     */
    floating: boolean;
    /**
     * If true, this floating renderable will be rendered by all cameras
     * (e.g. background image layers). If false (default), floating elements
     * are only rendered by the default camera (e.g. UI/HUD elements).
     * Only applies to floating renderables in multi-camera setups.
     * @type {boolean}
     * @default false
     */
    visibleInAllCameras: boolean;
    /**
     * When enabled, an object container will automatically apply
     * any defined transformation before calling the child draw method.
     * @type {boolean}
     * @default true
     * @example
     * // enable "automatic" transformation when the object is activated
     * onActivateEvent: function () {
     *     // reset the transformation matrix
     *     this.currentTransform.identity();
     *     // ensure the anchor point is the renderable center
     *     this.anchorPoint.set(0.5, 0.5);
     *     // enable auto transform
     *     this.autoTransform = true;
     *     ....
     * }
     */
    autoTransform: boolean;
    /**
     * Whether {@link Renderable#preDraw} applies the
     * {@link Renderable#anchorPoint} offset to the renderer transform.
     *
     * When `true` (the default), the renderable is shifted by
     * `-anchorPoint × (width, height)` so its anchor — not its top-left
     * corner — aligns with its position. Correct for sprites and other 2D
     * renderables.
     *
     * Set to `false` for a renderable that emits its own final world
     * coordinates and takes its origin from geometry rather than a bounds
     * box — e.g. a {@link Mesh} on the `Camera3d` world-space path (a 3D
     * mesh is positioned by its transform and has no anchor). The WebGL mesh
     * batcher reuses this same renderer transform as its **view matrix**,
     * so applying the normalized anchor there would shift every mesh by
     * half its OWN bounds box; because scene meshes size that box per node,
     * props and the platforms they rest on would drift apart and overlap.
     * @type {boolean}
     * @default true
     * @see Mesh#preDraw
     */
    applyAnchorTransform: boolean;
    /**
     * Define the renderable opacity<br>
     * Set to zero if you do not wish an object to be drawn
     *
     * Opacity **cascades**: it is multiplied with the alpha already on the
     * renderer, so fading a {@link Container} fades everything inside it,
     * and a child at `alpha` 0.5 inside a parent at 0.5 draws at 0.25.
     * Each renderable keeps its own value — the composition happens at
     * draw time, and is undone when the renderable is done.
     *
     * That is different from {@link Container#setChildsProperty}, which
     * assigns a value onto the children themselves. Use `alpha` to fade a
     * subtree, and `setChildsProperty` to change what the children are.
     * @see Renderable#setOpacity
     * @see Renderable#getOpacity
     * @see Container#setChildsProperty
     * @type {number}
     * @default 1.0
     * @example
     * // fades the whole rig, parts included
     * myModel.alpha = 0.3;
     */
    alpha: number;
    /**
     * a reference to the parent object that contains this renderable
     * @type {Container|Entity}
     * @default undefined
     */
    ancestor: Container | Entity;
    /**
     * A mask limits rendering elements to the shape and position of the given mask object.
     * So, if the renderable is larger than the mask, only the intersecting part of the renderable will be visible.
     * @type {Rect|RoundRect|Polygon|Line|Ellipse}
     * @default undefined
     * @example
     * // apply a mask in the shape of a Star
     * myNPCSprite.mask = new me.Polygon(myNPCSprite.width / 2, 0, [
     *    // draw a star
     *    {x: 0, y: 0},
     *    {x: 14, y: 30},
     *    {x: 47, y: 35},
     *    {x: 23, y: 57},
     *    {x: 44, y: 90},
     *    {x: 0, y: 62},
     *    {x: -44, y: 90},
     *    {x: -23, y: 57},
     *    {x: -47, y: 35},
     *    {x: -14, y: 30}
     * ]);
     */
    mask: Rect | RoundRect | Polygon | Line | Ellipse;
    /**
     * the list of post-processing shader effects applied to this renderable
     * (GPU backends — WebGL and WebGPU). Effects are applied in order. Use
     * {@link addPostEffect}, {@link getPostEffect}, and
     * {@link removePostEffect} to manage effects, or assign directly.
     * On the Canvas renderer effects stay inert (the scene keeps rendering
     * un-effected).
     * @type {Array<GLShader|ShaderEffect>}
     * @default []
     * @example
     * // add effects via helper methods
     * mySprite.addPostEffect(new DesaturateEffect(renderer));
     * mySprite.addPostEffect(new VignetteEffect(renderer));
     * @example
     * // assign directly
     * mySprite.postEffects = [new SepiaEffect(renderer), new VignetteEffect(renderer)];
     */
    postEffects: Array<GLShader | ShaderEffect>;
    /**
     * the blend mode to be applied to this renderable — any of the modes
     * listed on {@link CanvasRenderer#setBlendMode}, honoured identically by
     * every renderer
     * @type {string}
     * @default "normal"
     * @see CanvasRenderer#setBlendMode
     * @see WebGLRenderer#setBlendMode
     */
    blendMode: string;
    /**
     * The name of the renderable
     * @type {string}
     * @default ""
     */
    name: string;
    /**
     * If true then physic collision and input events will not impact this renderable
     * @type {boolean}
     * @default true
     */
    isKinematic: boolean;
    /**
     * 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
     */
    get parentApp(): Application;
    /**
     * Whether the renderable object is floating (i.e. used screen coordinates), or contained in a floating parent container
     * @see Renderable#floating
     * @type {boolean}
     */
    get isFloating(): boolean;
    set tint(value: Color);
    /**
     * define a tint for this renderable. a (255, 255, 255) r, g, b value will remove the tint effect.
     * @type {Color}
     * @default (255, 255, 255)
     * @example
     * // add a red tint to this renderable
     * this.tint.setColor(255, 128, 128);
     * // remove the tint
     * this.tint.setColor(255, 255, 255);
     */
    get tint(): Color;
    set depth(value: number);
    /**
     * the depth of this renderable on the z axis
     * @type {number}
     */
    get depth(): number;
    set inViewport(value: boolean);
    /**
     * Whether the renderable object is visible and within the viewport
     * @type {boolean}
     * @default false
     */
    get inViewport(): boolean;
    set shader(value: GLShader | ShaderEffect | undefined);
    /**
     * @deprecated since 19.2.0 — use {@link addPostEffect} / {@link getPostEffect} / {@link removePostEffect} instead
     * @type {GLShader|ShaderEffect|undefined}
     */
    get shader(): GLShader | ShaderEffect | undefined;
    /**
     * Add a post-processing shader effect to this renderable.
     * @param {GLShader|ShaderEffect} effect - the effect to add
     * @returns {GLShader|ShaderEffect} the added effect
     * @example
     * mySprite.addPostEffect(new DesaturateEffect(renderer));
     */
    addPostEffect(effect: GLShader | ShaderEffect): GLShader | ShaderEffect;
    /**
     * Get post-processing shader effects.
     * When called with a class, returns the first effect matching the given class.
     * When called without arguments, returns the full effects array.
     * @param {Function} [effectClass] - the effect class to search for
     * @returns {GLShader|ShaderEffect|Array|undefined} the matching effect, the effects array, or undefined
     * @example
     * const desat = sprite.getPostEffect(DesaturateEffect);
     * const allEffects = sprite.getPostEffect();
     */
    getPostEffect(effectClass?: Function): GLShader | ShaderEffect | any[] | undefined;
    /**
     * Remove all post-processing shader effects.
     * @example
     * sprite.clearPostEffects();
     */
    clearPostEffects(): void;
    /**
     * Remove a specific post-processing shader effect.
     * @param {GLShader|ShaderEffect} effect - the effect to remove
     * @example
     * sprite.removePostEffect(effect);
     */
    removePostEffect(effect: GLShader | ShaderEffect): void;
    /**
     * returns true if this renderable is flipped on the horizontal axis
     * @public
     * @see Renderable#flipX
     * @type {boolean}
     */
    public get isFlippedX(): boolean;
    /**
     * returns true if this renderable is flipped on the vertical axis
     * @public
     * @see Renderable#flipY
     * @type {boolean}
     */
    public get isFlippedY(): boolean;
    /**
     * returns the bounding box for this renderable
     * @returns {Bounds} bounding box Rectangle object
     */
    getBounds(): Bounds;
    /**
     * get the renderable alpha channel value<br>
     *
     * This is the renderable's OWN value. What it finally draws at is this
     * multiplied by every ancestor's — see {@link Renderable#alpha}.
     * @returns {number} current opacity value between 0 and 1
     */
    getOpacity(): number;
    /**
     * set the renderable alpha channel value<br>
     * @param {number} alpha - opacity value between 0.0 and 1.0
     */
    setOpacity(alpha: number): void;
    /**
     * flip the renderable on the horizontal axis (around the center of the renderable)
     * @see Matrix3d#scaleX
     * @param {boolean} [flip=true] - `true` to flip this renderable.
     * @returns {Renderable} Reference to this object for method chaining
     */
    flipX(flip?: boolean): Renderable;
    /**
     * flip the renderable on the vertical axis (around the center of the renderable)
     * @see Matrix3d#scaleY
     * @param {boolean} [flip=true] - `true` to flip this renderable.
     * @returns {Renderable} Reference to this object for method chaining
     */
    flipY(flip?: boolean): Renderable;
    /**
     * multiply the renderable currentTransform with the given matrix
     * @see Renderable#currentTransform
     * @param {Matrix2d|Matrix3d} m - the transformation matrix
     * @returns {Renderable} Reference to this object for method chaining
     */
    transform(m: Matrix2d | Matrix3d): Renderable;
    /**
     * return the angle to the specified target
     * @param {Renderable|Vector2d|Vector3d} target
     * @returns {number} angle in radians
     */
    angleTo(target: Renderable | Vector2d | Vector3d): number;
    /**
     * return the distance to the specified target
     * @param {Renderable|Vector2d|Vector3d} target
     * @returns {number} distance
     */
    distanceTo(target: Renderable | Vector2d | Vector3d): number;
    /**
     * Rotate this renderable towards the given target.
     * @param {Renderable|Vector2d|Vector3d} target - the renderable or position to look at
     * @returns {Renderable} Reference to this object for method chaining
     */
    lookAt(target: Renderable | Vector2d | Vector3d): Renderable;
    /**
     * Rotate this renderable by the specified angle (in radians).
     * When called with just an angle, rotates around the Z axis (2D rotation).
     * When called with an angle and a Vector3d axis, rotates around that axis in 3D.
     * @param {number} angle - The angle to rotate (in radians)
     * @param {Vector3d} [v] - the axis to rotate around (defaults to Z axis for 2D)
     * @returns {Renderable} Reference to this object for method chaining
     */
    rotate(angle: number, v?: Vector3d): Renderable;
    /**
     * scale the renderable around his anchor point.  Scaling actually applies changes
     * to the currentTransform member which is used by the renderer to scale the object
     * when rendering.  It does not scale the object itself.  For example if the renderable
     * is an image, the image.width and image.height properties are unaltered but the currentTransform
     * member will be changed.
     * @param {number} x - a number representing the abscissa of the scaling vector.
     * @param {number} [y=x] - a number representing the ordinate of the scaling vector.
     * @param {number} [z=1] - a number representing the depth of the scaling vector.
     * @returns {Renderable} Reference to this object for method chaining
     */
    scale(x: number, y?: number, z?: number): Renderable;
    /**
     * scale the renderable around his anchor point
     * @param {Vector2d} v - scaling vector
     * @returns {Renderable} Reference to this object for method chaining
     */
    scaleV(v: Vector2d): Renderable;
    /**
     * Translate the renderable by the specified offset.
     * @param {number} x - x offset
     * @param {number} [y=0] - y offset
     * @param {number} [z=0] - z offset
     * @returns {Renderable} Reference to this object for method chaining
     */
    translate(x: number, y?: number, z?: number): Renderable;
    /**
     * update function (automatically called by melonJS).
     * @param {number} dt - time since the last update in milliseconds.
     * @returns {boolean} true if the renderable is dirty
     */
    update(dt: number): boolean;
    /**
     * update the bounding box for this shape.
     * @param {boolean} [absolute=true] - update the bounds size and position in (world) absolute coordinates
     * @returns {Bounds} this shape bounding box Rectangle object
     */
    updateBounds(absolute?: boolean): Bounds;
    /**
     * Where this renderable IS in the game world — its own `pos` plus every
     * ancestor's, as a {@link Vector3d} so the z component is summed across
     * the chain too (important for {@link Camera3d}'s frustum culling, which
     * previously read `obj.depth` — local `pos.z` — and mis-culled children
     * nested under a container with its own non-zero depth).
     *
     * **Reach for this** for anything positional: culling, distance checks,
     * hit tests, placing one renderable relative to another. It is cheap, and
     * it is what the engine's own culling uses.
     *
     * **Reach for {@link Renderable#getWorldTransform} instead** when a
     * position is not enough — when rotation, scale or flip along the ancestor
     * chain matters, or when you need to map an arbitrary point rather than
     * just the origin. This method sums translations only, so under a rotated
     * or scaled ancestor it reports where the renderable's *pivot* is and
     * nothing about how its content is oriented.
     *
     * Note the two also frame the question differently. This one is "where am
     * I"; `getWorldTransform()` is "what space is my content drawn in". For a
     * {@link Container} those coincide, because a container offsets its
     * children by its own position. For a leaf they differ by exactly that
     * position, which a leaf applies inside its own `draw()`.
     *
     * The returned vector is pooled and reused — copy it if you need to hold
     * onto the value across another call.
     * @returns {Vector3d} this renderable's absolute position
     * @see Renderable#getWorldTransform
     */
    getAbsolutePosition(): Vector3d;
    /**
     * The transform this renderable interposes between its ancestor's frame
     * and the frame its own content is drawn in — a mirror of what
     * {@link Renderable#preDraw} applies to the renderer, as a matrix.
     *
     * **This is not {@link Renderable#currentTransform}.** A renderable's
     * placement is split across two members: `pos` holds where it is, and
     * `currentTransform` holds only what `rotate()` / `scale()` / `translate()`
     * accumulate — it never contains the position. `preDraw` composes the two
     * by conjugation, so a rotation pivots about the renderable's position
     * rather than the origin. On a renderable you never rotated,
     * `currentTransform` is therefore the *identity* and says nothing about
     * where its content lands, while this method returns the translation that
     * actually places it.
     *
     * {@link Container} extends this with the offset it applies to its
     * children, which a leaf renderable does not have: a leaf's own `draw()`
     * places itself from `pos`.
     * @protected
     * @param {Matrix3d} out - matrix to write into; nothing is stored on the
     * renderable itself, so callers own the lifetime
     * @returns {Matrix3d} `out`, for chaining
     * @see Renderable#getWorldTransform
     */
    protected getLocalTransform(out: Matrix3d): Matrix3d;
    /**
     * The space this renderable's content is drawn IN, as a matrix — the full
     * form of {@link Renderable#getAbsolutePosition}, which sums positions up
     * the ancestor chain and therefore cannot represent the rotation, scale or
     * flip accumulated along the way.
     *
     * **Reach for `getAbsolutePosition()` instead** for ordinary positional
     * work — culling, distance checks, hit tests. It is cheaper and it is what
     * the engine culls with. **Use this** when a position is not enough:
     *
     * - an ancestor is rotated or scaled, so a translation cannot describe the
     *   result
     * - you need to map an arbitrary point, not just the origin — a corner, a
     *   click position, one renderable's coordinates into another's space
     * - you need to compose or invert the transform (`inv(A) · B` converts
     *   between two frames, which is how `ParticleEmitter.referenceSpace`
     *   measures particles against a container that is not their parent)
     *
     * The two also frame the question differently, and it shows on a leaf.
     * `getAbsolutePosition()` is "where am I"; this is "what space is my
     * content drawn in". For a {@link Container} those coincide, because a
     * container offsets its children by its own position. For a leaf they
     * differ by exactly that position, which a leaf applies inside its own
     * `draw()`. So with no rotation, scale or flip anywhere, a container's
     * translation column equals its `getAbsolutePosition()` while a leaf's
     * equals its PARENT's.
     *
     * The walk stops at a `floating` ancestor, because a floating renderable
     * draws in screen space: {@link Container#draw} resets the transform
     * outright for those, so the chain genuinely ends there rather than
     * continuing to the root.
     *
     * The camera needs no special handling — {@link Camera2d} folds its view
     * transform into the root container's `currentTransform`, so it is picked
     * up like any other level.
     * @param {Matrix3d} out - matrix to write into; nothing is stored on the
     * renderable itself, so callers own the lifetime
     * @returns {Matrix3d} `out`, for chaining
     * @see Renderable#getAbsolutePosition
     * @example
     * // map a point from one renderable's space into another's
     * const from = a.getWorldTransform(new Matrix3d());
     * const into = b.getWorldTransform(new Matrix3d()).invert();
     * const point = new Vector2d(10, 20);       // in a's space
     * from.apply(point);                        // -> world
     * into.apply(point);                        // -> b's space
     * @example
     * // just need to know where something is? use the cheaper call
     * const where = renderable.getAbsolutePosition();
     */
    getWorldTransform(out: Matrix3d): Matrix3d;
    /**
     * Prepare the rendering context before drawing (automatically called by melonJS).
     * This will apply any defined transforms, anchor point, tint or blend mode and translate the context accordingly to this renderable position.
     * @see Renderable#draw
     * @see Renderable#postDraw
     * @param {CanvasRenderer|WebGLRenderer} renderer - a renderer object
     */
    preDraw(renderer: CanvasRenderer | WebGLRenderer): void;
    /**
     * Draw this renderable (automatically called by melonJS).
     * All draw operations for renderable are made respectively
     * 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: `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
     * @param {Camera2d} [viewport] - the viewport to (re)draw
     */
    draw(renderer: CanvasRenderer | WebGLRenderer, viewport?: Camera2d): void;
    /**
     * restore the rendering context after drawing (automatically called by melonJS).
     * @see Renderable#preDraw
     * @see Renderable#draw
     * @param {CanvasRenderer|WebGLRenderer} renderer - a renderer object
     */
    postDraw(renderer: CanvasRenderer | WebGLRenderer): void;
    /**
     * Legacy collision callback — fires every frame this renderable body is
     * overlapping another body. Kept for backward compatibility with code
     * written against pre-19.5 melonJS; semantics are unchanged from the
     * 19.4 contract.
     *
     * **NOTE — `onCollision` is NOT equivalent to {@link Renderable.onCollisionActive}.**
     * The two handlers exist side by side and have intentionally different
     * contracts:
     *
     * | | `onCollision` (legacy) | `onCollisionActive` (modern) |
     * |---|---|---|
     * | Cadence for dynamic-dynamic pairs | 2× per frame per side | 1× per frame per side |
     * | `response.a` semantics | Fixed per pair (first body in detector call) | Always the receiver (`response.a === this`) |
     * | `response.b` semantics | Fixed per pair | Always the partner (`response.b === other`) |
     * | `response.normal` / `response.depth` | ✗ | ✓ — `normal.y < -0.7` = "push me up" |
     * | `return false` to skip push-out | ✓ (honored by SAT) | ✗ — use `bodyDef.isSensor` or `setSensor` instead |
     *
     * If you're writing new code, prefer `onCollisionActive`. Keep
     * `onCollision` only when its every-frame, return-false, fixed-`a`/`b`
     * semantics are what you want.
     *
     * @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
     * // legacy collision handler — note the receiver-side check on response.a
     * onCollision(response) {
     *     if (response.b.body.collisionType === me.collision.types.ENEMY_OBJECT) {
     *         this.pos.sub(response.overlapV);
     *         this.hurt();
     *         return false;   // skip the SAT push-out
     *     }
     *     return true;
     * }
     */
    onCollision(response: import("../physics/response.js").default, other: Renderable): boolean;
    /**
     * OnDestroy Notification function<br>
     * 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;
    /**
     * Lifecycle hook fired by {@link Container} when this renderable is
     * added to a container that is part of the active scene graph.
     * 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 - the rest parameter exists for subclass-signature
     * compatibility; `Container.addChild` currently forwards nothing
     */
    onActivateEvent(..._args: any[]): void;
    /**
     * Lifecycle hook fired by {@link Container} when this renderable is
     * 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 - the rest parameter exists for subclass-signature
     * compatibility; `Container.removeChildNow` currently forwards nothing
     */
    onDeactivateEvent(..._args: any[]): void;
}
import { Rect } from "./../geometries/rectangle.ts";
import { ObservablePoint } from "../geometries/observablePoint.ts";
import { Matrix3d } from "../math/matrix3d.ts";
import type Container from "./container.js";
import type Entity from "./entity/entity.js";
import type { RoundRect } from "./../geometries/roundrect.ts";
import type { Polygon } from "../geometries/polygon.ts";
import type { Line } from "./../geometries/line.ts";
import type { Ellipse } from "./../geometries/ellipse.ts";
import type Application from "./../application/application.ts";
import type CanvasRenderer from "./../video/canvas/canvas_renderer.js";
import type WebGLRenderer from "./../video/webgl/webgl_renderer.js";
//# sourceMappingURL=renderable.d.ts.map