ohzi-core 6.4.0 → 6.5.2

package/src/render_mode/PlanarReflectionsRender.js

@@ -1,118 +1,118 @@
-import basic_color_frag from '../shaders/basic_color/basic_color.frag';
-import basic_color_vert from '../shaders/basic_color/basic_color.vert';
-import SceneManager from '../SceneManager';
-import CameraManager from '../CameraManager';
-import ReflectionPlaneContext from '../ReflectionPlaneContext';
-import Screen from '../Screen';
-import BaseRender from '../render_mode/BaseRender';
-
-import { ShaderMaterial } from 'three';
-import { Matrix4 } from 'three';
-import { Vector4 } from 'three';
-import { Scene } from 'three';
-import { MeshBasicMaterial } from 'three';
-import { Mesh } from 'three';
-
-export default class PlanarReflectionsRender extends BaseRender
-{
-  constructor()
-  {
-    super();
-    const color = 0.946;
-    this.plane_material_solid = new ShaderMaterial({
-      uniforms: {
-        _Color: { value: new Vector4(color, color, color, 0.5) }
-      },
-      vertexShader: basic_color_vert,
-      fragmentShader: basic_color_frag,
-      transparent: true,
-      depthWrite: false
-    });
-
-    this.stencil_mask_scene = new Scene();
-
-    this.original_view_matrix = new Matrix4();
-    this.inverted_view_matrix = new Matrix4();
-    this.reflection_matrix    = new Matrix4().set(1, 0, 0, 0,
-      0, -1, 0, 0,
-      0, 0, 1, 0,
-      0, 0, 0, 1);
-
-    this.gl = undefined;
-  }
-
-  on_enter(context, renderer)
-  {
-    this.gl = renderer.domElement.getContext('webgl');
-    CameraManager.current.parent = SceneManager.current;
-
-    const plane_material_mask = new MeshBasicMaterial({ color: CameraManager.current.clear_color, depthWrite: false });
-    this.plane_mask = new Mesh(ReflectionPlaneContext.target_geometry, plane_material_mask);
-    this.plane_solid = new Mesh(ReflectionPlaneContext.target_geometry, this.plane_material_solid);
-
-    const clear_color = CameraManager.current.clear_color;
-    this.plane_material_solid.uniforms._Color.value.set(clear_color.r, clear_color.g, clear_color.b, 0.5);
-
-    this.stencil_mask_scene.add(this.plane_mask);
-    SceneManager.current.add(this.plane_solid);
-    this.plane_solid.visible = false;
-
-    CameraManager.current.matrixAutoUpdate = false;
-    renderer.autoClear = false;
-  }
-
-  render(context, renderer)
-  {
-    if (CameraManager.current)
-    {
-      CameraManager.current.aspect = Screen.aspect_ratio;
-      CameraManager.current.updateProjectionMatrix();
-      CameraManager.current.updateMatrix();
-      CameraManager.current.updateMatrixWorld(true);
-
-      renderer.setClearColor(CameraManager.current.clear_color, CameraManager.current.clear_alpha);
-
-      this.__render_stencil_mask(renderer, this.gl);
-
-      this.plane_solid.visible = true;
-      this.__render_reflected_scene(renderer, this.gl);
-      this.plane_solid.visible = true;
-
-      // render scene
-
-      renderer.clear(false, true, false);
-      this.plane_solid.visible = true;
-      renderer.render(SceneManager.current, CameraManager.current);
-    }
-  }
-
-  __render_stencil_mask(renderer, gl)
-  {
-    // RENDER MASK
-    gl.enable(gl.STENCIL_TEST);
-    gl.stencilFunc(gl.ALWAYS, 1, 1);
-    gl.stencilOp(gl.KEEP, gl.REPLACE, gl.REPLACE);
-    renderer.clear(true, true, true);
-    renderer.render(this.stencil_mask_scene, CameraManager.current);
-  }
-
-  __render_reflected_scene(renderer, gl)
-  {
-    // // RENDER REFLECTION
-    gl.stencilFunc(gl.EQUAL, 1, 1);
-    gl.stencilOp(gl.KEEP, gl.REPLACE, gl.REPLACE);
-    this.reflection_matrix.set(1, 0, 0, 0,
-      0, -1, 0, ReflectionPlaneContext.target_position.y * 2,
-      0, 0, 1, 0,
-      0, 0, 0, 1);
-    this.original_view_matrix.copy(CameraManager.current.matrixWorldInverse);
-    this.inverted_view_matrix.copy(CameraManager.current.matrixWorldInverse).multiply(this.reflection_matrix);
-    CameraManager.current.matrixWorldInverse.copy(this.inverted_view_matrix.clone());
-
-    renderer.render(SceneManager.current, CameraManager.current);
-
-    gl.disable(gl.STENCIL_TEST);
-
-    CameraManager.current.matrixWorldInverse.copy(this.original_view_matrix);
-  }
-}
+import basic_color_frag from '../shaders/basic_color/basic_color.frag';
+import basic_color_vert from '../shaders/basic_color/basic_color.vert';
+import SceneManager from '../SceneManager';
+import CameraManager from '../CameraManager';
+import ReflectionPlaneContext from '../ReflectionPlaneContext';
+import Screen from '../Screen';
+import BaseRender from '../render_mode/BaseRender';
+
+import { ShaderMaterial } from 'three';
+import { Matrix4 } from 'three';
+import { Vector4 } from 'three';
+import { Scene } from 'three';
+import { MeshBasicMaterial } from 'three';
+import { Mesh } from 'three';
+
+export default class PlanarReflectionsRender extends BaseRender
+{
+  constructor()
+  {
+    super();
+    const color = 0.946;
+    this.plane_material_solid = new ShaderMaterial({
+      uniforms: {
+        _Color: { value: new Vector4(color, color, color, 0.5) }
+      },
+      vertexShader: basic_color_vert,
+      fragmentShader: basic_color_frag,
+      transparent: true,
+      depthWrite: false
+    });
+
+    this.stencil_mask_scene = new Scene();
+
+    this.original_view_matrix = new Matrix4();
+    this.inverted_view_matrix = new Matrix4();
+    this.reflection_matrix    = new Matrix4().set(1, 0, 0, 0,
+      0, -1, 0, 0,
+      0, 0, 1, 0,
+      0, 0, 0, 1);
+
+    this.gl = undefined;
+  }
+
+  on_enter(context, renderer)
+  {
+    this.gl = renderer.domElement.getContext('webgl');
+    CameraManager.current.parent = SceneManager.current;
+
+    const plane_material_mask = new MeshBasicMaterial({ color: CameraManager.current.clear_color, depthWrite: false });
+    this.plane_mask = new Mesh(ReflectionPlaneContext.target_geometry, plane_material_mask);
+    this.plane_solid = new Mesh(ReflectionPlaneContext.target_geometry, this.plane_material_solid);
+
+    const clear_color = CameraManager.current.clear_color;
+    this.plane_material_solid.uniforms._Color.value.set(clear_color.r, clear_color.g, clear_color.b, 0.5);
+
+    this.stencil_mask_scene.add(this.plane_mask);
+    SceneManager.current.add(this.plane_solid);
+    this.plane_solid.visible = false;
+
+    CameraManager.current.matrixAutoUpdate = false;
+    renderer.autoClear = false;
+  }
+
+  render(context, renderer)
+  {
+    if (CameraManager.current)
+    {
+      CameraManager.current.aspect = Screen.aspect_ratio;
+      CameraManager.current.updateProjectionMatrix();
+      CameraManager.current.updateMatrix();
+      CameraManager.current.updateMatrixWorld(true);
+
+      renderer.setClearColor(CameraManager.current.clear_color, CameraManager.current.clear_alpha);
+
+      this.__render_stencil_mask(renderer, this.gl);
+
+      this.plane_solid.visible = true;
+      this.__render_reflected_scene(renderer, this.gl);
+      this.plane_solid.visible = true;
+
+      // render scene
+
+      renderer.clear(false, true, false);
+      this.plane_solid.visible = true;
+      renderer.render(SceneManager.current, CameraManager.current);
+    }
+  }
+
+  __render_stencil_mask(renderer, gl)
+  {
+    // RENDER MASK
+    gl.enable(gl.STENCIL_TEST);
+    gl.stencilFunc(gl.ALWAYS, 1, 1);
+    gl.stencilOp(gl.KEEP, gl.REPLACE, gl.REPLACE);
+    renderer.clear(true, true, true);
+    renderer.render(this.stencil_mask_scene, CameraManager.current);
+  }
+
+  __render_reflected_scene(renderer, gl)
+  {
+    // // RENDER REFLECTION
+    gl.stencilFunc(gl.EQUAL, 1, 1);
+    gl.stencilOp(gl.KEEP, gl.REPLACE, gl.REPLACE);
+    this.reflection_matrix.set(1, 0, 0, 0,
+      0, -1, 0, ReflectionPlaneContext.target_position.y * 2,
+      0, 0, 1, 0,
+      0, 0, 0, 1);
+    this.original_view_matrix.copy(CameraManager.current.matrixWorldInverse);
+    this.inverted_view_matrix.copy(CameraManager.current.matrixWorldInverse).multiply(this.reflection_matrix);
+    CameraManager.current.matrixWorldInverse.copy(this.inverted_view_matrix.clone());
+
+    renderer.render(SceneManager.current, CameraManager.current);
+
+    gl.disable(gl.STENCIL_TEST);
+
+    CameraManager.current.matrixWorldInverse.copy(this.original_view_matrix);
+  }
+}

package/src/render_mode/TransparencyMixRender.js

@@ -1,143 +1,143 @@
-import Screen from '../Screen';
-import RenderLayers from '../RenderLayers';
-import transparent_mix_vert from '../shaders/transparent_mix/transparent_mix.vert';
-import transparent_mix_frag from '../shaders/transparent_mix/transparent_mix.frag';
-import copy_frag from '../shaders/transparent_mix/copy.frag';
-import fxaa from '../shaders/anti_aliasing/fxaa.frag';
-import Configuration from '../Configuration';
-
-import { Mesh } from 'three';
-import { WebGLRenderTarget } from 'three';
-import { ShaderMaterial } from 'three';
-import { Vector2 } from 'three';
-import { PlaneGeometry } from 'three';
-import { Scene } from 'three';
-
-export default class TransparencyMixRender
-{
-  constructor(webgl)
-  {
-    this.SSAA = Configuration.use_ssaa ? 2 : 1;
-    this.main_rt   = new WebGLRenderTarget(Screen.width * this.SSAA, Screen.height * this.SSAA);
-    this.opaque_rt = new WebGLRenderTarget(Screen.width * this.SSAA, Screen.height * this.SSAA);
-    this.fxaa_rt   = new WebGLRenderTarget(Screen.width * this.SSAA, Screen.height * this.SSAA);
-
-    this.mix_material = new ShaderMaterial({
-      uniforms: {
-        _OpaqueTex: { value: this.opaque_rt.texture },
-        _TransparentTex: { value: this.main_rt.texture },
-        _Resolution: { value: new Vector2(Screen.width, Screen.height) },
-        _Opacity: { value: Configuration.transparency_amount }
-      },
-      vertexShader: transparent_mix_vert,
-      fragmentShader: transparent_mix_frag,
-      depthTest: false,
-      depthWrite: false
-    });
-
-    this.copy_material = new ShaderMaterial({
-      uniforms: {
-        _MainTex: { value: this.main_rt.texture }
-      },
-      vertexShader: transparent_mix_vert,
-      fragmentShader: copy_frag,
-      depthTest: false,
-      depthWrite: false
-    });
-
-    this.fxaa_material = this.__get_fxaa_material();
-
-    const geometry = new PlaneGeometry(1, 1);
-    this.render_plane = new Mesh(geometry, this.mix_material);
-    this.render_plane.frustumCulled = false;
-
-    this.copy_plane = new Mesh(geometry, this.copy_material);
-    this.copy_plane.frustumCulled = false;
-
-    this.mix_scene = new Scene();
-    this.mix_scene.add(this.render_plane);
-    this.copy_scene = new Scene();
-    this.copy_scene.add(this.copy_plane);
-  }
-
-  resize()
-  {
-    this.main_rt.setSize(Screen.width * this.SSAA, Screen.height * this.SSAA);
-    this.opaque_rt.setSize(Screen.width * this.SSAA, Screen.height * this.SSAA);
-    this.fxaa_rt.setSize(Screen.width * this.SSAA, Screen.height * this.SSAA);
-    this.fxaa_material.uniforms._Resolution.value.set(Screen.width * this.SSAA, Screen.height * this.SSAA);
-    this.mix_material.uniforms._Resolution.value.set(Screen.width * this.SSAA, Screen.height * this.SSAA);
-  }
-
-  __get_fxaa_material()
-  {
-    return new ShaderMaterial({
-      uniforms: {
-        _MainTex: { value: this.fxaa_rt.texture },
-        _Resolution: { value: new Vector2(Screen.width * this.SSAA, Screen.height * this.SSAA) }
-      },
-      vertexShader: transparent_mix_vert,
-      fragmentShader: fxaa,
-      depthTest: false,
-      depthWrite: false
-    });
-  }
-
-  render(webgl)
-  {
-    webgl.camera.updateMatrix();
-    webgl.camera.updateMatrixWorld();
-
-    this.__render_opaque(webgl);
-    this.__render_transparent(webgl);
-
-    webgl.camera.layers.disable(RenderLayers.transparent);
-    webgl.camera.layers.enable(RenderLayers.opaque);
-
-    if (Configuration.use_fxaa)
-    {
-      webgl._renderer.render(this.mix_scene, webgl.camera, this.fxaa_rt, false);
-      this.mix_scene.overrideMaterial = this.fxaa_material;
-      webgl._renderer.render(this.mix_scene, webgl.camera, undefined, false);
-      this.mix_scene.overrideMaterial = undefined;
-    }
-    else
-    {
-      webgl._renderer.render(this.mix_scene, webgl.camera, undefined, false);
-    }
-  }
-
-  __render_opaque(webgl)
-  {
-    webgl._renderer.setClearColor(webgl.clear_color);
-    webgl._renderer.setClearAlpha(1);
-
-    webgl.camera.layers.disable(RenderLayers.transparent);
-    webgl.camera.layers.enable(RenderLayers.opaque);
-    webgl._renderer.clearTarget(this.main_rt, true, true, false);
-    webgl._renderer.render(webgl.scene, webgl.camera, this.main_rt, false);
-    webgl._renderer.render(this.copy_scene, webgl.camera, this.opaque_rt, false);
-  }
-
-  __render_transparent(webgl)
-  {
-    webgl._renderer.setClearColor(0x000000);
-    webgl._renderer.setClearAlpha(0);
-
-    webgl.camera.layers.disable(RenderLayers.opaque);
-    webgl.camera.layers.enable(RenderLayers.transparent);
-
-    webgl._renderer.clearTarget(this.main_rt, true, false, false);
-    webgl._renderer.render(webgl.scene, webgl.camera, this.main_rt, false);
-  }
-
-  on_enter(webgl)
-  {
-    webgl._renderer.autoClear = false;
-  }
-
-  on_exit(webgl)
-  {
-    webgl._renderer.autoClear = true;
-  }
-}
+import Screen from '../Screen';
+import RenderLayers from '../RenderLayers';
+import transparent_mix_vert from '../shaders/transparent_mix/transparent_mix.vert';
+import transparent_mix_frag from '../shaders/transparent_mix/transparent_mix.frag';
+import copy_frag from '../shaders/transparent_mix/copy.frag';
+import fxaa from '../shaders/anti_aliasing/fxaa.frag';
+import Configuration from '../Configuration';
+
+import { Mesh } from 'three';
+import { WebGLRenderTarget } from 'three';
+import { ShaderMaterial } from 'three';
+import { Vector2 } from 'three';
+import { PlaneGeometry } from 'three';
+import { Scene } from 'three';
+
+export default class TransparencyMixRender
+{
+  constructor(webgl)
+  {
+    this.SSAA = Configuration.use_ssaa ? 2 : 1;
+    this.main_rt   = new WebGLRenderTarget(Screen.width * this.SSAA, Screen.height * this.SSAA);
+    this.opaque_rt = new WebGLRenderTarget(Screen.width * this.SSAA, Screen.height * this.SSAA);
+    this.fxaa_rt   = new WebGLRenderTarget(Screen.width * this.SSAA, Screen.height * this.SSAA);
+
+    this.mix_material = new ShaderMaterial({
+      uniforms: {
+        _OpaqueTex: { value: this.opaque_rt.texture },
+        _TransparentTex: { value: this.main_rt.texture },
+        _Resolution: { value: new Vector2(Screen.width, Screen.height) },
+        _Opacity: { value: Configuration.transparency_amount }
+      },
+      vertexShader: transparent_mix_vert,
+      fragmentShader: transparent_mix_frag,
+      depthTest: false,
+      depthWrite: false
+    });
+
+    this.copy_material = new ShaderMaterial({
+      uniforms: {
+        _MainTex: { value: this.main_rt.texture }
+      },
+      vertexShader: transparent_mix_vert,
+      fragmentShader: copy_frag,
+      depthTest: false,
+      depthWrite: false
+    });
+
+    this.fxaa_material = this.__get_fxaa_material();
+
+    const geometry = new PlaneGeometry(1, 1);
+    this.render_plane = new Mesh(geometry, this.mix_material);
+    this.render_plane.frustumCulled = false;
+
+    this.copy_plane = new Mesh(geometry, this.copy_material);
+    this.copy_plane.frustumCulled = false;
+
+    this.mix_scene = new Scene();
+    this.mix_scene.add(this.render_plane);
+    this.copy_scene = new Scene();
+    this.copy_scene.add(this.copy_plane);
+  }
+
+  resize()
+  {
+    this.main_rt.setSize(Screen.width * this.SSAA, Screen.height * this.SSAA);
+    this.opaque_rt.setSize(Screen.width * this.SSAA, Screen.height * this.SSAA);
+    this.fxaa_rt.setSize(Screen.width * this.SSAA, Screen.height * this.SSAA);
+    this.fxaa_material.uniforms._Resolution.value.set(Screen.width * this.SSAA, Screen.height * this.SSAA);
+    this.mix_material.uniforms._Resolution.value.set(Screen.width * this.SSAA, Screen.height * this.SSAA);
+  }
+
+  __get_fxaa_material()
+  {
+    return new ShaderMaterial({
+      uniforms: {
+        _MainTex: { value: this.fxaa_rt.texture },
+        _Resolution: { value: new Vector2(Screen.width * this.SSAA, Screen.height * this.SSAA) }
+      },
+      vertexShader: transparent_mix_vert,
+      fragmentShader: fxaa,
+      depthTest: false,
+      depthWrite: false
+    });
+  }
+
+  render(webgl)
+  {
+    webgl.camera.updateMatrix();
+    webgl.camera.updateMatrixWorld();
+
+    this.__render_opaque(webgl);
+    this.__render_transparent(webgl);
+
+    webgl.camera.layers.disable(RenderLayers.transparent);
+    webgl.camera.layers.enable(RenderLayers.opaque);
+
+    if (Configuration.use_fxaa)
+    {
+      webgl._renderer.render(this.mix_scene, webgl.camera, this.fxaa_rt, false);
+      this.mix_scene.overrideMaterial = this.fxaa_material;
+      webgl._renderer.render(this.mix_scene, webgl.camera, undefined, false);
+      this.mix_scene.overrideMaterial = undefined;
+    }
+    else
+    {
+      webgl._renderer.render(this.mix_scene, webgl.camera, undefined, false);
+    }
+  }
+
+  __render_opaque(webgl)
+  {
+    webgl._renderer.setClearColor(webgl.clear_color);
+    webgl._renderer.setClearAlpha(1);
+
+    webgl.camera.layers.disable(RenderLayers.transparent);
+    webgl.camera.layers.enable(RenderLayers.opaque);
+    webgl._renderer.clearTarget(this.main_rt, true, true, false);
+    webgl._renderer.render(webgl.scene, webgl.camera, this.main_rt, false);
+    webgl._renderer.render(this.copy_scene, webgl.camera, this.opaque_rt, false);
+  }
+
+  __render_transparent(webgl)
+  {
+    webgl._renderer.setClearColor(0x000000);
+    webgl._renderer.setClearAlpha(0);
+
+    webgl.camera.layers.disable(RenderLayers.opaque);
+    webgl.camera.layers.enable(RenderLayers.transparent);
+
+    webgl._renderer.clearTarget(this.main_rt, true, false, false);
+    webgl._renderer.render(webgl.scene, webgl.camera, this.main_rt, false);
+  }
+
+  on_enter(webgl)
+  {
+    webgl._renderer.autoClear = false;
+  }
+
+  on_exit(webgl)
+  {
+    webgl._renderer.autoClear = true;
+  }
+}