ohzi-core 6.1.2 → 6.2.1

package/src/render_utilities/DualFilteringBlurrer.js

@@ -1,56 +1,56 @@
-import DualFilteringBlurMaterial from '../materials/DualFilteringBlurMaterial';
-import AlphaFilterMaterial from '../materials/AlphaFilterMaterial';
-import Graphics from '../Graphics';
-import { WebGLRenderTarget } from 'three';
-export default class DualFilteringBlurrer
-{
-  constructor(use_alpha_mask)
-  {
-    this.current_width  = 1;
-    this.current_height = 1;
-    this.RT0 = new WebGLRenderTarget(1, 1);
-    this.RT1 = new WebGLRenderTarget(1, 1);
-    this.RT2 = new WebGLRenderTarget(1, 1);
-    this.RT3 = new WebGLRenderTarget(1, 1);
-    this.RT4 = new WebGLRenderTarget(1, 1);
-
-    this.upscale_blur_mat   = new DualFilteringBlurMaterial(true);
-    this.downscale_blur_mat = new DualFilteringBlurMaterial(false);
-
-    this.alpha_filter_mat = new AlphaFilterMaterial();
-  }
-
-  blur(RT)
-  {
-    this.check_RT_resize(RT.width, RT.height);
-    Graphics.blit(RT,       this.RT1, this.alpha_filter_mat);
-
-    // Graphics.blit(this.RT0, this.RT1, this.downscale_blur_mat);
-    Graphics.blit(this.RT1, this.RT2, this.downscale_blur_mat);
-    Graphics.blit(this.RT2, this.RT3, this.downscale_blur_mat);
-    Graphics.blit(this.RT3, this.RT4, this.downscale_blur_mat);
-
-    // Graphics.blit(this.RT4, this.RT3, this.upscale_blur_mat);
-    // Graphics.blit(this.RT3, this.RT4, this.upscale_blur_mat);
-    Graphics.blit(this.RT4, this.RT3, this.upscale_blur_mat);
-    Graphics.blit(this.RT3, this.RT2, this.upscale_blur_mat);
-    Graphics.blit(this.RT2, RT, this.upscale_blur_mat);
-    // Graphics.blit(this.RT1, RT,       this.upscale_blur_mat);
-
-    // return this.RT2;
-  }
-
-  check_RT_resize(width, height)
-  {
-    if (this.current_width !== width || this.current_height !== height)
-    {
-      this.current_width = width;
-      this.current_height = height;
-      this.RT0.setSize(this.current_width / 2, this.current_height / 2);
-      this.RT1.setSize(this.current_width / 2, this.current_height / 2);
-      this.RT2.setSize(this.current_width / 4, this.current_height / 4);
-      this.RT3.setSize(this.current_width / 8, this.current_height / 8);
-      this.RT4.setSize(this.current_width / 16, this.current_height / 16);
-    }
-  }
-}
+import DualFilteringBlurMaterial from '../materials/DualFilteringBlurMaterial';
+import AlphaFilterMaterial from '../materials/AlphaFilterMaterial';
+import Graphics from '../Graphics';
+import { WebGLRenderTarget } from 'three';
+export default class DualFilteringBlurrer
+{
+  constructor(use_alpha_mask)
+  {
+    this.current_width  = 1;
+    this.current_height = 1;
+    this.RT0 = new WebGLRenderTarget(1, 1);
+    this.RT1 = new WebGLRenderTarget(1, 1);
+    this.RT2 = new WebGLRenderTarget(1, 1);
+    this.RT3 = new WebGLRenderTarget(1, 1);
+    this.RT4 = new WebGLRenderTarget(1, 1);
+
+    this.upscale_blur_mat   = new DualFilteringBlurMaterial(true);
+    this.downscale_blur_mat = new DualFilteringBlurMaterial(false);
+
+    this.alpha_filter_mat = new AlphaFilterMaterial();
+  }
+
+  blur(RT)
+  {
+    this.check_RT_resize(RT.width, RT.height);
+    Graphics.blit(RT,       this.RT1, this.alpha_filter_mat);
+
+    // Graphics.blit(this.RT0, this.RT1, this.downscale_blur_mat);
+    Graphics.blit(this.RT1, this.RT2, this.downscale_blur_mat);
+    Graphics.blit(this.RT2, this.RT3, this.downscale_blur_mat);
+    Graphics.blit(this.RT3, this.RT4, this.downscale_blur_mat);
+
+    // Graphics.blit(this.RT4, this.RT3, this.upscale_blur_mat);
+    // Graphics.blit(this.RT3, this.RT4, this.upscale_blur_mat);
+    Graphics.blit(this.RT4, this.RT3, this.upscale_blur_mat);
+    Graphics.blit(this.RT3, this.RT2, this.upscale_blur_mat);
+    Graphics.blit(this.RT2, RT, this.upscale_blur_mat);
+    // Graphics.blit(this.RT1, RT,       this.upscale_blur_mat);
+
+    // return this.RT2;
+  }
+
+  check_RT_resize(width, height)
+  {
+    if (this.current_width !== width || this.current_height !== height)
+    {
+      this.current_width = width;
+      this.current_height = height;
+      this.RT0.setSize(this.current_width / 2, this.current_height / 2);
+      this.RT1.setSize(this.current_width / 2, this.current_height / 2);
+      this.RT2.setSize(this.current_width / 4, this.current_height / 4);
+      this.RT3.setSize(this.current_width / 8, this.current_height / 8);
+      this.RT4.setSize(this.current_width / 16, this.current_height / 16);
+    }
+  }
+}

package/src/render_utilities/GaussianBlurrer.js

@@ -1,146 +1,146 @@
-import GaussianBlurMaterial from '../materials/GaussianBlurMaterial';
-import LuminosityHighPassMaterial from '../materials/LuminosityHighPassMaterial';
-import Graphics from '../Graphics';
-
-import { WebGLRenderTarget, LinearFilter, RGBAFormat } from 'three';
-
-export default class GaussianBlurrer
-{
-  constructor(nMips = 5)
-  {
-    this.current_width = 1;
-    this.current_height = 1;
-
-    this.separableBlurMaterials = [];
-    this.renderTargetsHorizontal = [];
-    this.renderTargetsVertical = [];
-
-    this.nMips = nMips;
-    this.kernelSizeArray = [3, 5, 7, 9, 11];
-    this.rt_pars = { minFilter: LinearFilter, magFilter: LinearFilter, format: RGBAFormat };
-
-    this.renderTargetBright = new WebGLRenderTarget(1, 1, this.rt_pars);
-    this.renderTargetBright.texture.generateMipmaps = false;
-
-    this.init_materials();
-    this.init_RT();
-
-    this.luminosity_high_pass_mat = new LuminosityHighPassMaterial();
-  }
-
-  blur(RT, use_luminosity_high_pass)
-  {
-    this.resize_RT(RT.width, RT.height);
-
-    if (use_luminosity_high_pass)
-    {
-      Graphics.blit(RT, this.renderTargetBright, this.luminosity_high_pass_mat);
-    }
-    else
-    {
-      Graphics.blit(RT, this.renderTargetBright);
-    }
-
-    let inputRenderTarget = this.renderTargetBright;
-
-    for (let i = 0; i < this.nMips; i++)
-    {
-      let mat = this.separableBlurMaterials[i];
-
-      mat.set_direction(1, 0);
-      Graphics.blit(inputRenderTarget, this.renderTargetsHorizontal[i], mat);
-
-      mat.set_direction(0, 1);
-      Graphics.blit(this.renderTargetsHorizontal[i], this.renderTargetsVertical[i], mat);
-
-      inputRenderTarget = this.renderTargetsVertical[i];
-    }
-  }
-
-  get_blurred_texture()
-  {
-    return this.renderTargetsHorizontal[0].texture;
-  }
-
-  get_blurred_RT()
-  {
-    return this.renderTargetsHorizontal[0];
-  }
-
-  init_RT()
-  {
-    this.dispose_RT();
-
-    this.renderTargetBright.setSize(1, 1);
-
-    for (let i = 0; i < this.nMips; i++)
-    {
-      let hor = new WebGLRenderTarget(1, 1, this.rt_pars);
-      let ver = new WebGLRenderTarget(1, 1, this.rt_pars);
-
-      hor.texture.generateMipmaps = false;
-      ver.texture.generateMipmaps = false;
-
-      this.renderTargetsHorizontal.push(hor);
-      this.renderTargetsVertical.push(ver);
-    }
-  }
-
-  resize_RT(texture_width, texture_height)
-  {
-    if (this.current_width === texture_width && this.current_height === texture_height)
-    {
-      return;
-    }
-
-    this.current_width = texture_width;
-    this.current_height = texture_height;
-
-    let width = Math.round(texture_width / 2);
-    let height = Math.round(texture_height / 2);
-
-    this.renderTargetBright.setSize(width, height);
-
-    for (let i = 0; i < this.nMips; i++)
-    {
-      this.renderTargetsVertical[i].setSize(width, height);
-      this.renderTargetsHorizontal[i].setSize(width, height);
-      this.separableBlurMaterials[i].set_size(width, height);
-
-      width   = Math.round(width / 2);
-      height  = Math.round(height / 2);
-    }
-  }
-
-  init_materials(texture_width, texture_height)
-  {
-    this.dispose_materials();
-
-    for (let i = 0; i < this.nMips; i++)
-    {
-      this.separableBlurMaterials.push(new GaussianBlurMaterial(this.kernelSizeArray[i]));
-    }
-  }
-
-  dispose_materials()
-  {
-    for (let i = 0; i < this.separableBlurMaterials.length; i++)
-    {
-      this.separableBlurMaterials[i].dispose();
-    }
-    this.separableBlurMaterials.length = 0;
-  }
-
-  dispose_RT()
-  {
-    for (let i = 0; i < this.renderTargetsVertical.length; i++)
-    {
-      this.renderTargetsHorizontal[i].dispose();
-      this.renderTargetsVertical[i].dispose();
-    }
-    this.renderTargetBright.dispose();
-
-    this.renderTargetsHorizontal.length = 0;
-    this.renderTargetsVertical.length = 0;
-  }
-}
+import GaussianBlurMaterial from '../materials/GaussianBlurMaterial';
+import LuminosityHighPassMaterial from '../materials/LuminosityHighPassMaterial';
+import Graphics from '../Graphics';
+
+import { WebGLRenderTarget, LinearFilter, RGBAFormat } from 'three';
+
+export default class GaussianBlurrer
+{
+  constructor(nMips = 5)
+  {
+    this.current_width = 1;
+    this.current_height = 1;
+
+    this.separableBlurMaterials = [];
+    this.renderTargetsHorizontal = [];
+    this.renderTargetsVertical = [];
+
+    this.nMips = nMips;
+    this.kernelSizeArray = [3, 5, 7, 9, 11];
+    this.rt_pars = { minFilter: LinearFilter, magFilter: LinearFilter, format: RGBAFormat };
+
+    this.renderTargetBright = new WebGLRenderTarget(1, 1, this.rt_pars);
+    this.renderTargetBright.texture.generateMipmaps = false;
+
+    this.init_materials();
+    this.init_RT();
+
+    this.luminosity_high_pass_mat = new LuminosityHighPassMaterial();
+  }
+
+  blur(RT, use_luminosity_high_pass)
+  {
+    this.resize_RT(RT.width, RT.height);
+
+    if (use_luminosity_high_pass)
+    {
+      Graphics.blit(RT, this.renderTargetBright, this.luminosity_high_pass_mat);
+    }
+    else
+    {
+      Graphics.blit(RT, this.renderTargetBright);
+    }
+
+    let inputRenderTarget = this.renderTargetBright;
+
+    for (let i = 0; i < this.nMips; i++)
+    {
+      let mat = this.separableBlurMaterials[i];
+
+      mat.set_direction(1, 0);
+      Graphics.blit(inputRenderTarget, this.renderTargetsHorizontal[i], mat);
+
+      mat.set_direction(0, 1);
+      Graphics.blit(this.renderTargetsHorizontal[i], this.renderTargetsVertical[i], mat);
+
+      inputRenderTarget = this.renderTargetsVertical[i];
+    }
+  }
+
+  get_blurred_texture()
+  {
+    return this.renderTargetsHorizontal[0].texture;
+  }
+
+  get_blurred_RT()
+  {
+    return this.renderTargetsHorizontal[0];
+  }
+
+  init_RT()
+  {
+    this.dispose_RT();
+
+    this.renderTargetBright.setSize(1, 1);
+
+    for (let i = 0; i < this.nMips; i++)
+    {
+      let hor = new WebGLRenderTarget(1, 1, this.rt_pars);
+      let ver = new WebGLRenderTarget(1, 1, this.rt_pars);
+
+      hor.texture.generateMipmaps = false;
+      ver.texture.generateMipmaps = false;
+
+      this.renderTargetsHorizontal.push(hor);
+      this.renderTargetsVertical.push(ver);
+    }
+  }
+
+  resize_RT(texture_width, texture_height)
+  {
+    if (this.current_width === texture_width && this.current_height === texture_height)
+    {
+      return;
+    }
+
+    this.current_width = texture_width;
+    this.current_height = texture_height;
+
+    let width = Math.round(texture_width / 2);
+    let height = Math.round(texture_height / 2);
+
+    this.renderTargetBright.setSize(width, height);
+
+    for (let i = 0; i < this.nMips; i++)
+    {
+      this.renderTargetsVertical[i].setSize(width, height);
+      this.renderTargetsHorizontal[i].setSize(width, height);
+      this.separableBlurMaterials[i].set_size(width, height);
+
+      width   = Math.round(width / 2);
+      height  = Math.round(height / 2);
+    }
+  }
+
+  init_materials(texture_width, texture_height)
+  {
+    this.dispose_materials();
+
+    for (let i = 0; i < this.nMips; i++)
+    {
+      this.separableBlurMaterials.push(new GaussianBlurMaterial(this.kernelSizeArray[i]));
+    }
+  }
+
+  dispose_materials()
+  {
+    for (let i = 0; i < this.separableBlurMaterials.length; i++)
+    {
+      this.separableBlurMaterials[i].dispose();
+    }
+    this.separableBlurMaterials.length = 0;
+  }
+
+  dispose_RT()
+  {
+    for (let i = 0; i < this.renderTargetsVertical.length; i++)
+    {
+      this.renderTargetsHorizontal[i].dispose();
+      this.renderTargetsVertical[i].dispose();
+    }
+    this.renderTargetBright.dispose();
+
+    this.renderTargetsHorizontal.length = 0;
+    this.renderTargetsVertical.length = 0;
+  }
+}

package/src/render_utilities/MedianFilter.js

@@ -1,66 +1,66 @@
-import MedianFilterMaterial from '../materials/MedianFilterMaterial';
-import Graphics from '../Graphics';
-
-import { WebGLRenderTarget, Vector2, RGBAFormat, FloatType, NearestFilter } from 'three';
-
-export default class MedianFilter
-{
-  constructor(renderer)
-  {
-    this.RT = new WebGLRenderTarget(1, 1, {
-      type: FloatType,
-      format: RGBAFormat,
-      minFilter: NearestFilter,
-      magFilter: NearestFilter
-    });
-    this.RT1 = new WebGLRenderTarget(1, 1, {
-      type: FloatType,
-      format: RGBAFormat,
-      minFilter: NearestFilter,
-      magFilter: NearestFilter
-    });
-
-    this.median_filter_mat = new MedianFilterMaterial();
-  }
-
-  filter(texture)
-  {
-    let tex_size = this.get_size(texture);
-    if (tex_size.x !== this.RT.width || tex_size.y !== this.RT.height)
-    {
-      this.RT.setSize(tex_size.x, tex_size.y);
-      this.RT1.setSize(tex_size.x, tex_size.y);
-    }
-
-    this.median_filter_mat.set_texture(texture);
-    Graphics.material_pass(this.median_filter_mat, this.RT);
-
-    for (let i = 0; i < 0; i++)
-    {
-      this.median_filter_mat.set_texture(this.RT.texture);
-      Graphics.material_pass(this.median_filter_mat, this.RT1);
-
-      this.median_filter_mat.set_texture(this.RT1.texture);
-      Graphics.material_pass(this.median_filter_mat, this.RT);
-    }
-
-    return this.RT;
-  }
-
-  get_size(tex)
-  {
-    if (tex.isVideoTexture)
-    {
-      return new Vector2(Math.max(1, tex.image.videoWidth), Math.max(1, tex.image.videoHeight));
-    }
-    if (tex.isWebGLRenderTarget)
-    {
-      return new Vector2(tex.width, tex.height);
-    }
-    if (tex.isTexture)
-    {
-      return new Vector2(tex.image.width, tex.image.height);
-    }
-    return new Vector2(1, 1);
-  }
-}
+import MedianFilterMaterial from '../materials/MedianFilterMaterial';
+import Graphics from '../Graphics';
+
+import { WebGLRenderTarget, Vector2, RGBAFormat, FloatType, NearestFilter } from 'three';
+
+export default class MedianFilter
+{
+  constructor(renderer)
+  {
+    this.RT = new WebGLRenderTarget(1, 1, {
+      type: FloatType,
+      format: RGBAFormat,
+      minFilter: NearestFilter,
+      magFilter: NearestFilter
+    });
+    this.RT1 = new WebGLRenderTarget(1, 1, {
+      type: FloatType,
+      format: RGBAFormat,
+      minFilter: NearestFilter,
+      magFilter: NearestFilter
+    });
+
+    this.median_filter_mat = new MedianFilterMaterial();
+  }
+
+  filter(texture)
+  {
+    let tex_size = this.get_size(texture);
+    if (tex_size.x !== this.RT.width || tex_size.y !== this.RT.height)
+    {
+      this.RT.setSize(tex_size.x, tex_size.y);
+      this.RT1.setSize(tex_size.x, tex_size.y);
+    }
+
+    this.median_filter_mat.set_texture(texture);
+    Graphics.material_pass(this.median_filter_mat, this.RT);
+
+    for (let i = 0; i < 0; i++)
+    {
+      this.median_filter_mat.set_texture(this.RT.texture);
+      Graphics.material_pass(this.median_filter_mat, this.RT1);
+
+      this.median_filter_mat.set_texture(this.RT1.texture);
+      Graphics.material_pass(this.median_filter_mat, this.RT);
+    }
+
+    return this.RT;
+  }
+
+  get_size(tex)
+  {
+    if (tex.isVideoTexture)
+    {
+      return new Vector2(Math.max(1, tex.image.videoWidth), Math.max(1, tex.image.videoHeight));
+    }
+    if (tex.isWebGLRenderTarget)
+    {
+      return new Vector2(tex.width, tex.height);
+    }
+    if (tex.isTexture)
+    {
+      return new Vector2(tex.image.width, tex.image.height);
+    }
+    return new Vector2(1, 1);
+  }
+}

package/src/render_utilities/ViewPositionRenderer.js

@@ -1,48 +1,48 @@
-import CameraManager from '../CameraManager';
-import SceneManager from '../SceneManager';
-import Screen from '../Screen';
-import ViewPositionMaterial from '../materials/ViewPositionMaterial';
-
-import { WebGLRenderTarget } from 'three';
-import { FloatType } from 'three';
-import { Color } from 'three';
-
-export default class ViewPositionRenderer
-{
-  constructor()
-  {
-    this.RT = new WebGLRenderTarget(Screen.width, Screen.height, { type: FloatType });
-    this.clear_color = new Color(0, 0, 0);
-    this.render_pos_mat = new ViewPositionMaterial();
-  }
-
-  render(context, renderer)
-  {
-    if (this.RT.width !== Screen.width || this.RT.height !== Screen.height)
-    {
-      this.RT.setSize(Screen.width, Screen.height);
-    }
-
-    if (CameraManager.current)
-    {
-      CameraManager.current.aspect = Screen.aspect_ratio;
-      CameraManager.current.updateProjectionMatrix();
-      CameraManager.current.updateMatrix();
-      CameraManager.current.updateMatrixWorld(true);
-
-      renderer.setRenderTarget(this.RT);
-      this.clear_color.set(CameraManager.current.far, CameraManager.current.far, CameraManager.current.far);
-      renderer.setClearColor(this.clear_color, 1);
-      renderer.clear(true, true, false);
-
-      SceneManager.current.overrideMaterial = this.render_pos_mat;
-      renderer.render(SceneManager.current, CameraManager.current, this.RT, false);
-      SceneManager.current.overrideMaterial = undefined;
-    }
-  }
-
-  get render_target()
-  {
-    return this.RT;
-  }
-}
+import CameraManager from '../CameraManager';
+import SceneManager from '../SceneManager';
+import Screen from '../Screen';
+import ViewPositionMaterial from '../materials/ViewPositionMaterial';
+
+import { WebGLRenderTarget } from 'three';
+import { FloatType } from 'three';
+import { Color } from 'three';
+
+export default class ViewPositionRenderer
+{
+  constructor()
+  {
+    this.RT = new WebGLRenderTarget(Screen.width, Screen.height, { type: FloatType });
+    this.clear_color = new Color(0, 0, 0);
+    this.render_pos_mat = new ViewPositionMaterial();
+  }
+
+  render(context, renderer)
+  {
+    if (this.RT.width !== Screen.width || this.RT.height !== Screen.height)
+    {
+      this.RT.setSize(Screen.width, Screen.height);
+    }
+
+    if (CameraManager.current)
+    {
+      CameraManager.current.aspect = Screen.aspect_ratio;
+      CameraManager.current.updateProjectionMatrix();
+      CameraManager.current.updateMatrix();
+      CameraManager.current.updateMatrixWorld(true);
+
+      renderer.setRenderTarget(this.RT);
+      this.clear_color.set(CameraManager.current.far, CameraManager.current.far, CameraManager.current.far);
+      renderer.setClearColor(this.clear_color, 1);
+      renderer.clear(true, true, false);
+
+      SceneManager.current.overrideMaterial = this.render_pos_mat;
+      renderer.render(SceneManager.current, CameraManager.current, this.RT, false);
+      SceneManager.current.overrideMaterial = undefined;
+    }
+  }
+
+  get render_target()
+  {
+    return this.RT;
+  }
+}