@fils/phy-three 0.0.1

package/lib/helper/ThreePhyHelper.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Phy Three Helper
+ * A ThreeJS helper for @fils/phy
+ * Supporting particles and springs
+ * To-Do: Move to @fils/phy-three
+ */
+import { Physics } from "@fils/phy";
+import { InstancedMesh, LineSegments, Object3D } from "three";
+export interface PhyThreeHelperParameters {
+    particleRadius?: number;
+}
+export declare class PhyThreeHelper extends Object3D {
+    particles: InstancedMesh;
+    physics: Physics;
+    springs: LineSegments;
+    constructor(phy: Physics, _params?: PhyThreeHelperParameters);
+    update(): void;
+}

package/lib/helper/ThreePhyHelper.js

@@ -0,0 +1,75 @@
+/**
+ * Phy Three Helper
+ * A ThreeJS helper for @fils/phy
+ * Supporting particles and springs
+ * To-Do: Move to @fils/phy-three
+ */
+import { BufferAttribute, BufferGeometry, Color, InstancedMesh, LineBasicMaterial, LineSegments, MeshBasicMaterial, Object3D, SphereGeometry } from "three";
+const dummy = new Object3D();
+const ParticleMat = new MeshBasicMaterial({
+    color: 0xffffff
+});
+const color1 = new Color(0xee3333);
+const color2 = new Color(0x3333ee);
+export class PhyThreeHelper extends Object3D {
+    constructor(phy, _params = {}) {
+        super();
+        this.physics = phy;
+        const ParticleGeo = new SphereGeometry(_params.particleRadius || .02, 32, 16);
+        this.particles = new InstancedMesh(ParticleGeo, ParticleMat, phy.particles.length);
+        let i = 0;
+        for (const p of phy.particles) {
+            this.particles.setColorAt(i++, p.locked ? color1 : color2);
+        }
+        this.add(this.particles);
+        const pos = [];
+        const col = [];
+        for (const s of phy.springs) {
+            const a = s.a.position;
+            const b = s.b.position;
+            pos.push(a.x, a.y, a.z);
+            pos.push(b.x, b.y, b.z);
+            if (s.a.locked)
+                col.push(color1.r, color1.g, color1.b);
+            else
+                col.push(color2.r, color2.g, color2.b);
+            if (s.b.locked)
+                col.push(color1.r, color1.g, color1.b);
+            else
+                col.push(color2.r, color2.g, color2.b);
+        }
+        const geo = new BufferGeometry();
+        geo.setAttribute('position', new BufferAttribute(new Float32Array(pos), 3));
+        geo.setAttribute('color', new BufferAttribute(new Float32Array(col), 3));
+        this.springs = new LineSegments(geo, new LineBasicMaterial({
+            color: 0xffffff,
+            vertexColors: true
+        }));
+        this.add(this.springs);
+        this.update();
+    }
+    update() {
+        const particles = this.physics.particles;
+        for (let i = 0, len = particles.length; i < len; i++) {
+            const p = particles[i];
+            dummy.position.copy(p.position);
+            dummy.updateMatrix();
+            this.particles.setMatrixAt(i, dummy.matrix);
+        }
+        this.particles.instanceMatrix.needsUpdate = true;
+        const pos = this.springs.geometry.attributes.position;
+        let k = 0;
+        for (let i = 0, len = this.physics.springs.length; i < len; i++) {
+            const s = this.physics.springs[i];
+            pos.array[k * 3] = s.a.position.x;
+            pos.array[k * 3 + 1] = s.a.position.y;
+            pos.array[k * 3 + 2] = s.a.position.z;
+            k++;
+            pos.array[k * 3] = s.b.position.x;
+            pos.array[k * 3 + 1] = s.b.position.y;
+            pos.array[k * 3 + 2] = s.b.position.z;
+            k++;
+        }
+        pos.needsUpdate = true;
+    }
+}

package/lib/main.d.ts

@@ -0,0 +1,3 @@
+import { PhyThreeHelper, PhyThreeHelperParameters } from "./helper/ThreePhyHelper";
+import { PhyThreeMesh, MeshParticle, PhyMeshParameters } from "./mesh/PhyThreeMesh";
+export { PhyThreeHelper, PhyThreeHelperParameters, PhyThreeMesh, MeshParticle, PhyMeshParameters };

package/lib/main.js

@@ -0,0 +1,3 @@
+import { PhyThreeHelper } from "./helper/ThreePhyHelper";
+import { PhyThreeMesh, MeshParticle } from "./mesh/PhyThreeMesh";
+export { PhyThreeHelper, PhyThreeMesh, MeshParticle };

package/lib/mesh/PhyThreeMesh.d.ts

@@ -0,0 +1,28 @@
+import { Vec } from "@fils/math";
+import { Particle, Physics } from "@fils/phy";
+import { Mesh } from "three";
+/**
+ * Mesh Particle
+ */
+export interface MeshParticleParameters {
+    x: number;
+    y: number;
+    z: number;
+}
+export declare class MeshParticle extends Particle {
+    restPosition: Vec;
+    constructor(_params: MeshParticleParameters, id?: number, drag?: number);
+}
+export interface PhyMeshParameters {
+    dragGen?(): number;
+    springStrGen?(): number;
+    useQuad?: boolean;
+}
+/**
+ * Wrapper to create a phy mesh
+ * with particles and springs given a ThreeJS Mesh
+ */
+export declare class PhyThreeMesh extends Physics {
+    particles: MeshParticle[];
+    constructor(mesh: Mesh, _params?: PhyMeshParameters);
+}

package/lib/mesh/PhyThreeMesh.js

@@ -0,0 +1,48 @@
+import { Vec } from "@fils/math";
+import { Particle, Physics, Spring } from "@fils/phy";
+import { Vector3 } from "three";
+export class MeshParticle extends Particle {
+    constructor(_params, id, drag) {
+        super(id, drag);
+        this.setPosition(_params.x, _params.y, _params.z);
+        this.restPosition = new Vec(_params.x, _params.y, _params.z);
+    }
+}
+const DEFAULT_DRAG = .5;
+const DEFAULT_SPRING_STRENGTH = .5;
+const tmp = new Vector3();
+/**
+ * Wrapper to create a phy mesh
+ * with particles and springs given a ThreeJS Mesh
+ */
+export class PhyThreeMesh extends Physics {
+    constructor(mesh, _params = {}) {
+        super();
+        mesh.updateMatrix();
+        const geo = mesh.geometry;
+        const pos = geo.attributes.position;
+        // add particles
+        for (let i = 0; i < pos.count; i++) {
+            tmp.set(pos.array[i * 3], pos.array[i * 3 + 1], pos.array[i * 3 + 2]).applyMatrix4(mesh.matrix);
+            const p = new MeshParticle({
+                x: tmp.x,
+                y: tmp.y,
+                z: tmp.z
+            }, i, _params.dragGen ? _params.dragGen() : DEFAULT_DRAG);
+            this.addParticle(p);
+        }
+        // add springs
+        const index = geo.index;
+        const part = this.particles;
+        for (let i = 0; i < index.count / 3; i++) {
+            const s1 = new Spring(part[index.array[i * 3]], part[index.array[i * 3 + 1]], _params.springStrGen ? _params.springStrGen() : DEFAULT_SPRING_STRENGTH);
+            this.addSpring(s1);
+            if (_params.useQuad !== true) {
+                const s2 = new Spring(part[index.array[i * 3 + 1]], part[index.array[i * 3 + 2]], _params.springStrGen ? _params.springStrGen() : DEFAULT_SPRING_STRENGTH);
+                this.addSpring(s2);
+                const s3 = new Spring(part[index.array[i * 3 + 2]], part[index.array[i * 3]], _params.springStrGen ? _params.springStrGen() : DEFAULT_SPRING_STRENGTH);
+                this.addSpring(s3);
+            }
+        }
+    }
+}

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@fils/phy-three",
+  "version": "0.0.1",
+  "description": "ThreeJS utils for @phy/three",
+  "main": "lib/main.js",
+  "repository": "git@github.com:fil-studio/fils.git",
+  "homepage": "https://github.com/fil-studio/fils/tree/main/packages/phy-three",
+  "author": "Fil Studio <hello@fil.studio>",
+  "license": "Apache-2.0",
+  "scripts": {
+    "prepare": "yarn build",
+    "build": "tsc"
+  },
+  "files": [
+    "lib"
+  ],
+  "devDependencies": {
+    "typescript": "^4.5.4"
+  },
+  "dependencies": {
+    "@fils/phy": "^0.0.4"
+  },
+  "peerDependencies": {
+		"three": "*"
+	}
+}