@xeokit/xeokit-sdk 2.4.0-alpha-81 → 2.4.0-alpha-83

package/src/viewer/scene/geometry/builders/index.js

@@ -0,0 +1,8 @@
+export * from "./buildBoxGeometry.js";
+export * from "./buildBoxLinesGeometry.js";
+export * from "./buildCylinderGeometry.js";
+export * from "./buildGridGeometry.js";
+export * from "./buildPlaneGeometry.js";
+export * from "./buildSphereGeometry.js";
+export * from "./buildTorusGeometry.js";
+export * from "./buildVectorTextGeometry.js";

package/src/viewer/scene/geometry/index.js

@@ -0,0 +1,4 @@
+export * from "./ReadableGeometry.js";
+export * from "./VBOGeometry.js";
+export * from "./loaders/index.js";
+export * from "./builders/index.js";

package/src/viewer/scene/geometry/loaders/index.js

@@ -0,0 +1,2 @@
+export * from "./load3DSGeometry.js";
+export * from "./loadOBJGeometry.js";

package/src/viewer/scene/geometry/loaders/load3DSGeometry.js

@@ -0,0 +1,103 @@
+import {utils} from '../../utils.js';
+import {K3D} from '../../libs/k3d.js';
+
+/**
+ * @desc Loads {@link Geometry} from 3DS.
+ *
+ * ## Usage
+ *
+ * In the example below we'll create a {@link Mesh} with {@link PhongMaterial}, {@link Texture} and a {@link ReadableGeometry} loaded from 3DS.
+ *
+ * [[Run this example](/examples/#geometry_loaders_3DS)]
+ *
+ * ````javascript
+ * import {Viewer, Mesh, load3DSGeometry, ReadableGeometry, PhongMaterial, Texture} from "xeokit-sdk.es.js";
+ *
+ * const viewer = new Viewer({
+ *      canvasId: "myCanvas"
+ * });
+ *
+ * viewer.scene.camera.eye = [40.04, 23.46, 79.06];
+ * viewer.scene.camera.look = [-6.48, 13.92, -0.56];
+ * viewer.scene.camera.up = [-0.04, 0.98, -0.08];
+ *
+ * load3DSGeometry(viewer.scene, {
+ *      src: "models/3ds/lexus.3ds",
+ *      compressGeometry: false
+ *
+ *  }).then(function (geometryCfg) {
+ *
+ *      // Success
+ *
+ *      new Mesh(viewer.scene, {
+ *
+ *          geometry: new ReadableGeometry(viewer.scene, geometryCfg),
+ *
+ *          material: new PhongMaterial(viewer.scene, {
+ *
+ *              emissive: [1, 1, 1],
+ *              emissiveMap: new Texture({  // .3DS has no normals so relies on emissive illumination
+ *                  src: "models/3ds/lexus.jpg"
+ *              })
+ *          }),
+ *
+ *          rotation: [-90, 0, 0] // +Z is up for this particular 3DS
+ *      });
+ *  }, function () {
+ *      // Error
+ *  });
+ * ````
+ *
+ * @function load3DSGeometry
+ * @param {Scene} scene Scene we're loading the geometry for.
+ * @param {*} cfg Configs, also added to the result object.
+ * @param {String} [cfg.src]  Path to 3DS file.
+ * @returns {Object} Configuration to pass into a {@link Geometry} constructor, containing geometry arrays loaded from the OBJ file.
+ */
+function load3DSGeometry(scene, cfg = {}) {
+
+    return new Promise(function (resolve, reject) {
+
+        if (!cfg.src) {
+            console.error("load3DSGeometry: Parameter expected: src");
+            reject();
+        }
+
+        var spinner = scene.canvas.spinner;
+        spinner.processes++;
+
+        utils.loadArraybuffer(cfg.src, function (data) {
+
+                if (!data.byteLength) {
+                    console.error("load3DSGeometry: no data loaded");
+                    spinner.processes--;
+                    reject();
+                }
+
+                var m = K3D.parse.from3DS(data);	// done !
+
+                var mesh = m.edit.objects[0].mesh;
+                var positions = mesh.vertices;
+                var uv = mesh.uvt;
+                var indices = mesh.indices;
+
+                spinner.processes--;
+
+                resolve(utils.apply(cfg, {
+                    primitive: "triangles",
+                    positions: positions,
+                    normals: null,
+                    uv: uv,
+                    indices: indices
+                }));
+            },
+
+            function (msg) {
+                console.error("load3DSGeometry: " + msg);
+                spinner.processes--;
+                reject();
+            });
+    });
+}
+
+export {load3DSGeometry};

package/src/viewer/scene/geometry/loaders/loadOBJGeometry.js

@@ -0,0 +1,130 @@
+import {utils} from '../../utils.js';
+import {K3D} from '../../libs/k3d.js';
+
+/**
+ * @desc Loads {@link Geometry} from OBJ.
+ *
+ * ## Usage
+ *
+ * In the example below we'll create a {@link Mesh} with {@link MetallicMaterial} and {@link ReadableGeometry} loaded from OBJ.
+ *
+ * [[Run this example](/examples/#geometry_loaders_OBJ)]
+ *
+ * ````javascript
+ * import {Viewer, Mesh, loadOBJGeometry, ReadableGeometry,
+ *      MetallicMaterial, Texture} from "xeokit-sdk.es.js";
+ *
+ * const viewer = new Viewer({
+ *      canvasId: "myCanvas"
+ * });
+ *
+ * viewer.scene.camera.eye = [0.57, 1.37, 1.14];
+ * viewer.scene.camera.look = [0.04, 0.58, 0.00];
+ * viewer.scene.camera.up = [-0.22, 0.84, -0.48];
+ *
+ * loadOBJGeometry(viewer.scene, {
+ *
+ *      src: "models/obj/fireHydrant/FireHydrantMesh.obj",
+ *      compressGeometry: false
+ *
+ *  }).then(function (geometryCfg) {
+ *
+ *      // Success
+ *
+ *      new Mesh(viewer.scene, {
+ *
+ *          geometry: new ReadableGeometry(viewer.scene, geometryCfg),
+ *
+ *          material: new MetallicMaterial(viewer.scene, {
+ *
+ *              baseColor: [1, 1, 1],
+ *              metallic: 1.0,
+ *              roughness: 1.0,
+ * 
+ *              baseColorMap: new Texture(viewer.scene, {
+ *                  src: "models/obj/fireHydrant/fire_hydrant_Base_Color.png",
+ *                  encoding: "sRGB"
+ *              }),
+ *              normalMap: new Texture(viewer.scene, {
+ *                  src: "models/obj/fireHydrant/fire_hydrant_Normal_OpenGL.png"
+ *              }),
+ *              roughnessMap: new Texture(viewer.scene, {
+ *                  src: "models/obj/fireHydrant/fire_hydrant_Roughness.png"
+ *              }),
+ *              metallicMap: new Texture(viewer.scene, {
+ *                  src: "models/obj/fireHydrant/fire_hydrant_Metallic.png"
+ *              }),
+ *              occlusionMap: new Texture(viewer.scene, {
+ *                  src: "models/obj/fireHydrant/fire_hydrant_Mixed_AO.png"
+ *              }),
+ * 
+ *              specularF0: 0.7
+ *          })
+ *      });
+ *  }, function () {
+ *      // Error
+ *  });
+ * ````
+ *
+ * @function loadOBJGeometry
+ * @param {Scene} scene Scene we're loading the geometry for.
+ * @param {*} [cfg] Configs, also added to the result object.
+ * @param {String} [cfg.src]  Path to OBJ file.
+ * @returns {Object} Configuration to pass into a {@link Geometry} constructor, containing geometry arrays loaded from the OBJ file.
+ */
+function loadOBJGeometry(scene, cfg = {}) {
+
+    return new Promise(function (resolve, reject) {
+
+        if (!cfg.src) {
+            console.error("loadOBJGeometry: Parameter expected: src");
+            reject();
+        }
+
+        var spinner = scene.canvas.spinner;
+        spinner.processes++;
+
+        utils.loadArraybuffer(cfg.src, function (data) {
+
+                if (!data.byteLength) {
+                    console.error("loadOBJGeometry: no data loaded");
+                    spinner.processes--;
+                    reject();
+                }
+
+                var m = K3D.parse.fromOBJ(data);	// done !
+
+                // unwrap simply duplicates some values, so they can be indexed with indices [0,1,2,3 ... ]
+                // In some rendering engines, you can have only one index value for vertices, UVs, normals ...,
+                // so "unwrapping" is a simple solution.
+
+                var positions = K3D.edit.unwrap(m.i_verts, m.c_verts, 3);
+                var normals = K3D.edit.unwrap(m.i_norms, m.c_norms, 3);
+                var uv = K3D.edit.unwrap(m.i_uvt, m.c_uvt, 2);
+                var indices = new Int32Array(m.i_verts.length);
+
+                for (var i = 0; i < m.i_verts.length; i++) {
+                    indices[i] = i;
+                }
+
+                spinner.processes--;
+
+                resolve(utils.apply(cfg, {
+                    primitive: "triangles",
+                    positions: positions,
+                    normals: normals.length > 0 ? normals : null,
+                    autoNormals: normals.length === 0,
+                    uv: uv,
+                    indices: indices
+                }));
+            },
+
+            function (msg) {
+                console.error("loadOBJGeometry: " + msg);
+                spinner.processes--;
+                reject();
+            });
+    });
+}
+
+export {loadOBJGeometry};

package/src/viewer/scene/index.js

@@ -0,0 +1,23 @@
+export * from "./camera/index.js";
+export * from "./geometry/index.js";
+export * from "./ImagePlane/index.js";
+export * from "./Bitmap/index.js";
+export * from "./LineSet/index.js";
+export * from "./lights/index.js";
+export * from "./marker/index.js";
+export * from "./materials/index.js";
+export * from "./math/index.js";
+export * from "./mementos/index.js";
+export * from "./mesh/index.js";
+export * from "./nodes/index.js";
+export * from "./paths/index.js";
+export * from "./model/index.js";
+export * from "./sectionPlane/index.js";
+export * from "./skybox/index.js";
+export * from "./utils/index.js";
+export * from "./Component.js";
+export * from "./utils.js";
+export * from "./stats.js";
+export * from "./constants/constants.js";
+export * from "./lod";
+export * from "./vfc";