@jdultra/threedtiles 10.0.0 → 10.0.2

package/README.md

@@ -6,24 +6,39 @@
 
 A faster 3DTiles viewer for three.js, now with OGC3DTiles 1.1 support
 
+## Demos
+
+[Google Tiles overlay](https://www.jdultra.com/overlay/index.html)
+overlay high quality meshes over google tiles with some shader magic to avoid overlap
+
 [Windows desktop viewer](https://github.com/ebeaufay/desktop-3dtiles-viewer)
+A viewer for windows based on flutter and this library
 
-[Google Map Tile API](https://www.jdultra.com/google-tiles/index.html) (experimental service with limited availability)
+[Google Map Tile API](https://www.jdultra.com/google-tiles/index.html) 
+google tiles in a geospatial framework [ULTRAGLOBE](https://github.com/ebeaufay/UltraGlobe)
 
-[Photogrametry (OBJ conversion)](https://ebeaufay.github.io/ThreedTilesViewer.github.io/)
+[Photogrametry](https://ebeaufay.github.io/ThreedTilesViewer.github.io/)
+Some tiles converted from OBJ via proprietary ULTRAMESH tool
 
 [Point cloud vs Mesh](https://www.jdultra.com/pointmeshing/index.html)
 
 [PBR material (GlTF conversion)](https://www.jdultra.com/pbr/)
 
 [Occlusion culling (IFC conversion)](https://www.jdultra.com/occlusion/index.html)
+Occlusion culling applied at the tile-loading level. This isn't just GPU occlusion culling, hidden tiles aren't even downloaded.
+
+[Instanced Tileset](https://www.jdultra.com/instanced/index.html)
+A multitude of identical meshes, each with its own LOD hiearchy but duplicate tiles are instanced
 
-[Instanced Tileset (pilot a swarm of highly detailed spaceships)](https://www.jdultra.com/instanced/index.html)
+## Getting started
 
-install the library and threejs if not done already:
+### DOC
+[JSDOC](https://www.jdultra.com/threedtiles/docs/)
+
+install the library:
 
 ```
-npm install three @jdultra/threedtiles --legacy-peer-deps
+npm install three @jdultra/threedtiles
 ```
 
 Adding a tileset to a scene is as easy as :
@@ -46,8 +61,8 @@ It's up to the user to call updates on the tileset.
 function animate() {
     requestAnimationFrame(animate);
     
-    ogc3DTile.update(camera);
-    ogc3DTile.tileLoader.update(); // important, since v10!
+    ogc3DTile.update(camera); // computes what tiles need to be refined and what tiles can be disposed.
+    ogc3DTile.tileLoader.update(); // downloads, loads and caches tiles in optimal order.
     
     ...
 
@@ -57,7 +72,7 @@ function animate() {
 It is discouraged to call the update functions outside the render loop in a setInterval for example.
 While that may work fine on desktop, mobile browsers tend to block an entire frame when a timeout triggers in it.
 
-Here is a simple project : [Getting started](https://drive.google.com/file/d/1kJ-yfYmy8ShOMMPPXgqW2gMgGkLOIidf/view?usp=share_link)
+Here is a simple project : [Getting started](https://drive.google.com/file/d/14lipb5eUqfad-n7EUgXuXul-drPdLifV/view?usp=sharing)
 
 Unzip and run :
 
@@ -69,7 +84,7 @@ Unzip and run :
 
 If you need to convert meshes to 3DTiles, from small assets to gigabytes of data, contact me for a trial on UltraMesh tool.
 It works for all types of meshes: photogrametry, BIM, colored or textured meshes with a single texture atlas or many individual textures.
-There's support for OBJ, IFC and glTF meshes and las/laz point clouds.
+There's support for OBJ, IFC, Collada and glTF meshes and las/laz point clouds.
 I aim for optimal quality in terms of mesh, texture and tileset structure and for optimal streaming speed, with no limit to the size of the input data.
 Contact: emeric.beaufays@jdultra.com
 
@@ -283,6 +298,8 @@ const ogc3DTile = new OGC3DTile({
 Then, you must update the occlusionCullingService within your render loop:
 ```
 function animate() {
+    ogc3DTile.update(camera);
+    ogc3DTile.tileLoader.update();
     requestAnimationFrame(animate);
     renderer.render(scene, camera);
     occlusionCullingService.update(scene, renderer, camera)
@@ -418,30 +435,17 @@ KTX uses an external wasm loaded at runtime so if you have trouble packaging you
 
 ### tileset update loop
 Updating a single tileset via OGC3DTile#update or InstancedOGC3DTile#update is quite fast, even when the tree is deep.
-For a single tileset, it's safe to call it regularly with a setInterval:
-```
-function startInterval() {
-        interval = setIntervalAsync(function () {
-            ogc3DTile.update(camera);
-        }, 20);
-    }
+For a single tileset, it's safe to call it on every frame:
 ```
-
-However, with instancedTilesets, you may have hundreds or even thousands of LOD trees that need to be updated individually. In order to preserve frame-rate,
-you may want to implement something a little smarter that yields the CPU to the render loop. In the example below, the process tries to update as many tilesets as it can in under 4 ms.
-
-```
-function now() {
-    return (typeof performance === 'undefined' ? Date : performance).now();
+function animate() {
+    requestAnimationFrame(animate);
+    ogc3DTile.update(camera);
+    ogc3DTile.tileLoader.update();
+    
+    ... // rest of render loop
 }
-let updateIndex = 0;
-setInterval(() => {
-    let startTime = now();
-    do{
-        instancedTilesets[updateIndex].update(camera);
-        updateIndex= (updateIndex+1)%instancedTilesets.length;
-    }while(updateIndex < instancedTilesets.length && now()-startTime<4);
-},50);
+animate();
 ```
 
-window#requestIdleCallback is also a good option but the rate of updates becomes slightly unpredictable.
+However, if you have several OGC3DTiles loaded or when you use instancedTilesets, you may have hundreds or even thousands of LOD trees that need to be updated individually. In order to preserve frame-rate,
+you'll want to avoid updating every single tileset on every frame.

package/dist/decoder/B3DMDecoder.d.ts

@@ -0,0 +1,8 @@
+export class B3DMDecoder {
+    constructor(renderer: any);
+    gltfLoader: any;
+    tempMatrix: any;
+    parseB3DM(arrayBuffer: any, meshCallback: any, sceneZupToYUp: any, meshZUpToYUp: any): Promise<any>;
+    checkLoaderInitialized: () => Promise<any>;
+    parseB3DMInstanced(arrayBuffer: any, meshCallback: any, maxCount: any, sceneZupToYUp: any, meshZupToYup: any): Promise<any>;
+}

package/dist/decoder/FeatureTable.d.ts

@@ -0,0 +1,14 @@
+export class FeatureTable {
+    constructor(buffer: any, start: any, headerLength: any, binLength: any);
+    buffer: any;
+    binOffset: any;
+    binLength: any;
+    header: any;
+    getKeys(): string[];
+    getData(key: any, count: any, defaultComponentType?: null, defaultType?: null): any;
+}
+export class BatchTable extends FeatureTable {
+    constructor(buffer: any, batchSize: any, start: any, headerLength: any, binLength: any);
+    batchSize: any;
+    getData(key: any, componentType?: null, type?: null): any;
+}

package/dist/draco-decoders/README.md

@@ -0,0 +1,32 @@
+# Draco 3D Data Compression
+
+Draco is an open-source library for compressing and decompressing 3D geometric meshes and point clouds. It is intended to improve the storage and transmission of 3D graphics.
+
+[Website](https://google.github.io/draco/) | [GitHub](https://github.com/google/draco)
+
+## Contents
+
+This folder contains three utilities:
+
+* `draco_decoder.js` — Emscripten-compiled decoder, compatible with any modern browser.
+* `draco_decoder.wasm` — WebAssembly decoder, compatible with newer browsers and devices.
+* `draco_wasm_wrapper.js` — JavaScript wrapper for the WASM decoder.
+
+Each file is provided in two variations:
+
+* **Default:** Latest stable builds, tracking the project's [master branch](https://github.com/google/draco).
+* **glTF:** Builds targeted by the [glTF mesh compression extension](https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_draco_mesh_compression), tracking the [corresponding Draco branch](https://github.com/google/draco/tree/gltf_2.0_draco_extension).
+
+Either variation may be used with `THREE.DRACOLoader`:
+
+```js
+var dracoLoader = new THREE.DRACOLoader();
+dracoLoader.setDecoderPath('path/to/decoders/');
+dracoLoader.setDecoderConfig({type: 'js'}); // (Optional) Override detection of WASM support.
+```
+
+Further [documentation on GitHub](https://github.com/google/draco/tree/master/javascript/example#static-loading-javascript-decoder).
+
+## License
+
+[Apache License 2.0](https://github.com/google/draco/blob/master/LICENSE)