@damienmortini/three 0.1.193 → 0.1.195

package/renderer/THREERenderer.js

@@ -1,123 +1,127 @@
 import {
-  WebGLRenderer,
-  WebGLRenderTarget,
   DepthTexture,
-  RGBAFormat,
   LinearFilter,
-  UnsignedShortType,
-  Scene,
-  OrthographicCamera,
   Mesh,
+  OrthographicCamera,
   PlaneGeometry,
-} from '../../../three/src/Three.js'
+  RGBAFormat,
+  Scene,
+  UnsignedShortType,
+  WebGLRenderer,
+  WebGLRenderTarget,
+} from '../../../three/src/Three.js';
 
 export default class THREERenderer extends WebGLRenderer {
   constructor(options) {
-    super(Object.assign({ antialias: true }, options))
+    super(Object.assign({ antialias: true }, options));
 
-    this.filters = []
-    this._renderTargets = new Map()
+    this.filters = [];
+    this._renderTargets = new Map();
 
     const renderTargetIn = new WebGLRenderTarget(this.domElement.width, this.domElement.height, {
       format: RGBAFormat,
       minFilter: LinearFilter,
       magFilter: LinearFilter,
       stencilBuffer: false,
-    })
-    renderTargetIn.texture.generateMipmaps = false
+    });
+    renderTargetIn.texture.generateMipmaps = false;
 
-    const renderTargetOut = renderTargetIn.clone()
-    renderTargetOut.texture.generateMipmaps = false
+    const renderTargetOut = renderTargetIn.clone();
+    renderTargetOut.texture.generateMipmaps = false;
 
     if (this.context.getExtension('WEBGL_depth_texture')) {
-      renderTargetIn.depthTexture = new DepthTexture()
-      renderTargetIn.depthTexture.type = UnsignedShortType
-      renderTargetOut.depthTexture = new DepthTexture()
-      renderTargetOut.depthTexture.type = UnsignedShortType
+      renderTargetIn.depthTexture = new DepthTexture();
+      renderTargetIn.depthTexture.type = UnsignedShortType;
+      renderTargetOut.depthTexture = new DepthTexture();
+      renderTargetOut.depthTexture.type = UnsignedShortType;
     }
 
     this._renderTargets.set(this, {
       in: renderTargetIn,
       out: renderTargetOut,
-    })
+    });
 
-    this.scene = new Scene()
-    this.scene.camera = new OrthographicCamera(-1, 1, 1, -1, 0, 1)
-    this._quad = new Mesh(new PlaneGeometry(2, 2))
-    this._quad.frustumCulled = false
-    this.scene.add(this._quad)
+    this.scene = new Scene();
+    this.scene.camera = new OrthographicCamera(-1, 1, 1, -1, 0, 1);
+    this._quad = new Mesh(new PlaneGeometry(2, 2));
+    this._quad.frustumCulled = false;
+    this.scene.add(this._quad);
 
     // Fix to make WebGLRenderer.render extendable
-    this._render = this.render
-    delete this.render
+    this._render = this.render;
+    delete this.render;
   }
 
   applyFilter(filter, renderTargetIn, renderTargetOut) {
-    this._quad.material = filter
+    this._quad.material = filter;
     if (filter.renderTargetTexture) {
-      filter.renderTargetTexture = renderTargetIn.texture
+      filter.renderTargetTexture = renderTargetIn.texture;
     }
     if (filter.renderTargetDepthTexture && renderTargetIn.depthTexture) {
-      filter.renderTargetDepthTexture = renderTargetIn.depthTexture
+      filter.renderTargetDepthTexture = renderTargetIn.depthTexture;
     }
-    this._render(this.scene, this.scene.camera, renderTargetOut)
+    this._render(this.scene, this.scene.camera, renderTargetOut);
   }
 
   resize(width, height) {
-    this.setSize(width, height, false)
-    const renderTargets = this._renderTargets.get(this)
-    renderTargets.in.setSize(width, height)
-    renderTargets.out.setSize(width, height)
+    this.setSize(width, height, false);
+    const renderTargets = this._renderTargets.get(this);
+    renderTargets.in.setSize(width, height);
+    renderTargets.out.setSize(width, height);
   }
 
   render({ scene, camera = undefined, filters = this.filters, renderTarget = undefined, viewport = undefined, scissor = viewport } = {}) {
     if (arguments.length > 1) {
-      this._render(...arguments)
-      return
+      this._render(...arguments);
+      return;
     }
-    let renderTargets = this._renderTargets.get(renderTarget || this)
+    let renderTargets = this._renderTargets.get(renderTarget || this);
     if (!renderTargets) {
       renderTargets = {
         in: renderTarget.clone(),
         out: renderTarget.clone(),
-      }
-      renderTargets.in.texture.generateMipmaps = false
-      renderTargets.out.texture.generateMipmaps = false
-      this._renderTargets.set(renderTarget, renderTargets)
+      };
+      renderTargets.in.texture.generateMipmaps = false;
+      renderTargets.out.texture.generateMipmaps = false;
+      this._renderTargets.set(renderTarget, renderTargets);
     }
     if (viewport || scissor) {
       if (viewport) {
         if (renderTarget) {
-          renderTarget.viewport.set(viewport[0], viewport[1], viewport[2], viewport[3])
-        } else {
-          this.setViewport(viewport[0], viewport[1], viewport[2], viewport[3])
+          renderTarget.viewport.set(viewport[0], viewport[1], viewport[2], viewport[3]);
+        }
+        else {
+          this.setViewport(viewport[0], viewport[1], viewport[2], viewport[3]);
         }
       }
       if (renderTarget) {
-        renderTarget.scissor.set(scissor[0], scissor[1], scissor[2], scissor[3])
-        renderTarget.scissorTest = true
-      } else {
-        this.setScissor(scissor[0], scissor[1], scissor[2], scissor[3])
-        this.setScissorTest(true)
+        renderTarget.scissor.set(scissor[0], scissor[1], scissor[2], scissor[3]);
+        renderTarget.scissorTest = true;
+      }
+      else {
+        this.setScissor(scissor[0], scissor[1], scissor[2], scissor[3]);
+        this.setScissorTest(true);
       }
-    } else {
+    }
+    else {
       if (renderTarget) {
-        renderTarget.viewport.set(0, 0, renderTarget.width, renderTarget.height)
-        renderTarget.scissor.set(0, 0, renderTarget.width, renderTarget.height)
-        renderTarget.scissorTest = false
-      } else {
-        this.setViewport(0, 0, this.domElement.width, this.domElement.height)
-        this.setScissor(0, 0, this.domElement.width, this.domElement.height)
-        this.setScissorTest(false)
+        renderTarget.viewport.set(0, 0, renderTarget.width, renderTarget.height);
+        renderTarget.scissor.set(0, 0, renderTarget.width, renderTarget.height);
+        renderTarget.scissorTest = false;
+      }
+      else {
+        this.setViewport(0, 0, this.domElement.width, this.domElement.height);
+        this.setScissor(0, 0, this.domElement.width, this.domElement.height);
+        this.setScissorTest(false);
       }
     }
     if (scene) {
-      camera = camera || scene.camera
-      this._render(scene, camera, filters.length ? renderTargets.in : renderTarget)
+      camera = camera || scene.camera;
+      this._render(scene, camera, filters.length ? renderTargets.in : renderTarget);
     }
     for (const [i, filter] of filters.entries()) {
       this.applyFilter(filter, renderTargets.in, i < filters.length - 1 ? renderTargets.out : renderTarget);
-      [renderTargets.in, renderTargets.out] = [renderTargets.out, renderTargets.in]
+      [renderTargets.in, renderTargets.out] = [renderTargets.out, renderTargets.in];
     }
   }
 }

package/renderer/THREEStereoRenderer.js

@@ -1,60 +1,63 @@
-import { WebGLRenderer, StereoCamera } from '../../../three/src/Three.js'
+import { StereoCamera, WebGLRenderer } from '../../../three/src/Three.js';
 
 export default class THREEStereoRenderer {
   constructor(renderer = new WebGLRenderer()) {
-    this.renderer = renderer
+    this.renderer = renderer;
 
-    this._stereoCamera = new StereoCamera()
-    this._stereoCamera.aspect = 0.5
+    this._stereoCamera = new StereoCamera();
+    this._stereoCamera.aspect = 0.5;
   }
 
   set eyeOffset(value) {
-    this._stereoCamera.eyeSep = value
+    this._stereoCamera.eyeSep = value;
   }
 
   setSize(width, height) {
-    this.renderer.setSize(width, height)
+    this.renderer.setSize(width, height);
   }
 
   render(scene, camera, renderTarget) {
-    scene.updateMatrixWorld()
+    scene.updateMatrixWorld();
 
-    if (camera.parent === null) camera.updateMatrixWorld()
+    if (camera.parent === null) camera.updateMatrixWorld();
 
-    this._stereoCamera.update(camera)
+    this._stereoCamera.update(camera);
 
-    const size = this.renderer.getSize()
+    const size = this.renderer.getSize();
 
-    this.renderer.clear()
+    this.renderer.clear();
 
     if (renderTarget) {
-      renderTarget.scissorTest = true
-      renderTarget.scissor.set(0, 0, size.width * .5, size.height)
-      renderTarget.viewport.set(0, 0, size.width * .5, size.height)
-    } else {
-      this.renderer.setScissorTest(true)
-      this.renderer.setScissor(0, 0, size.width * .5, size.height)
-      this.renderer.setViewport(0, 0, size.width * .5, size.height)
+      renderTarget.scissorTest = true;
+      renderTarget.scissor.set(0, 0, size.width * 0.5, size.height);
+      renderTarget.viewport.set(0, 0, size.width * 0.5, size.height);
+    }
+    else {
+      this.renderer.setScissorTest(true);
+      this.renderer.setScissor(0, 0, size.width * 0.5, size.height);
+      this.renderer.setViewport(0, 0, size.width * 0.5, size.height);
     }
-    this.renderer.render(scene, this._stereoCamera.cameraL, renderTarget)
+    this.renderer.render(scene, this._stereoCamera.cameraL, renderTarget);
 
     if (renderTarget) {
-      renderTarget.scissor.set(size.width * .5, 0, size.width * .5, size.height)
-      renderTarget.viewport.set(size.width * .5, 0, size.width * .5, size.height)
-    } else {
-      this.renderer.setScissor(size.width * .5, 0, size.width * .5, size.height)
-      this.renderer.setViewport(size.width * .5, 0, size.width * .5, size.height)
+      renderTarget.scissor.set(size.width * 0.5, 0, size.width * 0.5, size.height);
+      renderTarget.viewport.set(size.width * 0.5, 0, size.width * 0.5, size.height);
+    }
+    else {
+      this.renderer.setScissor(size.width * 0.5, 0, size.width * 0.5, size.height);
+      this.renderer.setViewport(size.width * 0.5, 0, size.width * 0.5, size.height);
     }
-    this.renderer.render(scene, this._stereoCamera.cameraR, renderTarget)
+    this.renderer.render(scene, this._stereoCamera.cameraR, renderTarget);
 
     if (renderTarget) {
-      renderTarget.scissorTest = false
-      renderTarget.scissor.set(0, 0, size.width, size.height)
-      renderTarget.viewport.set(0, 0, size.width, size.height)
-    } else {
-      this.renderer.setScissorTest(false)
-      this.renderer.setScissor(0, 0, size.width, size.height)
-      this.renderer.setViewport(0, 0, size.width, size.height)
+      renderTarget.scissorTest = false;
+      renderTarget.scissor.set(0, 0, size.width, size.height);
+      renderTarget.viewport.set(0, 0, size.width, size.height);
+    }
+    else {
+      this.renderer.setScissorTest(false);
+      this.renderer.setScissor(0, 0, size.width, size.height);
+      this.renderer.setViewport(0, 0, size.width, size.height);
     }
   }
 }

package/renderer/WebGLRenderTarget2D.js

@@ -1,9 +1,9 @@
-import { Scene, Mesh, PlaneGeometry, WebGLRenderTarget, OrthographicCamera } from 'three'
+import { Mesh, OrthographicCamera, PlaneGeometry, Scene, WebGLRenderTarget } from 'three';
 
 export class WebGLRenderTarget2D extends WebGLRenderTarget {
-  #scene
-  #camera
-  #quad
+  #scene;
+  #camera;
+  #quad;
 
   constructor({
     renderer,
@@ -36,28 +36,28 @@ export class WebGLRenderTarget2D extends WebGLRenderTarget {
       depthBuffer,
       stencilBuffer,
       depthTexture,
-    })
+    });
 
-    this.renderer = renderer
+    this.renderer = renderer;
 
-    this.#scene = new Scene()
-    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.#quad = new Mesh(new PlaneGeometry(2, 2), material)
-    this.#scene.add(this.#quad)
+    this.#quad = new Mesh(new PlaneGeometry(2, 2), material);
+    this.#scene.add(this.#quad);
   }
 
   get material() {
-    return this.#quad.material
+    return this.#quad.material;
   }
 
   set material(value) {
-    this.#quad.material = value
+    this.#quad.material = value;
   }
 
   render({ debug = false } = {}) {
-    if (!debug) this.renderer.setRenderTarget(this)
-    this.renderer.render(this.#scene, this.#camera)
-    this.renderer.setRenderTarget(null)
+    if (!debug) this.renderer.setRenderTarget(this);
+    this.renderer.render(this.#scene, this.#camera);
+    this.renderer.setRenderTarget(null);
   }
 }

package/shader/THREEBaseShader.js

@@ -30,4 +30,4 @@ export default {
       in float vFresnel;
     `],
   ],
-}
+};

package/types/index.d.ts

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

package/types/renderer/WebGLRenderTarget2D.d.ts

@@ -17,26 +17,26 @@ export class WebGLRenderTarget2D {
     stencilBuffer,
     depthTexture,
   }: {
-    renderer: any
-    material?: any
-    width?: number
-    height?: number
-    wrapS?: any
-    wrapT?: any
-    magFilter?: any
-    minFilter?: any
-    format?: any
-    type?: any
-    anisotropy?: any
-    encoding?: any
-    generateMipmaps?: any
-    depthBuffer?: any
-    stencilBuffer?: any
-    depthTexture?: any
-  })
-  renderer: any
-  set material(arg: any)
-  get material(): any
-  render({ debug }?: { debug?: boolean }): void
-  #private
+    renderer: any;
+    material?: any;
+    width?: number;
+    height?: number;
+    wrapS?: any;
+    wrapT?: any;
+    magFilter?: any;
+    minFilter?: any;
+    format?: any;
+    type?: any;
+    anisotropy?: any;
+    encoding?: any;
+    generateMipmaps?: any;
+    depthBuffer?: any;
+    stencilBuffer?: any;
+    depthTexture?: any;
+  });
+  renderer: any;
+  set material(arg: any);
+  get material(): any;
+  render({ debug }?: { debug?: boolean }): void;
+  #private;
 }