csyjk 1.1.1 → 1.2.2

package/src/lib/gltf/assets/yjkkit-sdk/src/viewer/scene/sectionPlane/SectionPlane.js

@@ -0,0 +1,194 @@
+import {Component} from '../Component.js';
+import {RenderState} from '../webgl/RenderState.js';
+import {math} from "../math/math.js";
+
+/**
+ *  @desc An arbitrarily-aligned World-space clipping plane.
+ *
+ * * Slices portions off objects to create cross-section views or reveal interiors.
+ * * Registered by {@link SectionPlane#id} in {@link Scene#sectionPlanes}.
+ * * Indicates World-space position in {@link SectionPlane#pos} and orientation in {@link SectionPlane#dir}.
+ * * Discards elements from the half-space in the direction of {@link SectionPlane#dir}.
+ * * Can be be enabled or disabled via {@link SectionPlane#active}.
+ *
+ * ## Usage
+ *
+ * In the example below, we'll create two SectionPlanes to slice a model loaded from glTF. Note that we could also create them
+ * using a {@link SectionPlanesPlugin}.
+ *
+ * ````javascript
+ * import {Viewer, GLTFLoaderPlugin, SectionPlane} from "yjkkit-sdk.es.js";
+ *
+ * const viewer = new Viewer({
+ *      canvasId: "myCanvas"
+ * });
+ *
+ * const gltfLoaderPlugin = new GLTFModelsPlugin(viewer, {
+ *      id: "GLTFModels"
+ * });
+ *
+ * const model = gltfLoaderPlugin.load({
+ *      id: "myModel",
+ *      src: "./models/gltf/mygltfmodel.gltf"
+ * });
+ *
+ * // Create a SectionPlane on negative diagonal
+ * const sectionPlane1 = new SectionPlane(viewer.scene, {
+ *     pos: [1.0, 1.0, 1.0],
+ *     dir: [-1.0, -1.0, -1.0],
+ *     active: true
+ * }),
+ *
+ * // Create a SectionPlane on positive diagonal
+ * const sectionPlane2 = new SectionPlane(viewer.scene, {
+ *     pos: [-1.0, -1.0, -1.0],
+ *     dir: [1.0, 1.0, 1.0],
+ *     active: true
+ * });
+ * ````
+ */
+class SectionPlane extends Component {
+
+    /**
+     @private
+     */
+    get type() {
+        return "SectionPlane";
+    }
+
+    /**
+     * @constructor
+     * @param {Component} [owner]  Owner component. When destroyed, the owner will destroy this SectionPlane as well.
+     * @param {*} [cfg]  SectionPlane configuration
+     * @param  {String} [cfg.id] Optional ID, unique among all components in the parent {@link Scene}, generated automatically when omitted.
+     * @param {Boolean} [cfg.active=true] Indicates whether or not this SectionPlane is active.
+     * @param {Number[]} [cfg.pos=[0,0,0]] World-space position of the SectionPlane.
+     * @param {Number[]} [cfg.dir=[0,0,-1]] Vector perpendicular to the plane surface, indicating the SectionPlane plane orientation.
+     */
+    constructor(owner, cfg = {}) {
+
+        super(owner, cfg);
+
+        this._state = new RenderState({
+            active: true,
+            pos: math.vec3(),
+            dir: math.vec3(),
+            dist: 0
+        });
+
+        this.active = cfg.active;
+        this.pos = cfg.pos;
+        this.dir = cfg.dir;
+
+        this.scene._sectionPlaneCreated(this);
+    }
+
+    /**
+     * Sets if this SectionPlane is active or not.
+     *
+     * Default value is ````true````.
+     *
+     * @param {Boolean} value Set ````true```` to activate else ````false```` to deactivate.
+     */
+    set active(value) {
+        this._state.active = value !== false;
+        this.glRedraw();
+        this.fire("active", this._state.active);
+    }
+
+    /**
+     * Gets if this SectionPlane is active or not.
+     *
+     * Default value is ````true````.
+     *
+     * @returns {Boolean} Returns ````true```` if active.
+     */
+    get active() {
+        return this._state.active;
+    }
+
+    /**
+     * Sets the World-space position of this SectionPlane's plane.
+     *
+     * Default value is ````[0, 0, 0]````.
+     *
+     * @param {Number[]} value New position.
+     */
+    set pos(value) {
+        this._state.pos.set(value || [0, 0, 0]);
+        this._state.dist = (-math.dotVec3(this._state.pos, this._state.dir));
+        this.fire("pos", this._state.pos);
+    }
+
+    /**
+     * Gets the World-space position of this SectionPlane's plane.
+     *
+     * Default value is ````[0, 0, 0]````.
+     *
+     * @returns {Number[]} Current position.
+     */
+    get pos() {
+        return this._state.pos;
+    }
+
+    /**
+     * Sets the direction of this SectionPlane's plane.
+     *
+     * Default value is ````[0, 0, -1]````.
+     *
+     * @param {Number[]} value New direction.
+     */
+    set dir(value) {
+        this._state.dir.set(value || [0, 0, -1]);
+        this._state.dist = (-math.dotVec3(this._state.pos, this._state.dir));
+        this.glRedraw();
+        this.fire("dir", this._state.dir);
+    }
+
+    /**
+     * Gets the direction of this SectionPlane's plane.
+     *
+     * Default value is ````[0, 0, -1]````.
+     *
+     * @returns {Number[]} value Current direction.
+     */
+    get dir() {
+        return this._state.dir;
+    }
+
+    /**
+     * Gets this SectionPlane's distance to the origin of the World-space coordinate system.
+     *
+     * This is the dot product of {@link SectionPlane#pos} and {@link SectionPlane#dir} and is automatically re-calculated
+     * each time either of two properties are updated.
+     *
+     * @returns {Number}
+     */
+    get dist() {
+        return this._state.dist;
+    }
+
+    /**
+     * Inverts the direction of {@link SectionPlane#dir}.
+     */
+    flipDir() {
+        const dir = this._state.dir;
+        dir[0] *= -1.0;
+        dir[1] *= -1.0;
+        dir[2] *= -1.0;
+        this._state.dist = (-math.dotVec3(this._state.pos, this._state.dir));
+        this.fire("dir", this._state.dir);
+        this.glRedraw();
+    }
+
+    /**
+     * @destroy
+     */
+    destroy() {
+        this._state.destroy();
+        this.scene._sectionPlaneDestroyed(this);
+        super.destroy();
+    }
+}
+
+export {SectionPlane};

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

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

package/src/lib/gltf/assets/yjkkit-sdk/src/viewer/scene/skybox/Skybox.js

@@ -0,0 +1,119 @@
+import {Component} from "../Component.js";
+import {Mesh} from "../mesh/Mesh.js";
+import {ReadableGeometry} from "../geometry/ReadableGeometry.js";
+import {PhongMaterial} from "../materials/PhongMaterial.js";
+import {Texture} from "../materials/Texture.js";
+
+/**
+ * @desc A Skybox.
+ */
+class Skybox extends Component {
+
+    /**
+     * @constructor
+     * @param {Component} owner Owner component. When destroyed, the owner will destroy this PointLight as well.
+     * @param {*} [cfg]  Skybox configuration
+     * @param {String} [cfg.id] Optional ID, unique among all components in the parent {Scene}, generated automatically when omitted.
+     * @param {String} [cfg.src=null] Path to skybox texture
+     * @param {String} [cfg.encoding="linear"] Texture encoding format.  See the {@link Texture#encoding} property for more info.
+     * @param {Number} [cfg.size=1000] Size of this Skybox, given as the distance from the center at ````[0,0,0]```` to each face.
+     * @param {Boolean} [cfg.active=true] True when this Skybox is visible.
+     */
+    constructor(owner, cfg = {}) {
+
+        super(owner, cfg);
+
+        this._skyboxMesh = new Mesh(this, {
+
+            geometry: new ReadableGeometry(this, { // Box-shaped geometry
+                primitive: "triangles",
+                positions: [
+                    1, 1, 1, -1, 1, 1, -1, -1, 1, 1, -1, 1, // v0-v1-v2-v3 front
+                    1, 1, 1, 1, -1, 1, 1, -1, -1, 1, 1, -1, // v0-v3-v4-v5 right
+                    1, 1, 1, 1, 1, -1, -1, 1, -1, -1, 1, 1, // v0-v5-v6-v1 top
+                    -1, 1, 1, -1, 1, -1, -1, -1, -1, -1, -1, 1, // v1-v6-v7-v2 left
+                    -1, -1, -1, 1, -1, -1, 1, -1, 1, -1, -1, 1, // v7-v4-v3-v2 bottom
+                    1, -1, -1, -1, -1, -1, -1, 1, -1, 1, 1, -1 // v4-v7-v6-v5 back
+                ],
+                uv: [
+                    0.5, 0.6666, 0.25, 0.6666, 0.25, 0.3333, 0.5, 0.3333, 0.5, 0.6666, 0.5, 0.3333, 0.75, 0.3333, 0.75, 0.6666,
+                    0.5, 0.6666, 0.5, 1, 0.25, 1, 0.25, 0.6666, 0.25, 0.6666, 0.0, 0.6666, 0.0, 0.3333, 0.25, 0.3333,
+                    0.25, 0, 0.50, 0, 0.50, 0.3333, 0.25, 0.3333, 0.75, 0.3333, 1.0, 0.3333, 1.0, 0.6666, 0.75, 0.6666
+                ],
+                indices: [
+                    0, 1, 2, 0, 2, 3, 4, 5, 6, 4, 6, 7, 8, 9, 10, 8, 10, 11,
+                    12, 13, 14, 12, 14, 15, 16, 17, 18, 16, 18, 19, 20, 21, 22, 20, 22, 23
+                ]
+            }),
+            scale: [2000, 2000, 2000], // Overridden when we initialize the 'size' property, below
+            rotation: [0, -90, 0],
+            material: new PhongMaterial(this, {
+                ambient: [0, 0, 0],
+                diffuse: [0, 0, 0],
+                specular: [0, 0, 0],
+                emissive: [1, 1, 1],
+                emissiveMap: new Texture(this, {
+                    src: cfg.src,
+                    flipY: true,
+                    encoding: cfg.encoding || "sRGB"
+                }),
+                backfaces: true // Show interior faces of our skybox geometry
+            }),
+            // stationary: true,
+            visible: false,
+            pickable: false,
+            collidable: false
+        });
+
+        this.size = cfg.size; // Sets 'xyz' property on the Mesh's Scale transform
+        this.active = cfg.active;
+    }
+
+
+    /**
+     * Sets the size of this Skybox, given as the distance from the center at [0,0,0] to each face.
+     *
+     * Default value is ````1000````.
+     *
+     * @param {Number} value The size.
+     */
+    set size(value) {
+        this._size = value || 1000;
+        this._skyboxMesh.scale = [this._size, this._size, this._size];
+    }
+
+    /**
+     * Gets the size of this Skybox, given as the distance from the center at [0,0,0] to each face.
+     *
+     * Default value is ````1000````.
+     *
+     * @returns {Number} The size.
+     */
+    get size() {
+        return this._size;
+    }
+
+    /**
+     * Sets whether this Skybox is visible or not.
+     *
+     * Default value is ````true````.
+     *
+     * @param {Boolean} active Whether to make active or not.
+     */
+    set active(active) {
+        this._skyboxMesh.visible = active;
+    }
+
+    /**
+     * Gets if this Skybox is visible or not.
+     *
+     * Default active is ````true````.
+     *
+     * @returns {Boolean} ````true```` if the Skybox is active.
+     */
+    get active() {
+        return this._skyboxMesh.visible;
+    }
+}
+
+export {Skybox}

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

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

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

@@ -0,0 +1,45 @@
+/**
+ * yjkkit runtime statistics.
+ * @private
+ * @type {{components: {models: number, objects: number, scenes: number, meshes: number}, memory: {indices: number, uvs: number, textures: number, materials: number, transforms: number, positions: number, programs: number, normals: number, meshes: number, colors: number}, build: {version: string}, client: {browser: string}, frame: {frameCount: number, useProgram: number, bindTexture: number, drawElements: number, bindArray: number, tasksRun: number, fps: number, drawArrays: number, tasksScheduled: number}}}
+ */
+const stats = {
+    build: {
+        version: "0.8"
+    },
+    client: {
+        browser: (navigator && navigator.userAgent) ? navigator.userAgent : "n/a"
+    },
+
+    components: {
+        scenes: 0,
+        models: 0,
+        meshes: 0,
+        objects: 0
+    },
+    memory: {
+        meshes: 0,
+        positions: 0,
+        colors: 0,
+        normals: 0,
+        uvs: 0,
+        indices: 0,
+        textures: 0,
+        transforms: 0,
+        materials: 0,
+        programs: 0
+    },
+    frame: {
+        frameCount: 0,
+        fps: 0,
+        useProgram: 0,
+        bindTexture: 0,
+        bindArray: 0,
+        drawElements: 0,
+        drawArrays: 0,
+        tasksRun: 0,
+        tasksScheduled: 0
+    }
+};
+
+export {stats};

package/src/lib/gltf/assets/yjkkit-sdk/src/viewer/scene/utils/Map.js

@@ -0,0 +1,45 @@
+/** @private */
+class Map {
+
+    constructor(items, baseId) {
+        this.items = items || [];
+        this._lastUniqueId = (baseId || 0) + 1;
+    }
+
+    /**
+     * Usage:
+     *
+     * id = myMap.addItem("foo") // ID internally generated
+     * id = myMap.addItem("foo", "bar") // ID is "foo"
+     */
+    addItem() {
+        let item;
+        if (arguments.length === 2) {
+            const id = arguments[0];
+            item = arguments[1];
+            if (this.items[id]) { // Won't happen if given ID is string
+                throw "ID clash: '" + id + "'";
+            }
+            this.items[id] = item;
+            return id;
+
+        } else {
+            item = arguments[0] || {};
+            while (true) {
+                const findId = this._lastUniqueId++;
+                if (!this.items[findId]) {
+                    this.items[findId] = item;
+                    return findId;
+                }
+            }
+        }
+    }
+
+    removeItem(id) {
+        const item = this.items[id];
+        delete this.items[id];
+        return item;
+    }
+}
+
+export {Map};

package/src/lib/gltf/assets/yjkkit-sdk/src/viewer/scene/utils/Queue.js

@@ -0,0 +1,56 @@
+// Fast queue that avoids using potentially inefficient array .shift() calls
+// Based on https://github.com/creationix/fastqueue
+
+/** @private */
+class Queue {
+
+    constructor() {
+
+        this._head = [];
+        this._headLength = 0;
+        this._tail = [];
+        this._index = 0;
+        this._length = 0;
+    }
+
+    get length() {
+        return this._length;
+    }
+
+    shift() {
+        if (this._index >= this._headLength) {
+            const t = this._head;
+            t.length = 0;
+            this._head = this._tail;
+            this._tail = t;
+            this._index = 0;
+            this._headLength = this._head.length;
+            if (!this._headLength) {
+                return;
+            }
+        }
+        const value = this._head[this._index];
+        if (this._index < 0) {
+            delete this._head[this._index++];
+        }
+        else {
+            this._head[this._index++] = undefined;
+        }
+        this._length--;
+        return value;
+    }
+
+    push(item) {
+        this._length++;
+        this._tail.push(item);
+        return this;
+    };
+
+    unshift(item) {
+        this._head[--this._index] = item;
+        this._length++;
+        return this;
+    }
+}
+
+export {Queue};

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

@@ -0,0 +1,2 @@
+export * from "./Map.js";
+export * from "./Queue.js";