ohzi-core 12.5.2 → 12.7.0

package/src/render_utilities/DepthAndNormalsRenderer.js

@@ -1,47 +1,47 @@
-import { CameraManager } from '../CameraManager';
-import { OScreen } from '../OScreen';
-
-import { ClearDepthNormalMaterial } from '../materials/ClearDepthNormalMaterial';
-import { DepthNormalMaterial } from '../materials/DepthNormalMaterial';
-
-import { WebGLRenderTarget } from 'three';
-import { Vector3 } from 'three';
-
-class DepthAndNormalsRenderer
-{
-  constructor()
-  {
-    this.RT = new WebGLRenderTarget(OScreen.width, OScreen.height);
-
-    this.clear_depth_normal_mat = new ClearDepthNormalMaterial(1, new Vector3(0, 0, 1));
-    this.depth_normal_material = new DepthNormalMaterial();
-  }
-
-  render(graphics)
-  {
-    this.__resize_RT_if_necessary();
-
-    graphics.clear(this.RT, undefined, true, true);
-
-    graphics.blit_clear_with_material(this.RT, this.clear_depth_normal_mat);
-
-    this.depth_normal_material.far_plane = CameraManager.current.far;
-
-    graphics.render(undefined, undefined, this.RT, this.depth_normal_material);
-  }
-
-  __resize_RT_if_necessary()
-  {
-    if (this.RT.width !== OScreen.width || this.RT.height !== OScreen.height)
-    {
-      this.RT.setSize(OScreen.width, OScreen.height);
-    }
-  }
-
-  get render_target()
-  {
-    return this.RT;
-  }
-}
-
-export { DepthAndNormalsRenderer };
+import { CameraManager } from '../CameraManager';
+import { OScreen } from '../OScreen';
+
+import { ClearDepthNormalMaterial } from '../materials/ClearDepthNormalMaterial';
+import { DepthNormalMaterial } from '../materials/DepthNormalMaterial';
+
+import { WebGLRenderTarget } from 'three';
+import { Vector3 } from 'three';
+
+class DepthAndNormalsRenderer
+{
+  constructor()
+  {
+    this.RT = new WebGLRenderTarget(OScreen.width, OScreen.height);
+
+    this.clear_depth_normal_mat = new ClearDepthNormalMaterial(1, new Vector3(0, 0, 1));
+    this.depth_normal_material = new DepthNormalMaterial();
+  }
+
+  render(graphics)
+  {
+    this.__resize_RT_if_necessary();
+
+    graphics.clear(this.RT, undefined, true, true);
+
+    graphics.blit_clear_with_material(this.RT, this.clear_depth_normal_mat);
+
+    this.depth_normal_material.far_plane = CameraManager.current.far;
+
+    graphics.render(undefined, undefined, this.RT, this.depth_normal_material);
+  }
+
+  __resize_RT_if_necessary()
+  {
+    if (this.RT.width !== OScreen.width || this.RT.height !== OScreen.height)
+    {
+      this.RT.setSize(OScreen.width, OScreen.height);
+    }
+  }
+
+  get render_target()
+  {
+    return this.RT;
+  }
+}
+
+export { DepthAndNormalsRenderer };

package/src/render_utilities/DualFilteringBlurrer.js

@@ -1,58 +1,58 @@
-import { DualFilteringBlurMaterial } from '../materials/DualFilteringBlurMaterial';
-import { AlphaFilterMaterial } from '../materials/AlphaFilterMaterial';
-import { Graphics } from '../Graphics';
-import { WebGLRenderTarget } from 'three';
-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);
-    }
-  }
-}
-
-export { DualFilteringBlurrer };
+import { DualFilteringBlurMaterial } from '../materials/DualFilteringBlurMaterial';
+import { AlphaFilterMaterial } from '../materials/AlphaFilterMaterial';
+import { Graphics } from '../Graphics';
+import { WebGLRenderTarget } from 'three';
+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);
+    }
+  }
+}
+
+export { DualFilteringBlurrer };

package/src/render_utilities/GaussianBlurrer.js

@@ -1,167 +1,167 @@
-import { GaussianBlurMaterial } from '../materials/GaussianBlurMaterial';
-import { LuminosityHighPassMaterial } from '../materials/LuminosityHighPassMaterial';
-import { Graphics } from '../Graphics';
-
-import { WebGLRenderTarget, LinearFilter, RGBAFormat, HalfFloatType, UnsignedByteType, SRGBColorSpace, LinearSRGBColorSpace } from 'three';
-
-class GaussianBlurrer
-{
-  constructor(use_half_float = false)
-  {
-    this.current_width = 1;
-    this.current_height = 1;
-
-    this.separableBlurMaterials = [];
-    this.renderTargetsHorizontal = [];
-    this.renderTargetsVertical = [];
-    this.use_half_float = use_half_float;
-    this.nMips = 5;
-    this.kernelSizeArray = [3, 5, 7, 9, 11];
-    this.rt_pars = {
-      minFilter: LinearFilter,
-      magFilter: LinearFilter,
-      format: RGBAFormat,
-      type: use_half_float ? HalfFloatType : UnsignedByteType,
-      colorSpace: use_half_float ? LinearSRGBColorSpace : SRGBColorSpace
-    };
-
-    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(use_half_float);
-  }
-
-  blur(RT, use_luminosity_high_pass)
-  {
-    this.resize_RT(RT.width, RT.height);
-
-    let inputRenderTarget = RT;
-
-    if (use_luminosity_high_pass)
-    {
-      Graphics.blit(RT, this.renderTargetBright, this.luminosity_high_pass_mat);
-      inputRenderTarget = this.renderTargetBright;
-    }
-
-    for (let i = 0; i < this.nMips; i++)
-    {
-      const 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++)
-    {
-      const hor = new WebGLRenderTarget(1, 1, this.rt_pars);
-      const ver = new WebGLRenderTarget(1, 1, this.rt_pars);
-
-      hor.texture.generateMipmaps = false;
-      ver.texture.generateMipmaps = false;
-
-      hor.texture.colorSpace = this.rt_pars.colorSpace;
-      ver.texture.colorSpace = this.rt_pars.colorSpace;
-
-      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()
-  {
-    this.dispose_materials();
-
-    for (let i = 0; i < this.nMips; i++)
-    {
-      this.separableBlurMaterials.push(new GaussianBlurMaterial(this.kernelSizeArray[i], this.use_half_float));
-    }
-  }
-
-  set_radius(value)
-  {
-    for (let i = 0; i < this.separableBlurMaterials.length; i++)
-    {
-      this.separableBlurMaterials[i].set_radius(value);
-    }
-  }
-
-  set_luminosity_threshold(value)
-  {
-    this.luminosity_high_pass_mat.set_threshold(value);
-  }
-
-  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;
-  }
-}
-
-export { GaussianBlurrer };
+import { GaussianBlurMaterial } from '../materials/GaussianBlurMaterial';
+import { LuminosityHighPassMaterial } from '../materials/LuminosityHighPassMaterial';
+import { Graphics } from '../Graphics';
+
+import { WebGLRenderTarget, LinearFilter, RGBAFormat, HalfFloatType, UnsignedByteType, SRGBColorSpace, LinearSRGBColorSpace } from 'three';
+
+class GaussianBlurrer
+{
+  constructor(use_half_float = false)
+  {
+    this.current_width = 1;
+    this.current_height = 1;
+
+    this.separableBlurMaterials = [];
+    this.renderTargetsHorizontal = [];
+    this.renderTargetsVertical = [];
+    this.use_half_float = use_half_float;
+    this.nMips = 5;
+    this.kernelSizeArray = [3, 5, 7, 9, 11];
+    this.rt_pars = {
+      minFilter: LinearFilter,
+      magFilter: LinearFilter,
+      format: RGBAFormat,
+      type: use_half_float ? HalfFloatType : UnsignedByteType,
+      colorSpace: use_half_float ? LinearSRGBColorSpace : SRGBColorSpace
+    };
+
+    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(use_half_float);
+  }
+
+  blur(RT, use_luminosity_high_pass)
+  {
+    this.resize_RT(RT.width, RT.height);
+
+    let inputRenderTarget = RT;
+
+    if (use_luminosity_high_pass)
+    {
+      Graphics.blit(RT, this.renderTargetBright, this.luminosity_high_pass_mat);
+      inputRenderTarget = this.renderTargetBright;
+    }
+
+    for (let i = 0; i < this.nMips; i++)
+    {
+      const 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++)
+    {
+      const hor = new WebGLRenderTarget(1, 1, this.rt_pars);
+      const ver = new WebGLRenderTarget(1, 1, this.rt_pars);
+
+      hor.texture.generateMipmaps = false;
+      ver.texture.generateMipmaps = false;
+
+      hor.texture.colorSpace = this.rt_pars.colorSpace;
+      ver.texture.colorSpace = this.rt_pars.colorSpace;
+
+      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()
+  {
+    this.dispose_materials();
+
+    for (let i = 0; i < this.nMips; i++)
+    {
+      this.separableBlurMaterials.push(new GaussianBlurMaterial(this.kernelSizeArray[i], this.use_half_float));
+    }
+  }
+
+  set_radius(value)
+  {
+    for (let i = 0; i < this.separableBlurMaterials.length; i++)
+    {
+      this.separableBlurMaterials[i].set_radius(value);
+    }
+  }
+
+  set_luminosity_threshold(value)
+  {
+    this.luminosity_high_pass_mat.set_threshold(value);
+  }
+
+  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;
+  }
+}
+
+export { GaussianBlurrer };

package/src/render_utilities/MedianFilter.js

@@ -1,68 +1,68 @@
-import { MedianFilterMaterial } from '../materials/MedianFilterMaterial';
-import { Graphics } from '../Graphics';
-
-import { WebGLRenderTarget, Vector2, RGBAFormat, FloatType, NearestFilter } from 'three';
-
-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)
-  {
-    const 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);
-  }
-}
-
-export { MedianFilter };
+import { MedianFilterMaterial } from '../materials/MedianFilterMaterial';
+import { Graphics } from '../Graphics';
+
+import { WebGLRenderTarget, Vector2, RGBAFormat, FloatType, NearestFilter } from 'three';
+
+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)
+  {
+    const 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);
+  }
+}
+
+export { MedianFilter };