ohzi-core 5.13.2 → 5.14.2

package/src/gpu_particles/ParticleAttribute.js

@@ -0,0 +1,83 @@
+import Graphics from '../Graphics';
+
+import { Scene } from 'three';
+import { NearestFilter } from 'three';
+import { RGBAFormat } from 'three';
+import { LinearEncoding } from 'three';
+import { HalfFloatType } from 'three';
+import { FloatType } from 'three';
+import { WebGLRenderTarget } from 'three';
+import { Points } from 'three';
+
+export default class ParticleAttribute
+{
+  constructor(attr_name)
+  {
+    this.read = undefined;
+    this.write = undefined;
+
+    this.name = attr_name;
+
+    this.update_material = undefined;
+
+    this.update_scene = new Scene();
+  }
+
+  init_from_geometry(geometry)
+  {
+    // overrided by inheritance
+  }
+
+  init_from_attribute(particle_attribute)
+  {
+
+  }
+
+  build_RT(particle_count)
+  {
+    let resolution = this.calculate_resolution(particle_count);
+    let options = {
+      minFilter: NearestFilter,
+      magFilter: NearestFilter,
+      format: RGBAFormat,
+      encoding: LinearEncoding,
+      type: (/(iPad|iPhone|iPod)/g.test(navigator.userAgent)) ? HalfFloatType : FloatType,
+      stencilBuffer: false,
+      depthBuffer: false
+    };
+
+    return new WebGLRenderTarget(resolution, resolution, options);
+  }
+
+  calculate_resolution(particle_count)
+  {
+    return Math.ceil(Math.sqrt(particle_count));
+  }
+
+  swap_RT()
+  {
+    let tmp = this.read;
+    this.read = this.write;
+    this.write = tmp;
+  }
+
+  update()
+  {
+    if (this.update_material)
+    {
+      Graphics.blit(this.read, this.write, this.update_material);
+      this.swap_RT();
+    }
+  }
+
+  render_geometry_to_RT(geometry, material, RT)
+  {
+    let points = new Points(geometry, material);
+    points.frustumCulled = false;
+    // let scene = new Scene();
+    // scene.add( points );
+    this.update_scene.add(points);
+    Graphics.render(this.update_scene, undefined, RT);
+    // Graphics.render(scene, undefined, RT);
+  }
+}

package/src/gpu_particles/ParticlePositionAttribute.js

@@ -0,0 +1,20 @@
+import ParticleAttribute from '../gpu_particles/ParticleAttribute';
+import PositionStorageMaterial from '../materials/gpu_particles/PositionStorageMaterial';
+
+export default class ParticlePositionAttribute extends ParticleAttribute
+{
+  constructor()
+  {
+    super('_Position');
+  }
+
+  init_from_geometry(geometry)
+  {
+    let pos_attr = geometry.getAttribute('position');
+    this.read    = this.build_RT(pos_attr.count);
+    this.write   = this.build_RT(pos_attr.count);
+
+    let mat = new PositionStorageMaterial();
+    this.render_geometry_to_RT(geometry, mat, this.read);
+  }
+}

package/src/html_utilities/CSSAnimator.js

@@ -0,0 +1,64 @@
+import Animating from './css_animator_states/Animating';
+import Idle from './css_animator_states/Idle';
+import EasingFunctions from '../utilities/EasingFunctions';
+
+export default class CSSAnimator
+{
+  constructor({
+    element,
+    css_property,
+    from = 0,
+    to = 1,
+    duration = 1,
+    value_prefix = '',
+    value_suffix =  '',
+    easing_function = EasingFunctions.ease_in_out_cubic,
+    finished_callback = () =>
+    {}
+  })
+  {
+    this.element = element;
+    this.css_property = css_property;
+    this.from = from;
+    this.to = to;
+    this.value_prefix = value_prefix;
+    this.value_suffix = value_suffix;
+    this.duration = duration;
+    this.easing_function = easing_function;
+    this.finished_callback = finished_callback;
+
+    this.current_state = new Idle();
+  }
+
+  animate()
+  {
+    this.set_current_state(new Animating());
+  }
+
+  stop()
+  {
+    this.set_current_state(new Idle());
+  }
+
+  set_property_value(value)
+  {
+    this.element.style[this.css_property] = `${this.value_prefix}${value}${this.value_suffix}`;
+  }
+
+  update()
+  {
+    this.current_state.update(this);
+  }
+
+  get is_animating()
+  {
+    return this.current_state.is_animating;
+  }
+
+  set_current_state(state)
+  {
+    this.current_state.on_exit(this);
+    this.current_state = state;
+    this.current_state.on_enter(this);
+  }
+}

package/src/html_utilities/css_animator_states/Animating.js

@@ -0,0 +1,45 @@
+import Time from '../../Time';
+import Idle from './Idle';
+
+import { Math as TMath } from 'three';
+
+export default class Animating
+{
+  constructor()
+  {
+    this.t = 0;
+    this.easing_function_t = 0;
+  }
+
+  get is_animating()
+  {
+    return true;
+  }
+
+  on_enter(animator)
+  {
+  }
+
+  update(animator)
+  {
+    this.t += Time.delta_time / animator.duration;
+
+    this.easing_function_t = animator.easing_function(this.t);
+    this.easing_function_t = TMath.clamp(this.easing_function_t, 0, 1);
+
+    animator.set_property_value(TMath.lerp(animator.from, animator.to, this.easing_function_t));
+
+    if (this.easing_function_t >= 0.9999)
+    {
+      animator.set_property_value(animator.to);
+
+      animator.set_current_state(new Idle());
+      animator.finished_callback(animator);
+    }
+  }
+
+  on_exit(view)
+  {
+
+  }
+}

package/src/html_utilities/css_animator_states/Idle.js

@@ -0,0 +1,25 @@
+export default class Idle
+{
+  constructor()
+  {
+  }
+
+  get is_animating()
+  {
+    return false;
+  }
+
+  on_enter(view)
+  {
+
+  }
+
+  update(view)
+  {
+  }
+
+  on_exit(view)
+  {
+
+  }
+}

package/src/index.js

@@ -0,0 +1,171 @@
+import AbstractLoader from './resource_loader/AbstractLoader';
+import ActionSequencerBuilder from './view_components/transition/ActionSequencerBuilder';
+import ApplicationView from './view_components/ApplicationView';
+import BaseApplication from './BaseApplication';
+import BaseRender from './render_mode/BaseRender';
+import BaseShaderMaterial from './materials/BaseShaderMaterial';
+import BasisLoader from './resource_loader/BasisLoader.js';
+import BlitMaterial from './materials/BlitMaterial';
+import CameraManager from './CameraManager';
+import Capabilities from './Capabilities';
+import CanvasDrawer from './canvas_drawer/CanvasDrawer';
+import Configuration from './Configuration';
+import CSSAnimator from './html_utilities/CSSAnimator';
+import DrawIOAnimationSheet from './view_components/transition/DrawIOAnimationSheet';
+import Debug from './Debug';
+import DebugNormalsRender from './render_mode/DebugNormalsRender';
+import EventManager from './EventManager';
+import Graphics from './Graphics';
+import Input from './Input';
+import Initializer from './Initializer';
+import JSONLoader from './resource_loader/JSONLoader';
+import NormalAORender from './render_mode/NormalAORender';
+import NormalRender from './render_mode/NormalRender';
+import UnrealBloomRender from './render_mode/UnrealBloomRender';
+import OrthographicCamera from './OrthographicCamera';
+import OS from './OS';
+import PerspectiveCamera from './PerspectiveCamera';
+import RenderLoop from './RenderLoop';
+import ResourceBatch from './resource_loader/ResourceBatch';
+import ResourceContainer from './ResourceContainer';
+import SceneManager from './SceneManager';
+import Screen from './Screen';
+import SimpleTextDrawer from './canvas_drawer/SimpleTextDrawer';
+import Time from './Time';
+import UI from './UI';
+import ViewComponent from './view_components/ViewComponent';
+import ViewComponentManager from './view_components/ViewComponentManager';
+import ViewManager from './view_components/ViewManager';
+import ViewContext from './view_components/ViewContext';
+import TransitionTable from './view_components/transition/TransitionTable';
+
+import Arrow from './primitives/Arrow';
+import Cube from './primitives/Cube';
+import HorizontalPlane from './primitives/HorizontalPlane';
+import Sphere from './primitives/Sphere';
+import VerticalPlane from './primitives/VerticalPlane';
+
+import ArrayUtilities from './utilities/ArrayUtilities';
+import CameraUtilities from './utilities/CameraUtilities';
+import EasingFunctions from './utilities/EasingFunctions';
+import FrustumPointFitter from './utilities/FrustumPointFitter';
+import GeometryUtilities from './utilities/GeometryUtilities';
+import ImageUtilities from './utilities/ImageUtilities';
+import MathUtilities from './utilities/MathUtilities';
+import MeshSampler from './utilities/MeshSampler';
+import ModelUtilities from './utilities/ModelUtilities';
+import ObjectUtilities from './utilities/ObjectUtilities';
+import StringUtilities from './utilities/StringUtilities';
+import TimeUtilities from './utilities/TimeUtilities';
+import Validation from './utilities/Validation';
+import PerspectiveFrustumPointFitter from './utilities/PerspectiveFrustumPointFitter';
+import OrthographicFrustumPointFitter from './utilities/OrthographicFrustumPointFitter';
+
+import Grid from './components/Grid';
+import Line from './components/Line';
+import Text2D from './components/Text2D';
+import UIElement from './components/UIElement';
+import UpdatableMaterialMesh from './components/UpdatableMaterialMesh';
+
+import SDFTextBatch from './components/sdf_text/SDFTextBatch';
+
+import ActionSequencer    from './action_sequencer/ActionSequencer';
+import ActionEvent        from './action_sequencer/ActionEvent';
+import ActionInterpolator from './action_sequencer/ActionInterpolator';
+import NumberInterpolator from './action_sequencer/NumberInterpolator';
+import VectorInterpolator from './action_sequencer/VectorInterpolator';
+
+import MedianFilter from './render_utilities/MedianFilter';
+import GaussianBlurrer from './render_utilities/GaussianBlurrer';
+import DualFilteringBlurrer from './render_utilities/DualFilteringBlurrer';
+
+import Blurrer from './render_utilities/Blurrer';
+
+import GPUParticleSystem from './gpu_particles/GPUParticleSystem';
+
+import DualFilteringBlurMaterial from './materials/DualFilteringBlurMaterial';
+
+export {
+  AbstractLoader,
+  ActionSequencerBuilder,
+  ApplicationView,
+  BaseApplication,
+  BaseShaderMaterial,
+  BasisLoader,
+  CameraManager,
+  Capabilities,
+  CanvasDrawer,
+  Configuration,
+  CSSAnimator,
+  DrawIOAnimationSheet,
+  Debug,
+  DebugNormalsRender,
+  EventManager,
+  Graphics,
+  Input,
+  Initializer,
+  JSONLoader,
+  NormalAORender,
+  NormalRender,
+  UnrealBloomRender,
+  OrthographicCamera,
+  OS,
+  PerspectiveCamera,
+  RenderLoop,
+  ResourceBatch,
+  ResourceContainer,
+  SceneManager,
+  Screen,
+  SimpleTextDrawer,
+  Time,
+  UI,
+  BlitMaterial,
+  BaseRender,
+  ArrayUtilities,
+  CameraUtilities,
+  EasingFunctions,
+  FrustumPointFitter,
+  GeometryUtilities,
+  ImageUtilities,
+  MathUtilities,
+  MeshSampler,
+  ModelUtilities,
+  ObjectUtilities,
+  StringUtilities,
+  TimeUtilities,
+  Validation,
+  ViewComponent,
+  ViewComponentManager,
+  ViewManager,
+  Grid,
+  Line,
+  Text2D,
+  TransitionTable,
+  UIElement,
+  SDFTextBatch,
+  UpdatableMaterialMesh,
+
+  Arrow,
+  Cube,
+  HorizontalPlane,
+  Sphere,
+  VerticalPlane,
+
+  ActionSequencer,
+  ActionEvent,
+  ActionInterpolator,
+  NumberInterpolator,
+  VectorInterpolator,
+  ViewContext,
+
+  MedianFilter,
+  GaussianBlurrer,
+  Blurrer,
+  DualFilteringBlurrer,
+
+  GPUParticleSystem,
+  PerspectiveFrustumPointFitter,
+  OrthographicFrustumPointFitter,
+
+  DualFilteringBlurMaterial
+};

package/src/materials/AddMaterial.js

@@ -0,0 +1,17 @@
+import BlitMaterial from './BlitMaterial';
+import frag from '../shaders/add/add.frag';
+
+export default class AddMaterial extends BlitMaterial
+{
+  constructor(nMips)
+  {
+    super(frag);
+
+    this.uniforms._SecondTex = { value: undefined };
+  }
+
+  set_add_texture(tex)
+  {
+    this.uniforms._SecondTex.value = tex;
+  }
+}

package/src/materials/AlphaFilterMaterial.js

@@ -0,0 +1,20 @@
+import BlitMaterial from './BlitMaterial';
+import frag from '../shaders/dual_filter_blur/alpha_filter.frag';
+
+export default class AlphaFilterMaterial extends BlitMaterial
+{
+  constructor(use_alpha_mask, upsample)
+  {
+    super(frag);
+  }
+
+  set offset(value)
+  {
+    this.uniforms._Offset.value = value;
+  }
+
+  get offset()
+  {
+    return this.uniforms._Offset.value;
+  }
+}

package/src/materials/BaseShaderMaterial.js

@@ -0,0 +1,19 @@
+import basic_vert from '../shaders/basic_color/basic_color.vert';
+import basic_frag from '../shaders/basic_color/basic_color.frag';
+
+import { ShaderMaterial } from 'three';
+import { Color } from 'three';
+
+export default class BaseShaderMaterial extends ShaderMaterial
+{
+  constructor(vert, frag, uniforms)
+  {
+    super({
+      vertexShader: vert   || basic_vert,
+      fragmentShader: frag || basic_frag,
+      uniforms: uniforms   || {
+        _Color: { value: new Color('#FF0000') }
+      }
+    });
+  }
+}

package/src/materials/BlitMaterial.js

@@ -0,0 +1,28 @@
+import vert from '../shaders/copy/copy.vert';
+import frag from '../shaders/copy/copy.frag';
+
+import { ShaderMaterial } from 'three';
+import { Vector2 } from 'three';
+import { NoBlending } from 'three';
+import { AlwaysDepth } from 'three';
+
+export default class BlitMaterial extends ShaderMaterial
+{
+  constructor(frag_shader, vert_shader, defines)
+  {
+    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
+    });
+  }
+}

package/src/materials/BloomComposeMaterial.js

@@ -0,0 +1,22 @@
+import BlitMaterial from './BlitMaterial';
+import frag from '../shaders/bloom/bloom_compose_frag';
+import cheap_frag from '../shaders/bloom/cheap_bloom_compose_frag';
+import { CustomBlending, OneFactor } from 'three';
+
+export default class BloomComposeMaterial extends BlitMaterial
+{
+  constructor(alpha_blending)
+  {
+    super(alpha_blending ? cheap_frag : frag);
+    this.uniforms._MainTex        = { value: undefined };
+    this.uniforms._BlurredTex     = { value: undefined };
+    this.uniforms._BloomStrength  = { value: 1 };
+
+    if (alpha_blending)
+    {
+      this.blending  = CustomBlending;
+      this.blendSrc  = OneFactor;
+      this.blendDst  = OneFactor;
+    }
+  }
+}

package/src/materials/BoxBlurMaterial.js

@@ -0,0 +1,13 @@
+import BlitMaterial from '../materials/BlitMaterial';
+import frag from '../shaders/box_blur/box_blur.frag';
+
+import { Vector2 } from 'three';
+
+export default class BoxBlurMaterial extends BlitMaterial
+{
+  constructor()
+  {
+    super(frag);
+    this.uniforms._SampleDir = { value: new Vector2() };
+  }
+}

package/src/materials/ClearAlphaMaterial.js

@@ -0,0 +1,13 @@
+import BlitMaterial from 'js/core/materials/BlitMaterial';
+import frag from 'js/core/shaders/clear/clear_alpha';
+import { SubtractiveBlending } from 'three';
+
+export default class ClearAlphaMaterial extends BlitMaterial
+{
+  constructor()
+  {
+    super(frag);
+
+    this.blending = SubtractiveBlending;
+  }
+}

package/src/materials/ClearColorMaterial.js

@@ -0,0 +1,31 @@
+import BlitMaterial from 'js/core/materials/BlitMaterial';
+import frag from 'js/core/shaders/clear/clear_color';
+import { LessEqualDepth, Color } from 'three';
+
+export default class ClearColorMaterial extends BlitMaterial
+{
+  constructor()
+  {
+    super(frag);
+    this.uniforms._Color = { value: new Color() };
+    this.uniforms._Opacity = { value: 1 };
+
+    this.depthTest = true;
+    this.depthFunc = LessEqualDepth;
+  }
+
+  set_color(col)
+  {
+    this.uniforms._Color.value.set(col);
+  }
+
+  copy_color(col)
+  {
+    this.uniforms._Color.value.copy(col);
+  }
+
+  set_opacity(value)
+  {
+    this.uniforms._Opacity.value = value;
+  }
+}

package/src/materials/ClearDepthNormalMaterial.js

@@ -0,0 +1,13 @@
+import BlitMaterial from '../materials/BlitMaterial';
+import frag from '../shaders/clear/clear_depth_normal.frag';
+
+import { Vector4 } from 'three';
+
+export default class ClearDepthNormalMaterial extends BlitMaterial
+{
+  constructor(clear_depth, clear_normal)
+  {
+    super(frag);
+    this.uniforms._DepthNormal = { value: new Vector4(clear_depth, clear_normal.x, clear_normal.y, clear_normal.z) };
+  }
+}

package/src/materials/DeferredRendererComposeMaterial.js

@@ -0,0 +1,32 @@
+import BlitMaterial from '../materials/BlitMaterial';
+import frag from '../shaders/deferred/deferred_compose.frag';
+import vert from '../shaders/deferred/blit_copy.vert';
+
+import { Matrix4 } from 'three';
+
+export default 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)
+  {
+    this.uniforms._NormalDepthRT.value = rt.texture;
+  }
+
+  set_albedo_rt(tex)
+  {
+    this.uniforms._AlbedoRT.value = tex;
+  }
+
+  set_proj_matrix(mat4)
+  {
+    this.uniforms._InverseProjMatrix.value.getInverse(mat4);
+  }
+}

package/src/materials/DepthNormalMaterial.js

@@ -0,0 +1,28 @@
+import vert from '../shaders/depth_normals/depth_normals.vert';
+import frag from '../shaders/depth_normals/depth_normals.frag';
+
+import { ShaderMaterial } from 'three';
+
+export default class DepthNormalMaterial extends ShaderMaterial
+{
+  constructor()
+  {
+    super({
+      uniforms: {
+        _FarPlane: { value: 1 }
+      },
+      vertexShader: vert,
+      fragmentShader: frag
+    });
+  }
+
+  set far_plane(value)
+  {
+    this.uniforms._FarPlane.value = value;
+  }
+
+  get far_plane()
+  {
+    return this.uniforms._FarPlane.value;
+  }
+}

package/src/materials/DisplayNormalTextureMaterial.js

@@ -0,0 +1,15 @@
+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';
+
+export default class DisplayNormalTextureMaterial extends BlitMaterial
+{
+  constructor()
+  {
+    super(frag, depth_normals_vert);
+    this.uniforms._FarPlane          = { value: 1 };
+    this.uniforms._InverseProjMatrix = { value: new Matrix4() };
+  }
+}

package/src/materials/DualFilteringBlurMaterial.js

@@ -0,0 +1,11 @@
+import BlitMaterial from './BlitMaterial';
+import downsample_frag from '../shaders/dual_filter_blur/downsample.frag';
+import upsample_frag from '../shaders/dual_filter_blur/upsample.frag';
+
+export default class DualFilteringBlurMaterial extends BlitMaterial
+{
+  constructor(upsample)
+  {
+    super(upsample ? upsample_frag : downsample_frag);
+  }
+}