import * as Core from "@intelligentgraphics/ig.gfx.core";
import { IScreenWorldConverter } from "../ScreenWorldConverter";
import { IMovementPlane } from "./MovementPlanes";
export interface IMouseConverter {
    transferCoordinates(coordinates: Core.ViewCoordinates): Core.WorldCoordinates;
}
/**
 * Class for converting mouse movement to movement in the 3D space.
 * It uses planes to which the movement of components is restricted.
 */
export declare class MouseTo3DMovement implements IMouseConverter {
    /** The planes in which the movement occurs */
    private planes;
    /** The converter (allows for converting from screen position to world ray) */
    private converter;
    /**
     * Class for converting mouse movement to movement in the 3D space.
     * It uses planes to which the movement of components is restricted.
     * @param converter
     * @param planes: Consists of main planes and non-main planes.
     * 				  These have to be constructed so that for any given ray from the camera,
     * 				  there is always at least one intersection with a plane.
     */
    constructor(converter: IScreenWorldConverter, planes: IMovementPlane[]);
    /**
     * Transfer movement in the camera plane (ViewCoordinates) to movement
     * in the movement planes. For this, look at the ray the camera emits
     * (through the current coordinates) and intersect it with all the planes.
     * If there is an intersection in a main plane, take the closest
     * one to the camera. Otherwise do the same for the other planes,
     * and project the result to the first main Plane.
     * @param coordinates the current coordinates on screen
     * @returns {Core.WorldCoordinates} the calculated position
     */
    transferCoordinates(coordinates: Core.ViewCoordinates): Core.WorldCoordinates;
    /**
     * Get the intersections ordered by distance to the camera.
     * @param coordinates
     * @param planes
     * @returns {Array<WorldCoordinates>}
     */
    private sortedIntersections;
    /**
     * Get all valid intersections that the camera ray has with the planes.
     * @param coordinates
     * @param movementPlanes
     * @returns {Array<WorldCoordinates>}
     */
    private validIntersections;
    /**
     * Sort the intersections by distance to the camera.
     * @param intersections
     * @returns {Array<vec3>}
     */
    private sortIntersections;
}
/**
 * Class that decides on the movement restriction for the passed objects.
 * Constructs instances of the IMovementPlanes interface.
 */
export declare class MovementPlaneDecider {
    /**
     * Decide if the group of ids can be moved on a wall
     * @param ids
     * @param orthographic
     * @returns {boolean}
     */
    private static isEligibleForWallMovement;
    /**
     * Get the movement planes for the current situation
     * @param converter
     * @param mouseAttachment
     * @param ids
     * @param keepFloating
     * @returns {IMovementPlane[]}
     */
    static planes(converter: IScreenWorldConverter, mouseAttachment: Core.WorldCoordinates, ids: Core.ComponentId[], keepFloating: boolean): IMovementPlane[];
    /**
     * Calculate the offset for the wall plane.
     * This is necessary so that the closest point of the bounding box is always directly at the wall.
     * @param mouseAttachment
     * @param ids
     * @param wallId
     * @returns {WorldCoordinates}
     */
    private static wallOffset;
}
