csyjk 1.1.1 → 1.2.2

package/src/lib/gltf/assets/yjkkit-sdk/src/viewer/scene/nodes/index.js

@@ -0,0 +1 @@
+export * from "./Node.js";

package/src/lib/gltf/assets/yjkkit-sdk/src/viewer/scene/paths/CubicBezierCurve.js

@@ -0,0 +1,194 @@
+import {Curve} from "./Curve.js"
+import {math} from "../math/math.js";
+
+/**
+ * @desc A {@link Curve} along which a 3D position can be animated.
+ *
+ * * As shown in the diagram below, a CubicBezierCurve is defined by four control points.
+ * * You can sample a {@link CubicBezierCurve#point} and a {@link CubicBezierCurve#tangent} vector on a CubicBezierCurve for any given value of {@link CubicBezierCurve#t} in the range [0..1].
+ * * When you set {@link CubicBezierCurve#t} on a CubicBezierCurve, its {@link CubicBezierCurve#point} and {@link CubicBezierCurve#tangent} properties will update accordingly.
+ * * To build a complex path, you can combine an unlimited combination of CubicBezierCurves, {@link QuadraticBezierCurve}s and {@link SplineCurve}s into a {@link Path}.
+ *
+ * <br>
+ * <img style="border:1px solid;" src="https://upload.wikimedia.org/wikipedia/commons/thumb/d/db/B%C3%A9zier_3_big.gif/240px-B%C3%A9zier_3_big.gif"/>
+ * <br>
+ * [Cubic Bezier Curve from WikiPedia](https://en.wikipedia.org/wiki/B%C3%A9zier_curve)
+ */
+class CubicBezierCurve extends Curve {
+
+    /**
+     * @constructor
+     * @param {Component} [owner]  Owner component. When destroyed, the owner will destroy this CubicBezierCurve as well.
+     * @param {*} [cfg] Configs
+     * @param {String} [cfg.id] Optional ID, unique among all components in the parent {@link Scene}, generated automatically when omitted.
+     * @param {Number[]} [cfg.v0=[0,0,0]] The starting point.
+     * @param {Number[]} [cfg.v1=[0,0,0]] The first control point.
+     * @param {Number[]} [cfg.v2=[0,0,0]] The middle control point.
+     * @param {Number[]} [cfg.v3=[0,0,0]] The ending point.
+     * @param {Number} [cfg.t=0] Current position on this CubicBezierCurve, in range between 0..1.
+     */
+    constructor(owner, cfg = {}) {
+        super(owner, cfg);
+        this.v0 = cfg.v0;
+        this.v1 = cfg.v1;
+        this.v2 = cfg.v2;
+        this.v3 = cfg.v3;
+        this.t = cfg.t;
+    }
+
+    /**
+     * Sets the starting point on this CubicBezierCurve.
+     *
+     * Default value is ````[0.0, 0.0, 0.0]````
+     *
+     * @param {Number[]} value The starting point.
+     */
+    set v0(value) {
+        this._v0 = value || math.vec3([0, 0, 0]);
+    }
+
+    /**
+     * Gets the starting point on this CubicBezierCurve.
+     *
+     * Default value is ````[0.0, 0.0, 0.0]````
+     *
+     * @returns {Number[]} The starting point.
+     */
+    get v0() {
+        return this._v0;
+    }
+
+    /**
+     * Sets the first control point on this CubicBezierCurve.
+     *
+     * Default value is ````[0.0, 0.0, 0.0]````
+     *
+     * @param {Number[]} value The first control point.
+     */
+    set v1(value) {
+        this._v1 = value || math.vec3([0, 0, 0]);
+    }
+
+    /**
+     * Gets the first control point on this CubicBezierCurve.
+     *
+     * Fires a {@link CubicBezierCurve#v1:event} event on change.
+     *
+     * Default value is ````[0.0, 0.0, 0.0]````
+     *
+     * @returns {Number[]} The first control point.
+     */
+    get v1() {
+        return this._v1;
+    }
+
+    /**
+     * Sets the second control point on this CubicBezierCurve.
+     *
+     * Default value is ````[0.0, 0.0, 0.0]````
+     *
+     * @param {Number[]} value The second control point.
+     */
+    set v2(value) {
+        this._v2 = value || math.vec3([0, 0, 0]);
+    }
+
+    /**
+     * Gets the second control point on this CubicBezierCurve.
+     *
+     * Default value is ````[0.0, 0.0, 0.0]````
+     *
+     * @returns {Number[]} The second control point.
+     */
+    get v2() {
+        return this._v2;
+    }
+
+    /**
+     * Sets the end point on this CubicBezierCurve.
+     *
+     * Fires a {@link CubicBezierCurve#v3:event} event on change.
+     *
+     * Default value is ````[0.0, 0.0, 0.0]````
+     *
+     * @param {Number[]} value The end point.
+     */
+    set v3(value) {
+        this.fire("v3", this._v3 = value || math.vec3([0, 0, 0]));
+    }
+
+    /**
+     * Gets the end point on this CubicBezierCurve.
+     *
+     * Fires a {@link CubicBezierCurve#v3:event} event on change.
+     *
+     * Default value is ````[0.0, 0.0, 0.0]````
+     *
+     * @returns {Number[]} The end point.
+     */
+    get v3() {
+        return this._v3;
+    }
+
+    /**
+     * Sets the current position of progress along this CubicBezierCurve.
+     *
+     * Automatically clamps to range ````[0..1]````.
+     *
+     * @param {Number} value New progress time value.
+     */
+    set t(value) {
+        value = value || 0;
+        this._t = value < 0.0 ? 0.0 : (value > 1.0 ? 1.0 : value);
+    }
+
+    /**
+     * Gets the current position of progress along this CubicBezierCurve.
+     *
+     * @returns {Number} Current progress time value.
+     */
+    get t() {
+        return this._t;
+    }
+
+    /**
+     * Returns point on this CubicBezierCurve at the given position.
+     *
+     * @param {Number} t Position to get point at.
+     *
+     * @returns {{Number[]}} The point at the given position.
+     */
+    get point() {
+        return this.getPoint(this._t);
+    }
+
+    /**
+     * Returns point on this CubicBezierCurve at the given position.
+     *
+     * @param {Number} t Position to get point at.
+     *
+     * @returns {{Number[]}} The point at the given position.
+     */
+    getPoint(t) {
+
+        var vector = math.vec3();
+
+        vector[0] = math.b3(t, this._v0[0], this._v1[0], this._v2[0], this._v3[0]);
+        vector[1] = math.b3(t, this._v0[1], this._v1[1], this._v2[1], this._v3[1]);
+        vector[2] = math.b3(t, this._v0[2], this._v1[2], this._v2[2], this._v3[2]);
+
+        return vector;
+    }
+
+    getJSON() {
+        return {
+            v0: this._v0,
+            v1: this._v1,
+            v2: this._v2,
+            v3: this._v3,
+            t: this._t
+        };
+    }
+}
+
+export {CubicBezierCurve}

package/src/lib/gltf/assets/yjkkit-sdk/src/viewer/scene/paths/Curve.js

@@ -0,0 +1,183 @@
+import {Component} from "../Component.js"
+import {math} from "../math/math.js";
+
+/**
+ * @desc Abstract base class for curve classes.
+ */
+class Curve extends Component {
+
+    /**
+     * @constructor
+     * @param {Component} [owner]  Owner component. When destroyed, the owner will destroy this Curve as well.
+     * @param {*} [cfg] Configs
+     * @param {String} [cfg.id] Optional ID, unique among all components in the parent {@link Curve}, generated automatically when omitted.
+     * @param {Object} [cfg] Configs for this Curve.
+     * @param {Number} [cfg.t=0] Current position on this Curve, in range between ````0..1````.
+     */
+    constructor(owner, cfg = {}) {
+        super(owner, cfg);
+        this.t = cfg.t;
+    }
+
+    /**
+     * Sets the progress along this Curve.
+     *
+     * Automatically clamps to range ````[0..1]````.
+     *
+     * Default value is ````0````.
+     *
+     * @param {Number} value The progress value.
+     */
+    set t(value) {
+        value = value || 0;
+        this._t = value < 0.0 ? 0.0 : (value > 1.0 ? 1.0 : value);
+    }
+
+    /**
+     * Gets the progress along this Curve.
+     *
+     * @returns {Number} The progress value.
+     */
+    get t() {
+        return this._t;
+    }
+
+    /**
+     * Gets the tangent on this Curve at position {@link Curve#t}.
+     *
+     * @returns {{Number[]}} The tangent.
+     */
+    get tangent() {
+        return this.getTangent(this._t);
+    }
+
+    /**
+     * Gets the length of this Curve.
+     *
+     * @returns {Number} The Curve length.
+     */
+    get length() {
+        var lengths = this._getLengths();
+        return lengths[lengths.length - 1];
+    }
+
+    /**
+     * Returns a normalized tangent vector on this Curve at the given position.
+     *
+     * @param {Number} t Position to get tangent at.
+     * @returns {{Number[]}} Normalized tangent vector
+     */
+    getTangent(t) {
+        var delta = 0.0001;
+        if (t === undefined) {
+            t = this._t;
+        }
+        var t1 = t - delta;
+        var t2 = t + delta;
+        if (t1 < 0) {
+            t1 = 0;
+        }
+        if (t2 > 1) {
+            t2 = 1;
+        }
+        var pt1 = this.getPoint(t1);
+        var pt2 = this.getPoint(t2);
+        var vec = math.subVec3(pt2, pt1, []);
+        return math.normalizeVec3(vec, []);
+    }
+
+    getPointAt(u) {
+        var t = this.getUToTMapping(u);
+        return this.getPoint(t);
+    }
+
+    /**
+     * Samples points on this Curve, at the given number of equally-spaced divisions.
+     *
+     * @param {Number} divisions The number of divisions.
+     * @returns {{Array of Array}} Array of sampled 3D points.
+     */
+    getPoints(divisions) {
+        if (!divisions) {
+            divisions = 5;
+        }
+        var d, pts = [];
+        for (d = 0; d <= divisions; d++) {
+            pts.push(this.getPoint(d / divisions));
+        }
+        return pts;
+    }
+
+    _getLengths(divisions) {
+        if (!divisions) {
+            divisions = (this.__arcLengthDivisions) ? (this.__arcLengthDivisions) : 200;
+        }
+        if (this.cacheArcLengths && (this.cacheArcLengths.length === divisions + 1) && !this.needsUpdate) {
+            return this.cacheArcLengths;
+
+        }
+        this.needsUpdate = false;
+        var cache = [];
+        var current;
+        var last = this.getPoint(0);
+        var p;
+        var sum = 0;
+        cache.push(0);
+        for (p = 1; p <= divisions; p++) {
+            current = this.getPoint(p / divisions);
+            sum += math.lenVec3(math.subVec3(current, last, []));
+            cache.push(sum);
+            last = current;
+        }
+        this.cacheArcLengths = cache;
+        return cache; // { sums: cache, sum:sum }, Sum is in the last element.
+    }
+
+    _updateArcLengths() {
+        this.needsUpdate = true;
+        this._getLengths();
+    }
+
+    // Given u ( 0 .. 1 ), get a t to find p. This gives you points which are equi distance
+
+    getUToTMapping(u, distance) {
+        var arcLengths = this._getLengths();
+        var i = 0;
+        var il = arcLengths.length;
+        var t;
+        var targetArcLength; // The targeted u distance value to get
+        if (distance) {
+            targetArcLength = distance;
+        } else {
+            targetArcLength = u * arcLengths[il - 1];
+        }
+        //var time = Date.now();
+        var low = 0, high = il - 1, comparison;
+        while (low <= high) {
+            i = Math.floor(low + (high - low) / 2); // less likely to overflow, though probably not issue here, JS doesn't really have integers, all numbers are floats
+            comparison = arcLengths[i] - targetArcLength;
+            if (comparison < 0) {
+                low = i + 1;
+            } else if (comparison > 0) {
+                high = i - 1;
+            } else {
+                high = i;
+                break;
+                // DONE
+            }
+        }
+        i = high;
+        if (arcLengths[i] === targetArcLength) {
+            t = i / (il - 1);
+            return t;
+        }
+        var lengthBefore = arcLengths[i];
+        var lengthAfter = arcLengths[i + 1];
+        var segmentLength = lengthAfter - lengthBefore;
+        var segmentFraction = (targetArcLength - lengthBefore) / segmentLength;
+        t = (i + segmentFraction) / (il - 1);
+        return t;
+    }
+}
+
+export {Curve}

package/src/lib/gltf/assets/yjkkit-sdk/src/viewer/scene/paths/Path.js

@@ -0,0 +1,239 @@
+import {utils} from "../utils.js";
+import {Curve} from "./Curve.js"
+
+/**
+ * @desc A complex curved path constructed from various {@link Curve} subtypes.
+ *
+ * * A Path can be constructed from these {@link Curve} subtypes: {@link SplineCurve}, {@link CubicBezierCurve} and {@link QuadraticBezierCurve}.
+ * * You can sample a {@link Path#point} and a {@link Curve#tangent} vector on a Path for any given value of {@link Path#t} in the range ````[0..1]````.
+ * * When you set {@link Path#t} on a Path, its {@link Path#point} and {@link Curve#tangent} properties will update accordingly.
+ */
+class Path extends Curve {
+
+    /**
+     * @constructor
+     * @param {Component} [owner]  Owner component. When destroyed, the owner will destroy this SectionPlane as well.
+     * @param {*} [cfg]  Path configuration
+     * @param {String} [cfg.id]  Optional ID, unique among all components in the parent {@link Scene}, generated automatically when omitted.
+     * @param {String []} [cfg.paths=[]] IDs or instances of {{#crossLink "path"}}{{/crossLink}} subtypes to add to this Path.
+     * @param {Number} [cfg.t=0] Current position on this Path, in range between 0..1.
+     */
+    constructor(owner, cfg = {}) {
+        super(owner, cfg);
+        this._cachedLengths = [];
+        this._dirty = true;
+        this._curves = []; // Array of child Curve components
+        this._t = 0;
+        this._dirtySubs = []; // Subscriptions to "dirty" events from child Curve components
+        this._destroyedSubs = []; // Subscriptions to "destroyed" events from child Curve components
+        this.curves = cfg.curves || [];    // Add initial curves
+        this.t = cfg.t; // Set initial progress
+    }
+
+    /**
+     * Adds a {@link Curve} to this Path.
+     *
+     * @param {Curve} curve The {@link Curve} to add.
+     */
+    addCurve(curve) {
+        this._curves.push(curve);
+        this._dirty = true;
+    }
+
+    /**
+     * Sets the {@link Curve}s in this Path.
+     *
+     * Default value is ````[]````.
+     *
+     * @param {{Array of Spline, Path, QuadraticBezierCurve or CubicBezierCurve}} value.
+     */
+    set curves(value) {
+
+        value = value || [];
+
+        var curve;
+        // Unsubscribe from events on old curves
+        var i;
+        var len;
+        for (i = 0, len = this._curves.length; i < len; i++) {
+            curve = this._curves[i];
+            curve.off(this._dirtySubs[i]);
+            curve.off(this._destroyedSubs[i]);
+        }
+
+        this._curves = [];
+        this._dirtySubs = [];
+        this._destroyedSubs = [];
+
+        var self = this;
+
+        function curveDirty() {
+            self._dirty = true;
+        }
+
+        function curveDestroyed() {
+            var id = this.id;
+            for (i = 0, len = self._curves.length; i < len; i++) {
+                if (self._curves[i].id === id) {
+                    self._curves = self._curves.slice(i, i + 1);
+                    self._dirtySubs = self._dirtySubs.slice(i, i + 1);
+                    self._destroyedSubs = self._destroyedSubs.slice(i, i + 1);
+                    self._dirty = true;
+                    return;
+                }
+            }
+        }
+
+        for (i = 0, len = value.length; i < len; i++) {
+            curve = value[i];
+            if (utils.isNumeric(curve) || utils.isString(curve)) {
+                // ID given for curve - find the curve component
+                var id = curve;
+                curve = this.scene.components[id];
+                if (!curve) {
+                    this.error("Component not found: " + _inQuotes(id));
+                    continue;
+                }
+            }
+
+            var type = curve.type;
+
+            if (type !== "yjkkit.SplineCurve" &&
+                type !== "yjkkit.Path" &&
+                type !== "yjkkit.CubicBezierCurve" &&
+                type !== "yjkkit.QuadraticBezierCurve") {
+
+                this.error("Component " + _inQuotes(curve.id)
+                    + " is not a yjkkit.SplineCurve, yjkkit.Path or yjkkit.QuadraticBezierCurve");
+
+                continue;
+            }
+
+            this._curves.push(curve);
+            this._dirtySubs.push(curve.on("dirty", curveDirty));
+            this._destroyedSubs.push(curve.once("destroyed", curveDestroyed));
+        }
+
+        this._dirty = true;
+    }
+
+    /**
+     * Gets the {@link Curve}s in this Path.
+     *
+     * @returns {{Array of Spline, Path, QuadraticBezierCurve or CubicBezierCurve}} the {@link Curve}s in this path.
+     */
+    get curves() {
+        return this._curves;
+    }
+
+    /**
+     * Sets the current point of progress along this Path.
+     *
+     * Automatically clamps to range ````[0..1]````.
+     *
+     * Default value is ````0````.
+     *
+     * @param {Number} value The current point of progress.
+     */
+    set t(value) {
+        value = value || 0;
+        this._t = value < 0.0 ? 0.0 : (value > 1.0 ? 1.0 : value);
+    }
+
+    /**
+     * Gets the current point of progress along this Path.
+     *
+     * Default value is ````0````.
+     *
+     * @returns {Number} The current point of progress.
+     */
+    get t() {
+        return this._t;
+    }
+
+    /**
+     * Gets point on this Path corresponding to the current value of {@link Path#t}.
+     *
+     * @returns {{Number[]}} The point.
+     */
+    get point() {
+        return this.getPoint(this._t);
+    }
+
+    /**
+     * Length of this Path, which is the cumulative length of all {@link Curve}s currently in {@link Path#curves}.
+     *
+     * @return {Number} Length of this path.
+     */
+    get length() {
+        var lens = this._getCurveLengths();
+        return lens[lens.length - 1];
+    }
+
+    /**
+     * Gets a point on this Path corresponding to the given progress position.
+     *
+     * @param {Number} t Indicates point of progress along this curve, in the range [0..1].
+     * @returns {{Number[]}}
+     */
+    getPoint(t) {
+        var d = t * this.length;
+        var curveLengths = this._getCurveLengths();
+        var i = 0, diff, curve;
+        while (i < curveLengths.length) {
+            if (curveLengths[i] >= d) {
+                diff = curveLengths[i] - d;
+                curve = this._curves[i];
+                var u = 1 - diff / curve.length;
+                return curve.getPointAt(u);
+            }
+            i++;
+        }
+        return null;
+    }
+
+    _getCurveLengths() {
+        if (!this._dirty) {
+            return this._cachedLengths;
+        }
+        var lengths = [];
+        var sums = 0;
+        var i, il = this._curves.length;
+        for (i = 0; i < il; i++) {
+            sums += this._curves[i].length;
+            lengths.push(sums);
+
+        }
+        this._cachedLengths = lengths;
+        this._dirty = false;
+        return lengths;
+    }
+
+    _getJSON() {
+        var curveIds = [];
+        for (var i = 0, len = this._curves.length; i < len; i++) {
+            curveIds.push(this._curves[i].id);
+        }
+        return {
+            curves: curveIds,
+            t: this._t
+        };
+    }
+
+    /**
+     * Destroys this Path.
+     */
+    destroy() {
+        super.destroy();
+        var i;
+        var len;
+        var curve;
+        for (i = 0, len = this._curves.length; i < len; i++) {
+            curve = this._curves[i];
+            curve.off(this._dirtySubs[i]);
+            curve.off(this._destroyedSubs[i]);
+        }
+    }
+}
+
+export {Path}