import { Matrix, Quaternion, Vector3 } from "@galacean/engine-math";
import { BoolUpdateFlag } from "./BoolUpdateFlag";
import { Component } from "./Component";
/**
 * Used to implement transformation related functions.
 */
export declare class Transform extends Component {
    private static _tempQuat0;
    private static _tempVec30;
    private static _tempVec31;
    private static _tempVec32;
    private static _tempMat30;
    private static _tempMat31;
    private static _tempMat32;
    private static _tempMat41;
    private static _tempMat42;
    private _position;
    private _rotation;
    private _rotationQuaternion;
    private _scale;
    private _localUniformScaling;
    private _worldPosition;
    private _worldRotation;
    private _worldRotationQuaternion;
    private _worldUniformScaling;
    private _lossyWorldScale;
    private _localMatrix;
    private _worldMatrix;
    private _worldForward;
    private _worldRight;
    private _worldUp;
    private _frontFaceInvert;
    protected _isParentDirty: boolean;
    private _parentTransformCache;
    private _dirtyFlag;
    /**
     * Local position.
     */
    get position(): Vector3;
    set position(value: Vector3);
    /**
     * World position.
     */
    get worldPosition(): Vector3;
    set worldPosition(value: Vector3);
    /**
     * Local rotation, defining the rotation value in degrees.
     * Rotations are performed around the Y axis, the X axis, and the Z axis, in that order.
     */
    get rotation(): Vector3;
    set rotation(value: Vector3);
    /**
     * World rotation, defining the rotation value in degrees.
     * Rotations are performed around the Y axis, the X axis, and the Z axis, in that order.
     */
    get worldRotation(): Vector3;
    set worldRotation(value: Vector3);
    /**
     * Local rotation, defining the rotation by using a unit quaternion.
     */
    get rotationQuaternion(): Quaternion;
    set rotationQuaternion(value: Quaternion);
    /**
     * World rotation, defining the rotation by using a unit quaternion.
     */
    get worldRotationQuaternion(): Quaternion;
    set worldRotationQuaternion(value: Quaternion);
    /**
     * Local scaling.
     */
    get scale(): Vector3;
    set scale(value: Vector3);
    /**
     * Local lossy scaling.
     * @remarks The value obtained may not be correct under certain conditions(for example, the parent node has non-uniform world scaling,
     * and the child node has a rotation), the scaling will be tilted.
     */
    get lossyWorldScale(): Vector3;
    /**
     * Local matrix.
     * @remarks Need to re-assign after modification to ensure that the modification takes effect.
     */
    get localMatrix(): Matrix;
    set localMatrix(value: Matrix);
    /**
     * World matrix.
     * @remarks Need to re-assign after modification to ensure that the modification takes effect.
     */
    get worldMatrix(): Matrix;
    set worldMatrix(value: Matrix);
    /**
     * Set local position by X, Y, Z value.
     * @param x - X coordinate
     * @param y - Y coordinate
     * @param z - Z coordinate
     */
    setPosition(x: number, y: number, z: number): void;
    /**
     * Set local rotation by the X, Y, Z components of the euler angle, unit in degrees.
     * Rotations are performed around the Y axis, the X axis, and the Z axis, in that order.
     * @param x - The angle of rotation around the X axis
     * @param y - The angle of rotation around the Y axis
     * @param z - The angle of rotation around the Z axis
     */
    setRotation(x: number, y: number, z: number): void;
    /**
     * Set local rotation by the X, Y, Z, and W components of the quaternion.
     * @param x - X component of quaternion
     * @param y - Y component of quaternion
     * @param z - Z component of quaternion
     * @param w - W component of quaternion
     */
    setRotationQuaternion(x: number, y: number, z: number, w: number): void;
    /**
     * Set local scaling by scaling values along X, Y, Z axis.
     * @param x - Scaling along X axis
     * @param y - Scaling along Y axis
     * @param z - Scaling along Z axis
     */
    setScale(x: number, y: number, z: number): void;
    /**
     * Set world position by X, Y, Z value.
     * @param x - X coordinate
     * @param y - Y coordinate
     * @param z - Z coordinate
     */
    setWorldPosition(x: number, y: number, z: number): void;
    /**
     * Set world rotation by the X, Y, Z components of the euler angle, unit in degrees, Yaw/Pitch/Roll sequence.
     * @param x - The angle of rotation around the X axis
     * @param y - The angle of rotation around the Y axis
     * @param z - The angle of rotation around the Z axis
     */
    setWorldRotation(x: number, y: number, z: number): void;
    /**
     * Set local rotation by the X, Y, Z, and W components of the quaternion.
     * @param x - X component of quaternion
     * @param y - Y component of quaternion
     * @param z - Z component of quaternion
     * @param w - W component of quaternion
     */
    setWorldRotationQuaternion(x: number, y: number, z: number, w: number): void;
    /**
     * The forward direction in world space.
     */
    get worldForward(): Vector3;
    /**
     * The right direction in world space.
     */
    get worldRight(): Vector3;
    /**
     * The up direction in world space.
     */
    get worldUp(): Vector3;
    /**
     * Translate in the direction and distance of the translation.
     * @param translation - Direction and distance of translation
     * @param relativeToLocal = `true` - Is relative to the local coordinate system
     */
    translate(translation: Vector3, relativeToLocal?: boolean): void;
    /**
     * Translate some distance by x along the x axis, y along the y axis, and z along the z axis.
     * @param x - Distance along the x axis
     * @param y - Distance along the y axis
     * @param z - Distance along the z axis
     * @param relativeToLocal = `true` - Is relative to the local coordinate system
     */
    translate(x: number, y: number, z: number, relativeToLocal?: boolean): void;
    /**
     * Rotate around the passed Vector3.
     * @param rotation - Euler angle in degrees
     * @param relativeToLocal = `true` - Is relative to the local coordinate system
     */
    rotate(rotation: Vector3, relativeToLocal?: boolean): void;
    /**
     * Rotate around the passed Vector3.
     * @param x - Rotation along x axis, in degrees
     * @param y - Rotation along y axis, in degrees
     * @param z - Rotation along z axis, in degrees
     * @param relativeToLocal = `true` - Is relative to the local coordinate system
     */
    rotate(x: number, y: number, z: number, relativeToLocal?: boolean): void;
    /**
     * Rotate around the specified axis according to the specified angle.
     * @param axis - Rotate axis
     * @param angle - Rotate angle in degrees
     * @param relativeToLocal = `true` - Relative to local space
     */
    rotateByAxis(axis: Vector3, angle: number, relativeToLocal?: boolean): void;
    /**
     * Rotate and ensure that the world front vector points to the target world position.
     * @param targetPosition - Target world position
     * @param worldUp - Up direction in world space, default is Vector3(0, 1, 0)
     */
    lookAt(targetPosition: Vector3, worldUp?: Vector3): void;
    private _propagateReparentDirty;
    protected _onLocalMatrixChanging(): void;
    protected _onWorldMatrixChanging(): void;
    protected _isContainDirtyFlags(targetDirtyFlags: number): boolean;
    protected _isContainDirtyFlag(type: number): boolean;
    protected _setDirtyFlagTrue(type: number): void;
    protected _setDirtyFlagFalse(type: number): void;
    protected _worldAssociatedChange(type: number): void;
    protected _getParentTransform(): Transform | null;
    protected _onPositionChanged(): void;
    protected _onWorldPositionChanged(): void;
    /**
     * Get worldMatrix: Will trigger the worldMatrix update of itself and all parent entities.
     * Get worldPosition: Will trigger the worldMatrix, local position update of itself and the worldMatrix update of all parent entities.
     * In summary, any update of related variables will cause the dirty mark of one of the full process (worldMatrix or worldRotationQuaternion) to be false.
     */
    private _updateWorldPositionFlag;
    /**
     * Get worldMatrix: Will trigger the worldMatrix update of itself and all parent entities.
     * Get worldPosition: Will trigger the worldMatrix, local position update of itself and the worldMatrix update of all parent entities.
     * Get worldRotationQuaternion: Will trigger the world rotation (in quaternion) update of itself and all parent entities.
     * Get worldRotation: Will trigger the world rotation(in euler and quaternion) update of itself and world rotation(in quaternion) update of all parent entities.
     * Get worldScale: Will trigger the scaling update of itself and all parent entities.
     * In summary, any update of related variables will cause the dirty mark of one of the full process (worldMatrix or worldRotationQuaternion) to be false.
     */
    private _updateWorldRotationFlag;
    /**
     * Get worldMatrix: Will trigger the worldMatrix update of itself and all parent entities.
     * Get worldPosition: Will trigger the worldMatrix, local position update of itself and the worldMatrix update of all parent entities.
     * Get worldRotationQuaternion: Will trigger the world rotation (in quaternion) update of itself and all parent entities.
     * Get worldRotation: Will trigger the world rotation(in euler and quaternion) update of itself and world rotation(in quaternion) update of all parent entities.
     * Get worldScale: Will trigger the scaling update of itself and all parent entities.
     * In summary, any update of related variables will cause the dirty mark of one of the full process (worldMatrix or worldRotationQuaternion) to be false.
     * @param flags - Dirty flag
     */
    private _updateWorldPositionAndRotationFlag;
    /**
     * Get worldMatrix: Will trigger the worldMatrix update of itself and all parent entities.
     * Get worldPosition: Will trigger the worldMatrix, local position update of itself and the worldMatrix update of all parent entities.
     * Get worldScale: Will trigger the scaling update of itself and all parent entities.
     * In summary, any update of related variables will cause the dirty mark of one of the full process (worldMatrix) to be false.
     * @param flags - Dirty flag
     */
    private _updateWorldScaleFlag;
    /**
     * Get worldMatrix: Will trigger the worldMatrix update of itself and all parent entities.
     * Get worldPosition: Will trigger the worldMatrix, local position update of itself and the worldMatrix update of all parent entities.
     * Get worldScale: Will trigger the scaling update of itself and all parent entities.
     * In summary, any update of related variables will cause the dirty mark of one of the full process (worldMatrix) to be false.
     * @param flags - Dirty flag
     */
    private _updateWorldPositionAndScaleFlag;
    /**
     * Update all world transform property dirty flag, the principle is the same as above.
     * @param flags - Dirty flag
     */
    private _updateAllWorldFlag;
    private _getScaleMatrix;
    private _rotateByQuat;
    private _translate;
    private _rotateXYZ;
    private _onRotationChanged;
    private _onWorldRotationChanged;
    private _onRotationQuaternionChanged;
    private _onWorldRotationQuaternionChanged;
    private _onScaleChanged;
    private _getWorldUniformScaling;
    /**
     * @deprecated
     * Listen for changes in the world pose of this `Entity`.
     * @returns Change flag
     */
    registerWorldChangeFlag(): BoolUpdateFlag;
}
/**
 * Dirty flag of transform.
 */
export declare enum TransformModifyFlags {
    LocalEuler = 1,
    LocalQuat = 2,
    WorldPosition = 4,
    WorldEuler = 8,
    WorldQuat = 16,
    WorldScale = 32,
    LocalMatrix = 64,
    WorldMatrix = 128,
    /** This is an internal flag used to assist in determining the dispatch
     *  of world scaling dirty flags in the case of non-uniform scaling.
     */
    IsWorldUniformScaling = 256,
    WorldFrontFaceInvert = 2048,
    /** WorldMatrix | WorldPosition */
    WmWp = 132,
    /** WorldMatrix | WorldEuler | WorldQuat */
    WmWeWq = 152,
    /** WorldMatrix | WorldEuler | WorldQuat | WorldScale | WorldFrontFaceInvert */
    WmWeWqWs = 2232,
    /** WorldMatrix | WorldPosition | WorldEuler | WorldQuat */
    WmWpWeWq = 156,
    /** WorldMatrix | WorldScale | WorldFrontFaceInvert */
    WmWs = 2208,
    /** WorldMatrix | WorldScale | WorldUniformScaling | WorldFrontFaceInvert */
    WmWsWus = 2464,
    /** WorldMatrix | WorldPosition | WorldScale | WorldFrontFaceInvert */
    WmWpWs = 2212,
    /** WorldMatrix | WorldPosition | WorldEuler | WorldQuat | WorldScale | WorldFrontFaceInvert */
    WmWpWeWqWs = 2236,
    /** WorldMatrix | WorldPosition | WorldEuler | WorldQuat | WorldScale | WorldUniformScaling | WorldFrontFaceInvert */
    WmWpWeWqWsWus = 2492,
    /** LocalQuat | LocalMatrix | WorldMatrix | WorldPosition | WorldEuler | WorldQuat | WorldScale | WorldUniformScaling | WorldFrontFaceInvert */
    LqLmWmWpWeWqWsWus = 2558
}
