@xviewer.js/core 1.0.0-alpha.33 → 1.0.0-alpha.34

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xviewer.js/core",
-  "version": "1.0.0-alpha.33",
+  "version": "1.0.0-alpha.34",
   "license": "MIT",
   "type": "module",
   "sideEffects": false,

package/types/Viewer.d.ts

@@ -114,7 +114,6 @@ export declare class Viewer extends EventEmitter {
     loadAsset(props: AssetProperties & TextureSettings): Promise<any>;
     addLoader(Loader: LoaderConstructor): void;
     load({ url, ext, onProgress, castShadow, receiveShadow, ...props }: AssetProperties & __P<Object3D, typeof Object3D>): Promise<any>;
-    tween(target: Object): import("./tween").Tween<Object>;
     timeline(target: Object): import("./tween").TweenChain;
     killTweensOf(target: Object): void;
     traverseMaterials(callback: (mat: Material) => void): void;

package/types/cinestation/CinestationBlendDefinition.d.ts

@@ -1,8 +1,8 @@
 export declare const CinestationBlendStyle: {
-    Linear: (amount: number) => number;
-    QuadraticIn: (amount: number) => number;
-    QuadraticOut: (amount: number) => number;
-    QuadraticInOut: (amount: number) => number;
+    Linear: import("../tween").EasingFunction;
+    QuadraticIn: import("../tween").EasingFunction;
+    QuadraticOut: import("../tween").EasingFunction;
+    QuadraticInOut: import("../tween").EasingFunction;
 };
 export type CinestationBlendStyle = typeof CinestationBlendStyle[keyof typeof CinestationBlendStyle];
 export declare class CinestationBlendDefinition {

package/types/cinestation/CinestationBrain.d.ts

@@ -7,9 +7,7 @@ export declare class CinestationBrain extends Component<PerspectiveCamera> {
     private _vcamSolo;
     private _vcams;
     private _lerpTime;
-    private _isChanged;
     brainBlend: CinestationBlendDefinition;
-    onChanged: (v: boolean) => void;
     get vcam(): VirtualCamera;
     get vcams(): VirtualCamera[];
     lastUpdate(dt: number): void;

package/types/cinestation/FreelookVirtualCamera.d.ts

@@ -1,27 +1,28 @@
-import { Object3D, Quaternion, Spherical, Vector2, Vector3 } from "three";
+import { Euler, Object3D, Quaternion, Vector2, Vector3 } from "three";
 import { VirtualCamera } from "./VirtualCamera";
 export declare class FreelookVirtualCamera extends VirtualCamera {
     static __loc0: Vector2;
     static __loc1: Vector2;
     static __center: Vector2;
     static __preCenter: Vector2;
-    static __moveDelta: Vector2;
-    static __worldPos: Vector3;
+    static __panDelta: Vector2;
+    static __panTarget: Vector2;
+    static __rotateDelta: Vector2;
     static __posDelta: Vector3;
     static __xAxis: Vector3;
     static __yAxis: Vector3;
     static __quat: Quaternion;
-    static __spherical: Spherical;
-    static __offsetDelta: Vector3;
     private _button;
     private _touchID;
-    private _distanceDelta;
     private _preLoc0;
     private _preLoc1;
-    private _rotateDelta;
-    private _panDelta;
+    private _spherical;
+    private _lookAtPosition;
+    private _lookAtOffset;
     private _tempSmoothing;
-    private _lookAtOffsetDelta;
+    private _targetFov;
+    private _targetLookAtOffset;
+    private _targetSpherical;
     forbidX: boolean;
     forbidY: boolean;
     forbidZ: boolean;
@@ -44,6 +45,8 @@ export declare class FreelookVirtualCamera extends VirtualCamera {
     onEnable(): void;
     onDisable(): void;
     reset(): void;
+    get lookAtPosition(): Vector3;
+    private _setSpherical;
     private _onPointerDown;
     private _onPointerUp;
     private _onPointerMove;
@@ -51,8 +54,10 @@ export declare class FreelookVirtualCamera extends VirtualCamera {
     private _onTouchStart;
     private _onTouchMove;
     private _calculateDistanceScale;
-    private _calculateRotateDelta;
+    private _calculateRotatelDelta;
     private _calculatePanDelta;
-    gotoPOI(position: Vector3, lookAt: Vector3, smoothing?: number): void;
+    private _calculateLookAtOffset;
+    private _calculateSpherical;
+    gotoPOI(springLength: number, rotation?: Euler, lookAt?: Vector3, fov?: number, smoothing?: number): void;
     update(dt: number): void;
 }

package/types/cinestation/VirtualCamera.d.ts

@@ -14,12 +14,9 @@ export declare class VirtualCamera extends Component<Object3D & {
     far: number;
     correctPosition: Vector3;
     correctRotation: Quaternion;
-    lookaheadPosition: Vector3;
-    lookAtOffset: Vector3;
     brain: CinestationBrain;
     get finalPosition(): Vector3;
     get finalRotation(): Quaternion;
     onLoad(): void;
     onDestroy(): void;
-    update(dt: number): void;
 }

package/types/math/Interpolation.d.ts

@@ -1,9 +1,9 @@
-import { Quaternion } from "three";
-export declare function VInterpTo(current: any, target: any, deltaTime: any, speed: any, out?: any): any;
-export declare function VInterpConstantTo(current: any, target: any, deltaTime: any, speed: any, out?: any): any;
+import { Quaternion, Vector3 } from "three";
+export declare function VInterpTo(current: Vector3, target: Vector3, deltaTime: number, speed: number, out?: Vector3): Vector3;
+export declare function VInterpConstantTo(current: Vector3, target: Vector3, deltaTime: number, speed: number, out?: Vector3): Vector3;
 export declare function Quat_Equals(a: Quaternion, b: Quaternion, epsilon?: number): boolean;
 export declare function Quat_AngularDistance(a: Quaternion, b: Quaternion): number;
 export declare function QInterpTo(current: Quaternion, target: Quaternion, deltaTime: number, speed: number): Quaternion;
-export declare function QInterpConstantTo(current: any, target: any, deltaTime: any, speed: any, out?: any): any;
-export declare function FInterpTo(current: any, target: any, deltaTime: any, speed: any): any;
-export declare function FInterpConstantTo(current: any, target: any, deltaTime: any, speed: any): any;
+export declare function QInterpConstantTo(current: Quaternion, target: Quaternion, deltaTime: number, speed: number, out?: Quaternion): Quaternion;
+export declare function FInterpTo(current: number, target: number, deltaTime: number, speed: number): number;
+export declare function FInterpConstantTo(current: number, target: number, deltaTime: number, speed: number): number;

package/types/tween/Easing.d.ts

@@ -0,0 +1,25 @@
+export type EasingFunction = (amount: number) => number;
+export type EasingFunctionGroup = {
+    In: EasingFunction;
+    Out: EasingFunction;
+    InOut: EasingFunction;
+};
+/**
+ * The Ease class provides a collection of easing functions for use with tween.js.
+ */
+export declare const Easing: Readonly<{
+    Linear: Readonly<EasingFunctionGroup & {
+        None: EasingFunction;
+    }>;
+    Quadratic: Readonly<EasingFunctionGroup>;
+    Cubic: Readonly<EasingFunctionGroup>;
+    Quartic: Readonly<EasingFunctionGroup>;
+    Quintic: Readonly<EasingFunctionGroup>;
+    Sinusoidal: Readonly<EasingFunctionGroup>;
+    Exponential: Readonly<EasingFunctionGroup>;
+    Circular: Readonly<EasingFunctionGroup>;
+    Elastic: Readonly<EasingFunctionGroup>;
+    Back: Readonly<EasingFunctionGroup>;
+    Bounce: Readonly<EasingFunctionGroup>;
+    generatePow(power?: number): EasingFunctionGroup;
+}>;

package/types/tween/Group.d.ts

@@ -0,0 +1,16 @@
+import type { Tween, UnknownProps } from './Tween';
+/**
+ * Controlling groups of tweens
+ *
+ * Using the TWEEN singleton to manage your tweens can cause issues in large apps with many components.
+ * In these cases, you may want to create your own smaller groups of tween
+ */
+export declare class Group {
+    private _tweens;
+    private _tweensAddedDuringUpdate;
+    getAll(): Array<Tween<UnknownProps>>;
+    removeAll(): void;
+    add(tween: Tween<UnknownProps>): void;
+    remove(tween: Tween<UnknownProps>): void;
+    update(time?: number, preserve?: boolean): boolean;
+}

package/types/tween/Interpolation.d.ts

@@ -0,0 +1,19 @@
+/**
+ *
+ */
+export type InterpolationFunction = (v: number[], k: number) => number;
+/**
+ *
+ */
+declare const Interpolation: {
+    Linear: (v: number[], k: number) => number;
+    Bezier: (v: number[], k: number) => number;
+    CatmullRom: (v: number[], k: number) => number;
+    Utils: {
+        Linear: (p0: number, p1: number, t: number) => number;
+        Bernstein: (n: number, i: number) => number;
+        Factorial: (n: number) => number;
+        CatmullRom: (p0: number, p1: number, p2: number, p3: number, t: number) => number;
+    };
+};
+export { Interpolation };

package/types/tween/Now.d.ts

@@ -0,0 +1,2 @@
+declare const now: () => number;
+export { now };

package/types/tween/Sequence.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Utils
+ */
+export declare class Sequence {
+    private static _nextId;
+    static nextId(): number;
+}

package/types/tween/Tween.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Tween.js - Licensed under the MIT license
+ * https://github.com/tweenjs/tween.js
+ * ----------------------------------------------
+ *
+ * See https://github.com/tweenjs/tween.js/graphs/contributors for the full list of contributors.
+ * Thank you all, you're awesome!
+ */
+import type { EasingFunction } from './Easing';
+import type { InterpolationFunction } from './Interpolation';
+import type { Group } from './Group';
+export declare class Tween<T extends UnknownProps> {
+    private _object;
+    private _group;
+    private _isPaused;
+    private _pauseStart;
+    private _valuesStart;
+    private _valuesEnd;
+    private _valuesStartRepeat;
+    private _duration;
+    private _isDynamic;
+    private _initialRepeat;
+    private _repeat;
+    private _repeatDelayTime?;
+    private _yoyo;
+    private _isPlaying;
+    private _reversed;
+    private _delayTime;
+    private _startTime;
+    private _easingFunction;
+    private _interpolationFunction;
+    private _chainedTweens;
+    private _onStartCallback?;
+    private _onStartCallbackFired;
+    private _onEveryStartCallback?;
+    private _onEveryStartCallbackFired;
+    private _onUpdateCallback?;
+    private _onRepeatCallback?;
+    private _onCompleteCallback?;
+    private _onStopCallback?;
+    private _onFinishCallback?;
+    private _id;
+    private _isChainStopped;
+    private _propertiesAreSetUp;
+    private _headTween;
+    private _tailTween;
+    private _headStart;
+    constructor(_object: T, _group?: Group | false);
+    getId(): number;
+    isPlaying(): boolean;
+    isPaused(): boolean;
+    getDuration(): number;
+    from(properties: UnknownProps): this;
+    to(target: UnknownProps, duration?: number): this;
+    duration(duration?: number): this;
+    dynamic(dynamic?: boolean): this;
+    start(time?: number, overrideStartingValues?: boolean): this;
+    startFromCurrentValues(time?: number): this;
+    private _setupProperties;
+    stop(): this;
+    end(): this;
+    pause(time?: number): this;
+    resume(time?: number): this;
+    stopChainedTweens(): this;
+    group(group?: Group): this;
+    call(callback: (object: T) => void): this;
+    delay(amount?: number): this;
+    union(headTween: Tween<T>, tailTween: Tween<T>): this;
+    repeat(times?: number): this;
+    repeatDelay(amount?: number): this;
+    yoyo(yoyo?: boolean): this;
+    easing(easingFunction?: EasingFunction): this;
+    interpolation(interpolationFunction?: InterpolationFunction): this;
+    chain(...tweens: Array<Tween<any>>): this;
+    unchain(...tweens: Array<Tween<any>>): this;
+    onStart(callback?: (object: T) => void): this;
+    onEveryStart(callback?: (object: T) => void): this;
+    onUpdate(callback?: (object: T, elapsed: number) => void): this;
+    onRepeat(callback?: (object: T) => void): this;
+    onComplete(callback?: (object: T) => void): this;
+    onStop(callback?: (object: T) => void): this;
+    private _goToEnd;
+    /**
+     * @returns true if the tween is still playing after the update, false
+     * otherwise (calling update on a paused tween still returns true because
+     * it is still playing, just paused).
+     */
+    update(time?: number, autoStart?: boolean): boolean;
+    private _calculateElapsedPortion;
+    private _calculateCompletionStatus;
+    private _processRepetition;
+    private _updateProperties;
+    private _handleRelativeValue;
+    private _swapEndStartRepeatValues;
+}
+export type UnknownProps = Record<string, any>;

package/types/tween/TweenChain.d.ts

@@ -1,4 +1,5 @@
-import { Group, Tween } from "./tween";
+import { Tween } from "./Tween";
+import { Group } from "./Group";
 export declare class TweenChain {
     private _object;
     private _group;

package/types/tween/TweenManager.d.ts

@@ -1,10 +1,8 @@
 import { TweenChain } from "./TweenChain";
-import { Tween } from "./tween";
 export declare class TweenManager {
     private _group;
     destroy(): void;
     update(time: number): void;
-    tween(target: Object): Tween<Object>;
     timeline(target: Object): TweenChain;
     killTweensOf(target: Object): void;
 }

package/types/tween/Version.d.ts

@@ -0,0 +1 @@
+export declare const VERSION = "23.1.2";

package/types/tween/index.d.ts

@@ -1,3 +1,5 @@
 export { TweenChain } from "./TweenChain";
 export { TweenManager } from "./TweenManager";
-export { Tween, Easing } from "./tween";
+export { Tween } from "./Tween";
+export type { EasingFunction } from "./Easing";
+export { Easing } from "./Easing";

package/types/tween/mainGroup.d.ts

@@ -0,0 +1,2 @@
+import { Group } from './Group';
+export declare const mainGroup: Group;

package/types/objects/Reflector.d.ts

@@ -1,18 +0,0 @@
-import { BufferGeometry, ColorRepresentation, Matrix4, Mesh, Vector3, WebGLRenderTarget, ShaderMaterial } from "three";
-export declare class Reflector extends Mesh<BufferGeometry, ShaderMaterial> {
-    isReflector: boolean;
-    constructor(options?: {
-        textureWidth?: number;
-        textureHeight?: number;
-        clipBias?: number;
-        multisample?: number;
-        color?: ColorRepresentation;
-        normal?: Vector3;
-        material?: ShaderMaterial;
-        geometry?: BufferGeometry;
-        layer?: number;
-    });
-    getTextureMatrix: () => Matrix4;
-    getRenderTarget: () => WebGLRenderTarget;
-    dispose: () => void;
-}

package/types/objects/index.d.ts

@@ -1 +0,0 @@
-export { Reflector } from "./Reflector";