import type * as BABYLON from "@babylonjs/core"; import type { Base } from "./base-inputs"; /** * Parameters for transform nodes: the invisible parents used to group and move several objects * together, and the queries that walk a node hierarchy. */ export declare namespace BabylonNode { /** * Feeds the `babylon.node` getters with the one transform node to read from. */ class NodeDto { constructor(node?: BABYLON.TransformNode); /** * The transform node to read from */ node: BABYLON.TransformNode; } /** * Feeds `babylon.node.translate` with a node, the direction in its own axes and how far to move * it. */ class NodeTranslationDto { constructor(node?: BABYLON.TransformNode, direction?: Base.Vector3, distance?: number); /** * The transform node to move; its children follow */ node: BABYLON.TransformNode; /** * The direction to move in, in the node's own local axes */ direction: Base.Vector3; /** * How far to move along the direction, in scene units */ distance: number; } /** * Feeds `babylon.node.setParent` with a node and the node to parent it to. */ class NodeParentDto { constructor(node?: BABYLON.TransformNode, parentNode?: BABYLON.TransformNode); /** * The transform node to reparent; it keeps its place in the world */ node: BABYLON.TransformNode; /** * The node it moves with from then on */ parentNode: BABYLON.TransformNode; } /** * Feeds `babylon.node.setDirection` with a node and the direction its local Z axis should point * along. */ class NodeDirectionDto { constructor(node?: BABYLON.TransformNode, direction?: Base.Vector3); /** * The transform node to turn; its children follow */ node: BABYLON.TransformNode; /** * The direction the node's local Z axis is turned to, as `[x, y, z]` */ direction: number[]; } /** * Feeds `babylon.node.setAbsolutePosition` with a node and the world point to move it to. */ class NodePositionDto { constructor(node?: BABYLON.TransformNode, position?: Base.Point3); /** * The transform node to move; its children follow */ node: BABYLON.TransformNode; /** * The point in world space to move the node to, whatever its parents */ position: Base.Point3; } /** * Feeds `babylon.node.rotate` with a node, an axis through its origin and the angle to turn by. */ class RotateNodeDto { constructor(node?: BABYLON.TransformNode, axis?: Base.Vector3, angle?: number); /** * The transform node to turn; its children follow */ node: BABYLON.TransformNode; /** * The axis direction through the node's origin, as `[x, y, z]` * @default [0, 1, 0] */ axis?: Base.Vector3 | undefined; /** * How far to turn, in degrees, added to the current rotation * @default 0 */ angle?: number | undefined; } /** * Feeds `babylon.node.rotateAroundAxisWithPosition`: the node, a point and an axis through it, * and the angle to orbit by. */ class RotateAroundAxisNodeDto { constructor(node?: BABYLON.TransformNode, position?: Base.Point3, axis?: Base.Vector3, angle?: number); /** * The transform node to turn around the axis; its children follow */ node: BABYLON.TransformNode; /** * A point the axis passes through * @default [0, 0, 0] */ position?: Base.Point3 | undefined; /** * The direction of the axis, as `[x, y, z]`; not a zero vector * @default [0, 1, 0] */ axis?: Base.Vector3 | undefined; /** * How far to turn, in degrees; positive follows the right-hand rule around the axis * @default 0 */ angle?: number | undefined; } /** * Feeds `babylon.node.createNodeFromRotation`: the optional parent, where the node sits and how * it is turned. */ class CreateNodeFromRotationDto { constructor(parent?: BABYLON.TransformNode, origin?: Base.Point3, rotation?: Base.Vector3); /** * The node to parent the new one to, or null for a top-level node */ parent: BABYLON.TransformNode | null; /** * Where the node sits, relative to its parent * @default [0, 0, 0] */ origin?: Base.Point3 | undefined; /** * The angles around X, Y and Z in degrees the node is turned by * @default [0, 0, 0] */ rotation?: Base.Vector3 | undefined; } /** * How a node's axes are drawn, shared by `DrawNodeDto` and `DrawNodesDto`: the color of each * axis line and its length. */ abstract class DrawNodeSharedDto { /** * Hex color of the line drawn along each node's X axis * @default #ff0000 */ colorX?: string | undefined; /** * Hex color of the line drawn along each node's Y axis * @default #00ff00 */ colorY?: string | undefined; /** * Hex color of the line drawn along each node's Z axis * @default #0000ff */ colorZ?: string | undefined; /** * Length of each axis line, in scene units * @default 2 */ size?: number | undefined; } /** * Feeds `babylon.node.drawNode` with the node to draw axes for, the color of each axis and * their length. */ class DrawNodeDto extends DrawNodeSharedDto { constructor(node?: BABYLON.TransformNode, colorX?: string, colorY?: string, colorZ?: string, size?: number); /** * The transform node the axis lines are parented to */ node: BABYLON.TransformNode; } /** * Feeds `babylon.node.drawNodes` with the nodes to draw axes for, the color of each axis and * their length. */ class DrawNodesDto extends DrawNodeSharedDto { constructor(nodes?: BABYLON.TransformNode[], colorX?: string, colorY?: string, colorZ?: string, size?: number); /** * The transform nodes, each getting its own set of axis lines */ nodes: BABYLON.TransformNode[]; } }