app/node_modules/@babylonjs/core/Events/pointerEvents.d.ts

import type { Nullable } from "../types";
import { Vector2 } from "../Maths/math.vector";
import type { PickingInfo } from "../Collisions/pickingInfo";
import type { IMouseEvent } from "./deviceInputEvents";
import type { InputManager } from "../Inputs/scene.inputManager";
import type { Ray } from "../Culling/ray";
/**
 * Gather the list of pointer event types as constants.
 */
export declare class PointerEventTypes {
    /**
     * The pointerdown event is fired when a pointer becomes active. For mouse, it is fired when the device transitions from no buttons depressed to at least one button depressed. For touch, it is fired when physical contact is made with the digitizer. For pen, it is fired when the stylus makes physical contact with the digitizer.
     */
    static readonly POINTERDOWN = 1;
    /**
     * The pointerup event is fired when a pointer is no longer active.
     */
    static readonly POINTERUP = 2;
    /**
     * The pointermove event is fired when a pointer changes coordinates.
     */
    static readonly POINTERMOVE = 4;
    /**
     * The pointerwheel event is fired when a mouse wheel has been rotated.
     */
    static readonly POINTERWHEEL = 8;
    /**
     * The pointerpick event is fired when a mesh or sprite has been picked by the pointer.
     */
    static readonly POINTERPICK = 16;
    /**
     * The pointertap event is fired when a the object has been touched and released without drag.
     */
    static readonly POINTERTAP = 32;
    /**
     * The pointerdoubletap event is fired when a the object has been touched and released twice without drag.
     */
    static readonly POINTERDOUBLETAP = 64;
}
/**
 * Base class of pointer info types.
 */
export declare class PointerInfoBase {
    /**
     * Defines the type of event (PointerEventTypes)
     */
    type: number;
    /**
     * Defines the related dom event
     */
    event: IMouseEvent;
    /**
     * Instantiates the base class of pointers info.
     * @param type Defines the type of event (PointerEventTypes)
     * @param event Defines the related dom event
     */
    constructor(
    /**
     * Defines the type of event (PointerEventTypes)
     */
    type: number, 
    /**
     * Defines the related dom event
     */
    event: IMouseEvent);
}
/**
 * This class is used to store pointer related info for the onPrePointerObservable event.
 * Set the skipOnPointerObservable property to true if you want the engine to stop any process after this event is triggered, even not calling onPointerObservable
 */
export declare class PointerInfoPre extends PointerInfoBase {
    /**
     * Ray from a pointer if available (eg. 6dof controller)
     */
    ray: Nullable<Ray>;
    /**
     * Defines picking info coming from a near interaction (proximity instead of ray-based picking)
     */
    nearInteractionPickingInfo: Nullable<PickingInfo>;
    /**
     * The original picking info that was used to trigger the pointer event
     */
    originalPickingInfo: Nullable<PickingInfo>;
    /**
     * Defines the local position of the pointer on the canvas.
     */
    localPosition: Vector2;
    /**
     * Defines whether the engine should skip the next OnPointerObservable associated to this pre.
     */
    skipOnPointerObservable: boolean;
    /**
     * Instantiates a PointerInfoPre to store pointer related info to the onPrePointerObservable event.
     * @param type Defines the type of event (PointerEventTypes)
     * @param event Defines the related dom event
     * @param localX Defines the local x coordinates of the pointer when the event occured
     * @param localY Defines the local y coordinates of the pointer when the event occured
     */
    constructor(type: number, event: IMouseEvent, localX: number, localY: number);
}
/**
 * This type contains all the data related to a pointer event in Babylon.js.
 * The event member is an instance of PointerEvent for all types except PointerWheel and is of type MouseWheelEvent when type equals PointerWheel. The different event types can be found in the PointerEventTypes class.
 */
export declare class PointerInfo extends PointerInfoBase {
    private _pickInfo;
    private _inputManager;
    /**
     * Defines the picking info associated with this PointerInfo object (if applicable)
     */
    get pickInfo(): Nullable<PickingInfo>;
    /**
     * Instantiates a PointerInfo to store pointer related info to the onPointerObservable event.
     * @param type Defines the type of event (PointerEventTypes)
     * @param event Defines the related dom event
     * @param pickInfo Defines the picking info associated to the info (if any)
     * @param inputManager Defines the InputManager to use if there is no pickInfo
     */
    constructor(type: number, event: IMouseEvent, pickInfo: Nullable<PickingInfo>, inputManager?: Nullable<InputManager>);
    /**
     * Generates the picking info if needed
     */
    /** @internal */
    _generatePickInfo(): void;
}
/**
 * Data relating to a touch event on the screen.
 */
export interface PointerTouch {
    /**
     * X coordinate of touch.
     */
    x: number;
    /**
     * Y coordinate of touch.
     */
    y: number;
    /**
     * Id of touch. Unique for each finger.
     */
    pointerId: number;
    /**
     * Event type passed from DOM.
     */
    type: any;
}