ohzi-core 5.13.2 → 5.14.2

package/src/shaders/ssao/ssao_compose.frag

@@ -0,0 +1,14 @@
+uniform sampler2D _MainTex;
+uniform sampler2D _AO;
+uniform vec2 _Resolution;
+uniform vec2 _SampleDir;
+varying vec2 vUv;
+
+void main()
+{
+
+
+  gl_FragColor.rgb = texture2D(_MainTex, vUv).rgb * (1.0 - texture2D(_AO, vUv).r);
+  gl_FragColor.a = 1.0;
+
+}

package/src/shaders/transparent_mix/copy.frag

@@ -0,0 +1,7 @@
+uniform sampler2D _MainTex;
+varying vec2 vUv;
+
+void main()
+{
+		gl_FragColor = texture2D( _MainTex, vUv);
+}

package/src/shaders/transparent_mix/transparent_mix.frag

@@ -0,0 +1,19 @@
+uniform sampler2D _OpaqueTex;
+uniform sampler2D _TransparentTex;
+uniform vec2 _Resolution;
+uniform float _Opacity;
+varying vec2 vUv;
+
+void main()
+{
+		vec4 opaque = texture2D( _OpaqueTex, vUv);
+		vec4 transparent = texture2D( _TransparentTex, vUv);
+
+		gl_FragColor = vec4(mix(opaque.rgb, transparent.rgb, transparent.a*_Opacity), 1.0);
+		// if(vUv.x > 0.5)
+		// 	gl_FragColor = vec4(opaque.rgb, 1.0);
+		// else
+		// 	gl_FragColor = vec4(transparent.rgb, 1.0);
+
+
+}

package/src/shaders/transparent_mix/transparent_mix.vert

@@ -0,0 +1,8 @@
+
+varying vec2 vUv;
+
+void main()
+{
+  gl_Position = vec4(uv * 2.0 - 1.0, 0.0, 1.0);
+  vUv = uv;
+}

package/src/shaders/ui/ss_texture.frag

@@ -0,0 +1,11 @@
+uniform sampler2D _MainTex;
+uniform vec2 _ScreenSize;
+uniform vec2 _TextureSize;
+varying vec2 vUv;
+
+
+
+void main()
+{
+	gl_FragColor = texture2D(_MainTex, vUv + vec2(0.5, 0.5)/_TextureSize);
+}

package/src/shaders/ui/ss_texture.vert

@@ -0,0 +1,32 @@
+uniform vec2 _ScreenSize;
+uniform vec2 _TextureSize;
+uniform vec2 _PixelOffset;
+uniform vec3 _NDC;
+uniform vec2 _PivotPoint;
+uniform float _DepthOffset;
+varying vec2 vUv;
+
+
+vec2 round_to_ceil(vec2 pos)
+{
+	pos = pos * 0.5 + 0.5;
+	pos *= _ScreenSize;
+	pos = ceil(pos)+0.5;
+	pos /= _ScreenSize;
+	return pos * 2.0 - 1.0;
+}
+void main()
+{
+	vec4 projected_pos = projectionMatrix * viewMatrix * vec4(_NDC, 1.0);
+  projected_pos.zw += _DepthOffset;
+
+	projected_pos.xyz /= projected_pos.w;
+	
+  vec2 normalized_size = _TextureSize/_ScreenSize;
+  vec2 dir = uv * 2.0 - 1.0;
+  dir -= _PivotPoint; 
+  vec2 pos = projected_pos.xy+ dir * normalized_size;
+  gl_Position = vec4(round_to_ceil(pos), projected_pos.z, 1.0);
+  vUv = uv;
+
+}

package/src/shaders/ui/ws_texture.vert

@@ -0,0 +1,39 @@
+
+uniform vec2 _ScreenSize;
+uniform vec2 _TextSize;
+uniform vec2 _PixelOffset;
+uniform float _DepthOffset;
+uniform float _FixedDepth;
+uniform float _DepthValue;
+uniform float _UseAbsoluteScreenPosition;
+uniform vec2 _ScreenPosition;
+uniform float _WorldTextSize;
+varying vec2 vUv;
+
+
+
+void main()
+{
+  vec3 w_pos;
+  w_pos.x = modelMatrix[0][3];
+  w_pos.y = modelMatrix[1][3];
+  w_pos.z = modelMatrix[2][3];
+
+  vec2 dir = uv * 2.0 - 1.0;
+  dir.x *= (_TextSize.x / _TextSize.y);
+
+  vec4 view_pos = modelViewMatrix * vec4(w_pos, 1.0);
+  vec3 forward = vec3(0., 0., 1.);
+  vec3 binormal = normalize(cross(forward, vec3(0.0, -1.0, 0.0)));
+  vec3 up = cross(forward, binormal);
+  vec3 normal = (binormal * dir.x + up * dir.y);
+
+  normal = normalize(normal);
+  view_pos.xyz += normal * _WorldTextSize * 0.5;
+
+  gl_Position = projectionMatrix * view_pos;
+
+
+  vUv = uv;
+
+}

package/src/shaders/ui_element/ui_element.frag

@@ -0,0 +1,11 @@
+uniform sampler2D _MainTex;
+uniform vec2 _ScreenSize;
+uniform vec2 _TextureSize;
+varying vec2 vUv;
+
+
+
+void main()
+{
+	gl_FragColor = texture2D(_MainTex, vUv + vec2(0.5, 0.5)/_TextureSize);
+}

package/src/shaders/ui_element/ui_element.vert

@@ -0,0 +1,32 @@
+uniform vec2 _ScreenSize;
+uniform vec2 _TextureSize;
+uniform vec2 _PixelOffset;
+uniform vec3 _NDC;
+uniform vec2 _PivotPoint;
+uniform float _DepthOffset;
+varying vec2 vUv;
+
+
+vec2 add_pixel_offset(vec2 pos)
+{
+	pos = pos * 0.5 + 0.5;
+	pos *= _ScreenSize;
+	pos = ceil(pos+_PixelOffset)+0.5;
+	pos /= _ScreenSize;
+	return pos * 2.0 - 1.0;
+}
+void main()
+{
+	vec4 projected_pos = projectionMatrix * viewMatrix * vec4(_NDC, 1.0);
+  projected_pos.zw += _DepthOffset;
+
+	projected_pos.xyz /= projected_pos.w;
+
+  vec2 normalized_size = _TextureSize/_ScreenSize;
+  vec2 dir = uv * 2.0 - 1.0;
+  dir -= _PivotPoint;
+  vec2 pos = projected_pos.xy+dir * normalized_size;
+  gl_Position = vec4(add_pixel_offset(pos), projected_pos.z, 1.0);
+  vUv = uv;
+
+}

package/src/shaders/unreal_blur/unreal_blur.frag

@@ -0,0 +1,25 @@
+#include <common>
+varying vec2 vUv;
+uniform sampler2D _MainTex;
+uniform vec2 _Resolution;
+uniform vec2 _SampleDir;
+
+float gaussianPdf(in float x, in float sigma) {
+	return 0.39894 * exp( -0.5 * x * x/( sigma * sigma))/sigma;
+}
+void main() {
+	vec2 invSize = 1.0 / _Resolution;
+	float fSigma = float(SIGMA);
+	float weightSum = gaussianPdf(0.0, fSigma);
+	vec3 diffuseSum = texture2D( _MainTex, vUv).rgb * weightSum;
+	for( int i = 1; i < KERNEL_RADIUS; i ++ ) {
+		float x = float(i);
+		float w = gaussianPdf(x, fSigma);
+		vec2 uvOffset = _SampleDir * invSize * x;
+		vec3 sample1 = texture2D( _MainTex, vUv + uvOffset).rgb;
+		vec3 sample2 = texture2D( _MainTex, vUv - uvOffset).rgb;
+		diffuseSum += (sample1 + sample2) * w;
+		weightSum += 2.0 * w;
+	}
+	gl_FragColor = vec4(diffuseSum/weightSum, 1.0);
+}

package/src/shaders/unreal_blur/unreal_compose.frag

@@ -0,0 +1,24 @@
+varying vec2 vUv;
+uniform sampler2D blurTexture1;
+uniform sampler2D blurTexture2;
+uniform sampler2D blurTexture3;
+uniform sampler2D blurTexture4;
+uniform sampler2D blurTexture5;
+uniform sampler2D dirtTexture;
+uniform float bloomStrength;
+uniform float bloomRadius;
+uniform float bloomFactors[NUM_MIPS];
+uniform vec3 bloomTintColors[NUM_MIPS];
+
+float lerpBloomFactor(const in float factor) { 
+	float mirrorFactor = 1.2 - factor;
+	return mix(factor, mirrorFactor, bloomRadius);
+}
+
+void main() {
+	gl_FragColor = bloomStrength * ( lerpBloomFactor(bloomFactors[0]) * vec4(bloomTintColors[0], 1.0) * texture2D(blurTexture1, vUv) + 
+									 lerpBloomFactor(bloomFactors[1]) * vec4(bloomTintColors[1], 1.0) * texture2D(blurTexture2, vUv) + 
+									 lerpBloomFactor(bloomFactors[2]) * vec4(bloomTintColors[2], 1.0) * texture2D(blurTexture3, vUv) + 
+									 lerpBloomFactor(bloomFactors[3]) * vec4(bloomTintColors[3], 1.0) * texture2D(blurTexture4, vUv) + 
+									 lerpBloomFactor(bloomFactors[4]) * vec4(bloomTintColors[4], 1.0) * texture2D(blurTexture5, vUv) );
+}

package/src/shaders/write_view_position/write_view_position.frag

@@ -0,0 +1,7 @@
+varying vec3 v_pos;
+
+
+void main()
+{
+    gl_FragColor = vec4(v_pos, 1.0);
+}

package/src/shaders/write_view_position/write_view_position.vert

@@ -0,0 +1,9 @@
+varying vec3 v_pos;
+
+void main()
+{
+  mat4 MVP = projectionMatrix * modelViewMatrix;
+
+  v_pos = (modelViewMatrix * vec4( position, 1.0 )).xyz;
+  gl_Position = MVP * vec4( position, 1.0 );
+}

package/src/static_batcher/GeometryBatch.js

@@ -0,0 +1,312 @@
+import { Vector2 } from 'three';
+import { ShaderMaterial } from 'three';
+import { Mesh } from 'three';
+import { DataTexture } from 'three';
+import { RGBAFormat } from 'three';
+import { RGBFormat } from 'three';
+import { FloatType } from 'three';
+
+export default class GeometryBatch
+{
+  constructor(geometry, batch_width)
+  {
+    this.geometry = geometry;
+
+    this.material = undefined;
+    this.uniforms = {};
+    this.batch_width = batch_width;
+
+    this.data_textures = [];
+
+    this.object_names = undefined;
+
+    this.zero_offset = new Vector2();
+    this.write_offset = new Vector2();
+
+    this.uniform_dirty_count = 0;
+
+    this.tmp_uploaded_data_count = 0;
+  }
+
+  init(object_names, vert_shader, frag_shader)
+  {
+    this.material = new ShaderMaterial({
+      uniforms: this.uniforms,
+      vertexShader: vert_shader,
+      fragmentShader: frag_shader
+    });
+    this.object_names = object_names;
+  }
+
+  add_global_uniform(name, data)
+  {
+    this.uniforms[name] = { value: data };
+    this.material.needsUpdate = true;
+  }
+
+  set_global_uniform(name, data)
+  {
+    this.uniforms[name].value = data;
+  }
+
+  add_object_uniform_v3(uniform_name, default_value_v3)
+  {
+    let src_tex       = this.__create_rgb_texture(this.batch_width);
+    let dst_tex       = this.__create_rgb_texture(this.batch_width);
+    let one_pixel_tex = this.__create_rgb_texture(1);
+
+    let new_data_tex = this.__add_data_texture(uniform_name, src_tex, dst_tex, one_pixel_tex);
+
+    if (default_value_v3)
+    {
+      this.__flood_data_texture_rgb(new_data_tex, default_value_v3);
+    }
+  }
+
+  add_object_uniform_v4(uniform_name, default_value_v4)
+  {
+    let src_tex       = this.__create_rgba_texture(this.batch_width);
+    let dst_tex       = this.__create_rgba_texture(this.batch_width);
+    let one_pixel_tex = this.__create_rgba_texture(1);
+
+    let new_data_tex = this.__add_data_texture(uniform_name, src_tex, dst_tex, one_pixel_tex);
+
+    if (default_value_v4)
+    {
+      this.__flood_data_texture_rgba(new_data_tex, default_value_v4);
+    }
+  }
+
+  add_object_uniform_v4_float(uniform_name, default_value_v4)
+  {
+    let src_tex       = this.__create_rgba_float_texture(this.batch_width);
+    let dst_tex       = this.__create_rgba_float_texture(this.batch_width);
+    let one_pixel_tex = this.__create_rgba_float_texture(1);
+
+    let new_data_tex = this.__add_data_texture(uniform_name, src_tex, dst_tex, one_pixel_tex);
+
+    if (default_value_v4)
+    {
+      this.__flood_data_texture_rgba(new_data_tex, default_value_v4);
+    }
+  }
+
+  set_object_uniform_v3(object_name, uniform_name, vector3, use_r, use_g, use_b)
+  {
+    let obj_index = this.__get_object_index(object_name);
+    let data_texture = this.__get_data_texture(uniform_name);
+
+    this.__set_pixel_rgb(data_texture.src, obj_index, vector3, use_r, use_g, use_b);
+    this.__set_pixel_rgb(data_texture.one_pixel, 0, vector3, use_r, use_g, use_b);
+
+    data_texture.last_accessed_index = obj_index;
+
+    data_texture.dirty_count++;
+  }
+
+  set_object_uniform_v4(object_name, uniform_name, vector4, use_r, use_g, use_b, use_a)
+  {
+    let obj_index = this.__get_object_index(object_name);
+    let data_texture = this.__get_data_texture(uniform_name);
+
+    this.__set_pixel_rgba(data_texture.src, obj_index, vector4, use_r, use_g, use_b, use_a);
+    this.__set_pixel_rgba(data_texture.one_pixel, 0, vector4, use_r, use_g, use_b, use_a);
+    data_texture.last_accessed_index = obj_index;
+
+    data_texture.dirty_count++;
+  }
+
+  upload_texture_data(renderer, upload_budget)
+  {
+    for (let i = 0; i < this.data_textures.length; i++)
+    {
+      if (upload_budget > 0 && this.data_textures[i].dirty_count > 0)
+      {
+        if (this.data_textures[i].dirty_count === 1)
+        {
+          this.__partial_texture_data_upload(renderer, this.data_textures[i]);
+        }
+        if (this.data_textures[i].dirty_count > 1)
+        {
+          this.__full_texture_data_upload(renderer, this.data_textures[i]);
+        }
+
+        this.data_textures[i].dirty_count = 0;
+
+        upload_budget--;
+      }
+    }
+  }
+
+  get_uniform_dirty_count()
+  {
+    this.uniform_dirty_count = 0;
+    for (let i = 0; i < this.data_textures.length; i++)
+    {
+      if (this.data_textures[i].dirty_count > 0)
+      {
+        this.uniform_dirty_count++;
+      }
+    }
+    return this.uniform_dirty_count;
+  }
+
+  __full_texture_data_upload(renderer, texture_data)
+  {
+    // console.log("full texture update of"+ texture_data.name);
+    texture_data.dst.needsUpdate = true;
+    renderer.copyTextureToTexture(
+      this.zero_offset,
+      texture_data.src,
+      texture_data.dst
+    );
+  }
+
+  __partial_texture_data_upload(renderer, texture_data)
+  {
+    // console.log("partial texture update"+ texture_data.name);
+    let index = texture_data.last_accessed_index;
+    if (index === -1)
+    {
+      return;
+    }
+
+    this.write_offset.y = Math.floor(index / this.batch_width);
+    this.write_offset.x = index - this.batch_width * this.write_offset.y;
+    renderer.copyTextureToTexture(
+      this.write_offset,
+      texture_data.one_pixel,
+      texture_data.dst
+    );
+  }
+
+  get_mesh()
+  {
+    return new Mesh(this.geometry, this.material);
+  }
+
+  __set_pixel_rgb(data_texture, index, vector3, use_r, use_g, use_b)
+  {
+    if (use_r)
+    {
+      data_texture.image.data[index * 3 + 0] = vector3.x;
+    }
+    if (use_g)
+    {
+      data_texture.image.data[index * 3 + 1] = vector3.y;
+    }
+    if (use_b)
+    {
+      data_texture.image.data[index * 3 + 2] = vector3.z;
+    }
+  }
+
+  __set_pixel_rgba(data_texture, index, vector4, use_r, use_g, use_b, use_a)
+  {
+    if (use_r)
+    {
+      data_texture.image.data[index * 4 + 0] = vector4.x;
+    }
+    if (use_g)
+    {
+      data_texture.image.data[index * 4 + 1] = vector4.y;
+    }
+    if (use_b)
+    {
+      data_texture.image.data[index * 4 + 2] = vector4.z;
+    }
+    if (use_a)
+    {
+      data_texture.image.data[index * 4 + 3] = vector4.w;
+    }
+  }
+
+  __flood_data_texture_rgb(data_texture, v3)
+  {
+    for (let i = 0; i < this.batch_width * this.batch_width; i++)
+    {
+      this.__set_pixel_rgb(data_texture.src, i, v3, true, true, true);
+      data_texture.dirty_count++;
+    }
+  }
+
+  __flood_data_texture_rgba(data_texture, v4)
+  {
+    for (let i = 0; i < this.batch_width * this.batch_width; i++)
+    {
+      this.__set_pixel_rgba(data_texture.src, i, v4, true, true, true, true);
+      data_texture.dirty_count++;
+    }
+  }
+
+  __create_rgb_texture(width)
+  {
+    let data = new Uint8Array(3 * width * width);
+    return new DataTexture(data, width, width, RGBFormat);
+  }
+
+  __create_rgba_texture(width)
+  {
+    let data = new Uint8Array(4 * width * width);
+    return new DataTexture(data, width, width, RGBAFormat);
+  }
+
+  __create_rgba_float_texture(width)
+  {
+    let data = new Float32Array(4 * width * width);
+    return new DataTexture(data, width, width, RGBAFormat, FloatType);
+  }
+
+  __get_data_texture(uniform_name)
+  {
+    for (let i = 0; i < this.data_textures.length; i++)
+    {
+      if (this.data_textures[i].name === uniform_name)
+      {
+        return this.data_textures[i];
+      }
+    }
+    console.error('Data texture ' + uniform_name + ' does not exist');
+    return undefined;
+  }
+
+  __get_object_index(name)
+  {
+    for (let i = 0; i < this.object_names.length; i++)
+    {
+      if (this.object_names[i] === name)
+      {
+        return i;
+      }
+    }
+    console.error('the name ' + name + ' is not contained in this batch');
+    return undefined;
+  }
+
+  __add_data_texture(uniform_name, src_texture, dst_texture, one_pixel_text)
+  {
+    dst_texture.needsUpdate = true;
+
+    this.data_textures.push({
+      name: uniform_name,
+      src: src_texture,
+      dst: dst_texture,
+      one_pixel: one_pixel_text,
+      last_accessed_index: -1,
+      dirty_count: 0
+    });
+
+    this.uniforms[uniform_name] = { value: dst_texture };
+    return this.data_textures[this.data_textures.length - 1];
+  }
+
+  dispose()
+  {
+    for (let i = 0; i < this.data_textures.length; i++)
+    {
+      this.data_textures[i].src.dispose();
+      this.data_textures[i].dst.dispose();
+      this.data_textures[i].one_pixel.dispose();
+    }
+  }
+}

package/src/static_batcher/GeometryBatcher.js

@@ -0,0 +1,62 @@
+import GeometryBatch from './GeometryBatch';
+import { BufferGeometryUtils } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
+
+import { Math as TMath } from 'three';
+import { BufferAttribute } from 'three';
+
+class GeometryBatcher
+{
+  init()
+  {
+    this.batches = [];
+  }
+
+  batch(buffer_geometries)
+  {
+    let attr_accessor_uvs = [];
+    let texture_width = TMath.ceilPowerOfTwo(Math.sqrt(buffer_geometries.length));
+    // console.log("Store count: " + buffer_geometries.length + ", Texture size: " +texture_width);
+
+    this.__init_uv_array(attr_accessor_uvs, texture_width);
+
+    let uv_index = 0;
+
+    for (let i = 0; i < buffer_geometries.length; i++)
+    {
+      let vertex_count = buffer_geometries[i].getAttribute('position').count;
+      let y = Math.floor(i / texture_width);
+      let x = i - texture_width * y;
+      for (let count = 0; count < vertex_count; count++)
+      {
+        attr_accessor_uvs[uv_index] = (x / texture_width) + 0.5 / texture_width;
+        attr_accessor_uvs[uv_index + 1] = (y / texture_width) + 0.5 / texture_width;
+        uv_index += 2;
+      }
+    }
+
+    let buffer_attribute = new BufferAttribute(new Float32Array(attr_accessor_uvs), 2);
+    let buffer_geometry = BufferGeometryUtils.mergeBufferGeometries(buffer_geometries);
+    buffer_geometry.setAttribute('attr_accessor_uv', buffer_attribute);
+
+    this.batches.push(new GeometryBatch(buffer_geometry, texture_width));
+    return this.batches[this.batches.length - 1];
+  }
+
+  upload_texture_data(renderer)
+  {
+    for (let i = 0; i < this.batches.length; i++)
+    {
+      this.batches[i].upload_texture_data(renderer, 1);
+    }
+  }
+
+  __init_uv_array(uvs, texture_width)
+  {
+    for (let i = 0; i < texture_width * texture_width * 2; i++)
+    {
+      uvs.push(0);
+    }
+  }
+}
+
+export default new GeometryBatcher();

package/src/ui/ui_element_position/ScreenSpacePosition.js

@@ -0,0 +1,14 @@
+import { Vector2 } from 'three';
+
+export default class ScreenSpacePosition
+{
+  constructor()
+  {
+    this.tmp_vec = new Vector2();
+  }
+
+  get_pos_NDC(position)
+  {
+    return this.tmp_vec.set(position.x, position.y);
+  }
+}

package/src/ui/ui_element_position/WorldSpacePosition.js

@@ -0,0 +1,21 @@
+import CameraManager from '../../CameraManager';
+
+import { Vector2 } from 'three';
+import { Vector3 } from 'three';
+
+export default class WorldSpacePosition
+{
+  constructor()
+  {
+    this.tmp_vec3 = new Vector3();
+    this.tmp_vec2 = new Vector2();
+  }
+
+  get_pos_NDC(position)
+  {
+    this.tmp_vec3.copy(position);
+    this.tmp_vec3.project(CameraManager.current);
+
+    return this.tmp_vec2.set(this.tmp_vec3.x, this.tmp_vec3.y);
+  }
+}

package/src/ui/ui_element_state/OnIdle.js

@@ -0,0 +1,17 @@
+import UIElementState from './UIElementState';
+
+export default class OnIdle extends UIElementState
+{
+  constructor()
+  {
+    super();
+  }
+
+  update(ui_element, normalized_mouse_position)
+  {
+    if (ui_element.is_mouse_over(normalized_mouse_position))
+    {
+      ui_element.set_state(ui_element._on_enter_state);
+    }
+  }
+}