ohzi-core 5.13.2 → 5.14.2

package/src/materials/FXAAMaterial.js

@@ -0,0 +1,10 @@
+import BlitMaterial from 'js/core/materials/BlitMaterial';
+import frag from 'js/core/shaders/anti_aliasing/fxaa_frag';
+
+export default class FXAAMaterial extends BlitMaterial
+{
+  constructor(upsample)
+  {
+    super(frag);
+  }
+}

package/src/materials/GaussianBlurMaterial.js

@@ -0,0 +1,28 @@
+import BlitMaterial from './BlitMaterial';
+import frag from '../shaders/gaussian_blur/gaussian_blur.frag';
+import { Vector2 } from 'three';
+
+export default class GaussianBlurMaterial extends BlitMaterial
+{
+  constructor(kernel_radius)
+  {
+    super(frag, undefined, {
+      KERNEL_RADIUS: kernel_radius,
+      SIGMA: kernel_radius
+    });
+
+    this.uniforms.texSize = { value: new Vector2(0.5, 0.5) };
+    this.uniforms.direction = { value: new Vector2(0.5, 0.5) };
+  }
+
+  set_size(w, h)
+  {
+    this.uniforms.texSize.value.x = w;
+    this.uniforms.texSize.value.y = h;
+  }
+
+  set_direction(x, y)
+  {
+    this.uniforms.direction.value.set(x, y);
+  }
+}

package/src/materials/LuminosityHighPassMaterial.js

@@ -0,0 +1,15 @@
+import BlitMaterial from './BlitMaterial';
+import frag from '../shaders/luminosity_high_pass/luminosity_high_pass.frag';
+import { Color } from 'three';
+export default class LuminosityHighPassMaterial extends BlitMaterial
+{
+  constructor(kernel_radius)
+  {
+    super(frag);
+
+    this.uniforms.luminosityThreshold = { value: 0.23 };
+    this.uniforms.smoothWidth         = { value: 0.01 };
+    this.uniforms.defaultColor        = { value: new Color('#000000') };
+    this.uniforms.defaultOpacity      = { value: 0.0 };
+  }
+}

package/src/materials/MedianFilterMaterial.js

@@ -0,0 +1,42 @@
+import BlitMaterial from '../materials/BlitMaterial';
+import frag from '../shaders/median_filter/median_filter.frag';
+
+import { Vector2 } from 'three';
+
+export default class MedianFilterMaterial extends BlitMaterial
+{
+  constructor()
+  {
+    super(frag, undefined, {
+      kernel3x3: true
+    });
+
+    this.uniforms._SourceTex = { value: undefined };
+    this.uniforms._SourceTexSize = { value: new Vector2(1, 1) };
+  }
+
+  set_texture(tex)
+  {
+    this.uniforms._SourceTex.value = tex;
+
+    let size = this.get_size(tex);
+    this.uniforms._SourceTexSize.value.copy(size);
+  }
+
+  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/materials/NormalMaterial.js

@@ -0,0 +1,17 @@
+import frag from '../shaders/normal/normal.frag';
+import vert from '../shaders/normal/normal.vert';
+
+import { ShaderMaterial } from 'three';
+
+export default class NormalMaterial extends ShaderMaterial
+{
+  constructor()
+  {
+    super({
+      uniforms: {
+      },
+      vertexShader: vert,
+      fragmentShader: frag
+    });
+  }
+}

package/src/materials/SDFScreenTextMaterial.js

@@ -0,0 +1,31 @@
+import BaseShaderMaterial from './BaseShaderMaterial';
+import frag from '../shaders/sdf_text/sdf_screen_text.frag';
+import vert from '../shaders/sdf_text/sdf_screen_text.vert';
+
+import { Vector2, DoubleSide, LinearFilter } from 'three';
+
+export default class SDFScreenTextMaterial extends BaseShaderMaterial
+{
+  constructor(texture)
+  {
+    super(vert, frag, {
+      _Texture: { value: texture },
+      _AtlasSize: { value: new Vector2(1, 1) }
+    });
+
+    this.transparent = true;
+    this.extensions = {
+      derivatives: true
+    };
+    this.depthWrite = false;
+    this.side = DoubleSide;
+    texture.minFilter = LinearFilter;
+    texture.magFilter = LinearFilter;
+    texture.generateMipMaps = false;
+  }
+
+  set_atlas_size(size)
+  {
+    this.uniforms._AtlasSize.value.copy(size);
+  }
+}

package/src/materials/SDFTextMaterial.js

@@ -0,0 +1,37 @@
+import BaseShaderMaterial from './BaseShaderMaterial';
+import frag from '../shaders/sdf_text/sdf_text.frag';
+import vert from '../shaders/sdf_text/sdf_text.vert';
+
+import { Vector2, DoubleSide, LinearFilter, Math as TMath } from 'three';
+
+export default class SDFTextMaterial extends BaseShaderMaterial
+{
+  constructor(texture)
+  {
+    super(vert, frag, {
+      _Texture: { value: texture },
+      _Boldness: { value: 0.5 },
+      _AtlasSize: { value: new Vector2(1, 1) }
+    });
+
+    this.transparent = true;
+    this.extensions = {
+      derivatives: true
+    };
+    this.depthWrite = false;
+    this.side = DoubleSide;
+    texture.minFilter = LinearFilter;
+    texture.magFilter = LinearFilter;
+    texture.generateMipMaps = false;
+  }
+
+  set_atlas_size(size)
+  {
+    this.uniforms._AtlasSize.value.copy(size);
+  }
+
+  set_boldness(value)
+  {
+    this.uniforms._Boldness.value = TMath.lerp(0.5, 0.2, value);
+  }
+}

package/src/materials/SSAOComposeMaterial.js

@@ -0,0 +1,11 @@
+import BlitMaterial from '../materials/BlitMaterial';
+import frag from '../shaders/ssao/ssao_compose.frag';
+
+export default class SSAOComposeMaterial extends BlitMaterial
+{
+  constructor()
+  {
+    super(frag);
+    this.uniforms._AO = { value: undefined };
+  }
+}

package/src/materials/SSAOMaterial.js

@@ -0,0 +1,66 @@
+import BlitMaterial from '../materials/BlitMaterial';
+import frag from '../shaders/ssao/ssao.frag';
+import vert from '../shaders/ssao/ssao.vert';
+
+import { Matrix4 } from 'three';
+import { Math as TMath } from 'three';
+import { Vector3 } from 'three';
+import { DataTexture } from 'three';
+import { RGBFormat } from 'three';
+import { RepeatWrapping } from 'three';
+
+export default class SSAOMaterial extends BlitMaterial
+{
+  constructor()
+  {
+    super(frag, vert);
+
+    this.uniforms._InverseProjMatrix = { value: new Matrix4() };
+    this.uniforms._ProjectionMatrix  = { value: new Matrix4() };
+
+    this.uniforms._Bias     = { value: 0.0125 };
+    this.uniforms._Radius   = { value: 0.3 };
+    this.uniforms._FarPlane = { value: 100 };
+
+    this.uniforms._SampleKernel = { value: this.__get_sample_kernel() };
+    this.uniforms._RandomRotation = { value: this.__get_rotation_kernel() };
+  }
+
+  __get_sample_kernel()
+  {
+    let sample_kernel = [];
+    let kernel_size = 64;
+
+    for (let i = 0; i < kernel_size; i++)
+    {
+      let dir = new Vector3(Math.random() * 2 - 1,
+        Math.random() * 2 - 1,
+        Math.random());
+      dir.normalize();
+      let scale = i / kernel_size;
+      scale   = TMath.lerp(0.1, 1.0, scale * scale);
+      dir.multiplyScalar(scale);
+
+      sample_kernel.push(dir);
+    }
+    return sample_kernel;
+  }
+
+  __get_rotation_kernel()
+  {
+    let rotation_kernel = new Uint8Array(3 * 16);
+    for (let i = 0; i < 16; i++)
+    {
+      rotation_kernel[i * 3 + 1] = Math.floor(Math.random() * 255);
+      rotation_kernel[i * 3 + 2] = Math.floor(Math.random() * 255);
+      rotation_kernel[i * 3 + 3] = 0;
+    }
+
+    let rotation_texture = new DataTexture(rotation_kernel, 4, 4, RGBFormat);
+    rotation_texture.wrapS = RepeatWrapping;
+    rotation_texture.wrapT = RepeatWrapping;
+
+    rotation_texture.needsUpdate = true;
+    return rotation_texture;
+  }
+}

package/src/materials/ScreenSpaceTextureMaterial.js

@@ -0,0 +1,65 @@
+import BaseShaderMaterial from './BaseShaderMaterial';
+import { Vector2 } from 'three';
+export default class ScreenSpaceTextureMaterial extends BaseShaderMaterial
+{
+  constructor(x, y, w, h)
+  {
+    let vert = `
+      uniform vec2 _ScreenSpacePosition;
+      uniform vec2 _ScreenSize;
+      uniform vec2 _TextureSize;
+      varying vec2 vUv;
+      void main()
+      {
+        vec2 pos = uv * vec2(_TextureSize.x / _ScreenSize.x, _TextureSize.y / _ScreenSize.y);
+        pos += vec2(_ScreenSpacePosition.x / _ScreenSize.x, _ScreenSpacePosition.y / _ScreenSize.y);
+
+        pos.x = pos.x * 2.0 - 1.0;
+        pos.y = pos.y * 2.0 - 1.0;
+
+        gl_Position = vec4(pos, 0.0, 1.0);
+        vUv = uv;
+      }
+    `;
+    let frag = `
+      uniform sampler2D _MainTex;
+      varying vec2 vUv;
+
+      void main()
+      {
+        gl_FragColor = texture2D(_MainTex, vUv);
+      }
+    `;
+    super(vert, frag, {
+      _MainTex: { value: undefined },
+      _ScreenSpacePosition: { value: new Vector2() },
+      _ScreenSize: { value: new Vector2() },
+      _TextureSize: { value: new Vector2() }
+    });
+  }
+
+  set_position(x, y)
+  {
+    this.uniforms._ScreenSpacePosition.value.set(x, y);
+  }
+
+  set_texture(tex, w, h)
+  {
+    this.uniforms._MainTex.value = tex;
+    this.uniforms._TextureSize.value.set(tex.image.width, tex.image.height);
+
+    if (w !== undefined)
+    {
+      this.uniforms._TextureSize.value.x = w;
+    }
+    if (h !== undefined)
+    {
+      this.uniforms._TextureSize.value.y = h;
+    }
+  }
+
+  set_screen_size(w, h)
+  {
+    this.uniforms._ScreenSize.value.set(w, h);
+  }
+}

package/src/materials/UIElementMaterial.js

@@ -0,0 +1,25 @@
+import vert from '../shaders/ui_element/ui_element.vert';
+import frag from '../shaders/ui_element/ui_element.frag';
+import BaseShaderMaterial from '../materials/BaseShaderMaterial';
+
+import { Vector2 } from 'three';
+import { Vector3 } from 'three';
+
+export default class UIElementMaterial extends BaseShaderMaterial
+{
+  constructor(intensity = 1)
+  {
+    super(vert, frag, {
+      _MainTex: { value: undefined },
+      _ScreenSize: { value: new Vector2(Screen.width, Screen.height) },
+      _TextureSize: { value: new Vector2() },
+      _PixelOffset: { value: new Vector2(0, 0) },
+      _NDC: { value: new Vector3() },
+      _PivotPoint: { value: new Vector2() },
+      _DepthOffset: { value: 0 }
+    });
+    this.transparent = true;
+    this.depthWrite = false;
+    this.depthTest = false;
+  }
+}

package/src/materials/UnrealBloomComposeMaterial.js

@@ -0,0 +1,95 @@
+import BlitMaterial from './BlitMaterial';
+import frag from '../shaders/gaussian_blur/unreal_bloom_compose.frag';
+import { Color } from 'three';
+export default class UnrealBloomComposeMaterial extends BlitMaterial
+{
+  constructor(nMips)
+  {
+    super(frag, undefined, {
+      NUM_MIPS: nMips
+    });
+    this.uniforms._MainTex        = { value: undefined };
+    this.uniforms._BlurredTex     = { value: undefined };
+    this.uniforms._BloomStrength  = { value: 1 };
+
+    this.uniforms.blurTexture1  = { value: null };
+    this.uniforms.blurTexture2  = { value: null };
+    this.uniforms.blurTexture3  = { value: null };
+    this.uniforms.blurTexture4  = { value: null };
+    this.uniforms.blurTexture5  = { value: null };
+
+    this.uniforms.bloomStrength = { value: 1.0 };
+    this.uniforms.bloomFactors  = { value: [1.0, 0.8, 0.6, 0.4, 0.2] };
+    this.uniforms.bloomRadius   = { value: 0.0 };
+
+    let bloomTintColors = [
+      new Color('#FFFFFF'),
+      new Color('#FFFFFF'),
+      new Color('#FFFFFF'),
+      new Color('#FFFFFF'),
+      new Color('#FFFFFF')
+    ];
+
+    this.uniforms.bloomTintColors = { value: bloomTintColors };
+  }
+
+  set_RT_0(rt)
+  {
+    this.uniforms.blurTexture1.value = rt;
+  }
+
+  set_RT_1(rt)
+  {
+    this.uniforms.blurTexture2.value = rt;
+  }
+
+  set_RT_2(rt)
+  {
+    this.uniforms.blurTexture3.value = rt;
+  }
+
+  set_RT_3(rt)
+  {
+    this.uniforms.blurTexture4.value = rt;
+  }
+
+  set_RT_4(rt)
+  {
+    this.uniforms.blurTexture5.value = rt;
+  }
+
+  set_bloom_strength(value)
+  {
+    this.uniforms.bloomStrength.value = value;
+  }
+
+  set_bloom_radius(value)
+  {
+    this.uniforms.bloomRadius.value = value;
+  }
+
+  set_tint_color_0(col_string)
+  {
+    this.uniforms.bloomTintColors.value[0].set(col_string);
+  }
+
+  set_tint_color_1(col_string)
+  {
+    this.uniforms.bloomTintColors.value[1].set(col_string);
+  }
+
+  set_tint_color_2(col_string)
+  {
+    this.uniforms.bloomTintColors.value[2].set(col_string);
+  }
+
+  set_tint_color_3(col_string)
+  {
+    this.uniforms.bloomTintColors.value[3].set(col_string);
+  }
+
+  set_tint_color_4(col_string)
+  {
+    this.uniforms.bloomTintColors.value[4].set(col_string);
+  }
+}

package/src/materials/UnrealBlurMaterial.js

@@ -0,0 +1,17 @@
+import BlitMaterial from '../materials/BlitMaterial';
+import frag from '../shaders/unreal_blur/unreal_blur.frag';
+
+import { Vector2 } from 'three';
+
+export default class UnrealBlurMaterial extends BlitMaterial
+{
+  constructor(kernel_radius)
+  {
+    let defines = {
+      KERNEL_RADIUS: kernel_radius,
+      SIGMA: kernel_radius
+    };
+    super(frag, undefined, defines);
+    this.uniforms._SampleDir = { value: new Vector2(0.5, 0.5) };
+  }
+}

package/src/materials/UnrealComposeMaterial.js

@@ -0,0 +1,24 @@
+import BlitMaterial from '../materials/BlitMaterial';
+import frag from '../shaders/unreal_blur/unreal_compose.frag';
+
+export default class UnrealComposeMaterial extends BlitMaterial
+{
+  constructor(nMips)
+  {
+    let defines = {
+      NUM_MIPS: nMips
+    };
+    super(frag, undefined, defines);
+
+    this.uniforms.blurTexture1    = { value: null };
+    this.uniforms.blurTexture2    = { value: null };
+    this.uniforms.blurTexture3    = { value: null };
+    this.uniforms.blurTexture4    = { value: null };
+    this.uniforms.blurTexture5    = { value: null };
+    this.uniforms.dirtTexture     = { value: null };
+    this.uniforms.bloomStrength   = { value: 1.0 };
+    this.uniforms.bloomFactors    = { value: null };
+    this.uniforms.bloomTintColors = { value: null };
+    this.uniforms.bloomRadius     = { value: 0.0 };
+  }
+}

package/src/materials/ViewPositionMaterial.js

@@ -0,0 +1,17 @@
+import frag from '../shaders/write_view_position/write_view_position.frag';
+import vert from '../shaders/write_view_position/write_view_position.vert';
+
+import { ShaderMaterial } from 'three';
+
+export default class ViewPositionMaterial extends ShaderMaterial
+{
+  constructor()
+  {
+    super({
+      uniforms: {
+      },
+      vertexShader: vert,
+      fragmentShader: frag
+    });
+  }
+}

package/src/materials/deferred/DeferredPointLightMaterial.js

@@ -0,0 +1,39 @@
+import vert from '../../shaders/deferred/point_light.vert';
+import frag from '../../shaders/deferred/point_light.frag';
+import BaseShaderMaterial from '../../materials/BaseShaderMaterial';
+
+import { Matrix4 } from 'three';
+import { AdditiveBlending } from 'three';
+import { BackSide } from 'three';
+
+export default class DeferredPointLightMaterial extends BaseShaderMaterial
+{
+  constructor(intensity = 1)
+  {
+    super(vert, frag, {
+      _Intensity: { value: intensity },
+      _AlbedoTex: { value: undefined },
+      _NormalDepthTex: { value: undefined },
+      _InverseProjMatrix: { value: new Matrix4() }
+    });
+
+    this.blending = AdditiveBlending;
+    this.depthWrite = false;
+    this.side = BackSide;
+  }
+
+  set_inverse_proj_matrix(mat4)
+  {
+    this.uniforms._InverseProjMatrix.value.copy(mat4);
+  }
+
+  set_normal_depth_rt(rt)
+  {
+    this.uniforms._NormalDepthTex.value = rt.texture;
+  }
+
+  set_albedo_rt(rt)
+  {
+    this.uniforms._AlbedoTex.value = rt.texture;
+  }
+}

package/src/materials/gpu_particles/AttributeUpdateMaterial.js

@@ -0,0 +1,33 @@
+import BlitMaterial from '../../materials/BlitMaterial';
+import frag from '../../shaders/gpu_particles/update/basic_update.frag';
+import Time from '../../Time';
+
+import common_utils from '../../shaders/gpu_particles/common_utils';
+
+import { Vector2 } from 'three';
+import { ShaderChunk } from 'three';
+
+export default class AttributeUpdateMaterial extends BlitMaterial
+{
+  constructor(custom_frag)
+  {
+    ShaderChunk.gpu_particles_utils = common_utils;
+
+    super(custom_frag || frag);
+    this.uniforms._Time = { value: new Vector2() };
+    this.multiplier = 0;
+  }
+
+  update()
+  {
+    this.uniforms._Time.value.x = Time.delta_time;
+    this.uniforms._Time.value.y += Time.delta_time;
+    // this.precision = "lowp";
+  }
+
+  set_multiplier(val)
+  {
+    console.log(val);
+    this.multiplier = val;
+  }
+}

package/src/materials/gpu_particles/BasicParticleMaterial.js

@@ -0,0 +1,23 @@
+import vert from '../../shaders/gpu_particles/visualize/visualize.vert';
+import frag from '../../shaders/gpu_particles/visualize/visualize.frag';
+
+import { ShaderMaterial } from 'three';
+
+export default class BasicParticleMaterial extends ShaderMaterial
+{
+  constructor()
+  {
+    // ShaderChunk["gpu_particles_utils"] = common_utils;
+
+    super({
+      uniforms: {
+        _Position: { value: undefined },
+        _Time: { value: 0 }
+      },
+      vertexShader: vert,
+      fragmentShader: frag,
+      transparent: true,
+      depthWrite: false
+    });
+  }
+}

package/src/materials/gpu_particles/ParticleStorageMaterial.js

@@ -0,0 +1,27 @@
+import frag from '../../shaders/gpu_particles/generic_storage.frag';
+import common_utils from '../../shaders/gpu_particles/common_utils.glsl';
+
+import { ShaderMaterial } from 'three';
+import { ShaderChunk } from 'three';
+import { NoBlending } from 'three';
+import { AlwaysDepth } from 'three';
+
+export default class ParticleStorageMaterial extends ShaderMaterial
+{
+  constructor(vert)
+  {
+    ShaderChunk.gpu_particles_utils = common_utils;
+
+    super({
+      uniforms: {
+
+      },
+      vertexShader: vert,
+      fragmentShader: frag,
+      depthWrite: false,
+      blending: NoBlending,
+      depthTest: false,
+      depthFunc: AlwaysDepth
+    });
+  }
+}

package/src/materials/gpu_particles/PositionStorageMaterial.js

@@ -0,0 +1,10 @@
+import ParticleStorageMaterial from '../../materials/gpu_particles/ParticleStorageMaterial';
+import vert from '../../shaders/gpu_particles/store/store_position.vert';
+
+export default class PositionStorageMaterial extends ParticleStorageMaterial
+{
+  constructor()
+  {
+    super(vert);
+  }
+}