@damienmortini/three 0.1.193 → 0.1.195

package/examples/utils/WorkerPool.js

@@ -1,102 +1,74 @@
-/**
- * @author Deepkolos / https://github.com/deepkolos
- */
-
+/**
+ * @author Deepkolos / https://github.com/deepkolos
+ */
+
 export class WorkerPool {
-
-	constructor( pool = 4 ) {
-
-		this.pool = pool;
-		this.queue = [];
-		this.workers = [];
-		this.workersResolve = [];
-		this.workerStatus = 0;
-
-	}
-
-	_initWorker( workerId ) {
-
-		if ( ! this.workers[ workerId ] ) {
-
-			const worker = this.workerCreator();
-			worker.addEventListener( 'message', this._onMessage.bind( this, workerId ) );
-			this.workers[ workerId ] = worker;
-
-		}
-
-	}
-
-	_getIdleWorker() {
-
-		for ( let i = 0; i < this.pool; i ++ )
-			if ( ! ( this.workerStatus & ( 1 << i ) ) ) return i;
-
-		return - 1;
-
-	}
-
-	_onMessage( workerId, msg ) {
-
-		const resolve = this.workersResolve[ workerId ];
-		resolve && resolve( msg );
-
-		if ( this.queue.length ) {
-
-			const { resolve, msg, transfer } = this.queue.shift();
-			this.workersResolve[ workerId ] = resolve;
-			this.workers[ workerId ].postMessage( msg, transfer );
-
-		} else {
-
-			this.workerStatus ^= 1 << workerId;
-
-		}
-
-	}
-
-	setWorkerCreator( workerCreator ) {
-
-		this.workerCreator = workerCreator;
-
-	}
-
-	setWorkerLimit( pool ) {
-
-		this.pool = pool;
-
-	}
-
-	postMessage( msg, transfer ) {
-
-		return new Promise( ( resolve ) => {
-
-			const workerId = this._getIdleWorker();
-
-			if ( workerId !== - 1 ) {
-
-				this._initWorker( workerId );
-				this.workerStatus |= 1 << workerId;
-				this.workersResolve[ workerId ] = resolve;
-				this.workers[ workerId ].postMessage( msg, transfer );
-
-			} else {
-
-				this.queue.push( { resolve, msg, transfer } );
-
-			}
-
-		} );
-
-	}
-
-	dispose() {
-
-		this.workers.forEach( ( worker ) => worker.terminate() );
-		this.workersResolve.length = 0;
-		this.workers.length = 0;
-		this.queue.length = 0;
-		this.workerStatus = 0;
-
-	}
-
-}
+  constructor(pool = 4) {
+    this.pool = pool;
+    this.queue = [];
+    this.workers = [];
+    this.workersResolve = [];
+    this.workerStatus = 0;
+  }
+
+  _initWorker(workerId) {
+    if (!this.workers[workerId]) {
+      const worker = this.workerCreator();
+      worker.addEventListener('message', this._onMessage.bind(this, workerId));
+      this.workers[workerId] = worker;
+    }
+  }
+
+  _getIdleWorker() {
+    for (let i = 0; i < this.pool; i++)
+      if (!(this.workerStatus & (1 << i))) return i;
+
+    return -1;
+  }
+
+  _onMessage(workerId, msg) {
+    const resolve = this.workersResolve[workerId];
+    resolve && resolve(msg);
+
+    if (this.queue.length) {
+      const { resolve, msg, transfer } = this.queue.shift();
+      this.workersResolve[workerId] = resolve;
+      this.workers[workerId].postMessage(msg, transfer);
+    }
+    else {
+      this.workerStatus ^= 1 << workerId;
+    }
+  }
+
+  setWorkerCreator(workerCreator) {
+    this.workerCreator = workerCreator;
+  }
+
+  setWorkerLimit(pool) {
+    this.pool = pool;
+  }
+
+  postMessage(msg, transfer) {
+    return new Promise((resolve) => {
+      const workerId = this._getIdleWorker();
+
+      if (workerId !== -1) {
+        this._initWorker(workerId);
+        this.workerStatus |= 1 << workerId;
+        this.workersResolve[workerId] = resolve;
+        this.workers[workerId].postMessage(msg, transfer);
+      }
+      else {
+        this.queue.push({ resolve, msg, transfer });
+      }
+    });
+  }
+
+  dispose() {
+    this.workers.forEach(worker => worker.terminate());
+    this.workersResolve.length = 0;
+    this.workers.length = 0;
+    this.queue.length = 0;
+    this.workerStatus = 0;
+  }
+}

package/gpgpu/THREEGPGPUSystem.js

@@ -1,10 +1,10 @@
-import { Mesh, OrthographicCamera, PlaneBufferGeometry, DataTexture, RGBAFormat, FloatType, WebGLRenderer, WebGLRenderTarget, Scene, NearestFilter, RGBFormat, HalfFloatType, MathUtils } from '../../../three/src/Three.js'
+import Float16 from '@damienmortini/core/math/Float16.js';
+import DatatextureShader from '@damienmortini/core/shader/DataTextureShader.js';
 
-import THREEShaderMaterial from '../material/THREEShaderMaterial.js'
-import DatatextureShader from '@damienmortini/core/shader/DataTextureShader.js'
-import Float16 from '@damienmortini/core/math/Float16.js'
+import { DataTexture, FloatType, HalfFloatType, MathUtils, Mesh, NearestFilter, OrthographicCamera, PlaneBufferGeometry, RGBAFormat, RGBFormat, Scene, WebGLRenderer, WebGLRenderTarget } from '../../../three/src/Three.js';
+import THREEShaderMaterial from '../material/THREEShaderMaterial.js';
 
-let DEBUG_RENDERER
+let DEBUG_RENDERER;
 
 export default class THREEGPGPUSystem {
   constructor({
@@ -16,29 +16,29 @@ export default class THREEGPGPUSystem {
     format = RGBAFormat,
     debug = false,
   }) {
-    this._renderer = renderer
-    this._stride = stride
+    this._renderer = renderer;
+    this._stride = stride;
 
-    const channels = format === RGBFormat ? 3 : 4
-    const dataSize = data.length / channels / stride
-    const width = MathUtils.ceilPowerOfTwo(Math.sqrt(dataSize))
-    this._dataTextureWidth = width * stride
-    this._dataTextureHeight = MathUtils.ceilPowerOfTwo(dataSize / width)
+    const channels = format === RGBFormat ? 3 : 4;
+    const dataSize = data.length / channels / stride;
+    const width = MathUtils.ceilPowerOfTwo(Math.sqrt(dataSize));
+    this._dataTextureWidth = width * stride;
+    this._dataTextureHeight = MathUtils.ceilPowerOfTwo(dataSize / width);
 
-    this.debug = debug
+    this.debug = debug;
 
-    const finalData = new Float32Array(this._dataTextureWidth * this._dataTextureHeight * channels)
-    finalData.set(data)
-    let dataTexture
+    const finalData = new Float32Array(this._dataTextureWidth * this._dataTextureHeight * channels);
+    finalData.set(data);
+    let dataTexture;
     // if (renderer.capabilities.isWebGL2) {
-    dataTexture = new DataTexture(finalData, this._dataTextureWidth, this._dataTextureHeight, format, FloatType)
+    dataTexture = new DataTexture(finalData, this._dataTextureWidth, this._dataTextureHeight, format, FloatType);
     // } else {
     // dataTexture = new DataTexture(Float16.fromFloat32Array(finalData), this._dataTextureWidth, this._dataTextureHeight, format, HalfFloatType);
     // }
-    dataTexture.needsUpdate = true
+    dataTexture.needsUpdate = true;
 
-    this.camera = new OrthographicCamera(-1, 1, 1, -1, 0, 1)
-    this.scene = new Scene()
+    this.camera = new OrthographicCamera(-1, 1, 1, -1, 0, 1);
+    this.scene = new Scene();
 
     this._webglRenderTargetIn = new WebGLRenderTarget(this._dataTextureWidth, this._dataTextureHeight, {
       minFilter: NearestFilter,
@@ -47,9 +47,9 @@ export default class THREEGPGPUSystem {
       stencilBuffer: false,
       depthBuffer: false,
       type: renderer.capabilities.isWebGL2 ? FloatType : HalfFloatType, // Half float for iOS
-    })
-    this._webglRenderTargetIn.texture.generateMipmaps = false
-    this._webglRenderTargetOut = this._webglRenderTargetIn.clone()
+    });
+    this._webglRenderTargetIn.texture.generateMipmaps = false;
+    this._webglRenderTargetOut = this._webglRenderTargetIn.clone();
 
     this._quad = new Mesh(new PlaneBufferGeometry(2, 2), new THREEShaderMaterial({
       uniforms: {
@@ -95,81 +95,81 @@ export default class THREEGPGPUSystem {
           }
         `],
       ],
-    }))
-    this.scene.add(this._quad)
+    }));
+    this.scene.add(this._quad);
   }
 
   get onBeforeRender() {
-    return this._quad.onBeforeRender
+    return this._quad.onBeforeRender;
   }
 
   set onBeforeRender(value) {
-    this._quad.onBeforeRender = value
+    this._quad.onBeforeRender = value;
   }
 
   get material() {
-    return this._quad.material
+    return this._quad.material;
   }
 
   get dataTextureWidth() {
-    return this._dataTextureWidth
+    return this._dataTextureWidth;
   }
 
   get dataTextureHeight() {
-    return this._dataTextureHeight
+    return this._dataTextureHeight;
   }
 
   get dataTextureSize() {
-    return [this._dataTextureWidth, this._dataTextureHeight]
+    return [this._dataTextureWidth, this._dataTextureHeight];
   }
 
   get dataTexture() {
-    return this._quad.material.dataTexture
+    return this._quad.material.dataTexture;
   }
 
   get stride() {
-    return this._stride
+    return this._stride;
   }
 
   get debug() {
-    return this._debug
+    return this._debug;
   }
 
   set debug(value) {
-    this._debug = value
+    this._debug = value;
     if (this._debug && !DEBUG_RENDERER) {
-      DEBUG_RENDERER = new WebGLRenderer()
-      document.body.appendChild(DEBUG_RENDERER.domElement)
-      DEBUG_RENDERER.setSize(this._dataTextureWidth, this._dataTextureHeight, false)
-      DEBUG_RENDERER.domElement.style.position = 'absolute'
-      DEBUG_RENDERER.domElement.style.bottom = '0'
-      DEBUG_RENDERER.domElement.style.left = '0'
-      DEBUG_RENDERER.domElement.style.width = '100%'
-      DEBUG_RENDERER.domElement.style.height = '25%'
-      DEBUG_RENDERER.domElement.style.imageRendering = 'pixelated'
+      DEBUG_RENDERER = new WebGLRenderer();
+      document.body.appendChild(DEBUG_RENDERER.domElement);
+      DEBUG_RENDERER.setSize(this._dataTextureWidth, this._dataTextureHeight, false);
+      DEBUG_RENDERER.domElement.style.position = 'absolute';
+      DEBUG_RENDERER.domElement.style.bottom = '0';
+      DEBUG_RENDERER.domElement.style.left = '0';
+      DEBUG_RENDERER.domElement.style.width = '100%';
+      DEBUG_RENDERER.domElement.style.height = '25%';
+      DEBUG_RENDERER.domElement.style.imageRendering = 'pixelated';
     }
     if (DEBUG_RENDERER) {
-      DEBUG_RENDERER.domElement.hidden = !this._debug
+      DEBUG_RENDERER.domElement.hidden = !this._debug;
     }
   }
 
   update() {
-    const savedRendertarget = this._renderer.getRenderTarget()
+    const savedRendertarget = this._renderer.getRenderTarget();
 
-    this._renderer.setRenderTarget(this._webglRenderTargetOut)
-    this._renderer.render(this.scene, this.camera)
+    this._renderer.setRenderTarget(this._webglRenderTargetOut);
+    this._renderer.render(this.scene, this.camera);
 
     if (this.debug) {
-      DEBUG_RENDERER.setRenderTarget(this._webglRenderTargetOut)
-      DEBUG_RENDERER.render(this.scene, this.camera)
-      DEBUG_RENDERER.setRenderTarget(null)
-      DEBUG_RENDERER.render(this.scene, this.camera)
+      DEBUG_RENDERER.setRenderTarget(this._webglRenderTargetOut);
+      DEBUG_RENDERER.render(this.scene, this.camera);
+      DEBUG_RENDERER.setRenderTarget(null);
+      DEBUG_RENDERER.render(this.scene, this.camera);
     }
 
-    [this._webglRenderTargetIn, this._webglRenderTargetOut] = [this._webglRenderTargetOut, this._webglRenderTargetIn]
+    [this._webglRenderTargetIn, this._webglRenderTargetOut] = [this._webglRenderTargetOut, this._webglRenderTargetIn];
 
-    this._quad.material.dataTexture = this._webglRenderTargetIn.texture
+    this._quad.material.dataTexture = this._webglRenderTargetIn.texture;
 
-    this._renderer.setRenderTarget(savedRendertarget)
+    this._renderer.setRenderTarget(savedRendertarget);
   }
 }

package/index.js

@@ -1 +1 @@
-export { WebGLRenderTarget2D } from './renderer/WebGLRenderTarget2D.js'
+export { WebGLRenderTarget2D } from './renderer/WebGLRenderTarget2D.js';

package/loader/THREELoader.js

@@ -1,117 +1,122 @@
-import { Loader } from '@damienmortini/core/util/Loader.js'
-import { BasisTextureLoader } from '../examples/loaders/BasisTextureLoader.js'
-import { DRACOLoader } from '../examples/loaders/DRACOLoader.js'
-import { GLTFLoader } from '../examples/loaders/GLTFLoader.js'
-import { KTX2Loader } from '../examples/loaders/KTX2Loader.js'
-import { Mesh, Line, LineSegments, Vector3, WebGLRenderer, TextureLoader } from '../../../three/src/Three.js'
+import { Loader } from '@damienmortini/core/util/Loader.js';
 
-let renderer
+import { Line, LineSegments, Mesh, TextureLoader, Vector3, WebGLRenderer } from '../../../three/src/Three.js';
+import { BasisTextureLoader } from '../examples/loaders/BasisTextureLoader.js';
+import { DRACOLoader } from '../examples/loaders/DRACOLoader.js';
+import { GLTFLoader } from '../examples/loaders/GLTFLoader.js';
+import { KTX2Loader } from '../examples/loaders/KTX2Loader.js';
+
+let renderer;
 const getEmptyRenderer = () => {
-  if (renderer) return renderer
+  if (renderer) return renderer;
   if (window.WebGL2RenderingContext !== undefined && !/\bforcewebgl1\b/.test(window.location.search)) {
-    const canvas = document.createElement('canvas')
+    const canvas = document.createElement('canvas');
     renderer = new WebGLRenderer({
       canvas: canvas,
       context: canvas.getContext('webgl2'),
-    })
-  } else {
-    renderer = new WebGLRenderer()
+    });
+  }
+  else {
+    renderer = new WebGLRenderer();
   }
-  return renderer
-}
+  return renderer;
+};
 
 function computeSceneGeometry(data, scale, offset) {
-  const hasOffset = offset.lengthSq() !== 0
+  const hasOffset = offset.lengthSq() !== 0;
   data.traverse((object3D) => {
     if (hasOffset) {
       if (object3D instanceof Mesh || object3D instanceof Line || object3D instanceof LineSegments) {
-        object3D.geometry.translate(offset.x, offset.y, offset.z)
+        object3D.geometry.translate(offset.x, offset.y, offset.z);
       }
     }
     if (scale !== 1) {
       if (object3D instanceof Mesh || object3D instanceof Line || object3D instanceof LineSegments) {
-        object3D.geometry.scale(scale, scale, scale)
+        object3D.geometry.scale(scale, scale, scale);
       }
-      object3D.position.multiplyScalar(scale)
+      object3D.position.multiplyScalar(scale);
     }
-  })
+  });
 }
 
-let gltfLoader
-let dracoLoader
-let basisLoader
-let ktx2Loader
+let gltfLoader;
+let dracoLoader;
+let basisLoader;
+let ktx2Loader;
 
-let meshOptimizerInitialized = false
+let meshOptimizerInitialized = false;
 
 class THREELoader extends Loader {
   constructor() {
-    super()
-    this.dracoDecoderPath = 'node_modules/three/examples/js/libs/draco/'
-    this.basisTranscoderPath = 'node_modules/three/examples/js/libs/basis/'
+    super();
+    this.dracoDecoderPath = 'node_modules/three/examples/js/libs/draco/';
+    this.basisTranscoderPath = 'node_modules/three/examples/js/libs/basis/';
 
-    this.extensionTypeMap.set('gltf', 'model/gltf+json')
-    this.extensionTypeMap.set('glb', 'model/gltf-binary')
-    this.extensionTypeMap.set('basis', 'image/basis')
+    this.extensionTypeMap.set('gltf', 'model/gltf+json');
+    this.extensionTypeMap.set('glb', 'model/gltf-binary');
+    this.extensionTypeMap.set('basis', 'image/basis');
   }
 
   async _loadFile({ src, type, scale = 1, offset = new Vector3(), meshOptimizer = false }) {
     if (type.startsWith('model')) {
-      const [, path, file] = /(.*[\/\\])(.*$)/.exec(src)
+      const [, path, file] = /(.*[\/\\])(.*$)/.exec(src);
 
       if (!gltfLoader) {
-        gltfLoader = new GLTFLoader(undefined)
-        dracoLoader = new DRACOLoader(undefined)
-        dracoLoader.setWorkerLimit(2)
-        gltfLoader.setDRACOLoader(dracoLoader)
-        ktx2Loader = new KTX2Loader()
-        gltfLoader.setKTX2Loader(ktx2Loader)
-        ktx2Loader.detectSupport(getEmptyRenderer())
+        gltfLoader = new GLTFLoader(undefined);
+        dracoLoader = new DRACOLoader(undefined);
+        dracoLoader.setWorkerLimit(2);
+        gltfLoader.setDRACOLoader(dracoLoader);
+        ktx2Loader = new KTX2Loader();
+        gltfLoader.setKTX2Loader(ktx2Loader);
+        ktx2Loader.detectSupport(getEmptyRenderer());
       }
 
       if (meshOptimizer && !meshOptimizerInitialized) {
-        await import('./meshoptimizerdecoder/meshopt_decoder.js')
-        const { EXT_meshopt_compression } = await import('./meshoptimizerdecoder/THREE.EXT_meshopt_compression.js')
+        await import('./meshoptimizerdecoder/meshopt_decoder.js');
+        const { EXT_meshopt_compression } = await import('./meshoptimizerdecoder/THREE.EXT_meshopt_compression.js');
         gltfLoader.register(function (parser) {
-          const res = new EXT_meshopt_compression(parser, MeshoptDecoder)
-          res.name = 'MESHOPT_compression'
-          return res
-        })
-        meshOptimizerInitialized = true
+          const res = new EXT_meshopt_compression(parser, MeshoptDecoder);
+          res.name = 'MESHOPT_compression';
+          return res;
+        });
+        meshOptimizerInitialized = true;
       }
 
-      dracoLoader.setDecoderPath(`${this.baseURI}${this.dracoDecoderPath}`)
-      ktx2Loader.setTranscoderPath(`${this.baseURI}${this.basisTranscoderPath}`)
-      gltfLoader.setPath(path)
+      dracoLoader.setDecoderPath(`${this.baseURI}${this.dracoDecoderPath}`);
+      ktx2Loader.setTranscoderPath(`${this.baseURI}${this.basisTranscoderPath}`);
+      gltfLoader.setPath(path);
 
       return new Promise((resolve) => {
         gltfLoader.load(file, (data) => {
-          computeSceneGeometry(data.scene, scale, offset)
-          resolve(data)
-        })
-      })
-    } else if (type === 'image/basis') {
+          computeSceneGeometry(data.scene, scale, offset);
+          resolve(data);
+        });
+      });
+    }
+    else if (type === 'image/basis') {
       if (!basisLoader) {
-        basisLoader = new BasisTextureLoader(undefined)
-        basisLoader.setWorkerLimit(2)
-        basisLoader.detectSupport(getEmptyRenderer())
+        basisLoader = new BasisTextureLoader(undefined);
+        basisLoader.setWorkerLimit(2);
+        basisLoader.detectSupport(getEmptyRenderer());
       }
-      basisLoader.setTranscoderPath(`${this.baseURI}${this.basisTranscoderPath}`)
+      basisLoader.setTranscoderPath(`${this.baseURI}${this.basisTranscoderPath}`);
       return new Promise((resolve) => {
         basisLoader.load(src, (texture) => {
-          resolve(texture)
-        })
-      })
-    } else if (type.startsWith('image') || type.startsWith('video')) {
+          resolve(texture);
+        });
+      });
+    }
+    else if (type.startsWith('image') || type.startsWith('video')) {
       return new Promise((resolve) => {
         new TextureLoader().load(src, (texture) => {
-          resolve(texture)
-        })
-      })
-    } else {
-      return super._loadFile({ src, type })
+          resolve(texture);
+        });
+      });
+    }
+    else {
+      return super._loadFile({ src, type });
     }
   }
 }
 
-export default new THREELoader()
+export default new THREELoader();

package/loader/meshoptimizerdecoder/THREE.EXT_meshopt_compression.js

@@ -2,40 +2,41 @@
 /* loader.register(function (parser) { return new EXT_meshopt_compression(parser, MeshoptDecoder); }); */
 const EXT_meshopt_compression = (function () {
   function EXT_meshopt_compression(parser, decoder) {
-    this.name = 'EXT_meshopt_compression'
-    this._parser = parser
-    this._decoder = decoder
+    this.name = 'EXT_meshopt_compression';
+    this._parser = parser;
+    this._decoder = decoder;
   }
 
   EXT_meshopt_compression.prototype.loadBufferView = function (index) {
-    	const bufferView = this._parser.json.bufferViews[index]
+    	const bufferView = this._parser.json.bufferViews[index];
 
     if (bufferView.extensions && bufferView.extensions[this.name]) {
-      const extensionDef = bufferView.extensions[this.name]
+      const extensionDef = bufferView.extensions[this.name];
 
-      const buffer = this._parser.getDependency('buffer', extensionDef.buffer)
-      const decoder = this._decoder
+      const buffer = this._parser.getDependency('buffer', extensionDef.buffer);
+      const decoder = this._decoder;
 
       return Promise.all([buffer, decoder.ready]).then(function (res) {
-            	const byteOffset = extensionDef.byteOffset || 0
-            	const byteLength = extensionDef.byteLength || 0
+            	const byteOffset = extensionDef.byteOffset || 0;
+            	const byteLength = extensionDef.byteLength || 0;
 
-            	const count = extensionDef.count
-            	const stride = extensionDef.byteStride
+            	const count = extensionDef.count;
+            	const stride = extensionDef.byteStride;
 
-            	const result = new ArrayBuffer(count * stride)
-            	const source = new Uint8Array(res[0], byteOffset, byteLength)
+            	const result = new ArrayBuffer(count * stride);
+            	const source = new Uint8Array(res[0], byteOffset, byteLength);
 
-            	decoder.decodeGltfBuffer(new Uint8Array(result), count, stride, source, extensionDef.mode, extensionDef.filter)
-            	return result
-      })
-    } else {
-      return null
+            	decoder.decodeGltfBuffer(new Uint8Array(result), count, stride, source, extensionDef.mode, extensionDef.filter);
+            	return result;
+      });
+    }
+    else {
+      return null;
     }
-  }
+  };
 
-  return EXT_meshopt_compression
-}())
+  return EXT_meshopt_compression;
+}());
 
 /* three.js uses JS modules exclusively since r124 */
-export { EXT_meshopt_compression }
+export { EXT_meshopt_compression };