three-zoo 0.0.2 → 0.0.3

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "three-zoo",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "zoo of tiny three js tools",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
   "exports": {
     ".": {
       "import": "./dist/index.js",

package/eslint.config.js

@@ -1,45 +0,0 @@
-import tsPlugin from "@typescript-eslint/eslint-plugin";
-import tsParser from "@typescript-eslint/parser";
-
-export default [
-  {
-    files: ["src/**/*.ts", "src/**/*.tsx"],
-    ignores: ["dist/**", "node_modules/**"],
-    languageOptions: {
-      parser: tsParser,
-      parserOptions: {
-        project: "./tsconfig.json",
-        tsconfigRootDir: process.cwd(),
-        sourceType: "module",
-      },
-    },
-    plugins: {
-      "@typescript-eslint": tsPlugin,
-    },
-    rules: {
-      "no-unused-vars": "off",
-      "@typescript-eslint/no-unused-vars": [
-        "error",
-        { argsIgnorePattern: "^_" },
-      ],
-      "no-console": "warn",
-      eqeqeq: ["error", "always"],
-
-      "@typescript-eslint/explicit-function-return-type": "error",
-      "@typescript-eslint/explicit-module-boundary-types": "error",
-      "@typescript-eslint/no-explicit-any": "error",
-      "@typescript-eslint/no-inferrable-types": "warn",
-
-      "@typescript-eslint/ban-ts-comment": "error",
-      "@typescript-eslint/no-floating-promises": "error",
-
-      "@typescript-eslint/member-ordering": "warn",
-      "@typescript-eslint/naming-convention": [
-        "error",
-        { selector: "default", format: ["camelCase"] },
-        { selector: "variableLike", format: ["camelCase", "UPPER_CASE"] },
-        { selector: "typeLike", format: ["PascalCase"] },
-      ],
-    },
-  },
-];

package/src/Bounds.ts

@@ -1,22 +0,0 @@
-import { Box3, Vector3 } from "three";
-
-export class Bounds extends Box3 {
-  private readonly tempVector3: Vector3 = new Vector3();
-
-  public get width(): number {
-    return this.max.x - this.min.x;
-  }
-
-  public get height(): number {
-    return this.max.y - this.min.y;
-  }
-
-  public get depth(): number {
-    return this.max.z - this.min.z;
-  }
-
-  public get diagonal(): number {
-    this.tempVector3.subVectors(this.max, this.min);
-    return this.tempVector3.length();
-  }
-}

package/src/Enumerator.ts

@@ -1,89 +0,0 @@
-import { Material, Mesh, Object3D } from "three";
-
-type Constructor<T> = abstract new (...args: never[]) => T;
-
-export class Enumerator {
-  public static getObjectByName(
-    object: Object3D,
-    name: string,
-  ): Object3D | null {
-    if (object.name === name) return object;
-
-    for (const child of object.children) {
-      const result = Enumerator.getObjectByName(child, name);
-      if (result) return result;
-    }
-
-    return null;
-  }
-
-  public static getMaterialByName(
-    object: Object3D,
-    name: string,
-  ): Material | null {
-    if (object instanceof Mesh) {
-      if (Array.isArray(object.material)) {
-        for (const material of object.material) {
-          if (material.name === name) return material;
-        }
-      } else if (object.material.name === name) {
-        return object.material;
-      }
-    }
-
-    for (const child of object.children) {
-      const material = Enumerator.getMaterialByName(child, name);
-      if (material) return material;
-    }
-
-    return null;
-  }
-
-  public static enumerateObjectsByType<T>(
-    object: Object3D,
-    type: Constructor<T>,
-    callback: (instance: T) => void,
-  ): void {
-    if (object instanceof type) {
-      callback(object);
-    }
-
-    for (const child of object.children) {
-      Enumerator.enumerateObjectsByType(child, type, callback);
-    }
-  }
-
-  public static enumerateMaterials(
-    object: Object3D,
-    callback: (material: Material) => void,
-  ): void {
-    if (object instanceof Mesh) {
-      if (Array.isArray(object.material)) {
-        for (const material of object.material) {
-          callback(material);
-        }
-      } else {
-        callback(object.material);
-      }
-    }
-
-    for (const child of object.children) {
-      Enumerator.enumerateMaterials(child, callback);
-    }
-  }
-
-  public static setShadowRecursive(
-    object: Object3D,
-    castShadow = true,
-    receiveShadow = true,
-  ): void {
-    if (object instanceof Mesh || "isMesh" in object) {
-      (object as Mesh).castShadow = castShadow;
-      (object as Mesh).receiveShadow = receiveShadow;
-    }
-
-    for (const child of object.children) {
-      Enumerator.setShadowRecursive(child, castShadow, receiveShadow);
-    }
-  }
-}

package/src/InstanceAssembler.ts

@@ -1,90 +0,0 @@
-import { InstancedMesh, Material, Mesh, Object3D } from "three";
-import { Enumerator } from "./Enumerator";
-
-interface IMeshDescriptor {
-  meshes: Mesh[];
-  materials: Material[];
-  castShadow: boolean;
-  receiveShadow: boolean;
-}
-
-interface IOptions {
-  container: Object3D;
-  filter?: (child: Mesh) => boolean;
-  disposeOriginal?: boolean;
-}
-
-export class InstanceAssembler {
-  public static assemble(options: IOptions): void {
-    const dictionary = new Map<string, IMeshDescriptor>();
-    const instancedMeshes: InstancedMesh[] = [];
-
-    Enumerator.enumerateObjectsByType(
-      options.container,
-      Mesh,
-      (child: Mesh) => {
-        if (
-          child.children.length === 0 &&
-          (!options.filter || options.filter(child))
-        ) {
-          const materials = Array.isArray(child.material)
-            ? child.material
-            : [child.material];
-
-          const key = `${child.geometry.uuid}|${materials.map((m) => m.uuid).join(",")}`;
-          const entry = dictionary.get(key) ?? {
-            meshes: [],
-            materials: materials,
-            castShadow: false,
-            receiveShadow: false,
-          };
-
-          if (child.castShadow) entry.castShadow = true;
-          if (child.receiveShadow) entry.receiveShadow = true;
-
-          dictionary.set(key, entry);
-        }
-      },
-    );
-
-    for (const descriptor of dictionary.values()) {
-      if (descriptor.meshes.length < 2) continue;
-      const { meshes, materials, castShadow, receiveShadow } = descriptor;
-
-      const sortedMeshes = meshes.sort((a, b) => a.name.localeCompare(b.name));
-      const defaultMesh = sortedMeshes[0];
-
-      const instancedMesh = new InstancedMesh(
-        defaultMesh.geometry,
-        materials.length === 1 ? materials[0] : materials,
-        sortedMeshes.length,
-      );
-
-      instancedMesh.name = defaultMesh.name;
-      instancedMesh.castShadow = castShadow;
-      instancedMesh.receiveShadow = receiveShadow;
-
-      for (let i = 0; i < sortedMeshes.length; i++) {
-        const mesh = sortedMeshes[i];
-        mesh.updateWorldMatrix(true, false);
-        instancedMesh.setMatrixAt(i, mesh.matrixWorld);
-        instancedMesh.userData[mesh.uuid] = mesh.userData;
-      }
-
-      instancedMesh.instanceMatrix.needsUpdate = true;
-      instancedMeshes.push(instancedMesh);
-
-      for (const mesh of sortedMeshes) {
-        mesh.parent?.remove(mesh);
-      }
-
-      if (options.disposeOriginal === true) {
-        for (const material of materials) {
-          material.dispose();
-        }
-      }
-    }
-
-    options.container.add(...instancedMeshes);
-  }
-}

package/src/SceneProcessor.ts

@@ -1,53 +0,0 @@
-import { FrontSide, Material, Mesh, Object3D } from "three";
-import { Enumerator } from "./Enumerator";
-import { InstanceAssembler } from "./InstanceAssembler";
-
-type IPattern = string | RegExp;
-
-interface IOptions {
-  asset: Object3D;
-  castShadowMeshNames?: IPattern[];
-  receiveShadowMeshNames?: IPattern[];
-  transparentMaterialNames?: IPattern[];
-  noDepthWriteMaterialNames?: IPattern[];
-}
-
-export class SceneProcessor {
-  public static process(options: IOptions): Object3D[] {
-    const container = options.asset.clone();
-    InstanceAssembler.assemble({ container: container });
-
-    Enumerator.enumerateMaterials(container, (material: Material) => {
-      material.transparent = SceneProcessor.matchesAny(
-        material.name,
-        options.transparentMaterialNames,
-      );
-      material.depthWrite = !SceneProcessor.matchesAny(
-        material.name,
-        options.noDepthWriteMaterialNames,
-      );
-      material.side = FrontSide;
-      material.forceSinglePass = true;
-      material.depthTest = true;
-    });
-
-    Enumerator.enumerateObjectsByType(container, Mesh, (child: Mesh) => {
-      child.castShadow = SceneProcessor.matchesAny(
-        child.name,
-        options.castShadowMeshNames,
-      );
-      child.receiveShadow = SceneProcessor.matchesAny(
-        child.name,
-        options.receiveShadowMeshNames,
-      );
-    });
-
-    return container.children;
-  }
-
-  private static matchesAny(value: string, patterns: IPattern[] = []): boolean {
-    return patterns.some((p) =>
-      typeof p === "string" ? value === p : p.test(value),
-    );
-  }
-}

package/src/Sun.ts

@@ -1,133 +0,0 @@
-import {
-  Box3,
-  DirectionalLight,
-  RGBAFormat,
-  Spherical,
-  Texture,
-  Vector3,
-} from "three";
-
-export class Sun extends DirectionalLight {
-  private tempVector3D0 = new Vector3();
-  private tempVector3D1 = new Vector3();
-  private tempVector3D2 = new Vector3();
-  private tempVector3D3 = new Vector3();
-  private tempVector3D4 = new Vector3();
-  private tempVector3D5 = new Vector3();
-  private tempVector3D6 = new Vector3();
-  private tempVector3D7 = new Vector3();
-
-  private tempBox3 = new Box3();
-  private tempSpherical = new Spherical();
-
-  public get distance(): number {
-    return this.position.length();
-  }
-
-  public get elevation(): number {
-    return this.tempSpherical.setFromVector3(this.position).phi;
-  }
-
-  public get azimuth(): number {
-    return this.tempSpherical.setFromVector3(this.position).theta;
-  }
-
-  public set distance(value: number) {
-    this.tempSpherical.setFromVector3(this.position);
-    this.position.setFromSphericalCoords(
-      value,
-      this.tempSpherical.phi,
-      this.tempSpherical.theta,
-    );
-  }
-
-  public set elevation(value: number) {
-    this.tempSpherical.setFromVector3(this.position);
-    this.position.setFromSphericalCoords(
-      this.tempSpherical.radius,
-      value,
-      this.tempSpherical.theta,
-    );
-  }
-
-  public set azimuth(value: number) {
-    this.tempSpherical.setFromVector3(this.position);
-    this.position.setFromSphericalCoords(
-      this.tempSpherical.radius,
-      this.tempSpherical.phi,
-      value,
-    );
-  }
-
-  public setShadowMapFromBox3(box3: Box3): void {
-    const camera = this.shadow.camera;
-
-    this.target.updateWorldMatrix(true, false);
-    this.lookAt(this.target.getWorldPosition(this.tempVector3D0));
-
-    this.updateWorldMatrix(true, false);
-
-    const points: Vector3[] = [
-      this.tempVector3D0.set(box3.min.x, box3.min.y, box3.min.z),
-      this.tempVector3D1.set(box3.min.x, box3.min.y, box3.max.z),
-      this.tempVector3D2.set(box3.min.x, box3.max.y, box3.min.z),
-      this.tempVector3D3.set(box3.min.x, box3.max.y, box3.max.z),
-      this.tempVector3D4.set(box3.max.x, box3.min.y, box3.min.z),
-      this.tempVector3D5.set(box3.max.x, box3.min.y, box3.max.z),
-      this.tempVector3D6.set(box3.max.x, box3.max.y, box3.min.z),
-      this.tempVector3D7.set(box3.max.x, box3.max.y, box3.max.z),
-    ];
-
-    const inverseMatrix = this.matrixWorld.clone().invert();
-
-    for (const point of points) {
-      point.applyMatrix4(inverseMatrix);
-    }
-
-    const newBox3 = this.tempBox3.setFromPoints(points);
-
-    camera.left = newBox3.min.x;
-    camera.bottom = newBox3.min.y;
-    camera.near = -newBox3.max.z;
-
-    camera.right = newBox3.max.x;
-    camera.top = newBox3.max.y;
-    camera.far = -newBox3.min.z;
-
-    camera.updateWorldMatrix(true, false);
-    camera.updateProjectionMatrix();
-  }
-
-  public setDirectionFromHDR(texture: Texture, distance = 1): void {
-    const data = texture.image.data;
-    const width = texture.image.width;
-    const height = texture.image.height;
-
-    let maxLuminance = 0;
-    let maxIndex = 0;
-
-    const step = texture.format === RGBAFormat ? 4 : 3;
-    for (let i = 0; i < data.length; i += step) {
-      const r = data[i];
-      const g = data[i + 1];
-      const b = data[i + 2];
-      const luminance = 0.2126 * r + 0.7152 * g + 0.0722 * b;
-      if (luminance > maxLuminance) {
-        maxLuminance = luminance;
-        maxIndex = i;
-      }
-    }
-
-    const pixelIndex = maxIndex / step;
-    const x = pixelIndex % width;
-    const y = Math.floor(pixelIndex / width);
-
-    const u = x / width;
-    const v = y / height;
-
-    const elevation = v * Math.PI;
-    const azimuth = u * -Math.PI * 2 - Math.PI / 2;
-
-    this.position.setFromSphericalCoords(distance, elevation, azimuth);
-  }
-}

package/src/index.ts

@@ -1,5 +0,0 @@
-export * from "./Bounds";
-export * from "./Enumerator";
-export * from "./InstanceAssembler";
-export * from "./SceneProcessor";
-export * from "./Sun";

package/tsconfig.json

@@ -1,21 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES6",
-    "module": "ESNext",
-    "moduleResolution": "Bundler",
-    "strict": true,
-    "noImplicitAny": true,
-    "strictNullChecks": true,
-    "strictFunctionTypes": true,
-    "strictBindCallApply": true,
-    "noImplicitThis": true,
-    "alwaysStrict": true,
-    "esModuleInterop": true,
-    "forceConsistentCasingInFileNames": true,
-    "skipLibCheck": false,
-    "outDir": "./dist",
-    "declaration": true,
-    "sourceMap": true
-  },
-  "include": ["src/**/*"]
-}