@combeenation/3d-viewer 0.0.1-types

package/dist/types/node_modules/@babylonjs/core/Actions/abstractActionManager.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Abstract class used to decouple action Manager from scene and meshes.
+ * Do not instantiate.
+ * @see https://doc.babylonjs.com/how_to/how_to_use_actions
+ */
+export class AbstractActionManager {
+    /**
+     * Does exist one action manager with at least one trigger
+     **/
+    static get HasTriggers(): boolean;
+    /**
+     * Does exist one action manager with at least one pick trigger
+     **/
+    static get HasPickTriggers(): boolean;
+    /**
+     * Does exist one action manager that handles actions of a given trigger
+     * @param trigger defines the trigger to be tested
+     * @returns a boolean indicating whether the trigger is handled by at least one action manager
+     **/
+    static HasSpecificTrigger(trigger: any): boolean;
+    /** Gets the cursor to use when hovering items */
+    hoverCursor: string;
+    /** Gets the list of actions */
+    actions: any[];
+    /**
+     * Gets or sets a boolean indicating that the manager is recursive meaning that it can trigger action from children
+     */
+    isRecursive: boolean;
+}
+export namespace AbstractActionManager {
+    const Triggers: {};
+}

package/dist/types/node_modules/@babylonjs/core/Actions/action.d.ts

@@ -0,0 +1,100 @@
+/**
+ * The action to be carried out following a trigger
+ * @see https://doc.babylonjs.com/how_to/how_to_use_actions#available-actions
+ */
+export class Action {
+    /**
+     * Creates a new Action
+     * @param triggerOptions the trigger, with or without parameters, for the action
+     * @param condition an optional determinant of action
+     */
+    constructor(triggerOptions: any, condition: any);
+    triggerOptions: any;
+    /**
+     * An event triggered prior to action being executed.
+     */
+    onBeforeExecuteObservable: Observable<any>;
+    trigger: any;
+    _triggerParameter: any;
+    _nextActiveAction: Action;
+    _condition: any;
+    /**
+     * Internal only
+     * @internal
+     */
+    _prepare(): void;
+    /**
+     * Gets the trigger parameter
+     * @returns the trigger parameter
+     */
+    getTriggerParameter(): any;
+    /**
+     * Sets the trigger parameter
+     * @param value defines the new trigger parameter
+     */
+    setTriggerParameter(value: any): void;
+    /**
+     * Internal only - Returns if the current condition allows to run the action
+     * @internal
+     */
+    _evaluateConditionForCurrentFrame(): any;
+    /**
+     * Internal only - executes current action event
+     * @internal
+     */
+    _executeCurrent(evt: any): void;
+    /**
+     * Execute placeholder for child classes
+     * @param evt optional action event
+     */
+    execute(evt: any): void;
+    /**
+     * Skips to next active action
+     */
+    skipToNextActiveAction(): void;
+    /**
+     * Adds action to chain of actions, may be a DoNothingAction
+     * @param action defines the next action to execute
+     * @returns The action passed in
+     * @see https://www.babylonjs-playground.com/#1T30HR#0
+     */
+    then(action: any): any;
+    _child: any;
+    /**
+     * Internal only
+     * @internal
+     */
+    _getProperty(propertyPath: any): any;
+    /**
+     * @internal
+     */
+    _getEffectiveTarget(target: any, propertyPath: any): any;
+    /**
+     * Serialize placeholder for child classes
+     * @param parent of child
+     * @returns the serialized object
+     */
+    serialize(parent: any): void;
+    /**
+     * Internal only called by serialize
+     * @internal
+     */
+    _serialize(serializedAction: any, parent: any): any;
+}
+export namespace Action {
+    /**
+     * Internal only
+     * @internal
+     */
+    function _SerializeValueAsString(value: any): any;
+    /**
+     * Internal only
+     * @internal
+     */
+    function _GetTargetProperty(target: any): {
+        name: string;
+        targetType: string;
+        value: any;
+    };
+}
+import { Observable } from "../Misc/observable.js";

package/dist/types/node_modules/@babylonjs/core/Actions/actionEvent.d.ts

@@ -0,0 +1,54 @@
+/**
+ * ActionEvent is the event being sent when an action is triggered.
+ */
+export class ActionEvent {
+    /**
+     * Helper function to auto-create an ActionEvent from a source mesh.
+     * @param source The source mesh that triggered the event
+     * @param evt The original (browser) event
+     * @param additionalData additional data for the event
+     * @returns the new ActionEvent
+     */
+    static CreateNew(source: any, evt: any, additionalData: any): ActionEvent;
+    /**
+     * Helper function to auto-create an ActionEvent from a source sprite
+     * @param source The source sprite that triggered the event
+     * @param scene Scene associated with the sprite
+     * @param evt The original (browser) event
+     * @param additionalData additional data for the event
+     * @returns the new ActionEvent
+     */
+    static CreateNewFromSprite(source: any, scene: any, evt: any, additionalData: any): ActionEvent;
+    /**
+     * Helper function to auto-create an ActionEvent from a scene. If triggered by a mesh use ActionEvent.CreateNew
+     * @param scene the scene where the event occurred
+     * @param evt The original (browser) event
+     * @returns the new ActionEvent
+     */
+    static CreateNewFromScene(scene: any, evt: any): ActionEvent;
+    /**
+     * Helper function to auto-create an ActionEvent from a primitive
+     * @param prim defines the target primitive
+     * @param pointerPos defines the pointer position
+     * @param evt The original (browser) event
+     * @param additionalData additional data for the event
+     * @returns the new ActionEvent
+     */
+    static CreateNewFromPrimitive(prim: any, pointerPos: any, evt: any, additionalData: any): ActionEvent;
+    /**
+     * Creates a new ActionEvent
+     * @param source The mesh or sprite that triggered the action
+     * @param pointerX The X mouse cursor position at the time of the event
+     * @param pointerY The Y mouse cursor position at the time of the event
+     * @param meshUnderPointer The mesh that is currently pointed at (can be null)
+     * @param sourceEvent the original (browser) event that triggered the ActionEvent
+     * @param additionalData additional data for the event
+     */
+    constructor(source: any, pointerX: any, pointerY: any, meshUnderPointer: any, sourceEvent: any, additionalData: any);
+    source: any;
+    pointerX: any;
+    pointerY: any;
+    meshUnderPointer: any;
+    sourceEvent: any;
+    additionalData: any;
+}

package/dist/types/node_modules/@babylonjs/core/Actions/actionManager.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Action Manager manages all events to be triggered on a given mesh or the global scene.
+ * A single scene can have many Action Managers to handle predefined actions on specific meshes.
+ * @see https://doc.babylonjs.com/how_to/how_to_use_actions
+ */
+export class ActionManager extends AbstractActionManager {
+    /**
+     * Creates a new ActionManager from a JSON data
+     * @param parsedActions defines the JSON data to read from
+     * @param object defines the hosting mesh
+     * @param scene defines the hosting scene
+     */
+    static Parse(parsedActions: any, object: any, scene: any): void;
+    /**
+     * Get a trigger name by index
+     * @param trigger defines the trigger index
+     * @returns a trigger name
+     */
+    static GetTriggerName(trigger: any): "" | "NothingTrigger" | "OnPickTrigger" | "OnLeftPickTrigger" | "OnRightPickTrigger" | "OnCenterPickTrigger" | "OnPickDownTrigger" | "OnPickUpTrigger" | "OnLongPressTrigger" | "OnPointerOverTrigger" | "OnPointerOutTrigger" | "OnEveryFrameTrigger" | "OnIntersectionEnterTrigger" | "OnIntersectionExitTrigger" | "OnKeyDownTrigger" | "OnKeyUpTrigger" | "OnPickOutTrigger";
+    /**
+     * Creates a new action manager
+     * @param scene defines the hosting scene
+     */
+    constructor(scene: any);
+    _scene: any;
+    /**
+     * Gets hosting scene
+     * @returns the hosting scene
+     */
+    getScene(): any;
+    /**
+     * Does this action manager handles actions of any of the given triggers
+     * @param triggers defines the triggers to be tested
+     * @returns a boolean indicating whether one (or more) of the triggers is handled
+     */
+    hasSpecificTriggers(triggers: any): boolean;
+    /**
+     * Does this action manager handles actions of any of the given triggers. This function takes two arguments for
+     * speed.
+     * @param triggerA defines the trigger to be tested
+     * @param triggerB defines the trigger to be tested
+     * @returns a boolean indicating whether one (or more) of the triggers is handled
+     */
+    hasSpecificTriggers2(triggerA: any, triggerB: any): boolean;
+    /**
+     * Does this action manager handles actions of a given trigger
+     * @param trigger defines the trigger to be tested
+     * @param parameterPredicate defines an optional predicate to filter triggers by parameter
+     * @returns whether the trigger is handled
+     */
+    hasSpecificTrigger(trigger: any, parameterPredicate: any): boolean;
+    /**
+     * Registers an action to this action manager
+     * @param action defines the action to be registered
+     * @returns the action amended (prepared) after registration
+     */
+    registerAction(action: any): any;
+    /**
+     * Unregisters an action to this action manager
+     * @param action defines the action to be unregistered
+     * @returns a boolean indicating whether the action has been unregistered
+     */
+    unregisterAction(action: any): boolean;
+    /**
+     * Process a specific trigger
+     * @param trigger defines the trigger to process
+     * @param evt defines the event details to be processed
+     */
+    processTrigger(trigger: any, evt: any): void;
+    /**
+     * @internal
+     */
+    _getEffectiveTarget(target: any, propertyPath: any): any;
+    /**
+     * @internal
+     */
+    _getProperty(propertyPath: any): any;
+    /**
+     * Serialize this manager to a JSON object
+     * @param name defines the property name to store this manager
+     * @returns a JSON representation of this manager
+     */
+    serialize(name: any): {
+        children: any[];
+        name: any;
+        type: number;
+        properties: any[];
+    };
+}
+export namespace ActionManager {
+    const NothingTrigger: number;
+    const OnPickTrigger: number;
+    const OnLeftPickTrigger: number;
+    const OnRightPickTrigger: number;
+    const OnCenterPickTrigger: number;
+    const OnPickDownTrigger: number;
+    const OnDoublePickTrigger: number;
+    const OnPickUpTrigger: number;
+    const OnPickOutTrigger: number;
+    const OnLongPressTrigger: number;
+    const OnPointerOverTrigger: number;
+    const OnPointerOutTrigger: number;
+    const OnEveryFrameTrigger: number;
+    const OnIntersectionEnterTrigger: number;
+    const OnIntersectionExitTrigger: number;
+    const OnKeyDownTrigger: number;
+    const OnKeyUpTrigger: number;
+}
+import { AbstractActionManager } from "./abstractActionManager.js";

package/dist/types/node_modules/@babylonjs/core/Actions/condition.d.ts

@@ -0,0 +1,141 @@
+/**
+ * A Condition applied to an Action
+ */
+export class Condition {
+    /**
+     * Creates a new Condition
+     * @param actionManager the manager of the action the condition is applied to
+     */
+    constructor(actionManager: any);
+    _actionManager: any;
+    /**
+     * Check if the current condition is valid
+     * @returns a boolean
+     */
+    isValid(): boolean;
+    /**
+     * @internal
+     */
+    _getProperty(propertyPath: any): any;
+    /**
+     * @internal
+     */
+    _getEffectiveTarget(target: any, propertyPath: any): any;
+    /**
+     * Serialize placeholder for child classes
+     * @returns the serialized object
+     */
+    serialize(): void;
+    /**
+     * @internal
+     */
+    _serialize(serializedCondition: any): {
+        type: number;
+        children: never[];
+        name: any;
+        properties: any;
+    };
+}
+/**
+ * Defines specific conditional operators as extensions of Condition
+ */
+export class ValueCondition extends Condition {
+    /**
+     * returns the number for IsEqual
+     */
+    static get IsEqual(): number;
+    /**
+     * Returns the number for IsDifferent
+     */
+    static get IsDifferent(): number;
+    /**
+     * Returns the number for IsGreater
+     */
+    static get IsGreater(): number;
+    /**
+     * Returns the number for IsLesser
+     */
+    static get IsLesser(): number;
+    /**
+     * Gets the name of the conditional operator for the ValueCondition
+     * @param operator the conditional operator
+     * @returns the name
+     */
+    static GetOperatorName(operator: any): "" | "IsEqual" | "IsDifferent" | "IsGreater" | "IsLesser";
+    /**
+     * Creates a new ValueCondition
+     * @param actionManager manager for the action the condition applies to
+     * @param target for the action
+     * @param propertyPath path to specify the property of the target the conditional operator uses
+     * @param value the value compared by the conditional operator against the current value of the property
+     * @param operator the conditional operator, default ValueCondition.IsEqual
+     */
+    constructor(actionManager: any, target: any, propertyPath: any, value: any, operator?: number);
+    propertyPath: any;
+    value: any;
+    operator: number;
+    _target: any;
+    _effectiveTarget: any;
+    _property: any;
+    /**
+     * Compares the given value with the property value for the specified conditional operator
+     * @returns the result of the comparison
+     */
+    isValid(): any;
+    /**
+     * Serialize the ValueCondition into a JSON compatible object
+     * @returns serialization object
+     */
+    serialize(): {
+        type: number;
+        children: never[];
+        name: any;
+        properties: any;
+    };
+}
+export namespace ValueCondition {
+    const _IsEqual: number;
+    const _IsDifferent: number;
+    const _IsGreater: number;
+    const _IsLesser: number;
+}
+/**
+ * Defines a predicate condition as an extension of Condition
+ */
+export class PredicateCondition extends Condition {
+    /**
+     * Creates a new PredicateCondition
+     * @param actionManager manager for the action the condition applies to
+     * @param predicate defines the predicate function used to validate the condition
+     */
+    constructor(actionManager: any, predicate: any);
+    predicate: any;
+    /**
+     * @returns the validity of the predicate condition
+     */
+    isValid(): any;
+}
+/**
+ * Defines a state condition as an extension of Condition
+ */
+export class StateCondition extends Condition {
+    /**
+     * Creates a new StateCondition
+     * @param actionManager manager for the action the condition applies to
+     * @param target of the condition
+     * @param value to compare with target state
+     */
+    constructor(actionManager: any, target: any, value: any);
+    value: any;
+    _target: any;
+    /**
+     * Serialize the StateCondition into a JSON compatible object
+     * @returns serialization object
+     */
+    serialize(): {
+        type: number;
+        children: never[];
+        name: any;
+        properties: any;
+    };
+}

package/dist/types/node_modules/@babylonjs/core/Actions/directActions.d.ts

@@ -0,0 +1,212 @@
+/**
+ * This defines an action responsible to toggle a boolean once triggered.
+ * @see https://doc.babylonjs.com/how_to/how_to_use_actions
+ */
+export class SwitchBooleanAction extends Action {
+    /**
+     * Instantiate the action
+     * @param triggerOptions defines the trigger options
+     * @param target defines the object containing the boolean
+     * @param propertyPath defines the path to the boolean property in the target object
+     * @param condition defines the trigger related conditions
+     */
+    constructor(triggerOptions: any, target: any, propertyPath: any, condition: any);
+    propertyPath: any;
+    _target: any;
+    _effectiveTarget: any;
+    _property: string | undefined;
+    /**
+     * Execute the action toggle the boolean value.
+     */
+    execute(): void;
+}
+/**
+ * This defines an action responsible to set a the state field of the target
+ *  to a desired value once triggered.
+ * @see https://doc.babylonjs.com/how_to/how_to_use_actions
+ */
+export class SetStateAction extends Action {
+    /**
+     * Instantiate the action
+     * @param triggerOptions defines the trigger options
+     * @param target defines the object containing the state property
+     * @param value defines the value to store in the state field
+     * @param condition defines the trigger related conditions
+     */
+    constructor(triggerOptions: any, target: any, value: any, condition: any);
+    value: any;
+    _target: any;
+    /**
+     * Execute the action and store the value on the target state property.
+     */
+    execute(): void;
+}
+/**
+ * This defines an action responsible to set a property of the target
+ *  to a desired value once triggered.
+ * @see https://doc.babylonjs.com/how_to/how_to_use_actions
+ */
+export class SetValueAction extends Action {
+    /**
+     * Instantiate the action
+     * @param triggerOptions defines the trigger options
+     * @param target defines the object containing the property
+     * @param propertyPath defines the path of the property to set in the target
+     * @param value defines the value to set in the property
+     * @param condition defines the trigger related conditions
+     */
+    constructor(triggerOptions: any, target: any, propertyPath: any, value: any, condition: any);
+    propertyPath: any;
+    value: any;
+    _target: any;
+    _effectiveTarget: any;
+    _property: string | undefined;
+    /**
+     * Execute the action and set the targeted property to the desired value.
+     */
+    execute(): void;
+}
+/**
+ * This defines an action responsible to increment the target value
+ *  to a desired value once triggered.
+ * @see https://doc.babylonjs.com/how_to/how_to_use_actions
+ */
+export class IncrementValueAction extends Action {
+    /**
+     * Instantiate the action
+     * @param triggerOptions defines the trigger options
+     * @param target defines the object containing the property
+     * @param propertyPath defines the path of the property to increment in the target
+     * @param value defines the value value we should increment the property by
+     * @param condition defines the trigger related conditions
+     */
+    constructor(triggerOptions: any, target: any, propertyPath: any, value: any, condition: any);
+    propertyPath: any;
+    value: any;
+    _target: any;
+    _effectiveTarget: any;
+    _property: string | undefined;
+    /**
+     * Execute the action and increment the target of the value amount.
+     */
+    execute(): void;
+}
+/**
+ * This defines an action responsible to start an animation once triggered.
+ * @see https://doc.babylonjs.com/how_to/how_to_use_actions
+ */
+export class PlayAnimationAction extends Action {
+    /**
+     * Instantiate the action
+     * @param triggerOptions defines the trigger options
+     * @param target defines the target animation or animation name
+     * @param from defines from where the animation should start (animation frame)
+     * @param to defines where the animation should stop (animation frame)
+     * @param loop defines if the animation should loop or stop after the first play
+     * @param condition defines the trigger related conditions
+     */
+    constructor(triggerOptions: any, target: any, from: any, to: any, loop: any, condition: any);
+    from: any;
+    to: any;
+    loop: any;
+    _target: any;
+    /**
+     * Execute the action and play the animation.
+     */
+    execute(): void;
+}
+/**
+ * This defines an action responsible to stop an animation once triggered.
+ * @see https://doc.babylonjs.com/how_to/how_to_use_actions
+ */
+export class StopAnimationAction extends Action {
+    /**
+     * Instantiate the action
+     * @param triggerOptions defines the trigger options
+     * @param target defines the target animation or animation name
+     * @param condition defines the trigger related conditions
+     */
+    constructor(triggerOptions: any, target: any, condition: any);
+    _target: any;
+    /**
+     * Execute the action and stop the animation.
+     */
+    execute(): void;
+}
+/**
+ * This defines an action responsible that does nothing once triggered.
+ * @see https://doc.babylonjs.com/how_to/how_to_use_actions
+ */
+export class DoNothingAction extends Action {
+    /**
+     * Instantiate the action
+     * @param triggerOptions defines the trigger options
+     * @param condition defines the trigger related conditions
+     */
+    constructor(triggerOptions: number | undefined, condition: any);
+    /**
+     * Execute the action and do nothing.
+     */
+    execute(): void;
+}
+/**
+ * This defines an action responsible to trigger several actions once triggered.
+ * @see https://doc.babylonjs.com/how_to/how_to_use_actions
+ */
+export class CombineAction extends Action {
+    /**
+     * Instantiate the action
+     * @param triggerOptions defines the trigger options
+     * @param children defines the list of aggregated animations to run
+     * @param condition defines the trigger related conditions
+     * @param enableChildrenConditions defines if the children actions conditions should be check before execution
+     */
+    constructor(triggerOptions: any, children: any, condition: any, enableChildrenConditions?: boolean);
+    children: any;
+    enableChildrenConditions: boolean;
+    /**
+     * Execute the action and executes all the aggregated actions.
+     * @param evt
+     */
+    execute(evt: any): void;
+}
+/**
+ * This defines an action responsible to run code (external event) once triggered.
+ * @see https://doc.babylonjs.com/how_to/how_to_use_actions
+ */
+export class ExecuteCodeAction extends Action {
+    /**
+     * Instantiate the action
+     * @param triggerOptions defines the trigger options
+     * @param func defines the callback function to run
+     * @param condition defines the trigger related conditions
+     */
+    constructor(triggerOptions: any, func: any, condition: any);
+    func: any;
+    /**
+     * Execute the action and run the attached code.
+     * @param evt
+     */
+    execute(evt: any): void;
+}
+/**
+ * This defines an action responsible to set the parent property of the target once triggered.
+ * @see https://doc.babylonjs.com/how_to/how_to_use_actions
+ */
+export class SetParentAction extends Action {
+    /**
+     * Instantiate the action
+     * @param triggerOptions defines the trigger options
+     * @param target defines the target containing the parent property
+     * @param parent defines from where the animation should start (animation frame)
+     * @param condition defines the trigger related conditions
+     */
+    constructor(triggerOptions: any, target: any, parent: any, condition: any);
+    _target: any;
+    _parent: any;
+    /**
+     * Execute the action and set the parent property.
+     */
+    execute(): void;
+}
+import { Action } from "./action.js";

package/dist/types/node_modules/@babylonjs/core/Actions/directAudioActions.d.ts

@@ -0,0 +1,35 @@
+/**
+ * This defines an action helpful to play a defined sound on a triggered action.
+ */
+export class PlaySoundAction extends Action {
+    /**
+     * Instantiate the action
+     * @param triggerOptions defines the trigger options
+     * @param sound defines the sound to play
+     * @param condition defines the trigger related conditions
+     */
+    constructor(triggerOptions: any, sound: any, condition: any);
+    _sound: any;
+    /**
+     * Execute the action and play the sound.
+     */
+    execute(): void;
+}
+/**
+ * This defines an action helpful to stop a defined sound on a triggered action.
+ */
+export class StopSoundAction extends Action {
+    /**
+     * Instantiate the action
+     * @param triggerOptions defines the trigger options
+     * @param sound defines the sound to stop
+     * @param condition defines the trigger related conditions
+     */
+    constructor(triggerOptions: any, sound: any, condition: any);
+    _sound: any;
+    /**
+     * Execute the action and stop the sound.
+     */
+    execute(): void;
+}
+import { Action } from "./action.js";

package/dist/types/node_modules/@babylonjs/core/Actions/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./abstractActionManager.js";
+export * from "./action.js";
+export * from "./actionEvent.js";
+export * from "./actionManager.js";
+export * from "./condition.js";
+export * from "./directActions.js";
+export * from "./directAudioActions.js";
+export * from "./interpolateValueAction.js";