ohzi-core 5.13.2 → 5.14.2

package/src/resource_loader/ResourceBatch.js

@@ -0,0 +1,174 @@
+import TextureLoader from './TextureLoader';
+import GLTFLoader from './GLTFLoader';
+import DAELoader from './DAELoader';
+import TextLoader from './TextLoader';
+import CubemapLoader from './CubemapLoader';
+import AudioLoader from './AudioLoader';
+import JSONLoader from './JSONLoader';
+import OBJLoader from './OBJLoader';
+import FontLoader from './FontLoader';
+import RGBETextureLoader from './RGBETextureLoader';
+import PointArrayLoader from './PointArrayLoader';
+import HDRCubeTextureLoader from './HDRCubeTextureLoader';
+import GLTFDRACOLoader from './GLTFDRACOLoader';
+import BasisLoader from './BasisLoader';
+import ResourceContainer from '../ResourceContainer';
+import FileLoader from './FileLoader';
+
+export default class ResourceBatch
+{
+  constructor(batch_name)
+  {
+    this.resource_loaders = [];
+    this.batch_name = batch_name || 'unnamed batch';
+  }
+
+  add_texture(resource_id, url, size)
+  {
+    this.resource_loaders.push(new TextureLoader(resource_id, url, size));
+  }
+
+  add_gltf(resource_id, url, size)
+  {
+    this.resource_loaders.push(new GLTFLoader(resource_id, url, size));
+  }
+
+  add_basis(resource_id, url, renderer, loader, size)
+  {
+    this.resource_loaders.push(new BasisLoader(resource_id, url, renderer, loader, size));
+  }
+
+  add_gltf_draco(resource_id, url, size)
+  {
+    this.resource_loaders.push(new GLTFDRACOLoader(resource_id, url, size));
+  }
+
+  add_dae(resource_id, url, size)
+  {
+    this.resource_loaders.push(new DAELoader(resource_id, url, size));
+  }
+
+  add_obj(resource_id, url, size)
+  {
+    this.resource_loaders.push(new OBJLoader(resource_id, url, size));
+  }
+
+  add_file(resource_id, url, size)
+  {
+    this.resource_loaders.push(new FileLoader(resource_id, url, size));
+  }
+
+  add_text(resource_id, url, size)
+  {
+    this.resource_loaders.push(new TextLoader(resource_id, url, size));
+  }
+
+  add_cubemap(resource_id, url, size)
+  {
+    this.resource_loaders.push(new CubemapLoader(resource_id, url, size));
+  }
+
+  add_audio(resource_id, url, loop, volume, size)
+  {
+    this.resource_loaders.push(new AudioLoader(resource_id, url, loop, volume, size));
+  }
+
+  add_json(resource_id, url, size)
+  {
+    this.resource_loaders.push(new JSONLoader(resource_id, url, size));
+  }
+
+  add_point_array(resource_id, url, size)
+  {
+    this.resource_loaders.push(new PointArrayLoader(resource_id, url, size));
+  }
+
+  add_hdr(resource_id, url, size)
+  {
+    this.resource_loaders.push(new RGBETextureLoader(resource_id, url, size));
+  }
+
+  add_hdr_cubemap(resource_id, url, size)
+  {
+    this.resource_loaders.push(new HDRCubeTextureLoader(resource_id, url, size));
+  }
+
+  add_font(resource_id, url, size)
+  {
+    this.resource_loaders.push(new FontLoader(resource_id, url, size));
+  }
+
+  add_loader(loader)
+  {
+    this.resource_loaders.push(loader);
+  }
+
+  load(resource_container)
+  {
+    for (let i = 0; i < this.resource_loaders.length; i++)
+    {
+      this.resource_loaders[i].load(resource_container || ResourceContainer);
+    }
+  }
+
+  get loading_finished()
+  {
+    let finished = true;
+    for (let i = 0; i < this.resource_loaders.length; i++)
+    {
+      finished = finished && this.resource_loaders[i].has_finished;
+    }
+    return finished;
+  }
+
+  get has_errors()
+  {
+    let has_error = false;
+    for (let i = 0; i < this.resource_loaders.length; i++)
+    {
+      has_error = has_error || this.resource_loaders[i].has_error;
+    }
+    return has_error;
+  }
+
+  print_errors()
+  {
+    console.error('Batch <' + this.batch_name + '> could not load successfully');
+    for (let i = 0; i < this.resource_loaders.length; i++)
+    {
+      if (this.resource_loaders[i].has_error)
+      {
+        this.resource_loaders[i].print_error();
+      }
+    }
+  }
+
+  get_progress()
+  {
+    return this.get_loaded_bytes() / this.get_total_bytes();
+  }
+
+  get_loaded_bytes()
+  {
+    let loaded_bytes = 1;
+
+    for (let i = 0; i < this.resource_loaders.length; i++)
+    {
+      loaded_bytes += this.resource_loaders[i].loaded_bytes;
+    }
+
+    return loaded_bytes;
+  }
+
+  get_total_bytes()
+  {
+    let total_bytes = 1;
+
+    for (let i = 0; i < this.resource_loaders.length; i++)
+    {
+      total_bytes += this.resource_loaders[i].total_bytes;
+    }
+
+    return total_bytes;
+  }
+}

package/src/resource_loader/SVGLoader.js

@@ -0,0 +1,39 @@
+import AbstractLoader from './AbstractLoader';
+
+import * as THREESVGLoader from 'three/examples/jsm/loaders/SVGLoader.js';
+
+export default class SVGLoader extends AbstractLoader
+{
+  constructor(resource_id, url, size)
+  {
+    super(resource_id, url, size);
+    this.loader = new THREESVGLoader.SVGLoader();
+  }
+
+  on_preloaded_finished(resource_container)
+  {
+    let ctx = this;
+
+    this.loader.load(this.url, (data) =>
+    {
+      resource_container.set_resource(ctx.resource_id, ctx.url, data);
+
+      ctx.__update_downloaded_bytes(1, 1);
+      ctx.__loading_ended();
+    },
+    (xhr) =>
+    {
+      // if (xhr)
+      // {
+      //   let total = xhr.total || this.total_bytes;
+      //   ctx.__update_downloaded_bytes(xhr.loaded, total);
+      // }
+    },
+    (msg) =>
+    {
+      ctx.__set_error(msg + '\n\n\t If the error says something about unexpected token < in JSON then the probably the problem is related to the file not being found. Check the name and path of the resource');
+      ctx.__loading_ended();
+    }
+    );
+  }
+}

package/src/resource_loader/TextLoader.js

@@ -0,0 +1,39 @@
+import AbstractLoader from './AbstractLoader';
+
+import { FileLoader as THREEFileLoader } from 'three';
+
+export default class TextLoader extends AbstractLoader
+{
+  constructor(resource_id, url, size)
+  {
+    super(resource_id, url, size);
+    this.loader = new THREEFileLoader();
+  }
+
+  on_preloaded_finished(resource_container)
+  {
+    let ctx = this;
+
+    this.loader.load(this.url, (gltf) =>
+    {
+      resource_container.set_resource(ctx.resource_id, ctx.url, gltf);
+
+      ctx.__update_downloaded_bytes(1, 1);
+      ctx.__loading_ended();
+    },
+    (xhr) =>
+    {
+      // if (xhr)
+      // {
+      //   let total = xhr.total || this.total_bytes;
+      //   ctx.__update_downloaded_bytes(xhr.loaded, total);
+      // }
+    },
+    (msg) =>
+    {
+      ctx.__set_error(msg);
+      ctx.__loading_ended();
+    }
+    );
+  }
+}

package/src/resource_loader/TextureLoader.js

@@ -0,0 +1,40 @@
+import AbstractLoader from './AbstractLoader';
+
+import { TextureLoader as THREETextureLoader } from 'three';
+
+export default class TextureLoader extends AbstractLoader
+{
+  constructor(resource_id, url, size)
+  {
+    super(resource_id, url, size);
+    this.loader = new THREETextureLoader();
+  }
+
+  on_preloaded_finished(resource_container)
+  {
+    let ctx = this;
+
+    this.loader.load(this.url, (image) =>
+    {
+      resource_container.set_resource(ctx.resource_id, ctx.url, image);
+
+      ctx.__update_downloaded_bytes(1, 1);
+      ctx.__loading_ended();
+    },
+    (xhr) =>
+    {
+      // This is never called (See THREE.ImageLoader)
+      // if (xhr)
+      // {
+      //   let total = xhr.total || this.total_bytes;
+      //   ctx.__update_downloaded_bytes(xhr.loaded, total);
+      // }
+    },
+    () =>
+    {
+      ctx.__set_error('Image could not  be loaded. Maybe wrong name or path, I don\'t know' + '¯\\_(ツ)_/¯');
+      ctx.__loading_ended();
+    }
+    );
+  }
+}

package/src/shaders/add/add.frag

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

package/src/shaders/anti_aliasing/fxaa.frag

@@ -0,0 +1,72 @@
+// 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

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

package/src/shaders/basic_color/basic_color.vert

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,37 @@
+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);
+
+}

package/src/shaders/basic_line/basic_line.vert

@@ -0,0 +1,37 @@
+uniform float _Thickness;
+
+
+attribute vec3 next_position;
+attribute vec3 previous_position;
+attribute float orientation;
+attribute float coverage;
+
+varying float line_coverage;
+varying float uv_u;
+
+vec3 w_space_normal(vec3 from, vec3 to)
+{
+  vec3 w_from = (modelMatrix * vec4(from, 1.0)).xyz;
+  vec3 w_to   = (modelMatrix * vec4(to, 1.0)).xyz;
+
+  vec3 z = normalize(w_to - w_from);
+  return normalize(cross(z , normalize(cameraPosition - w_from)));
+
+}
+
+void main()
+{
+
+  mat4 VP = projectionMatrix * viewMatrix;
+
+  vec3 pos = position;
+  vec3 normal = w_space_normal(next_position ,previous_position);
+  pos = (modelMatrix * vec4(pos, 1.0)).xyz;
+  pos += normal * (_Thickness * 0.5) * orientation;
+
+  gl_Position = VP * vec4(pos, 1.0);
+
+  line_coverage = coverage;
+  uv_u = orientation * 0.5 + 0.5;
+
+}

package/src/shaders/basic_texture/basic_texture.frag

@@ -0,0 +1,10 @@
+uniform sampler2D _MainTex;
+varying vec2 vUv;
+uniform float _Opacity;
+
+void main()
+{
+    gl_FragColor = texture2D(_MainTex, vUv);
+    gl_FragColor.a *= _Opacity;
+    //gl_FragColor.r = 1.0;
+}

package/src/shaders/basic_texture/basic_texture.vert

@@ -0,0 +1,17 @@
+varying vec2 vUv;
+uniform float _ScreenAligned;
+uniform float _Scale;
+void main()
+{
+  vec3 pos = position;
+
+  mat4 local_to_camera = modelViewMatrix;
+  // float scale = length(vec3(modelMatrix[0][0], modelMatrix[1][1], modelMatrix[2][2]))/2.0;
+  float scale = _Scale;
+  local_to_camera[0] = mix(modelViewMatrix[0], vec4(1.0 * scale, 0.0, 0.0, 0.0), _ScreenAligned);
+  local_to_camera[1] = mix(modelViewMatrix[1], vec4(0.0, 1.0 * scale, 0.0, 0.0), _ScreenAligned);
+  local_to_camera[2] = mix(modelViewMatrix[2], vec4(0.0, 0.0, 1.0 * scale, 0.0), _ScreenAligned);
+
+  gl_Position = projectionMatrix * local_to_camera * vec4( pos, 1.0 );
+  vUv = uv;
+}

package/src/shaders/bloom/bloom_compose_frag.glsl

@@ -0,0 +1,22 @@
+uniform sampler2D _MainTex;
+uniform sampler2D _BlurredTex;
+uniform vec2 _Resolution;
+uniform float _BloomStrength;
+varying vec2 vUv;
+
+vec4 pow_v4(vec4 vec, float p)
+{
+	vec4 v = vec;
+	v.r = pow(abs(v.r), p);
+	v.g = pow(abs(v.g), p);
+	v.b = pow(abs(v.b), p);
+	v.a = pow(abs(v.a), p);
+	return v;
+}
+
+void main()
+{
+		vec4 col = texture2D( _MainTex, vUv);
+		vec4 blur = texture2D( _BlurredTex, vUv);
+		gl_FragColor = col + blur * _BloomStrength;
+}

package/src/shaders/bloom/cheap_bloom_compose_frag.glsl

@@ -0,0 +1,13 @@
+uniform sampler2D _MainTex;
+uniform sampler2D _BlurredTex;
+uniform vec2 _Resolution;
+uniform float _BloomStrength;
+varying vec2 vUv;
+
+void main()
+{
+		// vec4 col = texture2D( _MainTex, vUv);
+		vec4 blur = texture2D( _BlurredTex, vUv);
+		gl_FragColor = blur;
+		// gl_FragColor = col + blur * _BloomStrength;
+}

package/src/shaders/box_blur/box_blur.frag

@@ -0,0 +1,24 @@
+uniform sampler2D _MainTex;
+uniform vec2 _Resolution;
+uniform vec2 _SampleDir;
+varying vec2 vUv;
+
+void main()
+{
+
+	vec4 sum = vec4(0.,0.,0.,0.);
+	vec2 dir = (0.5/_Resolution) * _SampleDir;
+	float _Distance = 2.0;
+	sum += texture2D( _MainTex, vUv + dir * -4. * _Distance ) * 0.0525;
+	sum += texture2D( _MainTex, vUv + dir * -3. * _Distance ) * 0.075;
+	sum += texture2D( _MainTex, vUv + dir * -2. * _Distance ) * 0.110;
+	sum += texture2D( _MainTex, vUv + dir * -1. * _Distance ) * 0.150;
+	sum += texture2D( _MainTex, vUv + dir *  0. * _Distance ) * 0.225;
+	sum += texture2D( _MainTex, vUv + dir *  1. * _Distance ) * 0.150;
+	sum += texture2D( _MainTex, vUv + dir *  2. * _Distance ) * 0.110;
+	sum += texture2D( _MainTex, vUv + dir *  3. * _Distance ) * 0.075;
+	sum += texture2D( _MainTex, vUv + dir *  4. * _Distance ) * 0.0525;
+	gl_FragColor = vec4(sum);
+
+
+}

package/src/shaders/box_blur/compose.frag

@@ -0,0 +1,31 @@
+uniform sampler2D _MainTex;
+uniform sampler2D _Blur;
+uniform vec2 _Screen;
+varying vec2 vUv;
+
+
+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()
+{
+	vec2 pixel_size = 1.0/_Screen;
+
+	vec4 color = texture2D( _MainTex, vUv);
+	float mask = 1.0 - color.a;
+
+	float blur = texture2D( _Blur, vUv).a;
+
+  // gl_FragColor = vec4(mask,mask,mask,0.0);
+  // gl_FragColor = color;
+
+	gl_FragColor = vec4(mix(color.rgb, mix(color.rgb, vec3(1.,0.,0.),aastep(0.076, blur)), mask), 1.0);
+}
+

package/src/shaders/clear/clear_depth_normal.frag

@@ -0,0 +1,25 @@
+uniform vec4 _DepthNormal;
+vec2 EncodeFloatRG( float v )
+{
+    vec2 kEncodeMul = vec2(1.0, 255.0);
+    float kEncodeBit = 1.0/255.0;
+    vec2 enc = kEncodeMul * v;
+    enc = fract (enc);
+    enc.x -= enc.y * kEncodeBit;
+    return enc;
+}
+
+vec2 EncodeNormal (vec3 n)
+{
+    float scale = 1.7777;
+    vec2 enc = n.xy / (n.z+1.0);
+    enc /= scale;
+    enc = enc*0.5+0.5;
+    return enc;
+}
+
+
+void main()
+{
+    gl_FragColor = vec4(EncodeFloatRG(_DepthNormal.x), EncodeNormal(normalize(_DepthNormal.yzw)));  
+}

package/src/shaders/copy/copy.frag

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

package/src/shaders/copy/copy.vert

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

package/src/shaders/deferred/blit_copy.vert

@@ -0,0 +1,11 @@
+varying vec2 vUv;
+varying vec4 vRay;
+
+uniform mat4 _InverseProjMatrix;
+
+void main()
+{
+	gl_Position = vec4(uv * 2.0 - 1.0, 1.0, 1.0);
+	vRay = _InverseProjMatrix * vec4(uv * 2.0 - 1.0, 1.0, 1.0);
+	vUv = uv;
+}