@xviewer.js/core 1.0.0-alpha.20 → 1.0.0-alpha.21

package/dist/module.js

@@ -1,4 +1,4 @@
-import { Mesh, EquirectangularReflectionMapping, FileLoader, TextureLoader, SRGBColorSpace, MathUtils, Vector3, Quaternion, Raycaster, Vector2, Spherical, Object3D, BoxGeometry, SphereGeometry, PlaneGeometry, HalfFloatType, FloatType, UnsignedByteType, OrthographicCamera, BufferGeometry, Float32BufferAttribute, WebGLRenderTarget, ClampToEdgeWrapping, NearestFilter, LinearFilter, LinearMipMapLinearFilter, WebGLCubeRenderTarget, DataTexture, RGBAFormat, UVMapping, Scene, LinearToneMapping, PerspectiveCamera, WebGLRenderer, PCFSoftShadowMap, LoadingManager } from 'three';
+import { Mesh, EquirectangularReflectionMapping, FileLoader, TextureLoader, SRGBColorSpace, MathUtils, Vector3, Quaternion, Raycaster, Vector2, LinearInterpolant, Spherical, Object3D, BoxGeometry, SphereGeometry, PlaneGeometry, HalfFloatType, FloatType, UnsignedByteType, OrthographicCamera, BufferGeometry, Float32BufferAttribute, WebGLRenderTarget, ClampToEdgeWrapping, NearestFilter, LinearFilter, LinearMipMapLinearFilter, WebGLCubeRenderTarget, DataTexture, RGBAFormat, UVMapping, Scene, LinearToneMapping, PerspectiveCamera, WebGLRenderer, PCFSoftShadowMap, LoadingManager } from 'three';
 import { EXRLoader } from 'three/examples/jsm/loaders/EXRLoader.js';
 import { FBXLoader } from 'three/examples/jsm/loaders/FBXLoader.js';
 import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';
@@ -1345,7 +1345,7 @@ class Component extends ObjectInstance {
     }
 }
 
-const { clamp: clamp$1, lerp } = MathUtils;
+const { clamp: clamp$4, lerp: lerp$1 } = MathUtils;
 class CinestationBrain extends Component {
     get vcam() {
         return this._vcam;
@@ -1359,7 +1359,7 @@ class CinestationBrain extends Component {
         this._vcams.forEach((v)=>v.enabled = v === vcam);
         if (this._lerpTime < this.brainBlend.time) {
             this._lerpTime += dt;
-            let t = clamp$1(this._lerpTime / this.brainBlend.time, 0, 1);
+            let t = clamp$4(this._lerpTime / this.brainBlend.time, 0, 1);
             this._lerpToMainCamera(vcam, this.brainBlend.style(t));
         } else {
             this._lerpToMainCamera(vcam, 1);
@@ -1395,9 +1395,9 @@ class CinestationBrain extends Component {
         const isChanged = isLensChanged || isTransformChanged;
         from.position.lerp(finalPosition, t);
         from.quaternion.slerp(finalRotation, t);
-        from.fov = lerp(from.fov, fov, t);
-        from.near = lerp(from.near, near, t);
-        from.far = lerp(from.far, far, t);
+        from.fov = lerp$1(from.fov, fov, t);
+        from.near = lerp$1(from.near, near, t);
+        from.far = lerp$1(from.far, far, t);
         if (isLensChanged) {
             from.updateProjectionMatrix();
         }
@@ -1998,15 +1998,579 @@ SystemInfo.cpuCoreCount = navigator.hardwareConcurrency || 1;
 SystemInfo.baseUrl = document.location.origin;
 SystemInfo.isIFrame = window.self !== window.top;
 
-const { min, max, exp } = Math;
+const { clamp: clamp$3 } = MathUtils;
+const { min, max: max$1, exp } = Math;
+const kNegligibleResidual = 0.01;
+const kLogNegligibleResidual = Math.log(kNegligibleResidual) // -4.605170186;
+;
+function exponentialDamp(current, target, dampTime, deltaTime) {
+    let k = -kLogNegligibleResidual / dampTime;
+    return current + (target - current) * (1 - exp(-k * deltaTime));
+}
 // cuve like exponentialDecay but cost less
 function quarticDamp(current, target, dampTime, deltaTime) {
     let t = 1 - min(deltaTime, dampTime) / dampTime;
     let tt = t * t;
     return current + (target - current) * (1 - tt * tt);
 }
+function smoothDamp(state, current, target, smoothTime, maxSpeed, deltaTime) {
+    if (state._velocity === undefined) {
+        state._velocity = 0;
+    }
+    smoothTime = max$1(0.0001, smoothTime);
+    let num = 2 / smoothTime;
+    let num2 = num * deltaTime;
+    let num3 = 1 / (1 + num2 + 0.48 * num2 * num2 + 0.235 * num2 * num2 * num2);
+    let num4 = current - target;
+    let num5 = target;
+    let num6 = maxSpeed * smoothTime;
+    num4 = clamp$3(num4, -num6, num6);
+    target = current - num4;
+    let num7 = (state._velocity + num * num4) * deltaTime;
+    state._velocity = (state._velocity - num * num7) * num3;
+    let num8 = target + (num4 + num7) * num3;
+    if (num5 - current > 0 == num8 > num5) {
+        num8 = num5;
+        state._velocity = (num8 - num5) / deltaTime;
+    }
+    return num8;
+}
+function Quat_exponentialDamp(current, target, dampTime, deltaTime, out = current) {
+    return out.copy(current).slerp(target, exponentialDamp(0, 1, dampTime, deltaTime));
+}
+function Quat_quarticDamp(current, target, dampTime, deltaTime, out = current) {
+    return out.copy(current).slerp(target, quarticDamp(0, 1, dampTime, deltaTime));
+}
+function Quat_smoothDamp(current, target, dampTime, deltaTime, out = current) {
+    return out.copy(current).slerp(target, smoothDamp(out, 0, 1, dampTime, Infinity, deltaTime));
+}
+function Vec3_smoothDamp(current, target, dampTime, deltaTime, out = current) {
+    return out.copy(current).lerp(target, smoothDamp(out, 0, 1, dampTime, Infinity, deltaTime));
+}
+
+const Vector3_UNIT_X = Object.freeze(new Vector3(1, 0, 0));
+const Vector3_UNIT_Y = Object.freeze(new Vector3(0, 1, 0));
+const Vector3_UNIT_Z = Object.freeze(new Vector3(0, 0, 1));
+const Vector3_RIGHT = Object.freeze(new Vector3(1, 0, 0));
+const Vector3_UP = Object.freeze(new Vector3(0, 1, 0));
+const Vector3_ZERO = Object.freeze(new Vector3(0, 0, 0));
+const Vector3_ONE = Object.freeze(new Vector3(1, 1, 1));
+const Vector3_NEG_ONE = Object.freeze(new Vector3(-1, -1, -1));
+
+const { clamp: clamp$2 } = MathUtils;
+const { max, abs: abs$1, acos } = Math;
+const EPSILON = 1.e-6;
+const __delta = new Vector3();
+function VInterpTo(current, target, deltaTime, speed, out = current) {
+    if (speed <= 0) {
+        return out.copy(target);
+    }
+    let dist = __delta.copy(target).sub(current);
+    if (dist.lengthSq() < EPSILON) {
+        return out.copy(target);
+    }
+    return out.copy(current).add(dist.multiplyScalar(clamp$2(deltaTime * speed, 0, 1)));
+}
+function VInterpConstantTo(current, target, deltaTime, speed, out = current) {
+    let delta = __delta.copy(target).sub(current);
+    let deltaM = delta.length();
+    let maxStep = speed * deltaTime;
+    if (deltaM > maxStep) {
+        if (maxStep > 0) {
+            let deltaN = delta.multiplyScalar(1 / deltaM);
+            return out.copy(current).add(deltaN);
+        } else {
+            return out.copy(current);
+        }
+    }
+    return out.copy(target);
+}
+function Quat_Equals(a, b, epsilon = EPSILON) {
+    return abs$1(a.x - b.x) <= epsilon * max(1., abs$1(a.x), abs$1(b.x)) && abs$1(a.y - b.y) <= epsilon * max(1., abs$1(a.y), abs$1(b.y)) && abs$1(a.z - b.z) <= epsilon * max(1., abs$1(a.z), abs$1(b.z)) && abs$1(a.w - b.w) <= epsilon * max(1., abs$1(a.w), abs$1(b.w));
+}
+function Quat_AngularDistance(a, b) {
+    let innerProd = a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w;
+    return acos(2 * innerProd * innerProd - 1);
+}
+function QInterpTo(current, target, deltaTime, speed) {
+    if (speed <= 0) {
+        return target;
+    }
+    if (Quat_Equals(current, target)) {
+        return target;
+    }
+    return current.slerp(target, clamp$2(speed * deltaTime, 0, 1));
+}
+function QInterpConstantTo(current, target, deltaTime, speed, out = current) {
+    if (speed <= 0) {
+        return out.copy(target);
+    }
+    if (Quat_Equals(current, target)) {
+        return out.copy(target);
+    }
+    let deltaSpeed = clamp$2(speed * deltaTime, 0, 1);
+    let angularDist = max(Quat_AngularDistance(current, target), EPSILON);
+    return out.copy(current).slerp(target, clamp$2(deltaSpeed / angularDist, 0, 1));
+}
+//非线性
+function FInterpTo(current, target, deltaTime, speed) {
+    if (speed <= 0) {
+        return target;
+    }
+    let dist = target - current;
+    if (abs$1(dist) < EPSILON) {
+        return target;
+    }
+    return current + dist * clamp$2(speed * deltaTime, 0, 1);
+}
+//线性插值
+function FInterpConstantTo(current, target, deltaTime, speed) {
+    let dist = target - current;
+    if (abs$1(dist) < EPSILON) {
+        return target;
+    }
+    let step = speed * deltaTime;
+    return current + clamp$2(dist, -step, step);
+}
+
+const { lerp, clamp: clamp$1 } = MathUtils;
+function catmullRom(t, p0, p1, p2, p3) {
+    const v0 = (p2 - p0) * 0.5;
+    const v1 = (p3 - p1) * 0.5;
+    const t2 = t * t;
+    const t3 = t * t2;
+    return (2 * p1 - 2 * p2 + v0 + v1) * t3 + (-3 * p1 + 3 * p2 - 2 * v0 - v1) * t2 + v0 * t + p1;
+}
+class CurvePoint {
+    set(x, y) {
+        this.x = x;
+        this.y = y;
+        return this;
+    }
+    lerp(p, t, out = this) {
+        out.x = lerp(this.x, p.x, t);
+        out.y = lerp(this.y, p.y, t);
+        return out;
+    }
+    constructor(x = 0, y = 0, mode = 0){
+        this.x = x;
+        this.y = y;
+        this.mode = mode;
+    }
+}
+class AnimationCurve {
+    _getInterpolant(samples) {
+        if (this._samples !== samples) {
+            this._samples = samples;
+            this._interpolant = new LinearInterpolant(new Float32Array(samples), new Float32Array(samples), 1, new Float32Array(samples));
+        }
+        return this._interpolant;
+    }
+    createCurvePoint(x, y, mode) {
+        return new CurvePoint(x, y, mode);
+    }
+    resample(samples = 100) {
+        const step = 1 / (samples - 1);
+        const interpolant = this._getInterpolant(samples);
+        const times = interpolant.parameterPositions;
+        const values = interpolant.sampleValues;
+        const point = this.createCurvePoint();
+        for(let i = 0; i < samples; i++){
+            this.getPoint(i * step, point);
+            times[i] = point.x;
+            values[i] = point.y;
+        }
+    }
+    evaluate(t) {
+        if (this.needsUpdate) {
+            this.needsUpdate = false;
+            this.resample();
+        }
+        return this._interpolant.evaluate(t)[0];
+    }
+    getPoint(t, out) {
+        const points = this.points;
+        if (t <= 0) {
+            return out.set(t, points[0].y);
+        }
+        if (t >= 1) {
+            return out.set(t, points[points.length - 1].y);
+        }
+        const p = (points.length - 1) * t;
+        const intPoint = Math.floor(p);
+        const weight = p - intPoint;
+        const p0 = points[intPoint === 0 ? intPoint : intPoint - 1];
+        const p1 = points[intPoint];
+        const p2 = points[intPoint > points.length - 2 ? points.length - 1 : intPoint + 1];
+        const p3 = points[intPoint > points.length - 3 ? points.length - 1 : intPoint + 2];
+        if (p1.mode === 1 || p0 === p1 && p2.mode === 1) {
+            return p1.lerp(p2, weight, out);
+        }
+        return out.set(clamp$1(catmullRom(weight, p0.x, p1.x, p2.x, p3.x), 0, 1), clamp$1(catmullRom(weight, p0.y, p1.y, p2.y, p3.y), 0, 1));
+    }
+    constructor(name = "", points = [
+        new CurvePoint(0, 0),
+        new CurvePoint(1, 1)
+    ]){
+        this.name = name;
+        this.points = points;
+        this.needsUpdate = true;
+        this.isAnimationCurve = true;
+        this._samples = 100;
+        this._interpolant = new LinearInterpolant(new Float32Array(100), new Float32Array(100), 1, new Float32Array(100));
+    }
+}
 
-const Vector3_ZERO = new Vector3();
+const { floor } = Math;
+// Copyright (C) 2016 Keijiro Takahashi
+// https://mrl.cs.nyu.edu/~perlin/noise/
+class Perlin {
+    static Noise(x, y, z) {
+        let fade = Perlin._Fade;
+        let grad = Perlin._Grad;
+        let lerp = Perlin._Lerp;
+        let p = Perlin._Permutation;
+        if (y !== undefined && z !== undefined) {
+            let xi = floor(x);
+            let yi = floor(y);
+            let zi = floor(z);
+            let X = xi & 0xff; // FIND UNIT CUBE THAT
+            let Y = yi & 0xff; // CONTAINS POINT.
+            let Z = zi & 0xff;
+            x -= xi; // FIND RELATIVE X,Y,Z
+            y -= yi; // OF POINT IN CUBE.
+            z -= zi;
+            let u = fade(x); // COMPUTE FADE CURVES
+            let v = fade(y); // FOR EACH OF X,Y,Z.
+            let w = fade(z);
+            let A = p[X] + Y, AA = p[A] + Z, AB = p[A + 1] + Z; // HASH COORDINATES OF
+            let B = p[X + 1] + Y, BA = p[B] + Z, BB = p[B + 1] + Z; // THE 8 CUBE CORNERS,
+            return lerp(w, lerp(v, lerp(u, grad(p[AA], x, y, z), grad(p[BA], x - 1, y, z)), lerp(u, grad(p[AB], x, y - 1, z), grad(p[BB], x - 1, y - 1, z))), lerp(v, lerp(u, grad(p[AA + 1], x, y, z - 1), grad(p[BA + 1], x - 1, y, z - 1)), lerp(u, grad(p[AB + 1], x, y - 1, z - 1), grad(p[BB + 1], x - 1, y - 1, z - 1))));
+        } else if (y !== undefined) {
+            let xi = floor(x);
+            let yi = floor(y);
+            let X = xi & 0xff;
+            let Y = yi & 0xff;
+            x -= xi;
+            y -= yi;
+            let u = fade(x);
+            let v = fade(y);
+            let A = p[X] + Y & 0xff;
+            let B = p[X + 1] + Y & 0xff;
+            return lerp(v, lerp(u, grad(p[A], x, y), grad(p[B], x - 1, y)), lerp(u, grad(p[A + 1], x, y - 1), grad(p[B + 1], x - 1, y - 1)));
+        } else {
+            let xi = floor(x);
+            let X = xi & 0xff;
+            x -= xi;
+            let u = fade(x);
+            return lerp(u, grad(p[X], x), grad(p[X + 1], x - 1));
+        }
+    }
+    static Fbm(octave, x, y, z) {
+        let f = 0;
+        let w = 0.5;
+        let noise = Perlin.Noise;
+        if (y !== undefined && z !== undefined) {
+            for(let i = 0; i < octave; i++){
+                f += w * noise(x, y, z);
+                x *= 2.0;
+                y *= 2.0;
+                z *= 2.0;
+                w *= 0.5;
+            }
+        } else if (y !== undefined) {
+            for(let i = 0; i < octave; i++){
+                f += w * noise(x, y);
+                x *= 2.0;
+                y *= 2.0;
+                w *= 0.5;
+            }
+        } else {
+            for(let i = 0; i < octave; i++){
+                f += w * noise(x);
+                x *= 2.0;
+                w *= 0.5;
+            }
+        }
+        return f;
+    }
+    static _Fade(t) {
+        return t * t * t * (t * (t * 6 - 15) + 10);
+    }
+    static _Lerp(t, a, b) {
+        return a + t * (b - a);
+    }
+    static _Grad(hash, x, y, z) {
+        if (y !== undefined && z !== undefined) {
+            let h = hash & 15; // CONVERT LO 4 BITS OF HASH CODE
+            let u = h < 8 ? x : y, v = h < 4 ? y : h == 12 || h == 14 ? x : z;
+            return ((h & 1) == 0 ? u : -u) + ((h & 2) == 0 ? v : -v);
+        } else if (y !== undefined) {
+            return ((hash & 1) == 0 ? x : -x) + ((hash & 2) == 0 ? y : -y);
+        } else {
+            return (hash & 1) == 0 ? x : -x;
+        }
+    }
+}
+Perlin._Permutation = [
+    151,
+    160,
+    137,
+    91,
+    90,
+    15,
+    131,
+    13,
+    201,
+    95,
+    96,
+    53,
+    194,
+    233,
+    7,
+    225,
+    140,
+    36,
+    103,
+    30,
+    69,
+    142,
+    8,
+    99,
+    37,
+    240,
+    21,
+    10,
+    23,
+    190,
+    6,
+    148,
+    247,
+    120,
+    234,
+    75,
+    0,
+    26,
+    197,
+    62,
+    94,
+    252,
+    219,
+    203,
+    117,
+    35,
+    11,
+    32,
+    57,
+    177,
+    33,
+    88,
+    237,
+    149,
+    56,
+    87,
+    174,
+    20,
+    125,
+    136,
+    171,
+    168,
+    68,
+    175,
+    74,
+    165,
+    71,
+    134,
+    139,
+    48,
+    27,
+    166,
+    77,
+    146,
+    158,
+    231,
+    83,
+    111,
+    229,
+    122,
+    60,
+    211,
+    133,
+    230,
+    220,
+    105,
+    92,
+    41,
+    55,
+    46,
+    245,
+    40,
+    244,
+    102,
+    143,
+    54,
+    65,
+    25,
+    63,
+    161,
+    1,
+    216,
+    80,
+    73,
+    209,
+    76,
+    132,
+    187,
+    208,
+    89,
+    18,
+    169,
+    200,
+    196,
+    135,
+    130,
+    116,
+    188,
+    159,
+    86,
+    164,
+    100,
+    109,
+    198,
+    173,
+    186,
+    3,
+    64,
+    52,
+    217,
+    226,
+    250,
+    124,
+    123,
+    5,
+    202,
+    38,
+    147,
+    118,
+    126,
+    255,
+    82,
+    85,
+    212,
+    207,
+    206,
+    59,
+    227,
+    47,
+    16,
+    58,
+    17,
+    182,
+    189,
+    28,
+    42,
+    223,
+    183,
+    170,
+    213,
+    119,
+    248,
+    152,
+    2,
+    44,
+    154,
+    163,
+    70,
+    221,
+    153,
+    101,
+    155,
+    167,
+    43,
+    172,
+    9,
+    129,
+    22,
+    39,
+    253,
+    19,
+    98,
+    108,
+    110,
+    79,
+    113,
+    224,
+    232,
+    178,
+    185,
+    112,
+    104,
+    218,
+    246,
+    97,
+    228,
+    251,
+    34,
+    242,
+    193,
+    238,
+    210,
+    144,
+    12,
+    191,
+    179,
+    162,
+    241,
+    81,
+    51,
+    145,
+    235,
+    249,
+    14,
+    239,
+    107,
+    49,
+    192,
+    214,
+    31,
+    181,
+    199,
+    106,
+    157,
+    184,
+    84,
+    204,
+    176,
+    115,
+    121,
+    50,
+    45,
+    127,
+    4,
+    150,
+    254,
+    138,
+    236,
+    205,
+    93,
+    222,
+    114,
+    67,
+    29,
+    24,
+    72,
+    243,
+    141,
+    128,
+    195,
+    78,
+    66,
+    215,
+    61,
+    156,
+    180,
+    151
+];
 
 const { clamp, degToRad } = MathUtils;
 const { abs, tan } = Math;
@@ -3417,6 +3981,9 @@ class Viewer extends EventEmitter {
         this._camera = camera;
         return result;
     }
+    blit(renderTarget, material, lod, face) {
+        Viewer.Blit(this._renderer, renderTarget, material, lod, face);
+    }
     compile(target) {
         if (Array.isArray(target)) {
             if (target.every((v)=>v.isMaterial)) {
@@ -3547,5 +4114,5 @@ class Plugin extends ObjectInstance {
     }
 }
 
-export { Box, CinestationBlendDefinition, CinestationBrain, Component, Easing, EventEmitter, FreelookVirtualCamera, Logger, ObjectInstance, Plane, Plugin, PropertyManager, Sphere, SystemInfo, Tween, TweenChain, TweenManager, Viewer, VirtualCamera, aEXRLoader, aFBXLoader, aGLTFLoader, aHDRLoader, aJSONLoader, aTextureLoader, getClassInstance, mixin, property };
+export { AnimationCurve, Box, CinestationBlendDefinition, CinestationBrain, Component, DeviceInput, Easing, EventEmitter, FInterpConstantTo, FInterpTo, FreelookVirtualCamera, Logger, ObjectInstance, Perlin, Plane, Plugin, PropertyManager, QInterpConstantTo, QInterpTo, Quat_AngularDistance, Quat_Equals, Quat_exponentialDamp, Quat_quarticDamp, Quat_smoothDamp, Sphere, SystemInfo, Tween, TweenChain, TweenManager, VInterpConstantTo, VInterpTo, Vec3_smoothDamp, Vector3_NEG_ONE, Vector3_ONE, Vector3_RIGHT, Vector3_UNIT_X, Vector3_UNIT_Y, Vector3_UNIT_Z, Vector3_UP, Vector3_ZERO, Viewer, VirtualCamera, aEXRLoader, aFBXLoader, aGLTFLoader, aHDRLoader, aJSONLoader, aTextureLoader, exponentialDamp, getClassInstance, mixin, property, quarticDamp, smoothDamp };
 //# sourceMappingURL=module.js.map