ohzi-core 13.3.0 → 15.0.0

package/src/components/EdgeMesh.ts

@@ -1,150 +0,0 @@
-import corners_frag from '../shaders/edges/corners.frag';
-import corners_vert from '../shaders/edges/corners.vert';
-import edge_line_frag from '../shaders/edges/edges.frag';
-import edge_line_vert from '../shaders/edges/edges.vert';
-
-import * as BufferGeometryUtils from 'three/examples/jsm/utils/BufferGeometryUtils.js';
-
-import type { BufferGeometry , InterleavedBufferAttribute} from 'three';
-import { BufferAttribute, Color, EdgesGeometry, LineBasicMaterial, LineSegments, Mesh, Object3D, PlaneGeometry, ShaderMaterial, Vector3 } from 'three';
-
-class EdgeMesh extends Object3D
-{
-  corners_material: ShaderMaterial;
-  corners_mesh: Mesh;
-  edges_material: ShaderMaterial;
-  edges_mesh: Mesh;
-
-  constructor(buffer_geometry: BufferGeometry, thickness: number, color: string)
-  {
-    super();
-    thickness = thickness || 0.1;
-    color = color || '#555555';
-    this.edges_material = new ShaderMaterial({
-      uniforms: {
-        _Thickness: { value: thickness },
-        _Color: { value: new Color(color) }
-      },
-      vertexShader: edge_line_vert,
-      fragmentShader: edge_line_frag,
-      transparent: true,
-      depthWrite: false
-    });
-
-    this.corners_material = new ShaderMaterial({
-      uniforms: {
-        _Thickness: { value: thickness },
-        _Color: { value: new Color(color) }
-      },
-      vertexShader: corners_vert,
-      fragmentShader: corners_frag,
-      transparent: true,
-      depthWrite: false
-    });
-
-    const edges_geometry    = this.__get_edges_geometry(this.__get_edges(buffer_geometry));
-    const corners_geometry  = this.__get_corners_geometry(buffer_geometry.getAttribute('position'));
-
-    this.edges_mesh   = new Mesh(edges_geometry, this.edges_material);
-    this.corners_mesh = new Mesh(corners_geometry, this.corners_material);
-
-    this.edges_mesh.frustumCulled = false;
-    this.corners_mesh.frustumCulled = false;
-    this.add(this.edges_mesh);
-    this.add(this.corners_mesh);
-  }
-
-  __get_edges(cube_geometry: BufferGeometry): Vector3[]
-  {
-    const edges = new EdgesGeometry(cube_geometry);
-    const line = new LineSegments(edges, new LineBasicMaterial());
-    const points_array = line.geometry.attributes.position.array;
-
-    const points = [];
-    for (let i = 0; i < points_array.length; i += 3)
-    {
-      points.push(new Vector3(points_array[i], points_array[i + 1], points_array[i + 2]));
-    }
-    return points;
-  }
-
-  update(time: number): void 
-  {
-
-  }
-
-  __get_edges_geometry(points: Vector3[])
-  {
-    const buffer_geometries = [];
-    for (let i = 0; i < points.length; i += 2)
-    {
-      const dir = points[i + 1].clone().sub(points[i]).normalize();
-      const geometry = new PlaneGeometry(1, 1);
-      const vertices = geometry.getAttribute('position');
-      // top right
-      vertices.array[0] = points[i].x;
-      vertices.array[1] = points[i].y;
-      vertices.array[2] = points[i].z;
-      // top left
-      vertices.array[3] = points[i].x;
-      vertices.array[4] = points[i].y;
-      vertices.array[5] = points[i].z;
-
-      // bottom right
-      vertices.array[6] = points[i + 1].x;
-      vertices.array[7] = points[i + 1].y;
-      vertices.array[8] = points[i + 1].z;
-      // bottom left
-      vertices.array[9] = points[i + 1].x;
-      vertices.array[10] = points[i + 1].y;
-      vertices.array[11] = points[i + 1].z;
-
-      const dirs = [];
-      for (let d = 0; d < vertices.count; d++)
-      {
-        dirs.push(dir.x);
-        dirs.push(dir.y);
-        dirs.push(dir.z);
-      }
-      const dir_array = new Float32Array(dirs);
-      geometry.setAttribute('tangent', new BufferAttribute(dir_array, 3));
-      buffer_geometries.push(geometry);
-    }
-
-    return BufferGeometryUtils.mergeGeometries(buffer_geometries);
-  }
-
-  __get_corners_geometry(geometry_vertices: BufferAttribute | InterleavedBufferAttribute): BufferGeometry
-  {
-    const circle_buffer_geometries = [];
-    for (let i = 0; i < geometry_vertices.count; i++)
-    {
-      const plane_geometry = new PlaneGeometry(1, 1);
-      const plane_vertices = plane_geometry.getAttribute('position');
-      const w_pos = [];
-      for (let d = 0; d < plane_vertices.count; d++)
-      {
-        w_pos.push(geometry_vertices.array[i * 3 + 0]);
-        w_pos.push(geometry_vertices.array[i * 3 + 1]);
-        w_pos.push(geometry_vertices.array[i * 3 + 2]);
-      }
-      const pos_array = new Float32Array(w_pos);
-      plane_geometry.setAttribute('w_pos', new BufferAttribute(pos_array, 3));
-      circle_buffer_geometries.push(plane_geometry);
-    }
-    return BufferGeometryUtils.mergeGeometries(circle_buffer_geometries);
-  }
-
-  set_visible(boolean: boolean): void
-  {
-    this.edges_mesh.visible = boolean;
-    this.corners_mesh.visible = boolean;
-  }
-
-  dispose(): void
-  {
-
-  }
-}
-
-export { EdgeMesh };

package/src/components/GeometryEdgeVisualizer.ts

@@ -1,49 +0,0 @@
-import edge_visualizer_frag from '../shaders/edge_visualizer/edge_visualizer.frag';
-import edge_visualizer_vert from '../shaders/edge_visualizer/edge_visualizer.vert';
-
-import { GeometryUtilities } from '../utilities/GeometryUtilities';
-
-import type { BufferGeometry } from 'three';
-import { Color, Mesh, ShaderMaterial } from 'three';
-
-class GeometryEdgeVisualizer extends Mesh
-{
-  material: ShaderMaterial;
-
-  constructor(geometry: BufferGeometry, line_color?: string | number)
-  {
-    line_color = line_color || '#91EE91';
-
-    const material = new ShaderMaterial({
-      uniforms: {
-        _Color: { value: new Color('#CC3333') },
-        _LineColor: { value: new Color(line_color) },
-        _Alpha: { value: 1 },
-        _DepthOffset: { value: 0.001 },
-        _Thickness: { value: 2.5 }
-      },
-      vertexShader: edge_visualizer_vert,
-      fragmentShader: edge_visualizer_frag,
-      transparent: true,
-      depthWrite: false
-    });
-
-    let non_indexed_geometry = geometry;
-    if (non_indexed_geometry.index)
-    {
-      non_indexed_geometry = GeometryUtilities.convert_to_non_indexed_geometry(geometry);
-    }
-
-    GeometryUtilities.add_barycentric_attribute(non_indexed_geometry);
-
-    super(non_indexed_geometry, material);
-    this.material = material;
-  }
-
-  hide_faces(): void
-  {
-    this.material.uniforms._Alpha.value = 0;
-  }
-}
-
-export { GeometryEdgeVisualizer };

package/src/components/MultiLinePath.ts

@@ -1,25 +0,0 @@
-import { Line } from './Line';
-
-import type { Vector3 } from 'three';
-import { Object3D } from 'three';
-
-class MultiLinePath extends Object3D
-{
-  paths: Line[];
-
-  constructor(paths: Array<Vector3[]>)
-  {
-    super();
-
-    this.paths = [];
-
-    for (let i = 0; i < paths.length; i++)
-    {
-      const line = new Line(paths[i]);
-      this.paths.push(line);
-      this.add(line);
-    }
-  }
-}
-
-export { MultiLinePath };

package/src/components/MultiLineText2D.ts

@@ -1,65 +0,0 @@
-import { Text2D } from './Text2D';
-
-import { Object3D, Vector2 } from 'three';
-
-class MultiLineText2D extends Object3D
-{
-  text_array: Text2D[];
-
-  constructor(text_array: string[], font?: string, color?: string | number, pivot?: Vector2, is_static?: boolean) 
-  {
-    super();
-
-    font = font || '200px Arial';
-    color = color || '#000000';
-    pivot = pivot || new Vector2();
-
-    this.text_array = [];
-
-    for (let i = 0; i < text_array.length; i++)
-    {
-      const text2D = new Text2D(text_array[i], font, color, pivot);
-      this.text_array.push(text2D);
-      this.add(text2D);
-    }
-
-    this.update_text_positions();
-  }
-
-  update_text_positions()
-  {
-    for (let i = 0; i < this.text_array.length; i++)
-    {
-      this.text_array[i].position.y = -this.text_array[i].size.y * i;
-    }
-  }
-
-  set texts(text_array)
-  {
-    for (let i = 0; i < this.text_array.length; i++)
-    {
-      this.text_array[i].text = text_array[i];
-    }
-  }
-
-  set size(value)
-  {
-    for (let i = 0; i < this.text_array.length; i++)
-    {
-      this.text_array[i].size.set(value, value, value);
-    }
-    this.update_text_positions();
-  }
-
-  get texts(): string[]
-  {
-    return [];
-  }
-
-  get size()
-  {
-    return 1;
-  }
-}
-
-export { MultiLineText2D };

package/src/components/Shape2D.ts

@@ -1,42 +0,0 @@
-import { GeometryEdgeVisualizer } from './GeometryEdgeVisualizer';
-
-import type { Vector2 } from 'three';
-import { Mesh, MeshBasicMaterial, Shape, ShapeGeometry } from 'three';
-
-class Shape2D extends Mesh
-{
-  constructor(points_2D: Vector2[], show_edges: boolean)
-  {
-    const shape = new Shape(points_2D);
-    const geometry = new ShapeGeometry(shape);
-    geometry.rotateX(3.14 / 2);
-
-    const material = new MeshBasicMaterial({ color: 0xff0000 });
-    super(geometry, material);
-    this.invert_normals(geometry);
-
-    if (show_edges)
-    {
-      const edge_mesh = new GeometryEdgeVisualizer(geometry);
-      edge_mesh.hide_faces();
-      edge_mesh.material.depthTest = false;
-      this.add(edge_mesh);
-    }
-  }
-
-  invert_normals(geometry: ShapeGeometry)
-  {
-    const indices = geometry.index.array;
-    for (let i = 0; i < indices.length; i += 3)
-    {
-      const x = indices[i + 0];
-      const z = indices[i + 2];
-
-      indices[i + 0] = z;
-      indices[i + 2] = x;
-    }
-    geometry.computeVertexNormals();
-  }
-}
-
-export { Shape2D };

package/src/components/Shape3D.ts

@@ -1,38 +0,0 @@
-import { GeometryEdgeVisualizer } from './GeometryEdgeVisualizer';
-
-import type { Vector2 } from 'three';
-import { ExtrudeGeometry, Mesh, MeshNormalMaterial, Shape } from 'three';
-
-class Shape3D extends Mesh
-{
-  constructor(points_2D: Vector2[], show_edges: boolean, height?: number)
-  {
-    const shape = new Shape(points_2D);
-    height = height || 1;
-
-    const extrudeSettings = {
-      steps: 2,
-      depth: height,
-      bevelEnabled: false,
-      bevelThickness: 1,
-      bevelSize: 1,
-      bevelSegments: 1
-    };
-
-    const geometry = new ExtrudeGeometry(shape, extrudeSettings);
-    geometry.rotateX(3.14 / 2);
-    geometry.translate(0, height, 0);
-
-    const material = new MeshNormalMaterial();
-    super(geometry, material);
-
-    if (show_edges)
-    {
-      const edge_mesh = new GeometryEdgeVisualizer(geometry, '#FF0000');
-      edge_mesh.hide_faces();
-      this.add(edge_mesh);
-    }
-  }
-}
-
-export { Shape3D };

package/src/gpu_particles/GPUParticleSystem.ts

@@ -1,122 +0,0 @@
-import { BufferAttribute, BufferGeometry, InstancedBufferAttribute, InstancedBufferGeometry, Mesh, Object3D, PlaneGeometry, Points, Scene } from 'three';
-import { ParticleAttribute } from './ParticleAttribute';
-
-class GPUParticleSystem extends Object3D
-{
-  attribute_writter_mesh: Points;
-  attribute_writter_scene: Scene;
-  attributes: ParticleAttribute[];
-  mesh: Mesh;
-
-  constructor(particle_count: number, material: any)
-  {
-    super();
-    this.attributes = [];
-
-    this.mesh = this.build_point_mesh(particle_count, material);
-    this.add(this.mesh);
-
-    this.attribute_writter_mesh = this.build_attribute_writter_mesh(particle_count);
-    this.attribute_writter_scene = new Scene();
-    this.attribute_writter_scene.add(this.attribute_writter_mesh);
-  }
-
-  add_texture_attribute(buffer_attribute: ParticleAttribute)
-  {
-    this.attributes.push(buffer_attribute);
-  }
-
-  add_update_attribute_array(name: string, array: Float32Array, item_size: number)
-  {
-    this.attribute_writter_mesh.geometry.setAttribute(name, new BufferAttribute(array, item_size, false));
-  }
-
-  add_attribute_array(name: string, array: Float32Array, item_size: number)
-  {
-    this.mesh.geometry.setAttribute(name, new InstancedBufferAttribute(array, item_size, false));
-  }
-
-  update()
-  {
-    const mat = this.mesh.material;
-
-    if (Array.isArray(mat)) {
-      mat.forEach(m => m.dispose());
-    } else {
-      mat.dispose();
-    }
-    
-    for (let i = 0; i < this.attributes.length; i++)
-    {
-      this.attributes[i].update(this.attribute_writter_scene);
-    }
-  }
-
-  dispose()
-  {
-    this.mesh.geometry.dispose();
-    
-    const mat = this.mesh.material;
-
-    if (Array.isArray(mat)) {
-      mat.forEach(m => m.dispose());
-    } else {
-      mat.dispose();
-    }
-  }
-
-  build_point_mesh(instance_count = 1, material: any)
-  {
-    const geo = new PlaneGeometry();
-
-    const instanced_geo = new InstancedBufferGeometry();
-    instanced_geo.setAttribute('position', geo.getAttribute('position'));
-    instanced_geo.index = geo.index;
-
-    instanced_geo.setAttribute('storage_uv', this.build_uv_storage_attribute(instance_count));
-    instanced_geo.instanceCount = instance_count;
-    const mesh = new Mesh(instanced_geo, material);
-    mesh.frustumCulled = false;
-    return mesh;
-  }
-
-  build_attribute_writter_mesh(particle_count: any)
-  {
-    const { width, height } = ParticleAttribute.calculate_resolution(particle_count);
-
-    const uvs = new Float32Array(particle_count * 3);
-
-    for (let i = 0; i < particle_count; i++)
-    {
-      const x = i % width;
-      const y = Math.floor(i / width);
-      uvs[i * 3 + 0] = (x + 0.5) / width;
-      uvs[i * 3 + 1] = (y + 0.5) / height;
-      uvs[i * 3 + 2] = i;
-    }
-    const geo = new BufferGeometry();
-    geo.setAttribute('position', new BufferAttribute(uvs, 3, false));
-
-    const points = new Points(geo);
-    points.frustumCulled = false;
-    return points;
-  }
-
-  build_uv_storage_attribute(particle_count: any)
-  {
-    const { width, height } = ParticleAttribute.calculate_resolution(particle_count);
-
-    const uvs = new Float32Array(particle_count * 2);
-
-    for (let i = 0; i < particle_count; i++)
-    {
-      const x = i % width;
-      const y = Math.floor(i / width);
-      uvs[i * 2 + 0] = (x + 0.5) / width;
-      uvs[i * 2 + 1] = (y + 0.5) / height;
-    }
-    return new InstancedBufferAttribute(uvs, 2, false);
-  }
-}
-
-export { GPUParticleSystem };

package/src/gpu_particles/ParticleAttribute.ts

@@ -1,110 +0,0 @@
-import { Graphics } from '../Graphics';
-
-import type { BufferAttribute, BufferGeometry, Scene } from 'three';
-import { FloatType, HalfFloatType, Mesh, NearestFilter, NoColorSpace, RenderTarget, RGBAFormat } from 'three';
-import { Capabilities } from '../Capabilities';
-
-class ParticleAttribute
-{
-  name: any;
-  read: RenderTarget;
-  update_material: any;
-  write: RenderTarget;
-
-  constructor(attr_name: string, update_material: any)
-  {
-    this.read = undefined;
-    this.write = undefined;
-
-    this.name = attr_name;
-
-    this.update_material = update_material;
-  }
-
-  init_from_geometry(geometry: BufferGeometry)
-  {
-    // overrided by inheritance
-  }
-
-  init_from_attribute(particle_attribute: ParticleAttribute)
-  {
-
-  }
-
-  build_RT(particle_count: number)
-  {
-    const resolution = ParticleAttribute.calculate_resolution(particle_count);
-    const options = {
-      minFilter: NearestFilter,
-      magFilter: NearestFilter,
-      format: RGBAFormat,
-      colorScape: NoColorSpace,
-      type: Capabilities.fp_textures_available ? FloatType : HalfFloatType,
-      stencilBuffer: false,
-      depthBuffer: false
-    };
-
-    return new RenderTarget(resolution.width, resolution.height, options);
-  }
-
-  static calculate_resolution(particle_count: number)
-  {
-    const width = Math.min(particle_count, 512);
-    const height = Math.max(1, Math.ceil(particle_count / width));
-    return { width, height };
-  }
-
-  swap_RT()
-  {
-    const tmp = this.read;
-    this.read = this.write;
-    this.write = tmp;
-  }
-
-  update(attribute_writter_scene: Scene)
-  {
-    if (this.update_material)
-    {
-      this.update_material.update();
-
-      if (attribute_writter_scene.children[0] instanceof Mesh)
-      {
-        attribute_writter_scene.children[0].material = this.update_material;
-      }
-
-      this.update_material.uniforms._MainTex.value = this.read.texture;
-      Graphics.render(attribute_writter_scene, undefined, this.write);
-
-      if (attribute_writter_scene.children[0] instanceof Mesh)
-      {
-        attribute_writter_scene.children[0].material = undefined;
-      }
-
-      this.swap_RT();
-    }
-  }
-
-  store_geometry_attribute_in_RT(attribute: BufferAttribute, RT: RenderTarget, storage_material: any, attribute_writter_scene: Scene)
-  {
-    if (attribute_writter_scene.children[0] instanceof Mesh)
-    {
-      attribute_writter_scene.children[0].geometry.setAttribute('data', attribute);
-      attribute_writter_scene.children[0].material = storage_material;
-    }
-
-    Graphics.render(attribute_writter_scene, undefined, RT);
-
-    if (attribute_writter_scene.children[0] instanceof Mesh)
-    {
-      attribute_writter_scene.children[0].geometry.deleteAttribute('data');
-      attribute_writter_scene.children[0].material = undefined;
-    }
-  }
-
-  get_texture()
-  {
-    return this.read.texture;
-  }
-}
-
-export { ParticleAttribute };

package/src/gpu_particles/ParticlePositionAttribute.ts

@@ -1,46 +0,0 @@
-import type { BufferGeometry, RenderTarget, Scene, Vector3 } from 'three';
-import { BufferAttribute } from 'three';
-
-import { ParticleAttribute } from '../gpu_particles/ParticleAttribute';
-import { ParticleStorageMaterial } from '../materials/gpu_particles/ParticleStorageMaterial';
-
-class ParticlePositionAttribute extends ParticleAttribute
-{
-  read: RenderTarget;
-  write: RenderTarget;
-
-  constructor(update_material: any)
-  {
-    super('_Position', update_material);
-  }
-
-  store_geometry(geometry: BufferGeometry, attribute_writter_scene: Scene)
-  {
-    const pos_attr = geometry.getAttribute('position');
-    this.read    = this.build_RT(pos_attr.count);
-    this.write   = this.build_RT(pos_attr.count);
-
-    const mat = new ParticleStorageMaterial();
-    this.store_geometry_attribute_in_RT(geometry.getAttribute('position') as BufferAttribute, this.read, mat, attribute_writter_scene);
-  }
-
-  store_positions(positions: Array<Vector3>, attribute_writter_scene: Scene)
-  {
-    this.read    = this.build_RT(positions.length);
-    this.write   = this.build_RT(positions.length);
-
-    const arr = new Float32Array(positions.length * 4);
-
-    for (let i = 0; i < positions.length; i++)
-    {
-      arr[i * 4 + 0] = positions[i].x;
-      arr[i * 4 + 1] = positions[i].y;
-      arr[i * 4 + 2] = positions[i].z;
-      arr[i * 4 + 3] = (Math.random() * 2 - 1) * 10;
-    }
-    const mat = new ParticleStorageMaterial();
-    this.store_geometry_attribute_in_RT(new BufferAttribute(arr, 4), this.read, mat, attribute_writter_scene);
-  }
-}
-
-export { ParticlePositionAttribute };

package/src/materials/AlphaFilterMaterial.ts

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

package/src/materials/BaseShaderMaterial.ts

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