dacha 0.18.0-alpha.8 → 0.18.0

package/build/contrib/systems/character-controller/one-way-validator.js

@@ -0,0 +1,73 @@
+import { RigidBody, Transform } from '../../components';
+import { VectorOps } from '../../../engine/math-lib';
+export class OneWayValidator {
+    ignoredOneWayContacts;
+    touchedActors;
+    oneWayContactUpdateIndex;
+    constructor() {
+        this.ignoredOneWayContacts = new Map();
+        this.touchedActors = new Set();
+        this.oneWayContactUpdateIndex = 0;
+    }
+    clearOneWayContacts() {
+        this.touchedActors.forEach((actor) => {
+            const ignoredContacts = this.ignoredOneWayContacts.get(actor);
+            if (!ignoredContacts) {
+                return;
+            }
+            ignoredContacts.forEach((lastSeenUpdate, otherActor) => {
+                if (lastSeenUpdate !== this.oneWayContactUpdateIndex) {
+                    ignoredContacts.delete(otherActor);
+                }
+            });
+            if (ignoredContacts.size === 0) {
+                this.ignoredOneWayContacts.delete(actor);
+            }
+        });
+        if (this.ignoredOneWayContacts.size === 0) {
+            this.oneWayContactUpdateIndex = 0;
+        }
+    }
+    trackOneWayContact(actor, oneWayActor) {
+        let ignoredContacts = this.ignoredOneWayContacts.get(actor);
+        if (!ignoredContacts) {
+            ignoredContacts = new Map();
+            this.ignoredOneWayContacts.set(actor, ignoredContacts);
+        }
+        ignoredContacts.set(oneWayActor, this.oneWayContactUpdateIndex);
+    }
+    touch(actor) {
+        this.touchedActors.add(actor);
+    }
+    shouldBlock(oneWayActor, otherActor, normal) {
+        if (this.ignoredOneWayContacts.get(otherActor)?.has(oneWayActor)) {
+            this.trackOneWayContact(otherActor, oneWayActor);
+            return false;
+        }
+        const rigidBody = oneWayActor.getComponent(RigidBody);
+        const transform = oneWayActor.getComponent(Transform);
+        const oneWayNormal = VectorOps.rotatePoint(rigidBody.oneWayNormal, transform.world.rotation);
+        if (VectorOps.dotProduct(oneWayNormal, normal) > 0) {
+            return true;
+        }
+        this.trackOneWayContact(otherActor, oneWayActor);
+        return false;
+    }
+    delete(actor) {
+        this.ignoredOneWayContacts.delete(actor);
+        this.touchedActors.delete(actor);
+        this.ignoredOneWayContacts.forEach((ignoredContacts, trackedActor) => {
+            ignoredContacts.delete(actor);
+            if (ignoredContacts.size === 0) {
+                this.ignoredOneWayContacts.delete(trackedActor);
+            }
+        });
+    }
+    update() {
+        this.oneWayContactUpdateIndex += 1;
+    }
+    lateUpdate() {
+        this.clearOneWayContacts();
+        this.touchedActors.clear();
+    }
+}

package/build/contrib/systems/game-stats-meter/index.d.ts

@@ -1,5 +1,5 @@
 import { WorldSystem } from '../../../engine/system';
-import type { WorldSystemOptions, UpdateOptions } from '../../../engine/system';
+import type { WorldSystemOptions } from '../../../engine/system';
 import type { Scene } from '../../../engine/scene';
 /**
  * Game statistics meter that tracks and reports performance metrics
@@ -13,12 +13,13 @@ import type { Scene } from '../../../engine/scene';
  */
 export declare class GameStatsMeter extends WorldSystem {
     private world;
+    private time;
     private actorQuery?;
     private frequency;
     private fps;
-    private time;
+    private elapsed;
     constructor(options: WorldSystemOptions);
     onSceneEnter(scene: Scene): void;
     onSceneExit(): void;
-    update(options: UpdateOptions): void;
+    update(): void;
 }

package/build/contrib/systems/game-stats-meter/index.js

@@ -1,7 +1,7 @@
 import { WorldSystem } from '../../../engine/system';
 import { GameStatsUpdate } from '../../events';
 import { ActorQuery } from '../../../engine/actor';
-const MS_IN_SEC = 1000;
+const DEFAULT_FREQUENCY = 1;
 /**
  * Game statistics meter that tracks and reports performance metrics
  *
@@ -14,17 +14,19 @@ const MS_IN_SEC = 1000;
  */
 export class GameStatsMeter extends WorldSystem {
     world;
+    time;
     actorQuery;
     frequency;
     fps;
-    time;
+    elapsed;
     constructor(options) {
         super();
         const { world, frequency } = options;
         this.world = world;
-        this.frequency = frequency || MS_IN_SEC;
+        this.time = options.time;
+        this.frequency = frequency || DEFAULT_FREQUENCY;
         this.fps = 0;
-        this.time = 0;
+        this.elapsed = 0;
     }
     onSceneEnter(scene) {
         this.actorQuery = new ActorQuery({ scene, filter: [] });
@@ -32,17 +34,16 @@ export class GameStatsMeter extends WorldSystem {
     onSceneExit() {
         this.actorQuery = undefined;
     }
-    update(options) {
-        const { deltaTime } = options;
+    update() {
         this.fps += 1;
-        this.time += deltaTime;
-        if (this.time >= this.frequency) {
+        this.elapsed += this.time.deltaTime;
+        if (this.elapsed >= this.frequency) {
             this.world.dispatchEvent(GameStatsUpdate, {
-                fps: (this.fps * MS_IN_SEC) / this.time,
+                fps: this.fps / this.elapsed,
                 actorsCount: this.actorQuery?.getActors().size ?? 0,
             });
             this.fps = 0;
-            this.time = 0;
+            this.elapsed = 0;
         }
     }
 }

package/build/contrib/systems/index.d.ts

@@ -4,6 +4,8 @@ export { GameStatsMeter } from './game-stats-meter';
 export { KeyboardInputSystem } from './keyboard-input-system';
 export { KeyboardControlSystem } from './keyboard-control-system';
 export { CharacterController } from './character-controller';
+export { Interpolator, InterpolatorAPI } from './interpolator';
+export type { RenderTransform } from './interpolator';
 export { MouseControlSystem } from './mouse-control-system';
 export { MouseInputSystem } from './mouse-input-system';
 export { PhysicsSystem, PhysicsAPI } from './physics-system';

package/build/contrib/systems/index.js

@@ -4,6 +4,7 @@ export { GameStatsMeter } from './game-stats-meter';
 export { KeyboardInputSystem } from './keyboard-input-system';
 export { KeyboardControlSystem } from './keyboard-control-system';
 export { CharacterController } from './character-controller';
+export { Interpolator, InterpolatorAPI } from './interpolator';
 export { MouseControlSystem } from './mouse-control-system';
 export { MouseInputSystem } from './mouse-input-system';
 export { PhysicsSystem, PhysicsAPI } from './physics-system';

package/build/contrib/systems/interpolator/api.d.ts

@@ -0,0 +1,40 @@
+import type { Actor } from '../../../engine/actor';
+import type { Time } from '../../../engine/time';
+export interface RenderTransform {
+    x: number;
+    y: number;
+    rotation: number;
+}
+interface InterpolatorAPIOptions {
+    time: Time;
+}
+/**
+ * Public API for reading render-facing (visually smoothed) transforms.
+ *
+ * Retrieve it via `world.systemApi.get(InterpolatorAPI)`. Use it in
+ * systems and behaviors that position visuals against moving actors —
+ * e.g. a camera-follow script — instead of reading the authoritative
+ * Transform, which advances in fixed steps.
+ *
+ * Values are computed from the current `Time.alpha`, so this API is only
+ * meaningful during the update phase (not inside `fixedUpdate`).
+ *
+ * @category Systems
+ */
+export declare class InterpolatorAPI {
+    private time;
+    constructor(options: InterpolatorAPIOptions);
+    /**
+     * Returns the world-space transform the actor is rendered with this
+     * frame. Falls back to the Transform for actors (and
+     * ancestors) without an active Interpolation component.
+     */
+    getRenderTransform(actor: Actor): RenderTransform;
+    /**
+     * Requests an immediate visual jump to the actor's
+     * Transform. Call right after teleporting the actor.
+     */
+    snap(actor: Actor): void;
+    private composeRenderWorldMatrix;
+}
+export {};

package/build/contrib/systems/interpolator/api.js

@@ -0,0 +1,70 @@
+import { Matrix } from '../../../engine/math-lib';
+import { Interpolation } from '../../components/interpolation';
+import { Transform } from '../../components/transform';
+import { computeRenderValues } from './utils';
+/**
+ * Public API for reading render-facing (visually smoothed) transforms.
+ *
+ * Retrieve it via `world.systemApi.get(InterpolatorAPI)`. Use it in
+ * systems and behaviors that position visuals against moving actors —
+ * e.g. a camera-follow script — instead of reading the authoritative
+ * Transform, which advances in fixed steps.
+ *
+ * Values are computed from the current `Time.alpha`, so this API is only
+ * meaningful during the update phase (not inside `fixedUpdate`).
+ *
+ * @category Systems
+ */
+export class InterpolatorAPI {
+    time;
+    constructor(options) {
+        this.time = options.time;
+    }
+    /**
+     * Returns the world-space transform the actor is rendered with this
+     * frame. Falls back to the Transform for actors (and
+     * ancestors) without an active Interpolation component.
+     */
+    getRenderTransform(actor) {
+        const matrix = this.composeRenderWorldMatrix(actor);
+        return {
+            x: matrix.tx,
+            y: matrix.ty,
+            rotation: Math.atan2(matrix.b, matrix.a),
+        };
+    }
+    /**
+     * Requests an immediate visual jump to the actor's
+     * Transform. Call right after teleporting the actor.
+     */
+    snap(actor) {
+        const interpolation = actor.getComponent(Interpolation);
+        interpolation?.snap();
+    }
+    composeRenderWorldMatrix(actor) {
+        const transform = actor.getComponent(Transform);
+        const interpolation = actor.getComponent(Interpolation);
+        const useRender = interpolation !== undefined &&
+            !interpolation.disabled &&
+            interpolation.initialized;
+        if (useRender) {
+            computeRenderValues(actor, interpolation, this.time.alpha, this.time.fixedDeltaTime);
+        }
+        const x = useRender ? interpolation.renderX : transform.local.position.x;
+        const y = useRender ? interpolation.renderY : transform.local.position.y;
+        const rotation = useRender
+            ? interpolation.renderRotation
+            : transform.local.rotation;
+        const { scale } = transform.local;
+        const cos = Math.cos(rotation);
+        const sin = Math.sin(rotation);
+        const localMatrix = new Matrix(cos * scale.x, sin * scale.x, -sin * scale.y, cos * scale.y, x, y);
+        const parentTransform = transform.getParentComponent();
+        if (!parentTransform?.actor) {
+            return localMatrix;
+        }
+        const result = new Matrix(1, 0, 0, 1, 0, 0);
+        Matrix.multiply(result, this.composeRenderWorldMatrix(parentTransform.actor), localMatrix);
+        return result;
+    }
+}

package/build/contrib/systems/interpolator/index.d.ts

@@ -0,0 +1,3 @@
+export { Interpolator } from './system';
+export { InterpolatorAPI } from './api';
+export type { RenderTransform } from './api';

package/build/contrib/systems/interpolator/index.js

@@ -0,0 +1,2 @@
+export { Interpolator } from './system';
+export { InterpolatorAPI } from './api';

package/build/contrib/systems/interpolator/system.d.ts

@@ -0,0 +1,31 @@
+import { SceneSystem } from '../../../engine/system';
+import type { SceneSystemOptions } from '../../../engine/system';
+/**
+ * System that produces smooth render-facing transforms for actors moved
+ * during fixed updates.
+ *
+ * During `fixedUpdate` it snapshots the local Transform of every actor with
+ * an Interpolation component. During `update` it blends the last two
+ * snapshots using `Time.alpha` and writes the result into the component's
+ * `renderX`/`renderY`/`renderRotation`, which the renderer prefers over the
+ * Transform.
+ *
+ * Ordering: place this system AFTER every system that moves transforms in
+ * fixed updates (`PhysicsSystem`, `CharacterController`, behavior scripts
+ * that move actors in `fixedUpdate`) and BEFORE `Renderer` in the system
+ * configuration.
+ *
+ * @category Systems
+ */
+export declare class Interpolator extends SceneSystem {
+    private actorQuery;
+    private time;
+    private world;
+    private api;
+    constructor(options: SceneSystemOptions);
+    onSceneEnter(): void;
+    onSceneExit(): void;
+    onSceneDestroy(): void;
+    fixedUpdate(): void;
+    update(): void;
+}

package/build/contrib/systems/interpolator/system.js

@@ -0,0 +1,96 @@
+import { ActorQuery } from '../../../engine/actor';
+import { SceneSystem } from '../../../engine/system';
+import { Interpolation } from '../../components/interpolation';
+import { Transform } from '../../components/transform';
+import { InterpolatorAPI } from './api';
+import { snapToTransform, computeRenderValues } from './utils';
+/**
+ * System that produces smooth render-facing transforms for actors moved
+ * during fixed updates.
+ *
+ * During `fixedUpdate` it snapshots the local Transform of every actor with
+ * an Interpolation component. During `update` it blends the last two
+ * snapshots using `Time.alpha` and writes the result into the component's
+ * `renderX`/`renderY`/`renderRotation`, which the renderer prefers over the
+ * Transform.
+ *
+ * Ordering: place this system AFTER every system that moves transforms in
+ * fixed updates (`PhysicsSystem`, `CharacterController`, behavior scripts
+ * that move actors in `fixedUpdate`) and BEFORE `Renderer` in the system
+ * configuration.
+ *
+ * @category Systems
+ */
+export class Interpolator extends SceneSystem {
+    actorQuery;
+    time;
+    world;
+    api;
+    constructor(options) {
+        super();
+        this.time = options.time;
+        this.world = options.world;
+        this.actorQuery = new ActorQuery({
+            scene: options.scene,
+            filter: [Interpolation, Transform],
+        });
+        this.api = new InterpolatorAPI({ time: options.time });
+    }
+    onSceneEnter() {
+        this.world.systemApi.register(this.api);
+    }
+    onSceneExit() {
+        this.world.systemApi.unregister(InterpolatorAPI);
+    }
+    onSceneDestroy() {
+        this.actorQuery.destroy();
+    }
+    fixedUpdate() {
+        for (const actor of this.actorQuery.getActors()) {
+            const interpolation = actor.getComponent(Interpolation);
+            const { local } = actor.getComponent(Transform);
+            if (interpolation.disabled) {
+                interpolation._initialized = false;
+                continue;
+            }
+            if (!interpolation._initialized || interpolation._snapRequested) {
+                snapToTransform(interpolation, local);
+                continue;
+            }
+            interpolation._prevX = interpolation._currX;
+            interpolation._prevY = interpolation._currY;
+            interpolation._prevRotation = interpolation._currRotation;
+            interpolation._currX = local.position.x;
+            interpolation._currY = local.position.y;
+            interpolation._currRotation = local.rotation;
+            const threshold = interpolation.snapThreshold;
+            if (threshold > 0) {
+                const dx = interpolation._currX - interpolation._prevX;
+                const dy = interpolation._currY - interpolation._prevY;
+                if (dx * dx + dy * dy > threshold * threshold) {
+                    interpolation._prevX = interpolation._currX;
+                    interpolation._prevY = interpolation._currY;
+                    interpolation._prevRotation = interpolation._currRotation;
+                }
+            }
+        }
+    }
+    update() {
+        const { alpha, fixedDeltaTime } = this.time;
+        for (const actor of this.actorQuery.getActors()) {
+            const interpolation = actor.getComponent(Interpolation);
+            if (interpolation.disabled) {
+                continue;
+            }
+            if (interpolation._snapRequested) {
+                snapToTransform(interpolation, actor.getComponent(Transform).local);
+                continue;
+            }
+            if (!interpolation._initialized) {
+                continue;
+            }
+            computeRenderValues(actor, interpolation, alpha, fixedDeltaTime);
+        }
+    }
+}
+Interpolator.systemName = 'Interpolator';

package/build/contrib/systems/interpolator/tests/helpers.d.ts

@@ -0,0 +1,13 @@
+import { Actor } from '../../../../engine/actor';
+import { Scene } from '../../../../engine/scene';
+import { World } from '../../../../engine/world';
+import { Time } from '../../../../engine/time';
+import type { InterpolationConfig } from '../../../components/interpolation';
+import { Interpolator } from '../system';
+export declare const createScene: () => Scene;
+export declare const createInterpolator: (scene: Scene) => {
+    system: Interpolator;
+    world: World;
+    time: Time;
+};
+export declare const createInterpolatedActor: (id: string, x: number, y: number, config?: InterpolationConfig) => Actor;

package/build/contrib/systems/interpolator/tests/helpers.js

@@ -0,0 +1,45 @@
+import { Actor, ActorCreator, ActorSpawner } from '../../../../engine/actor';
+import { Scene } from '../../../../engine/scene';
+import { TemplateCollection } from '../../../../engine/template';
+import { World } from '../../../../engine/world';
+import { Time } from '../../../../engine/time';
+import { Interpolation } from '../../../components/interpolation';
+import { Transform } from '../../../components/transform';
+import { Interpolator } from '../system';
+export const createScene = () => {
+    const templateCollection = new TemplateCollection();
+    const actorCreator = new ActorCreator([], templateCollection);
+    return new Scene({
+        id: 'scene',
+        name: 'scene',
+        actors: [],
+        actorCreator,
+        templateCollection,
+    });
+};
+export const createInterpolator = (scene) => {
+    const world = new World({ id: 'world', name: 'world' });
+    const templateCollection = new TemplateCollection();
+    const actorCreator = new ActorCreator([], templateCollection);
+    const time = new Time();
+    time.fixedDeltaTime = 0.1;
+    world.appendChild(scene);
+    const system = new Interpolator({
+        scene,
+        world,
+        actorSpawner: new ActorSpawner(actorCreator),
+        globalOptions: {},
+        templateCollection,
+        time,
+    });
+    system.onSceneEnter?.();
+    return { system, world, time };
+};
+export const createInterpolatedActor = (id, x, y, config = {}) => {
+    const actor = new Actor({ id, name: id });
+    const transform = actor.getComponent(Transform);
+    transform.local.position.x = x;
+    transform.local.position.y = y;
+    actor.setComponent(new Interpolation(config));
+    return actor;
+};

package/build/contrib/systems/interpolator/utils.d.ts

@@ -0,0 +1,5 @@
+import type { Actor } from '../../../engine/actor';
+import type { Interpolation } from '../../components/interpolation';
+import type { LocalTransform } from '../../components/transform/local-transform';
+export declare const snapToTransform: (interpolation: Interpolation, local: LocalTransform) => void;
+export declare const computeRenderValues: (actor: Actor, interpolation: Interpolation, alpha: number, fixedDeltaTime: number) => void;

package/build/contrib/systems/interpolator/utils.js

@@ -0,0 +1,41 @@
+import { MathOps } from '../../../engine/math-lib';
+import { RigidBody } from '../../components/rigid-body';
+export const snapToTransform = (interpolation, local) => {
+    interpolation._prevX = local.position.x;
+    interpolation._prevY = local.position.y;
+    interpolation._prevRotation = local.rotation;
+    interpolation._currX = local.position.x;
+    interpolation._currY = local.position.y;
+    interpolation._currRotation = local.rotation;
+    interpolation.renderX = local.position.x;
+    interpolation.renderY = local.position.y;
+    interpolation.renderRotation = local.rotation;
+    interpolation._initialized = true;
+    interpolation._snapRequested = false;
+};
+export const computeRenderValues = (actor, interpolation, alpha, fixedDeltaTime) => {
+    if (interpolation.mode === 'extrapolate') {
+        const rigidBody = actor.getComponent(RigidBody);
+        if (rigidBody !== undefined && !rigidBody.disabled) {
+            const timeAhead = alpha * fixedDeltaTime;
+            interpolation.renderX =
+                interpolation._currX + rigidBody.linearVelocity.x * timeAhead;
+            interpolation.renderY =
+                interpolation._currY + rigidBody.linearVelocity.y * timeAhead;
+            interpolation.renderRotation = rigidBody.lockRotation
+                ? interpolation._currRotation
+                : interpolation._currRotation + rigidBody.angularVelocity * timeAhead;
+            return;
+        }
+    }
+    interpolation.renderX =
+        interpolation._prevX +
+            (interpolation._currX - interpolation._prevX) * alpha;
+    interpolation.renderY =
+        interpolation._prevY +
+            (interpolation._currY - interpolation._prevY) * alpha;
+    interpolation.renderRotation =
+        interpolation._prevRotation +
+            MathOps.getAngleDelta(interpolation._prevRotation, interpolation._currRotation) *
+                alpha;
+};

package/build/contrib/systems/physics-system/api.d.ts

@@ -1,5 +1,5 @@
 import type { Vector2 } from '../../../engine/math-lib';
-import type { CastHit, OverlapHit, RaycastParams, OverlapParams, OverlapActorParams, ShapeCastParams, CastActorParams } from './types';
+import type { CastHit, OverlapHit, RaycastParams, OverlapParams, OverlapActorParams, ShapeCastParams, CastActorParams, CastHitCallback, OverlapHitCallback } from './types';
 export interface PhysicsAPIHandlers {
     raycast(params: RaycastParams): CastHit | null;
     raycastAll(params: RaycastParams): CastHit[];
@@ -9,6 +9,11 @@ export interface PhysicsAPIHandlers {
     shapeCastAll(params: ShapeCastParams): CastHit[];
     castActor(params: CastActorParams): CastHit | null;
     castActorAll(params: CastActorParams): CastHit[];
+    raycastEach(params: RaycastParams, callback: CastHitCallback): void;
+    shapeCastEach(params: ShapeCastParams, callback: CastHitCallback): void;
+    overlapEach(params: OverlapParams, callback: OverlapHitCallback): void;
+    castActorEach(params: CastActorParams, callback: CastHitCallback): void;
+    overlapActorEach(params: OverlapActorParams, callback: OverlapHitCallback): void;
     getGravity(): Vector2;
     setGravity(gravity: Vector2): void;
 }
@@ -55,6 +60,13 @@ export declare class PhysicsAPI {
      * @returns All hits sorted from nearest to farthest
      */
     raycastAll(params: RaycastParams): CastHit[];
+    /**
+     * Casts a ray and invokes `callback` for every hit.
+     *
+     * @param params - Raycast parameters
+     * @param callback - Invoked once per hit with a reused hit object
+     */
+    raycastEach(params: RaycastParams, callback: CastHitCallback): void;
     /**
      * Returns all collider intersections for the given query shape.
      *
@@ -62,6 +74,13 @@ export declare class PhysicsAPI {
      * @returns All overlap hits
      */
     overlapShape(params: OverlapParams): OverlapHit[];
+    /**
+     * Invokes `callback` for every collider intersecting the query shape.
+     *
+     * @param params - Overlap parameters
+     * @param callback - Invoked once per overlap with a reused hit object
+     */
+    overlapEach(params: OverlapParams, callback: OverlapHitCallback): void;
     /**
      * Returns all collider intersections for an actor's collider.
      *
@@ -69,6 +88,13 @@ export declare class PhysicsAPI {
      * @returns All overlap hits
      */
     overlapActor(params: OverlapActorParams): OverlapHit[];
+    /**
+     * Invokes `callback` for every collider intersecting an actor's collider.
+     *
+     * @param params - Actor overlap parameters
+     * @param callback - Invoked once per overlap with a reused hit object
+     */
+    overlapActorEach(params: OverlapActorParams, callback: OverlapHitCallback): void;
     /**
      * Casts a shape and returns the nearest hit, if any.
      *
@@ -83,6 +109,13 @@ export declare class PhysicsAPI {
      * @returns All hits sorted from nearest to farthest
      */
     shapeCastAll(params: ShapeCastParams): CastHit[];
+    /**
+     * Casts a shape and invokes `callback` for every hit.
+     *
+     * @param params - Shape cast parameters
+     * @param callback - Invoked once per hit with a reused hit object
+     */
+    shapeCastEach(params: ShapeCastParams, callback: CastHitCallback): void;
     /**
      * Casts an actor's collider and returns the nearest hit, if any.
      *
@@ -97,4 +130,15 @@ export declare class PhysicsAPI {
      * @returns All hits sorted from nearest to farthest
      */
     castActorAll(params: CastActorParams): CastHit[];
+    /**
+     * Casts an actor's collider and invokes `callback` for every hit.
+     *
+     * The `hit` passed to `callback` is a single object reused across
+     * invocations and is only valid for the duration of the call. Copy any
+     * fields you need to keep. Hits are delivered in arbitrary order.
+     *
+     * @param params - Actor cast parameters
+     * @param callback - Invoked once per hit with a reused hit object
+     */
+    castActorEach(params: CastActorParams, callback: CastHitCallback): void;
 }