@intelligentgraphics/3d.ig.gfx.standard 1.8.2

package/IG.GFX.Standard.d.ts

@@ -0,0 +1,1045 @@
+/*
+ * Version: 1.8.2.100
+ * Commit: 6f0359b
+ * Date: 2023-01-26T10:52:15.606Z
+*
+* @preserve			
+*/
+/// <reference types="@intelligentgraphics/3d.ig.math" />
+/// <reference types="@intelligentgraphics/3d.ig.gfx.core" />
+declare module IGX.Std {
+    class KinematicChain {
+        /** how are these joints inserted? (unit vector for all joints) */
+        GeometryBase: string;
+        /**
+         * List of components acting as joints in the kinematic chain.
+         * The first joint is the origin. Head of origin is fixed.
+         * All joints are connected with its next joint (0.tail -> 1.head).
+         * So the right order inside joints array is important!
+         */
+        Joints: [
+            {
+                /** (optional) name of this joint */
+                Name?: string;
+                /** component id for head (relative path from interaktor node) */
+                HeadX: string;
+                /** component id for head (relative path from interaktor node) */
+                HeadY: string;
+                /** component id for head (relative path from interaktor node) */
+                HeadZ: string;
+                /** component id for tail (relative path from interaktor node) */
+                Tail: string;
+                /** (optional)(experimental) how is this joint inserted? (will override defined GeometryDirection) */
+                GeometryBase?: string;
+                /**
+                 * (optional) this joint strictly follows a node from another joint.
+                 * Needs path to node in other joint. Used as Head for this joint.
+                 */
+                FollowJointNode?: string;
+                /** (optional) max angle (DEG) for rotation to the left (affects position of Head) */
+                LimitLeft?: number;
+                /** (optional) max angle (DEG) for rotation to the right (affects position of Head) */
+                LimitRight?: number;
+                /** (optional) max angle (DEG) for rotation to the up (affects position of Head) */
+                LimitUp?: number;
+                /** (optional) max angle (DEG) for rotation to the bottom (affects position of Head) */
+                LimitDown?: number;
+                /** internal */
+                _Length?: number;
+                /** internal */
+                _HeadPos?: IG.Math.Vector3;
+                /** internal */
+                _TailPos?: IG.Math.Vector3;
+                /** internal */
+                _Rotation?: IG.Math.Quaternion;
+                /** internal */
+                _Blocked?: boolean;
+            }
+        ];
+        /** Absolute path (+ component id) to target node. When using multi target kinematics this can be set to "subbase". */
+        Target: string;
+        /**
+         * (optional) When using multi target kinematics this references path to subbase kinematic chain (relative to interactor)
+         * or is set to "root" for the first chain
+         */
+        Parent?: string;
+        /** Tolerance as break condition for the IK solver */
+        Tolerance: number;
+        /** (optional) Max number of iterations */
+        MaxIterations?: number;
+        /** internal */
+        _RootId?: string;
+        /** internal */
+        _ChainPath?: string;
+        /** internal */
+        _ParentChain?: KinematicChain;
+        /** internal */
+        _Level?: number;
+        /** internal */
+        _Origin?: string;
+        /** internal */
+        _TotalLength?: number;
+        /** internal */
+        _OriginPos?: IG.Math.Vector3;
+        /** internal */
+        _TargetPos?: IG.Math.Vector3;
+    }
+}
+/** Data-controlled IG.GFX Animations.
+ *
+ * Version 1.4 (1.4.0.100)
+ *
+ * Copyright (C) 2013 - 2023 intelligentgraphics AG. All Rights Reserved.
+ */
+declare module IGX.Std {
+    /**
+     * Describes an animation state. An animation state may provide values for
+     * Rotation and/or Position and/or Scaling and/or Deformation.
+     */
+    class AnimationState {
+        /**
+         * If available, the position of the component is described.
+         * If not available, but another state involved in the interpolation,
+         * provides a position, the position is implicitly considered to be 0, 0, 0.
+         * Only non-undefined values are considered. If undefined but needed, e.g.
+         * in interpolation, 0 is assumed.
+         * Positions are defined the same way as in the IG.GFX data.
+         */
+        Position?: {
+            X?: number | string;
+            Y?: number | string;
+            Z?: number | string;
+        };
+        /**
+         * If available, the rotation of the component is described.
+         * If not available, but another state involved in the interpolation,
+         * provides a rotation, the rotation is implicitly considered to be 0, 0, 0.
+         * Only non-undefined values are considered. If undefined but needed, e.g.
+         * in interpolation, 0 is assumed.
+         * Rotations are defined the same way as in the IG.GFX data.
+         */
+        Rotation?: {
+            X?: number | string;
+            Y?: number | string;
+            Z?: number | string;
+        };
+        /**
+         * If available, the scaling of the component is described.
+         * If not available, but another state involved in the interpolation,
+         * provides a scaling, the scaling is implicitly considered to be 1, 1, 1.
+         * Only non-undefined values are considered. If undefined but needed, e.g.
+         * in interpolation, 1 is assumed.
+         * Scaling is defined the same way as in the IG.GFX data.
+         */
+        Scaling?: {
+            X?: number | string;
+            Y?: number | string;
+            Z?: number | string;
+        };
+        /**
+         * If not undefined, it describes the deformation to be applied.
+         * If undefined but needed, e.g. in interpolation, 0 is assumed.
+         * Deformation is defined the same way as in the IG.GFX data.
+         */
+        Deformation?: number | string;
+        /** If defined, sets the visibility. */
+        Visibility?: boolean | string;
+    }
+    /**
+     * Data structure for animation descriptions.
+     * An animation is processed by IGX.Std.AnimationInteractor and
+     * may contain different micro animations.
+     */
+    class Animation {
+        /**
+         * The id of the animation. Must be a usual identifier, e.g. start with uppercase letter,
+         * no spaces, etc., and unique in the package. The file should be named then <Id>.animation.json
+         */
+        Id: string;
+        /**
+         * One or more micro animations. Each micro animation is assigned to a component.
+         * You may assign multiple micro animations to one and the same component.
+         */
+        Animations: {
+            /**
+             * The path that identifies the component to be animated.
+             * If path is undefined or ".", the component to which the Interactor is assigned, is considered.
+             */
+            Path?: string;
+            /**
+             * The interpolation mode to be applied for this micro animation.<br>
+             * Mode Linear (or undefined) requests a linear interpolation of two animation states.
+             */
+            Mode?: "Linear";
+            /**
+             * Two or more animation states. The time values must be in the range 0.0 to 1.0.<br>
+             * If there is no state for time 0.0, the smallest time value is used for 0.0.<br>
+             * If there is no state for time 1.0, the highest time value is used for 1.0.<br>
+             * If the requested time value is outside an epsilon range of an explicitly provided time
+             * value, a proportional interpolation of the closest two explicit animation states will
+             * be applied under consideration of the mode.<br>
+             * The time value must be a number string in scientific notation.
+             */
+            States: {
+                [time: string]: AnimationState;
+            };
+        }[];
+        /**
+         * Move Snappoints following a given (usually geometryless) node
+         */
+        LinkedPoints?: {
+            [path: string]: string[];
+        };
+        /**
+         * (optional) Build kinematic chains with this param.
+         * For a documentation see Gfx/userdoc/kinematics/index.html
+         */
+        Kinematics?: KinematicChain | KinematicChain[];
+        /** For internal optimization. Sorted by increasing time. */
+        _loops?: {
+            path: string;
+            mode: string;
+            states: {
+                time: number;
+                period?: number;
+                state1: AnimationState;
+                state2?: AnimationState;
+            }[];
+        }[];
+    }
+}
+declare module IGX.Std {
+    const Minimum = "Minimum";
+    const Maximum = "Maximum";
+    const Snap = "Snap";
+    const Raster = "Raster";
+    const Values = "Values";
+    const StartValue = "StartValue";
+    const EndValue = "EndValue";
+    const StartTime = "StartTime";
+    const EndTime = "EndTime";
+    const Steps = "Steps";
+    const Mode = "Mode";
+    const XPosition = "XPosition";
+    const YPosition = "YPosition";
+    const ZPosition = "ZPosition";
+    const XRotation = "XRotation";
+    const YRotation = "YRotation";
+    const ZRotation = "ZRotation";
+    const Start = "Start";
+    const End = "End";
+    const Stage = "Stage";
+    const Period = "Period";
+    const BackwardPeriod = "BackwardPeriod";
+    const StageStart = "StageStart";
+    const StageEnd = "StageEnd";
+    const Manual = "Manual";
+    const cString = "string";
+    const cNumber = "number";
+    interface AnimationParameters {
+        Start?: string | number;
+        End?: string | number;
+        StageStart?: string | number;
+        StageEnd?: string | number;
+        Stage?: string | number;
+        Period?: string | number;
+        BackwardPeriod?: string | number;
+        Values?: number[] | string;
+        IntermediateCalculation?: string | number;
+        DebugLevel?: number;
+        Record?: string | boolean;
+    }
+    function SetupValue<K extends keyof AnimationParameters>(parameters: AnimationParameters & {
+        [key: string]: any;
+    }, key: K, fallbackValue: number): void;
+    function SetupValue(parameters: {
+        [key: string]: any;
+    }, key: string, fallbackValue: number): void;
+    var SetupValues: (parameters: AnimationParameters & {
+        [key: string]: any;
+    }, fallbackValues: number[]) => void;
+    function GetValue<K extends keyof AnimationParameters>(parameters: AnimationParameters & {
+        [key: string]: any;
+    }, parameter: K): number;
+    function GetValue(parameters: AnimationParameters & {
+        [key: string]: any;
+    }, parameter: string): number;
+    var SetupAnimation: (parameters: AnimationParameters) => void;
+    /**
+     * Resturns the absolute path of a node inside a component
+     * @param componentId absolute path of component
+     * @param relPath relative path inside component
+     */
+    function getAbsPath(componentId: string, relPath: string): string;
+}
+declare module IGX.Std {
+    type Array3 = [number, number, number];
+    export type ShadowScene = Record<string, {
+        position: Float3;
+        rotation: Array3;
+        scaling: Float3;
+        visibility: boolean;
+        deformation?: number;
+        activedeformation?: boolean;
+    }>;
+    /**
+     * Collection of API calls implementing IGX.API.*
+     *
+     * works on ThreeJS scenegraph OR internal virtual scenegraph("shadow scene") that is actually a subset of the real scenegraph
+     *
+     * @export
+     * @class ApiConnection
+     */
+    export class ApiConnection {
+        private shadow?;
+        private useShadowApi;
+        private debug;
+        callLog: string[];
+        printCallAsError: boolean;
+        constructor(debug?: boolean);
+        /**
+         * accesses real scenegraph
+         *
+         * @private
+         * @param {string} id
+         * @returns
+         * @memberof ApiConnection
+         */
+        private getNodeInfo;
+        makeShadow(componentId: string, subNodes?: string[]): ShadowScene;
+        setShadowWithParameters(componentId: string, subNodes: string[], absoluteNodesToBeCached: string[], parameters: Animation, interactorParams: {
+            [t: string]: any;
+        }, backwards?: boolean): ShadowScene;
+        private cloneShadow;
+        setShadow(id: string, joints?: string[]): any;
+        getShadow(): any;
+        setUseShadow(value: boolean): void;
+        getUseShadow(): boolean;
+        /**
+         * write shadow scene into real scenegraph
+         *
+         * @param {ShadowScene} [shadow]
+         * @memberof ApiConnection
+         */
+        setOriginalSceneFromShadow(shadow?: ShadowScene, componentId?: string, this_animation_LinkedPoints?: {
+            [path: string]: string[];
+        }): void;
+        private appendNode;
+        SetPoint(componentId: string, key: string, position: Float3, rotation: Float3, visibility?: boolean | null): void;
+        GetParent(componentId: string): string;
+        IsValid(componentId: string): boolean;
+        GetPosition(componentId: string): Float3;
+        GetVisibility(componentId: string): boolean;
+        GetScaling(componentId: string): Float3;
+        GetXRotation(componentId: string): number;
+        GetYRotation(componentId: string): number;
+        GetZRotation(componentId: string): number;
+        /**
+         *
+         * @param {string} componentId
+         * @returns {number}
+         * @memberof ApiConnection
+         */
+        GetDeformation(componentId: string): number;
+        SetDeformation(componentId: string, value: number): void;
+        SetPosition(componentId: string, pos: IGX.Float3): void;
+        SetXRotation(componentId: string, rotation: number): void;
+        SetYRotation(componentId: string, rotation: number): void;
+        SetZRotation(componentId: string, rotation: number): void;
+        SetVisibility(componentId: string, visible: boolean): void;
+        SetScaling(componentId: string, scaling: IGX.Float3): void;
+    }
+    export {};
+}
+declare namespace IGX.Std {
+    /**
+     * Helper class for FourBar linkage
+     *
+     * Describing a nonlinear folding mechanism often used to access a bed box
+     * Idea1: calculations are done for scene graph points
+     * Idea2: the linear rotation of Vector Alo-Aup around Alo is the thing set for a given position and the rest of the positions are calculated from that
+     *
+     * Steps:
+     *  1) Model Bed so
+     *  1a) Matress and hinges and upper screws (Aup, Bup) form a proper subtree of a scenegraph
+     *  1b) Box and lower screws (Alo, Blo) form a proper subtree of a scenegraph
+     *  1c) Alo, Blo, Aup, Bup  HAVE TO BE IN ONE PLANE (looking at their world coordinates)
+     *  1d) Bars are attached to lower screws respectively and modeled flat,
+     *      i.e. the Alo-Aup bar is attached to Alo and has an initial z rotation of e.g. 20 degrees
+     *  2) Add an interactor as the one here
+     *  3) Get the point ids of Alo, Aup, Bup and Blo respectively
+     *
+     *  4) call the helper like so
+     *
+     *  const tMove = FourBarHelper.calculatePosition(child,startangle,endangle,Alo, Aup,Bup, Blo,position, []);
+     *
+     *  where
+     *  child is the id of the mattress subtree
+     *  startangle is something like 20
+     *  endangle is something like 70
+     *  Alo, Aup, Bup, Blo are the ids of these points respectively
+     *  position is the interactor state 0..1
+     *  additionalpoints can be empty (i.e. []) for the first test
+     *
+     *  5) call the interactor with position 0
+     *  --> look at the console to find out the original (position:0 angles)
+     *  --> the A angle is the one to be used for startangle
+     *
+     * 6) adjust startangle accordingly
+     *
+     * 7) use the tMove result to correctly change the matress position
+     *
+     *   // save initial matress position
+     *  let tPosition = IGX.API.GetPosition(child);
+     *  IGX.API.SetZRotation(child, -tMove.rotation);
+     *  IGX.API.SetPosition(child, {
+     *    x: tPosition.x + tMove.positionDifference.x,
+     *    y: tPosition.y + tMove.positionDifference.y,
+     *    z: tPosition.z + tMove.positionDifference.z
+     *    });
+     *
+     * NB: which set*Rotation is necessary depends one the spatial direction of the matress
+     *     also the sign might need flipping
+     *
+     *
+     *  Graphical example
+     *
+     *  simplest example:
+     *  Matress
+     *  Box
+     *  2 Screws Aup, Bup attached to matress
+     *  Aup is nearer to the origin (similar to rotation axis) of matress
+     *  2 Screws Alo, Blo attached to Box and unmoved
+     *
+     * #############################################################
+     * ##############################################################
+     * ##############################################################
+     * ########### Aup-------Bup ####################################
+     * org ######## \    ###    \   ################################
+     * ============= \ =========  \ ==============================
+     * |              \             \                            |
+     * |              Alo           Blo                          |
+     * |                                                         |
+     * |                                                         |
+     * |         BOX                                             |
+     * ===========================================================
+     *
+     * 8) Make sure the matress is correctly moving
+     * 9) Add rotation to bars (example for Alo-Aup)
+     *
+     *  let angdeg = FourBarHelper.berechneWinkelGegenHinten(tMove, Alo, Aup);
+     *  IGX.API.SetZRotation(okid, angdeg );  //stange A
+     *
+     * 10) Fix the angle, possibly you need another sign, or some offset like +180
+     * The first important step is to make setPosition(0) look like nothing changed
+     *
+     * 11) Do steps 9 + 10 for the other bar Blo-Bup
+     *
+     * +++++ Additional work for dampers ++++++++++++++++++++++++++++
+     *  12a) model a damper consisting of 2 parts, where the upper one is attached to Cup
+     *       and the lower one is attached to Clo
+     *
+     *  12b) Add top screws to the last paramter of calculatePosition() and replace the original call with that
+     *
+     *  let pts = [Cup]
+     *  const tMove = FourBarHelper.calculatePosition(child,startangle,endangle,Alo, Aup,Bup, Blo,position, pts);
+     *
+     *  13) intentionally left blank
+     *  14) now tMove also contains the new position of the additional point Cup
+     *
+     * #############################################################
+     * ##############################################################
+     * ##############################################################
+     * ########### Aup-------Bup ################## Cup #############
+     * org ######## \    ###    \   ############### | | #############
+     * ============= \ =========  \ =============== ||| ==========
+     * |              \             \                |           |
+     * |              Alo           Blo             Clo          |
+     * |                                                         |
+     * |                                                         |
+     * |         BOX                                             |
+     * ===========================================================
+     *
+     * 15) calculate the angle of Clo-Cup
+     *  let angdeg = FourBarHelper.berechneWinkelGegenHinten(tMove, Clo, Cup);
+     * 16) rotate the lower part attached to Clo accordingly
+     * 17) rotate the upper part attached to Cup by angdeg and tMove.rotation
+     *     as the base, i.e. matress is now also rotating itself
+     *
+     * For a rotated bed, the points have to like that:
+     *   ############################################################
+     * ##############################################################
+     * ##############################################################
+     * ############ Cup ################## Bup-------Aup ############
+     *  ########### | | ################  /    ###    /  ######## org
+     *   ========== ||| =============== / =========  / ==============
+     *   |           |                /             /               |
+     *   |          Clo              Blo           Alo              |
+     *   |                                                          |
+     *   |                                                          |
+     *   |       BOX                                                |
+     *   ============================================================
+     *
+     *
+     *
+     */
+    class FourBar {
+        static debug: boolean;
+        static dlog(...x: any[]): void;
+        /**
+         * Deprecated because it always works on non overwritten API
+         *
+         * Specialised fourbar algorithm
+         * @param mattressId       id of the main object to be rotated
+         * @param startAngleDeg    minimum angle between AloAup and BloAlo
+         * @param endAngleDeg      maximum angle between AloAup and BloAlo
+         * @param Alo              id of lower screw of vertical bar next to origin
+         * @param Aup              id of upper screw of vertical bar next to origin
+         * @param Bup              id of upper screw of vertical bar away from origin
+         * @param Blo              id of lower screw of vertical bar away from origin
+         * @param position         0...1 as usual in interactor
+         * @param topAttacheds     ids of screws attached to matress
+         * @param tLocalRoot       id of local root element for fourbar animation
+         */
+        static calculatePosition(mattressId: string, startAngleDeg: number, endAngleDeg: number, Alo: string, Aup: string, Bup: string, Blo: string, position: number, topAttacheds: string[], tLocalRoot?: string | undefined): IMove;
+        static calculateAngleAgainstBaseBack(tMove: IMove, slantbegin: string, slantend: string, tRoot: string, _api: any): number;
+    }
+    interface IMove {
+        rotation: number;
+        positionDifference: Float3;
+        topAttached: {
+            [key: string]: {
+                originalpos: Float3;
+                newpos: Float3;
+            };
+        };
+        baseLineDir: Float3;
+    }
+    interface IPlane {
+        point: Float3;
+        normal: Float3;
+    }
+    interface IRay {
+        origin: Float3;
+        direction: Float3;
+    }
+    /**
+     * Custom vector / matrix functions
+     */
+    class Util {
+        static factorOfDirectionFromRayToPlane(ray: IRay, plane: IPlane): number | null;
+        static intersectionPoint(ray: IRay, plane: IPlane): Float3 | null;
+        static rotatedVectorAaroundPointBbyNormalCangleRadR(a: Float3, b: Float3, n: Float3, ang: number): Float3;
+        /**
+         * returns the relative position of local object
+         * @param root the root node of local object
+         * @param node the node inside this object
+         */
+        static GetLocalPosition(root: string, node: string, _api: IGX._API): IGX.Float3;
+        /**
+         * returns the relative rotation of local object
+         * @param root the root node of local object
+         * @param node the node inside this object
+         */
+        static GetLocalRotation(root: string, node: string, _api: IGX._API): IG.Math.Euler;
+        /**
+         * returns the relative transformation of local object
+         * Returning Object[] consists of [0: Position as Vector3, 1: Rotation as Quaternion, 2: Scale as Vector3]
+         * @param root the root node of local object
+         * @param node the node inside this object
+         */
+        static GetLocalTransform(root: string, node: string, _api: IGX._API): Object[];
+        /**
+         *
+         * @param root the root node of local object
+         * @param baseNode the node you work with
+         * @param targetNode the node outside your workspace node
+         */
+        static GetRelativePosition(root: string, baseNode: string, targetNode: string, _api: any): IG.Math.Vector3;
+        /** @deprecated use IG.Math.Deg2Rad */
+        static DEG2RAD: number;
+        /** @deprecated use IG.Math.Rad2Deg */
+        static RAD2DEG: number;
+        /** @deprecated use IG.Math.Vector3.add */
+        static add(a: Float3, b: Float3): Float3;
+        /** @deprecated use IG.Math.Vector3.sub */
+        static sub(a: Float3, b: Float3): Float3;
+        /** @deprecated use IG.Math.Vector3.innerProduct */
+        static dot(a: Float3, b: Float3): number;
+        /** @deprecated use IG.Math.Vector3.magnitude */
+        static mag(a: Float3): number;
+        /** @deprecated use IG.Math.Vector3.crossProduct */
+        static cross(a: Float3, b: Float3): Float3;
+        /** @deprecated use IG.Math.Vector3.scalarMultiply */
+        static scale(num: number, a: Float3): Float3;
+        /** @deprecated use IG.Math.Vector3.normalize */
+        static normalize(a: Float3): Float3 | null;
+        /** @deprecated use IG.Math.Matrix3.multiplyWithVector3 */
+        static multMat(m: number[][], a: Float3): Float3;
+        /** @deprecated use IG.Math.Vector3.angleBetween */
+        static angleBetweenRad(u: Float3, v: Float3): number;
+        /** @deprecated use IG.Math.Matrix3.makeRotationMatrixFromNormalVector */
+        static rotationMatrix(rotationNormal: Float3, angRad: number): number[][];
+    }
+}
+declare module IGX.Std {
+    class XRangeRotator extends IGX.Core.Interactor {
+        absRotation: number;
+        nullAxis: IGX.Float3;
+        bAutoReset: boolean;
+        constructor(parameters: any);
+        SetPosition(position: any): void;
+        SetStagePosition(stage: number, position: number): void;
+        SingleTouchStart(touch: IGX.Core.Touch): void;
+        SingleTouchMotion(touch: IGX.Core.Touch): void;
+        SingleTouchEnd(touch: IGX.Core.Touch): void;
+        ApplyMotion(touch: IGX.Core.Touch, isFinal: boolean): void;
+    }
+}
+declare module IGX.Std {
+    class XRangeTranslator extends IGX.Core.Interactor {
+        osCoords: any;
+        startPosition: number;
+        bAutoReset: boolean;
+        constructor(parameters: any);
+        SetPosition(position: any): void;
+        SetStagePosition(stage: number, position: number): void;
+        SingleTouchStart(touch: IGX.Core.Touch): void;
+        SingleTouchMotion(touch: IGX.Core.Touch): void;
+        SingleTouchEnd(touch: IGX.Core.Touch): void;
+        ApplyMotion(touch: IGX.Core.Touch, isFinal: boolean): void;
+    }
+}
+declare module IGX.Std {
+    class XRasterRotator extends IGX.Core.Interactor {
+        absRotation: number;
+        nullAxis: Float3;
+        bAutoReset: boolean;
+        constructor(parameters: any);
+        SetPosition(position: any): void;
+        SetStagePosition(stage: number, position: number): void;
+        SingleTouchStart(touch: IGX.Core.Touch): void;
+        SingleTouchMotion(touch: IGX.Core.Touch): void;
+        SingleTouchEnd(touch: IGX.Core.Touch): void;
+        ApplyMotion(touch: IGX.Core.Touch, isFinal: boolean): void;
+    }
+}
+declare module IGX.Std {
+    class XRasterTranslator extends IGX.Core.Interactor {
+        osCoords: Float3;
+        startPosition: number;
+        bAutoReset: boolean;
+        constructor(parameters: any);
+        SetPosition(position: any): void;
+        SetStagePosition(stage: number, position: number): void;
+        SingleTouchStart(touch: IGX.Core.Touch): void;
+        SingleTouchMotion(touch: IGX.Core.Touch): void;
+        SingleTouchEnd(touch: IGX.Core.Touch): void;
+        ApplyMotion(touch: IGX.Core.Touch, isFinal: boolean): void;
+    }
+}
+declare module IGX.Std {
+    class XValueRotator extends IGX.Core.Interactor {
+        absRotation: number;
+        nullAxis: Float3;
+        constructor(parameters: any);
+        SetPosition(position: any): void;
+        SingleTouchStart(touch: IGX.Core.Touch): void;
+        SingleTouchMotion(touch: IGX.Core.Touch): void;
+        SingleTouchEnd(touch: IGX.Core.Touch): void;
+        ApplyMotion(touch: IGX.Core.Touch, isFinal: boolean): void;
+    }
+}
+declare module IGX.Std {
+    class XValueTranslator extends IGX.Core.Interactor {
+        osCoords: Float3;
+        startPosition: number;
+        constructor(parameters: any);
+        SetPosition(position: any): void;
+        SingleTouchStart(touch: IGX.Core.Touch): void;
+        SingleTouchMotion(touch: IGX.Core.Touch): void;
+        SingleTouchEnd(touch: IGX.Core.Touch): void;
+        ApplyMotion(touch: IGX.Core.Touch, isFinal: boolean): void;
+    }
+}
+declare module IGX.Std {
+    class YRangeRotator extends IGX.Core.Interactor {
+        absRotation: number;
+        nullAxis: Float3;
+        bAutoReset: boolean;
+        constructor(parameters: any);
+        SetPosition(position: any): void;
+        SetStagePosition(stage: number, position: number): void;
+        SingleTouchStart(touch: IGX.Core.Touch): void;
+        SingleTouchMotion(touch: IGX.Core.Touch): void;
+        SingleTouchEnd(touch: IGX.Core.Touch): void;
+        ApplyMotion(touch: IGX.Core.Touch, isFinal: boolean): void;
+    }
+}
+declare module IGX.Std {
+    class YRangeTranslator extends IGX.Core.Interactor {
+        osCoords: Float3;
+        startPosition: number;
+        bAutoReset: boolean;
+        constructor(parameters: any);
+        SetPosition(position: any): void;
+        SetStagePosition(stage: number, position: number): void;
+        SingleTouchStart(touch: IGX.Core.Touch): void;
+        SingleTouchMotion(touch: IGX.Core.Touch): void;
+        SingleTouchEnd(touch: IGX.Core.Touch): void;
+        ApplyMotion(touch: IGX.Core.Touch, isFinal: boolean): void;
+    }
+}
+declare module IGX.Std {
+    class YRasterRotator extends IGX.Core.Interactor {
+        absRotation: number;
+        nullAxis: Float3;
+        bAutoReset: boolean;
+        constructor(parameters: any);
+        SetPosition(position: any): void;
+        SetStagePosition(stage: number, position: number): void;
+        SingleTouchStart(touch: IGX.Core.Touch): void;
+        SingleTouchMotion(touch: IGX.Core.Touch): void;
+        SingleTouchEnd(touch: IGX.Core.Touch): void;
+        ApplyMotion(touch: IGX.Core.Touch, isFinal: boolean): void;
+    }
+}
+declare module IGX.Std {
+    class YRasterTranslator extends IGX.Core.Interactor {
+        osCoords: Float3;
+        startPosition: number;
+        bAutoReset: boolean;
+        constructor(parameters: any);
+        SetPosition(position: any): void;
+        SetStagePosition(stage: number, position: number): void;
+        SingleTouchStart(touch: IGX.Core.Touch): void;
+        SingleTouchMotion(touch: IGX.Core.Touch): void;
+        SingleTouchEnd(touch: IGX.Core.Touch): void;
+        ApplyMotion(touch: IGX.Core.Touch, isFinal: boolean): void;
+    }
+}
+declare module IGX.Std {
+    class YValueRotator extends IGX.Core.Interactor {
+        absRotation: number;
+        nullAxis: Float3;
+        constructor(parameters: any);
+        SetPosition(position: any): void;
+        SingleTouchStart(touch: IGX.Core.Touch): void;
+        SingleTouchMotion(touch: IGX.Core.Touch): void;
+        SingleTouchEnd(touch: IGX.Core.Touch): void;
+        ApplyMotion(touch: IGX.Core.Touch, isFinal: boolean): void;
+    }
+}
+declare module IGX.Std {
+    class YValueTranslator extends IGX.Core.Interactor {
+        osCoords: Float3;
+        startPosition: number;
+        constructor(parameters: any);
+        SetPosition(position: any): void;
+        SingleTouchStart(touch: IGX.Core.Touch): void;
+        SingleTouchMotion(touch: IGX.Core.Touch): void;
+        SingleTouchEnd(touch: IGX.Core.Touch): void;
+        ApplyMotion(touch: IGX.Core.Touch, isFinal: boolean): void;
+    }
+}
+declare module IGX.Std {
+    class ZRangeRotator extends IGX.Core.Interactor {
+        absRotation: number;
+        nullAxis: Float3;
+        bAutoReset: boolean;
+        constructor(parameters: any);
+        SetPosition(position: any): void;
+        SetStagePosition(stage: number, position: number): void;
+        SingleTouchStart(touch: IGX.Core.Touch): void;
+        SingleTouchMotion(touch: IGX.Core.Touch): void;
+        SingleTouchEnd(touch: IGX.Core.Touch): void;
+        ApplyMotion(touch: IGX.Core.Touch, isFinal: boolean): void;
+    }
+}
+declare module IGX.Std {
+    class ZRangeTranslator extends IGX.Core.Interactor {
+        osCoords: Float3;
+        startPosition: number;
+        bAutoReset: boolean;
+        constructor(parameters: any);
+        SetPosition(position: any): void;
+        SetStagePosition(stage: number, position: number): void;
+        SingleTouchStart(touch: IGX.Core.Touch): void;
+        SingleTouchMotion(touch: IGX.Core.Touch): void;
+        SingleTouchEnd(touch: IGX.Core.Touch): void;
+        ApplyMotion(touch: IGX.Core.Touch, isFinal: boolean): void;
+    }
+}
+declare module IGX.Std {
+    class ZRasterRotator extends IGX.Core.Interactor {
+        absRotation: number;
+        nullAxis: Float3;
+        bAutoReset: boolean;
+        constructor(parameters: any);
+        SetPosition(position: any): void;
+        SetStagePosition(stage: number, position: number): void;
+        SingleTouchStart(touch: IGX.Core.Touch): void;
+        SingleTouchMotion(touch: IGX.Core.Touch): void;
+        SingleTouchEnd(touch: IGX.Core.Touch): void;
+        ApplyMotion(touch: IGX.Core.Touch, isFinal: boolean): void;
+    }
+}
+declare module IGX.Std {
+    class ZRasterTranslator extends IGX.Core.Interactor {
+        osCoords: Float3;
+        startPosition: number;
+        bAutoReset: boolean;
+        constructor(parameters: any);
+        SetPosition(position: any): void;
+        SetStagePosition(stage: number, position: number): void;
+        SingleTouchStart(touch: IGX.Core.Touch): void;
+        SingleTouchMotion(touch: IGX.Core.Touch): void;
+        SingleTouchEnd(touch: IGX.Core.Touch): void;
+        ApplyMotion(touch: IGX.Core.Touch, isFinal: boolean): void;
+    }
+}
+declare module IGX.Std {
+    class ZValueRotator extends IGX.Core.Interactor {
+        absRotation: number;
+        nullAxis: Float3;
+        constructor(parameters: any);
+        SetPosition(position: any): void;
+        SingleTouchStart(touch: IGX.Core.Touch): void;
+        SingleTouchMotion(touch: IGX.Core.Touch): void;
+        SingleTouchEnd(touch: IGX.Core.Touch): void;
+        ApplyMotion(touch: IGX.Core.Touch, isFinal: boolean): void;
+    }
+}
+declare module IGX.Std {
+    class ZValueTranslator extends IGX.Core.Interactor {
+        osCoords: Float3;
+        startPosition: number;
+        constructor(parameters: any);
+        SetPosition(position: any): void;
+        SingleTouchStart(touch: IGX.Core.Touch): void;
+        SingleTouchMotion(touch: IGX.Core.Touch): void;
+        SingleTouchEnd(touch: IGX.Core.Touch): void;
+        ApplyMotion(touch: IGX.Core.Touch, isFinal: boolean): void;
+    }
+}
+declare module IGX.Std {
+    class BasicLinearInteractor extends IGX.Core.Interactor {
+        constructor(parameters: {
+            [key: string]: any;
+        });
+        SetPosition(position: string): void;
+        private ApplyValue;
+        SetStagePosition(stage: number, position: number): void;
+    }
+}
+declare module IGX.Std {
+    class DeformationInteractor extends IGX.Core.Interactor {
+        bAutoReset: boolean;
+        constructor(parameters: any);
+        SetPosition(position: string): void;
+        SetStagePosition(stage: number, position: number): void;
+    }
+}
+declare module IGX.Std {
+    class OffsetRotator extends IGX.Core.Interactor {
+        position: Float3;
+        bAutoReset: boolean;
+        constructor(parameters: any);
+        SetPosition(position: string): void;
+        setPosition(position: number): void;
+        SetStagePosition(stage: number, position: number): void;
+    }
+}
+declare module IGX.Std {
+    class VisibilityInteractor extends IGX.Core.Interactor {
+        constructor(parameters: any);
+        SetPosition(position: string): void;
+        SetStagePosition(stage: number, position: number): void;
+    }
+}
+declare module IGX.Std {
+    /**
+     * An Interactor for JSON animations with inverse kinematics.
+     * Needs AnimationInteractor!
+     */
+    class KinematicsInteractor {
+        private _MultiTargetChain;
+        private _MultiTargetChainStructure;
+        private _Chain;
+        private _ChainList;
+        private _ComponentId;
+        private _MaxIteration;
+        private IGX_API;
+        constructor(param: any, api: any);
+        /**
+         * Solves the kinematic problem
+         * Also writes the resultsvia draw()
+         * @param kinematicComponentId path to interactor
+         * @param params animation interactor params
+         * @param movedJoints already animated components that shouldnt be affected by the kinematic solver
+         */
+        KinematicSolver(kinematicComponentId: string, params: string[], movedJoints: string[], _api: any): void;
+        /**
+         * assign data structure and check consistency for each chain
+         * @param _C chain
+         * @param params animation interactor params
+         * @param movedJoints already animated components that shouldnt be affected by the kinematic solver
+         * @param tR "t1__oX." = path to interactor component
+         * @param tRoot "t1__"
+         */
+        private buildDataStructure;
+        /**
+         * Checks given nodes if they have a relation
+         * @param parentNode ancestor
+         * @param childNode descendant
+         */
+        private isParent;
+        /**
+         * returns the base vector
+         * @param idx joint index
+         */
+        private getGeometryBase;
+        /**
+         * returns the euler angles for given joint
+         * @param base geometry base
+         * @param eye starting vector
+         * @param target where to look at
+         */
+        private getBoneEuler;
+        /**
+         * checks if all constraints are defined for given joint
+         * @param idx joint index
+         */
+        private isConstraintActive;
+        private getChainLevel;
+        /**
+         * Returns all end effectors sorted by parent path of this level
+         * @param level the level where to look for end effectors
+         */
+        private getEndEffectors;
+        private getJoint;
+        private isFollowingJoint;
+        /**
+         * Algorithm for one chain and one target
+         * @param tR path to root component
+         */
+        private singleTargetKinematics;
+        /**
+         * Algorithm for multiple targets and one chain divided into multiple subchains
+         * @param tR path to root component
+         */
+        private multiTargetKinematics;
+        private multiTargetSolve;
+        /**
+         * set relative positions and apply rotations on the chain
+         * @param tR path to root component
+         */
+        private draw;
+        /**
+         * Solves the centroid problem
+         * @param chainList end effector list
+         */
+        private solveCentroid;
+        /**
+         * simple inverse kinematics solver based on the FABRIK method
+         * see: http://www.andreasaristidou.com/FABRIK.html
+         */
+        private solve;
+        /**
+         * FABRIK method - backwards
+         */
+        private backward;
+        /**
+         * FABRIK method - forwards
+         */
+        private forward;
+        /**
+         * check constrains and correct new pos if necessary
+         * @param calc Vector3 - (new position tail - new position head)
+         * @param line Vector3 - convex cone (unit vector of (new Tail - new Head))
+         * @param idx - current joint of chain
+         */
+        private constrain;
+    }
+}
+declare module IGX.Std {
+    class Cache {
+        private rootId;
+        private stepSize;
+        private subNodes;
+        private animation;
+        private interactorParams;
+        private cachedScenes;
+        private steps;
+        private date;
+        constructor(rootId: string, stepSize: number, subNodes: string[], animation: Animation, interactorParams: {
+            [t: string]: any;
+        });
+        /**
+         * set shadow scene at position 0
+         *
+         * @param {ShadowScene} s
+         * @memberof Cache
+         */
+        initialize(s: ShadowScene): void;
+        debugInfo(): void;
+        getStepSize(): number;
+        getCache(): ShadowScene[];
+        setCache(position: number, scene: ShadowScene): void;
+        clearCache(): void;
+        interpolate(position: number): ShadowScene;
+    }
+}
+declare module IGX.Std {
+    /** An Interactor for JSON animations */
+    class AnimationInteractor extends IGX.Core.Interactor {
+        static PARAM_COUNT: number;
+        params: string[];
+        animation: Animation;
+        backwardAnimation?: Animation;
+        kinematics: KinematicsInteractor;
+        backwardKinematics: KinematicsInteractor;
+        private lastPositionForIntermediateCalculationOnly;
+        private useCache;
+        private stepSize;
+        private forwardCache;
+        private forwardCache_debug;
+        private backwardsCache;
+        private nodesToBeCached;
+        private absoluteNodesToBeCached;
+        private useDebugCache;
+        private debugapi;
+        private d;
+        private IGX_API;
+        Debug: boolean;
+        constructor(parameters: any);
+        setUseCache(value: boolean): void;
+        private PrepAnimation;
+        SetPosition(position: "Start" | "End"): void;
+        SetStagePosition(stage: number, position: number, backwards?: boolean): void;
+        debug_compareShadows(a: ShadowScene, b: ShadowScene): void;
+        /**
+         * Calculates auxilaries left and right of position
+         * via setStagePositionInternal and writes them into cache
+         *
+         * @param position number between 0 and 1 including the boundaries
+         */
+        private calculateMissing;
+        private calculate___SetStagePositionInternal;
+    }
+    const Test1: Animation;
+}
+declare module IGX.Std {
+    /**
+     * Empty interactor to be used as placeholder
+     *
+     * @export
+     * @class EmptyInteractor
+     * @extends {IGX.Core.Interactor}
+     */
+    class EmptyInteractor extends IGX.Core.Interactor {
+        constructor(parameters: any);
+        SetPosition(position: string): void;
+        SetStagePosition(stage: number, position: number): void;
+    }
+}