phaser-raycaster/types/types.d.ts

Raycasting plugin for Phaser 3.

/**
 * Point object
 */
declare type Point = {
    x: number;
    y: number;
};

/**
 * Raycaster plugin class.
 */
declare class PhaserRaycaster extends Phaser.Plugins.ScenePlugin {
    constructor(scene: Phaser.Scene, pluginManager: Phaser.Plugins.PluginManager);
    /**
     * Create Raycaster object.
     * @param [options] - Raycaster's congfiguration options. May include:
     * @param [options.mapSegmentCount = 0] - Number of segments of circle maps. If set to 0, map will be teste
     * @param [options.objects] - Game object or array of game objects to map.
     * @param [options.boundingBox] - Raycaster's bounding box. If not passed, {@link Raycaster Raycaster} will set it's bounding box based on Arcade Physics / Matter physics world bounds.
     * @param [options.autoUpdate = true] - If set true, automatically update dynamic maps on scene update event.
     * @param [options.debug] - Enable debug mode or configure it {@link Raycaster#debugOptions debugOptions}.
     * @returns {@link Raycaster Raycaster} instance
     */
    createRaycaster(options?: {
        mapSegmentCount?: number;
        objects?: any | object[];
        boundingBox?: Phaser.Geom.Rectangle;
        autoUpdate?: boolean;
        debug?: boolean | any;
    }): Raycaster;
}

declare namespace Raycaster {
    /**
     * Map class responsible for mapping game objects.
     * @param options - Map specific configuration settings.
     * @param [raycaster] - Parent raycaster object.
     */
    class Map {
        constructor(options: any, raycaster?: Raycaster);
        /**
         * Configure map.
         * @param [options] - Map's congfiguration options. May include:
         * @param options.object - Game object to map
         * @param [options.type] - Map type. If not defined, it will be determined based on object.
         * @param [options.dynamic = false] - If set true, map will be dynamic (updated on scene update event).
         * @param [options.active = true] - If set true, map will be active (will provide points, segments and will be updated).
         * @param [options.segmentCount] - Circle map's segment count. If set to 0, map won't be generating segments and relay only on tangent points calculated for currently testing ray.
         * @param [options.mapChild] - Container's child. If set, only set child will be mapped.
         * @param [options.forceConvex] - If set true, matter body map will use convex body (hull) for non-covex bodies.
         * @param [options.forceVerticesMapping] - If set true, matter body map will use only vertices for mapping circle bodies.
         * @returns {@link Raycaster.Map Raycaster.Map} instance
         */
        config(options?: {
            object: any;
            type?: string;
            dynamic?: boolean;
            active?: boolean;
            segmentCount?: number;
            mapChild?: any;
            forceConvex?: boolean;
            forceVerticesMapping?: boolean;
        }): Raycaster.Map;
        /**
         * Destroy object
         */
        destroy(): void;
        /**
         * Mapped object's type
         */
        readonly type: string;
        /**
         * If set true, map will be tested by ray. Otherwise it will be ignored.
         */
        active: boolean;
        /**
         * If set true, map will be treated by ray as circle. Set automaticalyy on map update.
         */
        circle: boolean;
        /**
         * Reference to mapped object.
         */
        readonly object: any;
        /**
         * Get array of mapped object's vertices used as rays targets.
         * @param [ray] - {@link Raycaster.Ray Raycaster.Ray} object used in some some types of maps.
         * @returns Array of mapped object's vertices.
         */
        getPoints(ray?: Raycaster.Ray): Phaser.Geom.Point[];
        /**
         * Get array of mapped object's segments used to test object's intersection with ray.
         * @param [ray] - {@link Raycaster.Ray Raycaster.Ray} object used in some some types of maps.
         * @returns Array of mapped object's segments.
         */
        getSegments(ray?: Raycaster.Ray): Phaser.Geom.Line[];
        /**
         * Get mapped object's bounding box.
         * @returns Mapped object's bounding box.
         */
        getBoundingBox(): Phaser.Geom.Rectangle;
        /**
         * Update object's map of points and segments.
         * @returns {@link Raycaster.Map Raycaster.Map} instance
         */
        updateMap(): Raycaster.Map;
        /**
         * Set tile types which should be mapped (for Phaser.Tilemaps.StaticTilemapLayer and Phaser.Tilemaps.DynamicTilemapLayer maps only).
         * @param [tiles = []] - Set of tile's indexes to map.
         * @returns {@link Raycaster.Map Raycaster.Map} instance
         */
        setCollisionTiles(tiles?: any[]): Raycaster.Map;
        /**
         * Set segment count for cirle's map.
         * If set to 0, map won't be generating segments and relay only on tangent points calculated for currently testing ray.
         * @param count - Circle map's segment count.
         * @returns {@link Raycaster.Map Raycaster.Map} instance
         */
        setSegmentCount(count: number): Raycaster.Map;
    }
    /**
     * Ray class responsible for casting ray's and testing their collisions with mapped objects.
     * @param [options] - Ray's congfiguration options. May include:
     * @param [options.origin = {x:0, y:0}] - Ray's position.
     * @param [options.angle = 0] - Ray's angle in radians.
     * @param [options.angleDeg = 0] - Ray's angle in degrees.
     * @param [options.cone = 0] - Ray's cone angle in radians.
     * @param [options.coneDeg = 0] - Ray's cone angle in degrees.
     * @param [options.range = Phaser.Math.MAX_SAFE_INTEGER] - Ray's range.
     * @param [options.collisionRange = Phaser.Math.MAX_SAFE_INTEGER] - Ray's maximum collision range of ray's field of view.
     * @param [options.detectionRange = Phaser.Math.MAX_SAFE_INTEGER] - Maximum distance between ray's position and tested objects bounding boxes.
     * @param [options.ignoreNotIntersectedRays = true] - If set true, ray returns false when it didn't hit anything. Otherwise returns ray's target position.
     * @param [options.autoSlice = false] - If set true, ray will automatically slice intersections into array of triangles and store it in {@link Raycaster.Ray#slicedIntersections Ray.slicedIntersections}.
     * @param [options.round = false] - If set true, point where ray hit will be rounded.
     * @param [options.enablePhysics = false] - Add to ray physics body. Body will be a circle with radius equal to {@link Raycaster.Ray#collisionRange Ray.collisionRange}. If set true, arcade physics body will be added.
     * @param [raycaster] - Parent raycaster object.
     */
    class Ray {
        constructor(options?: {
            origin?: Phaser.Geom.Point | Point;
            angle?: number;
            angleDeg?: number;
            cone?: number;
            coneDeg?: number;
            range?: number;
            collisionRange?: number;
            detectionRange?: number;
            ignoreNotIntersectedRays?: boolean;
            autoSlice?: boolean;
            round?: boolean;
            enablePhysics?: boolean | 'arcade' | 'matter';
        }, raycaster?: Raycaster);
        /**
         * Set ray's angle (direction) in radians.
         * @param [angle = 0] - Ray's angle in radians.
         * @returns {@link Raycaster.Ray Raycaster.Ray} instance
         */
        setAngle(angle?: number): Raycaster.Ray;
        /**
         * Set ray's angle (direction) in degrees.
         * @param [angle = 0] - Ray's angle in degrees.
         * @returns {@link Raycaster.Ray Raycaster.Ray} instance
         */
        setAngleDeg(angle?: number): Raycaster.Ray;
        /**
         * Cast ray to find closest intersection with tested mapped objects.
         * @param [options] - options that may include:
         * @param [options.objects = {Raycaster#mappedObjects}] - Array of game objects to test. If not provided test all mapped game objects.
         * @param [options.target] - Ray's target point. Used in other casting methods to determine if ray was targeting mapped objects point.
         * @param [options.internal = false] - Flag determining if method is used by other casting method.
         * @returns Ray's closest intersection with tested objects. Returns false if no intersection has been found. Additionally contains reference to hit mapped object and segment if available.
         */
        cast(options?: {
            objects?: object[];
            target?: Phaser.Geom.Point | Point;
            internal?: boolean;
        }): Phaser.Geom.Point | boolean;
        /**
         * Cast ray in all directions to find closest intersections with tested mapped objects.
         * @param [options] - options that may include:
         * @param [options.objects = Raycaster.mappedObjects] - Array of game objects to test. If not provided test all mapped game objects.
         * @returns Array of points of ray's closest intersections with tested objects. Additionally each point contains reference to hit mapped object and it's segment if available.
         */
        castCircle(options?: {
            objects?: object[];
        }): Phaser.Geom.Point[];
        /**
         * Cast ray in a cone to find closest intersections with tested mapped objects.
         * @param [options] - options that may include:
         * @param [options.objects = Raycaster.mappedObjects] - Array of game objects to test. If not provided test all mapped game objects.
         * @returns Array of points of ray's closest intersections with tested objects. Additionally each point contains reference to hit mapped object and it's segment if available.
         */
        castCone(options?: {
            objects?: object[];
        }): Phaser.Geom.Point[];
        /**
         * Set ray's cone angle (width) in radians.
         * @param [cone = 0] - Ray's cone angle in radians.
         * @returns {@link Raycaster.Ray Raycaster.Ray} instance
         */
        setCone(cone?: number): Raycaster.Ray;
        /**
         * Set ray's cone angle (width) in degrees.
         * @param [cone = 0] - Ray's cone angle in degrees.
         * @returns {@link Raycaster.Ray Raycaster.Ray} instance
         */
        setConeDeg(cone?: number): Raycaster.Ray;
        /**
         * Configure ray.
         * @param [options] - Ray's congfiguration options. May include:
         * @param [options.origin = {x:0, y:0}] - Ray's position.
         * @param [options.angle = 0] - Ray's angle in radians.
         * @param [options.angleDeg = 0] - Ray's angle in degrees.
         * @param [options.cone = 0] - Ray's cone angle in radians.
         * @param [options.coneDeg = 0] - Ray's cone angle in degrees.
         * @param [options.range = Phaser.Math.MAX_SAFE_INTEGER] - Ray's range.
         * @param [options.collisionRange = Phaser.Math.MAX_SAFE_INTEGER] - Ray's maximum collision range of ray's field of view.
         * @param [options.detectionRange = Phaser.Math.MAX_SAFE_INTEGER] - Maximum distance between ray's position and tested objects bounding boxes.
         * @param [options.ignoreNotIntersectedRays = true] - If set true, ray returns false when it didn't hit anything. Otherwise returns ray's target position.
         * @param [options.autoSlice = false] - If set true, ray will automatically slice intersections into array of triangles and store it in {@link Raycaster.Ray#slicedIntersections Ray.slicedIntersections}.
         * @param [options.round = false] - If set true, point where ray hit will be rounded.
         * @param [options.enablePhysics = false] - Add to ray physics body. Body will be a circle with radius equal to {@link Raycaster.Ray#collisionRange Ray.collisionRange}. If set true, arcade physics body will be added.
         * @returns {@link Raycaster.Ray Raycaster.Ray} instance
         */
        config(options?: {
            origin?: Phaser.Geom.Point | Point;
            angle?: number;
            angleDeg?: number;
            cone?: number;
            coneDeg?: number;
            range?: number;
            collisionRange?: number;
            detectionRange?: number;
            ignoreNotIntersectedRays?: boolean;
            autoSlice?: boolean;
            round?: boolean;
            enablePhysics?: boolean | 'arcade' | 'matter';
        }): Raycaster.Ray;
        /**
         * Destroy object
         */
        destroy(): void;
        /**
         * Add to ray physics body. Body will be a circle with radius equal to {@link Raycaster.Ray#collisionRange Ray.collisionRange}. Physics body can be added only once.
         * @param [type = 'arcade'] - Physics type
         * @returns {@link Raycaster.Ray Raycaster.Ray} instance
         */
        enablePhysics(type?: 'arcade' | 'matter'): Raycaster.Ray;
        /**
         * Sets the collision category of this ray's Matter Body. This number must be a power of two between 2^0 (= 1) and 2^31.
         * Two bodies with different collision groups (see {@link #setCollisionGroup}) will only collide if their collision
         * categories are included in their collision masks (see {@link #setCollidesWith}).
         * @param value - Unique category bitfield.
         * @returns {@link Raycaster.Ray Raycaster.Ray} instance
         */
        setCollisionCategory(value: number): Raycaster.Ray;
        /**
         * Sets the collision category of this ray's Matter Body. This number must be a power of two between 2^0 (= 1) and 2^31.
         * Two bodies with different collision groups (see {@link #setCollisionGroup}) will only collide if their collision
         * categories are included in their collision masks (see {@link #setCollidesWith}).
         * @param value - Unique category bitfield.
         * @returns {@link Raycaster.Ray Raycaster.Ray} instance
         */
        setCollisionCategory(value: number): Raycaster.Ray;
        /**
         * Sets the collision mask for this ray's Matter Body. Two Matter Bodies with different collision groups will only
         * collide if each one includes the other's category in its mask based on a bitwise AND, i.e. `(categoryA & maskB) !== 0`
         * and `(categoryB & maskA) !== 0` are both true.*
         * @param categories - A unique category bitfield, or an array of them.
         * @returns {@link Raycaster.Ray Raycaster.Ray} instance
         */
        setCollidesWith(categories: number | number[]): Raycaster.Ray;
        /**
         * The callback is sent a `Phaser.Types.Physics.Matter.MatterCollisionData` object.
         *
         * This does not change the bodies collision category, group or filter. Those must be set in addition
         * to the callback.
         * @param callback - The callback to invoke when this body starts colliding with another.
         * @returns {@link Raycaster.Ray Raycaster.Ray} instance
         */
        setOnCollide(callback: (...params: any[]) => any): Raycaster.Ray;
        /**
         * The callback is sent a `Phaser.Types.Physics.Matter.MatterCollisionData` object.
         *
         * This does not change the bodies collision category, group or filter. Those must be set in addition
         * to the callback.
         * @param callback - The callback to invoke when this body stops colliding with another.
         * @returns {@link Raycaster.Ray Raycaster.Ray} instance
         */
        setOnCollideEnd(callback: (...params: any[]) => any): Raycaster.Ray;
        /**
         * The callback is sent a `Phaser.Types.Physics.Matter.MatterCollisionData` object.
         *
         * This does not change the bodies collision category, group or filter. Those must be set in addition
         * to the callback.
         * @param callback - The callback to invoke for the duration of this body colliding with another.
         * @returns {@link Raycaster.Ray Raycaster.Ray} instance
         */
        setOnCollideActive(callback: (...params: any[]) => any): Raycaster.Ray;
        /**
         * The callback is sent a reference to the other body, along with a `Phaser.Types.Physics.Matter.MatterCollisionData` object.
         *
         * This does not change the bodies collision category, group or filter. Those must be set in addition
         * to the callback.
         * @param body - The body, or an array of bodies, to test for collisions with.
         * @param callback - The callback to invoke when this body collides with the given body or bodies.
         * @returns {@link Raycaster.Ray Raycaster.Ray} instance
         */
        setOnCollideWith(body: MatterJS.Body | MatterJS.Body[], callback: (...params: any[]) => any): Raycaster.Ray;
        /**
         * Set ray's source position.
         * @param x - X coordinate.
         * @param y - Y coordinate.
         * @returns {@link Raycaster.Ray Raycaster.Ray} instance
         */
        setOrigin(x: number, y: number): Raycaster.Ray;
        /**
         * Get game objects overlaping field of view.
         * @param [objects] - Game object / array off game objects to test.
         * @returns Array of game objects that overlaps with field of view.
         */
        overlap(objects?: any | object[]): object[];
        /**
         * Process callback for physics collider / overlap.
         * @param object1 - Game object or matter body passed by collider / overlap or matter CollisionInfo object.
         * @param object2 - Game object or matter body passed by collider / overlap. Ignored if matter CollisionInfo object was passed as first argument.
         * @returns Return true if game object is overlapping ray's field of view.
         */
        processOverlap(object1: any, object2: any): boolean;
        /**
         * Set ray's range.
         * @param [rayRange = Phaser.Math.MAX_SAFE_INTEGER] - Ray's range.
         * @returns {@link Raycaster.Ray Raycaster.Ray} instance
         */
        setRayRange(rayRange?: number): Raycaster.Ray;
        /**
         * Set ray's maximum detection range. Objects outside detection range won't be tested.
         * Ray tests all objects when set to 0.
         * @param [detectionRange = 0] - Maximum distance between ray's position and tested objects bounding boxes.
         * @returns {@link Raycaster.Ray Raycaster.Ray} instance
         */
        setDetectionRange(detectionRange?: number): Raycaster.Ray;
        /**
         * Set ray's field of view maximum collision range. Objects outside collision range won't be tested by {@link Raycaster.Ray#overlap Raycaster.Ray.overlap} method.
         * Determines ray's physics body radius.
         * @param [collisionRange = Phaser.Math.MAX_SAFE_INTEGER] - Ray's collision range and physics body radius.
         * @returns {@link Raycaster.Ray Raycaster.Ray} instance
         */
        setCollisionRange(collisionRange?: number): Raycaster.Ray;
        /**
         * Test if object's bounding box is in ray's detection range.
         * @param object - Tested object
         * @param [bounds = false] - Tested object's bounds. If not passed bounds will be generated automatically.
         * @returns Information if object is in ray's detection range.
         */
        boundsInRange(object: any, bounds?: Phaser.Geom.Rectangle | boolean): boolean;
        /**
         * Ray's source position.
         */
        origin: Phaser.Geom.Point;
        /**
         * Ray's angle in radians.
         */
        angle: number;
        /**
         * Ray's cone width angle in radians.
         */
        cone: number;
        /**
         * Ray's maximum range
         */
        rayRange: number;
        /**
         * Ray's maximum detection range. Objects outside detection range won't be tested.
         * Ray tests all objects when set to 0.
         */
        detectionRange: number;
        /**
         * Ray's maximum collision range of ray's field of view. Radius of {@link Raycaster.Ray#collisionRangeCircle Ray.body}.
         */
        collisionRange: number;
        /**
         * If set true, ray returns false when it didn't hit anything. Otherwise returns ray's target position.
         */
        ignoreNotIntersectedRays: boolean;
        /**
         * If set true, ray's hit points will be rounded.
         */
        round: boolean;
        /**
         * If set true, ray will automatically slice intersections into array of triangles and store it in {@link Raycaster.Ray#slicedIntersections Ray.slicedIntersections}.
         */
        autoSlice: boolean;
        /**
         * Array of intersections from last raycast representing field of view.
         */
        intersections: object[];
        /**
         * Array of triangles representing slices of field of view from last raycast.
         */
        slicedIntersections: Phaser.Geom.Triangle[];
        /**
         * Physics body for testing field of view collisions.
         */
        body: any;
        /**
         * Physics body type.
         */
        bodyType: boolean | 'arcade' | 'matter';
        /**
         * Set ray's position, direction (angle) and range.
         * @param x - X coordinate.
         * @param y - Y coordinate.
         * @param [angle] - Ray's angle in radians.
         * @param [range = Phaser.Math.MAX_SAFE_INTEGER] - Ray's range.
         * @returns {@link Raycaster.Ray Raycaster.Ray} instance
         */
        setRay(x: number, y: number, angle?: number, range?: number): Raycaster.Ray;
        /**
         * Slice ray's field of view represented by polygon or array of points into array of triangles.
         * @param [fov = {Ray#fov}] - Array of points or polygon representing field of view. If not passed, filed of view from last raycaste will be used.
         * @param [closed = true|{Ray#fov}] - Define if field of view polygon is closed (first and last vertices sholud be connected). If fov was not passed, value depends of last type of casting.
         * @returns Array of triangles representing slices of field of view.
         */
        slice(fov?: object[] | Phaser.Geom.Polygon, closed?: boolean): Phaser.Geom.Triangle[];
        /**
         * Get ray statistics for last casting. Stats include
        * number of casted rays,
        * number of tested mapped objects,
        * number of tested map segments.
        * casting time
         * @returns Statisticss from last casting.
         */
        getStats(): any;
    }
}

/**
 * Raycaster class responsible for creating ray objects and managing mapped objects.
 * @param [options] - Raycaster's configuration options. May include:
 * @param [options.scene] - Scene in which Raycaster will be used.
 * @param [options.mapSegmentCount = 0] - Number of segments of circle maps. If set to 0, map will be teste
 * @param [options.objects] - Game object or array of game objects to map.
 * @param [options.boundingBox] - Raycaster's bounding box. If not passed, {@link Raycaster Raycaster} will set it's bounding box based on Arcade Physics / Matter physics world bounds.
 * @param [options.autoUpdate = true] - If set true, automatically update dynamic maps on scene update event.
 * @param [options.debug] - Enable debug mode or configure it {@link Raycaster#debugOptions debugOptions}.
 */
declare class Raycaster {
    constructor(options?: {
        scene?: Phaser.Scene;
        mapSegmentCount?: number;
        objects?: any | object[];
        boundingBox?: Phaser.Geom.Rectangle;
        autoUpdate?: boolean;
        debug?: boolean | any;
    });
    /**
     * If set true, map will be automatically updated on scene update event.
     */
    static Map_dynamic: boolean;
    /**
     * Plugin version.
     */
    readonly version: string;
    /**
     * Raycaster's debug config
     * @property [enable = false] - Enable debug mode
     * @property [maps = true] - Enable maps debug
     * @property graphics - Debug graphics options
     * @property [graphics.ray = 0x00ff00] - Debug ray color. Set false to disable.
     * @property [graphics.rayPoint = 0xff00ff] - Debug ray point color. Set false to disable.
     * @property [graphics.mapPoint = 0x00ffff] - debug map point color. Set false to disable.
     * @property [graphics.mapSegment = 0x0000ff] - Debug map segment color. Set false to disable.
     * @property [graphics.mapBoundingBox = 0xff0000] - Debug map bounding box color. Set false to disable.
     */
    debugOptions: {
        enable?: boolean;
        maps?: boolean;
        graphics: {
            ray?: boolean | number;
            rayPoint?: boolean | number;
            mapPoint?: boolean | number;
            mapSegment?: boolean | number;
            mapBoundingBox?: boolean | number;
        };
    };
    /**
     * Array of mapped game objects.
     */
    mappedObjects: object[];
    /**
     * Array of dynamic mapped game objects.
     */
    dynamicMappedObjects: object[];
    /**
     * Number of segments of circle maps.
     */
    mapSegmentCount: number;
    /**
     * Configure raycaster.
     * @param [options] - Raycaster's congfiguration options. May include:
     * @param [options.scene] - Scene in which Raycaster will be used.
     * @param [options.mapSegmentCount = 0] - Number of segments of circle maps.
     * @param [options.objects] - Game object or array of game objects to map.
     * @param [options.boundingBox] - Raycaster's bounding box.
     * @param [options.debug] - Enable debug mode or cofigure {@link Raycaster#debugOptions debugOptions}.
     * @returns {@link Raycaster Raycaster} instance
     */
    setOptions(options?: {
        scene?: Phaser.Scene;
        mapSegmentCount?: number;
        objects?: any | object[];
        boundingBox?: Phaser.Geom.Rectangle;
        debug?: boolean | any;
    }): Raycaster;
    /**
     * Set Raycaster's bounding box.
     * @param x - The X coordinate of the top left corner of bounding box.
     * @param y - The Y coordinate of the top left corner of bounding box.
     * @param width - The width of bounding box.
     * @param height - The height of bounding box.
     * @returns {@link Raycaster Raycaster} instance
     */
    setBoundingBox(x: number, y: number, width: number, height: number): Raycaster;
    /**
     * Map game objects
     * @param objects - Game object / matter body or array of game objects / matter bodies to map.
     * @param [dynamic = false] - {@link Raycaster.Map Raycaster.Map} dynamic flag (determines map will be updated automatically).
     * @param [options] - Additional options for {@link Raycaster.Map Raycaster.Map}
     * @returns {@link Raycaster Raycaster} instance
     */
    mapGameObjects(objects: any | object[], dynamic?: boolean, options?: any): Raycaster;
    /**
     * Remove game object's {@link Raycaster.Map Raycaster.Map} maps.
     * @param objects - Game object or array of game objects which maps will be removed.
     * @returns {@link Raycaster Raycaster} instance
     */
    removeMappedObjects(objects: any | object[]): Raycaster;
    /**
     * Enable game object's {@link Raycaster.Map Raycaster.Map} maps.
     * @param objects - Game object or array of game objects which maps will be enabled.
     * @returns {@link Raycaster Raycaster} instance
     */
    enableMaps(objects: any | object[]): Raycaster;
    /**
     * Disable game object's {@link Raycaster.Map Raycaster.Map} maps.
     * @param objects - Game object or array of game objects which maps will be disabled.
     * @returns {@link Raycaster Raycaster} instance
     */
    disableMaps(objects: any | object[]): Raycaster;
    /**
     * Updates all {@link Raycaster.Map Raycaster.Map} dynamic maps. Fired on Phaser.Scene update event.
     * @returns {@link Raycaster Raycaster} instance
     */
    update(): Raycaster;
    /**
     * Create {@link Raycaster.Ray Raycaster.Ray} object.
     * @param [options] - Ray's congfiguration options. May include:
     * @param [options.origin = {x:0, y:0}] - Ray's position.
     * @param [options.angle = 0] - Ray's angle in radians.
     * @param [options.angleDeg = 0] - Ray's angle in degrees.
     * @param [options.cone = 0] - Ray's cone angle in radians.
     * @param [options.coneDeg = 0] - Ray's cone angle in degrees.
     * @param [options.range = Phaser.Math.MAX_SAFE_INTEGER] - Ray's range.
     * @param [options.collisionRange = Phaser.Math.MAX_SAFE_INTEGER] - Ray's maximum collision range of ray's field of view.
     * @param [options.detectionRange = Phaser.Math.MAX_SAFE_INTEGER] - Maximum distance between ray's position and tested objects bounding boxes.
     * @param [options.ignoreNotIntersectedRays = true] - If set true, ray returns false when it didn't hit anything. Otherwise returns ray's target position.
     * @param [options.autoSlice = false] - If set true, ray will automatically slice intersections into array of triangles and store it in {@link Raycaster.Ray#slicedIntersections Ray.slicedIntersections}.
     * @param [options.round = false] - If set true, point where ray hit will be rounded.
     * @param [options.enablePhysics = false] - Add to ray physics body. Body will be a circle with radius equal to {@link Raycaster.Ray#collisionRange Ray.collisionRange}. If set true, arcade physics body will be added.
     * @returns {@link Raycaster.Ray Raycaster.Ray} instance
     */
    createRay(options?: {
        origin?: Phaser.Geom.Point | Point;
        angle?: number;
        angleDeg?: number;
        cone?: number;
        coneDeg?: number;
        range?: number;
        collisionRange?: number;
        detectionRange?: number;
        ignoreNotIntersectedRays?: boolean;
        autoSlice?: boolean;
        round?: boolean;
        enablePhysics?: boolean | 'arcade' | 'matter';
    }): Raycaster.Ray;
    /**
     * Get raycaster statistics.
     * @returns Raycaster statistics.
     */
    getStats(): any;
    /**
     * Destroy object and all mapped objects.
     */
    destroy(): void;
}


declare module 'phaser-raycaster' {
    export = PhaserRaycaster;
}