ohzi-core 13.3.0 → 15.0.0

package/src/materials/BlitMaterial.ts

@@ -1,27 +0,0 @@
-import frag from '../shaders/copy/copy.frag';
-import vert from '../shaders/copy/copy.vert';
-
-import { AlwaysDepth, NoBlending, ShaderMaterial, Vector2 } from 'three';
-
-class BlitMaterial extends ShaderMaterial
-{
-  constructor(frag_shader?: string, vert_shader?: string, defines?: Record<string, any>)
-  {
-    super({
-      uniforms: {
-        _MainTex: { value: null },
-        _Resolution: { value: new Vector2(0, 0) },
-        _TargetResolution: { value: new Vector2(0, 0) }
-      },
-      defines: defines || {},
-      vertexShader: vert_shader || vert,
-      fragmentShader: frag_shader || frag,
-      depthWrite: false,
-      blending: NoBlending,
-      depthTest: false,
-      depthFunc: AlwaysDepth
-    });
-  }
-}
-
-export { BlitMaterial };

package/src/materials/DeferredRendererComposeMaterial.ts

@@ -1,36 +0,0 @@
-import { BlitMaterial } from '../materials/BlitMaterial';
-
-import vert from '../shaders/deferred/blit_copy.vert';
-import frag from '../shaders/deferred/deferred_compose.frag';
-
-import type { RenderTarget, Texture } from 'three';
-import { Matrix4 } from 'three';
-
-class DeferredRendererComposeMaterial extends BlitMaterial
-{
-  constructor()
-  {
-    super(frag, vert);
-
-    this.uniforms._NormalDepthRT = { value: undefined };
-    this.uniforms._AlbedoRT = { value: undefined };
-    this.uniforms._InverseProjMatrix = { value: new Matrix4() };
-  }
-
-  set_normal_depth_rt(rt: RenderTarget)
-  {
-    this.uniforms._NormalDepthRT.value = rt.texture;
-  }
-
-  set_albedo_rt(tex: Texture)
-  {
-    this.uniforms._AlbedoRT.value = tex;
-  }
-
-  set_proj_matrix(mat4: Matrix4)
-  {
-    this.uniforms._InverseProjMatrix.value = mat4.clone().invert();
-  }
-}
-
-export { DeferredRendererComposeMaterial };

package/src/materials/DisplayNormalTextureMaterial.ts

@@ -1,18 +0,0 @@
-import { BlitMaterial } from '../materials/BlitMaterial';
-
-import frag from '../shaders/depth_normals/debug_normals.frag';
-import depth_normals_vert from '../shaders/ssao/ssao.vert';
-
-import { Matrix4 } from 'three';
-
-class DisplayNormalTextureMaterial extends BlitMaterial
-{
-  constructor()
-  {
-    super(frag, depth_normals_vert);
-    this.uniforms._FarPlane          = { value: 1 };
-    this.uniforms._InverseProjMatrix = { value: new Matrix4() };
-  }
-}
-
-export { DisplayNormalTextureMaterial };

package/src/materials/FXAAMaterial.ts

@@ -1,12 +0,0 @@
-import frag from 'js/core/shaders/anti_aliasing/fxaa.frag';
-import { BlitMaterial } from './BlitMaterial';
-
-class FXAAMaterial extends BlitMaterial
-{
-  constructor()
-  {
-    super(frag);
-  }
-}
-
-export { FXAAMaterial };

package/src/materials/MedianFilterMaterial.ts

@@ -1,46 +0,0 @@
-import { BlitMaterial } from '../materials/BlitMaterial';
-
-import frag from '../shaders/median_filter/median_filter.frag';
-
-import type { Texture, VideoTexture, WebGLRenderTarget } from 'three';
-import { Vector2 } from 'three';
-
-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: Texture)
-  {
-    this.uniforms._SourceTex.value = tex;
-
-    const size = this.get_size(tex);
-    (this.uniforms._SourceTexSize.value as Vector2).copy(size);
-  }
-
-  get_size(tex: Texture)
-  {
-    if ((tex as VideoTexture).isVideoTexture)
-    {
-      return new Vector2(Math.max(1, (tex.image as HTMLVideoElement).videoWidth), Math.max(1, (tex.image as HTMLVideoElement).videoHeight));
-    }
-    if ((tex as unknown as WebGLRenderTarget).isWebGLRenderTarget)
-    {
-      return new Vector2(tex.width, tex.height);
-    }
-    if (tex.isTexture)
-    {
-      return new Vector2((tex.image as ImageBitmap).width, (tex.image as ImageBitmap).height);
-    }
-    return new Vector2(1, 1);
-  }
-}
-
-export { MedianFilterMaterial };

package/src/materials/SDFScreenTextMaterial.ts

@@ -1,32 +0,0 @@
-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 type { Texture } from 'three';
-import { DoubleSide, LinearFilter, Vector2 } from 'three';
-
-class SDFScreenTextMaterial extends BaseShaderMaterial
-{
-  constructor(texture: Texture)
-  {
-    super(vert, frag, {
-      _Texture: { value: texture },
-      _AtlasSize: { value: new Vector2(1, 1) }
-    });
-
-    this.transparent = true;
-    this.depthWrite = false;
-    this.side = DoubleSide;
-    texture.minFilter = LinearFilter;
-    texture.magFilter = LinearFilter;
-    texture.generateMipmaps = false;
-  }
-
-  set_atlas_size(size: Vector2)
-  {
-    (this.uniforms._AtlasSize.value as Vector2).copy(size);
-  }
-}
-
-export { SDFScreenTextMaterial };

package/src/materials/UnrealBlurMaterial.ts

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

package/src/materials/UnrealComposeMaterial.ts

@@ -1,27 +0,0 @@
-import { BlitMaterial } from '../materials/BlitMaterial';
-
-import frag from '../shaders/unreal_blur/unreal_compose.frag';
-
-class UnrealComposeMaterial extends BlitMaterial
-{
-  constructor(nMips: number)
-  {
-    const 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 };
-  }
-}
-
-export { UnrealComposeMaterial };

package/src/materials/ViewPositionMaterial.ts

@@ -1,19 +0,0 @@
-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';
-
-class ViewPositionMaterial extends ShaderMaterial
-{
-  constructor()
-  {
-    super({
-      uniforms: {
-      },
-      vertexShader: vert,
-      fragmentShader: frag
-    });
-  }
-}
-
-export { ViewPositionMaterial };

package/src/materials/gpu_particles/AttributeUpdateMaterial.ts

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

package/src/materials/gpu_particles/BasicParticleMaterial.ts

@@ -1,25 +0,0 @@
-import frag from '../../shaders/gpu_particles/visualize/visualize.frag';
-import vert from '../../shaders/gpu_particles/visualize/visualize.vert';
-
-import { ShaderMaterial } from 'three';
-
-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
-    });
-  }
-}
-
-export { BasicParticleMaterial };

package/src/materials/gpu_particles/ParticleStorageMaterial.ts

@@ -1,36 +0,0 @@
-import frag from '../../shaders/gpu_particles/generic_storage.frag';
-
-import { AlwaysDepth, NoBlending, ShaderMaterial } from 'three';
-
-class ParticleStorageMaterial extends ShaderMaterial
-{
-  constructor(vert?: string)
-  {
-    vert = vert || `
-      varying vec4 value;
-      attribute vec4 data;
-
-      void main()
-      {
-          gl_Position = vec4(position.xy * 2.0 - 1.0, 1.0,1.0);
-          gl_PointSize = 1.0;
-
-          value = data;
-      }
-    `;
-
-    super({
-      uniforms: {
-
-      },
-      vertexShader: vert,
-      fragmentShader: frag,
-      depthWrite: false,
-      blending: NoBlending,
-      depthTest: false,
-      depthFunc: AlwaysDepth
-    });
-  }
-}
-
-export { ParticleStorageMaterial };

package/src/materials/gpu_particles/PositionStorageMaterial.ts

@@ -1,27 +0,0 @@
-import { ParticleStorageMaterial } from '../../materials/gpu_particles/ParticleStorageMaterial';
-
-class PositionStorageMaterial extends ParticleStorageMaterial
-{
-  constructor()
-  {
-    const vert = `
-
-      varying vec4 value;
-
-      attribute vec2 storage_uv;
-
-      void main()
-      {
-          gl_Position = vec4(storage_uv * 2.0 - 1.0, 1.0,1.0);
-          gl_PointSize = 1.0;
-
-          value = vec4(position.xyz, 1.0);
-      }
-
-    `;
-    
-    super(vert);
-  }
-}
-
-export { PositionStorageMaterial };

package/src/render_utilities/MedianFilter.ts

@@ -1,72 +0,0 @@
-import { Graphics } from '../Graphics';
-import { MedianFilterMaterial } from '../materials/MedianFilterMaterial';
-
-import { FloatType, NearestFilter, RenderTarget, RGBAFormat, Vector2 } from 'three';
-
-class MedianFilter
-{
-  RT: RenderTarget;
-  RT1: RenderTarget;
-  median_filter_mat: MedianFilterMaterial;
-
-  constructor()
-  {
-    this.RT = new RenderTarget(1, 1, {
-      type: FloatType,
-      format: RGBAFormat,
-      minFilter: NearestFilter,
-      magFilter: NearestFilter
-    });
-    this.RT1 = new RenderTarget(1, 1, {
-      type: FloatType,
-      format: RGBAFormat,
-      minFilter: NearestFilter,
-      magFilter: NearestFilter
-    });
-
-    this.median_filter_mat = new MedianFilterMaterial();
-  }
-
-  filter(texture: any)
-  {
-    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: any)
-  {
-    if (tex.isVideoTexture)
-    {
-      return new Vector2(Math.max(1, tex.image.videoWidth), Math.max(1, tex.image.videoHeight));
-    }
-    if (tex.isRenderTarget)
-    {
-      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 };

package/src/render_utilities/ViewPositionRenderer.ts

@@ -1,53 +0,0 @@
-import type { Renderer } from 'three/webgpu';
-import { CameraManager } from '../CameraManager';
-import { OScreen } from '../OScreen';
-import { SceneManager } from '../SceneManager';
-import { ViewPositionMaterial } from '../materials/ViewPositionMaterial';
-
-import { Color, FloatType, RenderTarget } from 'three';
-
-class ViewPositionRenderer
-{
-  RT: RenderTarget;
-  clear_color: Color;
-  render_pos_mat: ViewPositionMaterial;
-
-  constructor()
-  {
-    this.RT = new RenderTarget(OScreen.width, OScreen.height, { type: FloatType });
-    this.clear_color = new Color(0, 0, 0);
-    this.render_pos_mat = new ViewPositionMaterial();
-  }
-
-  render(context: any, renderer: Renderer)
-  {
-    if (this.RT.width !== OScreen.width || this.RT.height !== OScreen.height)
-    {
-      this.RT.setSize(OScreen.width, OScreen.height);
-    }
-
-    if (CameraManager.current)
-    {
-      CameraManager.current.aspect = OScreen.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;
-  }
-}
-
-export { ViewPositionRenderer };

package/src/shaders/add/add.frag

@@ -1,28 +0,0 @@
-uniform sampler2D _MainTex;
-uniform sampler2D _SecondTex;
-
-varying vec2 vUv;
-
-vec4 sampleTex(sampler2D tex, vec2 uv)
-{
-  vec4 col = texture2D( tex, uv);
-
-  #ifndef USE_LINEAR_COLOR_SPACE
-    col.rgb = pow(col.rgb, vec3(2.2));
-  #endif
-
-  return col;
-}
-void main()
-{
-	vec4 col0 = sampleTex(_MainTex, vUv);
-	vec4 col1 = sampleTex(_SecondTex, vUv);
-
-
-  gl_FragColor = col0+col1;
-	// gl_FragColor = texture2D(_SecondTex, vUv);
-  gl_FragColor.rgb = pow(gl_FragColor.rgb, vec3(0.4545));
-
-	// gl_FragColor = texture2D(_MainTex, vUv)+texture2D(_SecondTex, vUv);
-
-}

package/src/shaders/anti_aliasing/fxaa.frag

@@ -1,72 +0,0 @@
-// FXAA shader, GLSL code adapted from:
-// http://horde3d.org/wiki/index.php5?title=Shading_Technique_-_FXAA
-// Whitepaper describing the technique:
-// http://developer.download.nvidia.com/assets/gamedev/files/sdk/11/FXAA_WhitePaper.pdf
-
-// from: https://code.google.com/p/processing/source/browse/trunk/processing/java/libraries/opengl/examples/Shaders/FXAA/data/fxaa.glsl?r=9668
-
-uniform sampler2D _MainTex;
-uniform vec2 _Resolution;
-
-varying vec2 vUv;
-
-
-void main() {
-    // The inverse of the texture dimensions along X and Y
-  vec2 texcoordOffset = 1. / _Resolution;
-
-  //varying vec4 vertColor;
-  vec4 vertTexcoord = vec4( vUv, 1., 1. );
-
-  // The parameters are hardcoded for now, but could be
-  // made into uniforms to control fromt he program.
-  float FXAA_SPAN_MAX = 8.0;
-  float FXAA_REDUCE_MUL = 1.0/8.0;
-  float FXAA_REDUCE_MIN = (1.0/128.0);
-
-  vec3 rgbNW = texture2D(_MainTex, vertTexcoord.xy + (vec2(-1.0, -1.0) * texcoordOffset)).xyz;
-  vec3 rgbNE = texture2D(_MainTex, vertTexcoord.xy + (vec2(+1.0, -1.0) * texcoordOffset)).xyz;
-  vec3 rgbSW = texture2D(_MainTex, vertTexcoord.xy + (vec2(-1.0, +1.0) * texcoordOffset)).xyz;
-  vec3 rgbSE = texture2D(_MainTex, vertTexcoord.xy + (vec2(+1.0, +1.0) * texcoordOffset)).xyz;
-  vec3 rgbM  = texture2D(_MainTex, vertTexcoord.xy).xyz;
-
-  vec3 luma = vec3(0.299, 0.587, 0.114);
-  float lumaNW = dot(rgbNW, luma);
-  float lumaNE = dot(rgbNE, luma);
-  float lumaSW = dot(rgbSW, luma);
-  float lumaSE = dot(rgbSE, luma);
-  float lumaM  = dot( rgbM, luma);
-
-  float lumaMin = min(lumaM, min(min(lumaNW, lumaNE), min(lumaSW, lumaSE)));
-  float lumaMax = max(lumaM, max(max(lumaNW, lumaNE), max(lumaSW, lumaSE)));
-
-  vec2 dir;
-  dir.x = -((lumaNW + lumaNE) - (lumaSW + lumaSE));
-  dir.y =  ((lumaNW + lumaSW) - (lumaNE + lumaSE));
-
-  float dirReduce = max((lumaNW + lumaNE + lumaSW + lumaSE) * (0.25 * FXAA_REDUCE_MUL), FXAA_REDUCE_MIN);
-
-  float rcpDirMin = 1.0/(min(abs(dir.x), abs(dir.y)) + dirReduce);
-
-  dir = min(vec2(FXAA_SPAN_MAX,  FXAA_SPAN_MAX),
-        max(vec2(-FXAA_SPAN_MAX, -FXAA_SPAN_MAX), dir * rcpDirMin)) * texcoordOffset;
-
-  vec3 rgbA = (1.0/2.0) * (
-              texture2D(_MainTex, vertTexcoord.xy + dir * (1.0/3.0 - 0.5)).xyz +
-              texture2D(_MainTex, vertTexcoord.xy + dir * (2.0/3.0 - 0.5)).xyz);
-  vec3 rgbB = rgbA * (1.0/2.0) + (1.0/4.0) * (
-              texture2D(_MainTex, vertTexcoord.xy + dir * (0.0/3.0 - 0.5)).xyz +
-              texture2D(_MainTex, vertTexcoord.xy + dir * (3.0/3.0 - 0.5)).xyz);
-  float lumaB = dot(rgbB, luma);
-
-  if((lumaB < lumaMin) || (lumaB > lumaMax)){
-    gl_FragColor.xyz=rgbA;
-  } else {
-    gl_FragColor.xyz=rgbB;
-  }
-  gl_FragColor.a = 1.0;
-
-  // gl_FragColor = vec4(texture2D(_MainTex, vUv).rgb, 1.0);
-  // gl_FragColor = vec4(1.0, 0.0, 0.0, 0.0);
-  //gl_FragColor *= vertColor;
-}

package/src/shaders/basic_color/basic_color.frag

@@ -1,6 +0,0 @@
-uniform vec3 _Color;
-
-void main()
-{
-    gl_FragColor = vec4(_Color, 1.0);
-}

package/src/shaders/basic_color/basic_color.vert

@@ -1,10 +0,0 @@
-varying vec2 vUv;
-
-void main()
-{
-  vec3 pos = position;
-  mat4 MVP = projectionMatrix * modelViewMatrix;
-
-  gl_Position = MVP * vec4( pos, 1.0 );
-  vUv = uv;
-}

package/src/shaders/basic_line/basic_line.frag

@@ -1,37 +0,0 @@
-uniform float _Length;
-uniform float _ElapsedTime;
-uniform float _Thickness;
-uniform vec3  _Color;
-
-varying float line_coverage;
-varying float uv_u;
-
-
-
-
-float aastep(float threshold, float value) {
-  #ifdef GL_OES_standard_derivatives
-    float afwidth = length(vec2(dFdx(value), dFdy(value))) * 0.70710678118654757;
-    return smoothstep(threshold-afwidth, threshold+afwidth, value);
-  #else
-    return step(threshold, value);
-  #endif
-}
-
-void main()
-{
-
-    // float y = fract(line_coverage /_Thickness - _TrueElapsedTime) ;
-
-    // vec2 uv = vec2(uv_u, y);
-
-
-    // vec4 col = texture2D(_ArrowsTex,uv);
-    // col.rgb *= _ForwardColor;
-    // col.a = aastep(0.5, col.a);
-    // gl_FragColor = col;
-    float u = (1.0 - abs(uv_u * 2.0 - 1.0));
-    float diffuse = dot(vec2(u, u), vec2(0.0, 1.0)) * 0.5+0.5;
-    gl_FragColor = vec4(_Color * diffuse, 1.0);
-
-}