@woosh/meep-engine 2.35.8 → 2.35.12

package/engine/graphics/ecs/path/tube/TubePathBuilder.js

@@ -1,522 +0,0 @@
-import {
-    BufferGeometry,
-    CatmullRomCurve3,
-    Float32BufferAttribute,
-    MeshMatcapMaterial,
-    MeshStandardMaterial,
-    TubeGeometry,
-    Vector3
-} from "three";
-import { InterpolationType } from "../../../../navigation/ecs/components/InterpolationType.js";
-import EntityBuilder from "../../../../ecs/EntityBuilder.js";
-import { Transform } from "../../../../ecs/transform/Transform.js";
-import Renderable from "../../../../ecs/components/Renderable.js";
-import ThreeFactory from "../../../three/ThreeFactory.js";
-import { TubeMaterialType } from "./TubeMaterialType.js";
-import { GameAssetType } from "../../../../asset/GameAssetType.js";
-import { Matrix4 } from "three/src/math/Matrix4.js";
-import * as MathUtils from "three/src/math/MathUtils.js";
-import { max2 } from "../../../../../core/math/max2.js";
-import { min2 } from "../../../../../core/math/min2.js";
-
-/**
- * some useful references:
- * https://stackoverflow.com/questions/29438398/cheap-way-of-calculating-cubic-bezier-length
- * https://stackoverflow.com/questions/1147249/connecting-catmull-rom-splines-together-and-calculating-its-length
- * @param {Path} path
- * @param {number} epsilon
- */
-function estimatePathViaIterativeIntegral(path, epsilon) {
-    let sum = 0;
-
-    let p0 = new Vector3();
-    let p1 = new Vector3();
-
-    if (!path.sample(p0, 0)) {
-        // path has 0 length
-        return 0;
-    }
-
-    for (let p = epsilon; ; i += epsilon) {
-        const ended = path.sample(p1, p);
-
-        if (ended) {
-            break;
-        }
-
-        sum += p0.distanceTo(p1);
-
-        const swap = p1;
-
-        p1 = p0;
-        p0 = swap;
-    }
-
-    return sum;
-}
-
-/**
- * @see https://github.com/mrdoob/three.js/blob/c12c9a166a1369cdd58622fff2aff7e3a84305d7/src/extras/core/Curve.js#L260
- * @param {Vector3[]} points
- * @param {boolean} [closed]
- */
-function computeFrenetFrames(points, closed = false) {
-// see http://www.cs.indiana.edu/pub/techreports/TR425.pdf
-
-    const normal = new Vector3();
-
-    const tangents = [];
-    const normals = [];
-    const binormals = [];
-
-    const vec = new Vector3();
-    const mat = new Matrix4();
-
-    const segments = points.length - 1;
-
-    const v3_0 = new Vector3();
-    const v3_1 = new Vector3();
-
-    /**
-     *
-     * @param {number} i
-     * @param {Vector3} destination
-     */
-    function getTangent(i, destination) {
-        // get points on either side
-        const i0 = max2(i - 1, 0);
-        const i1 = min2(i + 1, segments);
-
-        const p0 = points[i0];
-        const pR = points[i];
-        const p1 = points[i1];
-
-        // get points along the lines close to the reference
-        v3_0.subVectors(p0, pR);
-        v3_0.normalize();
-
-        v3_1.subVectors(p1, pR);
-        v3_1.normalize();
-
-        destination.subVectors(v3_1, v3_0);
-        destination.normalize();
-    }
-
-    // compute the tangent vectors for each segment on the curve
-
-    for (let i = 0; i <= segments; i++) {
-
-        const tangent = new Vector3();
-        getTangent(i, tangent);
-
-        tangents[i] = tangent;
-
-    }
-
-    // select an initial normal vector perpendicular to the first tangent vector,
-    // and in the direction of the minimum tangent xyz component
-
-    normals[0] = new Vector3();
-    binormals[0] = new Vector3();
-    let min = Number.MAX_VALUE;
-    const tx = Math.abs(tangents[0].x);
-    const ty = Math.abs(tangents[0].y);
-    const tz = Math.abs(tangents[0].z);
-
-    if (tx <= min) {
-
-        min = tx;
-        normal.set(1, 0, 0);
-
-    }
-
-    if (ty <= min) {
-
-        min = ty;
-        normal.set(0, 1, 0);
-
-    }
-
-    if (tz <= min) {
-
-        normal.set(0, 0, 1);
-
-    }
-
-    vec.crossVectors(tangents[0], normal).normalize();
-
-    normals[0].crossVectors(tangents[0], vec);
-    binormals[0].crossVectors(tangents[0], normals[0]);
-
-
-    // compute the slowly-varying normal and binormal vectors for each segment on the curve
-
-    for (let i = 1; i <= segments; i++) {
-
-        normals[i] = normals[i - 1].clone();
-
-        binormals[i] = binormals[i - 1].clone();
-
-        vec.crossVectors(tangents[i - 1], tangents[i]);
-
-        if (vec.length() > Number.EPSILON) {
-
-            vec.normalize();
-
-            const theta = Math.acos(MathUtils.clamp(tangents[i - 1].dot(tangents[i]), -1, 1)); // clamp for floating pt errors
-
-            normals[i].applyMatrix4(mat.makeRotationAxis(vec, theta));
-
-        }
-
-        binormals[i].crossVectors(tangents[i], normals[i]);
-
-    }
-
-    // if the curve is closed, postprocess the vectors so the first and last normal vectors are the same
-
-    if (closed === true) {
-
-        let theta = Math.acos(MathUtils.clamp(normals[0].dot(normals[segments]), -1, 1));
-        theta /= segments;
-
-        if (tangents[0].dot(vec.crossVectors(normals[0], normals[segments])) > 0) {
-
-            theta = -theta;
-
-        }
-
-        for (let i = 1; i <= segments; i++) {
-
-            // twist a little...
-            normals[i].applyMatrix4(mat.makeRotationAxis(tangents[i], theta * i));
-            binormals[i].crossVectors(tangents[i], normals[i]);
-
-        }
-
-    }
-
-    return {
-        tangents: tangents,
-        normals: normals,
-        binormals: binormals
-    };
-}
-
-/**
- * @see https://github.com/mrdoob/three.js/blob/master/src/geometries/TubeGeometry.js
- * @param {Vector3[]} points
- * @param {Vector3[]} _normals
- * @param {Vector3[]} binormals
- * @param {number} radius
- * @param {number} radialSegments
- * @param {boolean} [closed]
- * @returns {BufferGeometry}
- */
-function makeTubeGeometry(points, _normals, binormals, radius, radialSegments, closed = false) {
-    const geometry = new BufferGeometry();
-    // helper variables
-
-    const vertex = new Vector3();
-    const normal = new Vector3();
-
-    // buffer
-
-    const vertices = [];
-    const normals = [];
-    const uvs = [];
-    const indices = [];
-
-    const tubularSegments = points.length - 1;
-
-    // create buffer data
-
-    generateBufferData();
-
-    // build geometry
-
-    geometry.setIndex(indices);
-    geometry.setAttribute('position', new Float32BufferAttribute(vertices, 3));
-    geometry.setAttribute('normal', new Float32BufferAttribute(normals, 3));
-    geometry.setAttribute('uv', new Float32BufferAttribute(uvs, 2));
-
-    // functions
-
-    function generateBufferData() {
-
-        for (let i = 0; i < tubularSegments; i++) {
-
-            generateSegment(i);
-
-        }
-
-        // if the geometry is not closed, generate the last row of vertices and normals
-        // at the regular position on the given path
-        //
-        // if the geometry is closed, duplicate the first row of vertices and normals (uvs will differ)
-
-        generateSegment((closed === false) ? tubularSegments : 0);
-
-        // uvs are generated in a separate function.
-        // this makes it easy compute correct values for closed geometries
-
-        generateUVs();
-
-        // finally create faces
-
-        generateIndices();
-
-    }
-
-    function generateSegment(i) {
-
-        // we use getPointAt to sample evenly distributed points from the given path
-
-        const P = points[i];
-
-        // retrieve corresponding normal and binormal
-
-        const N = _normals[i];
-        const B = binormals[i];
-
-        // generate normals and vertices for the current segment
-
-        for (let j = 0; j <= radialSegments; j++) {
-
-            const v = j / radialSegments * Math.PI * 2;
-
-            const sin = Math.sin(v);
-            const cos = -Math.cos(v);
-
-            // normal
-
-            normal.x = (cos * N.x + sin * B.x);
-            normal.y = (cos * N.y + sin * B.y);
-            normal.z = (cos * N.z + sin * B.z);
-            normal.normalize();
-
-            normals.push(normal.x, normal.y, normal.z);
-
-            // vertex
-
-            vertex.x = P.x + radius * normal.x;
-            vertex.y = P.y + radius * normal.y;
-            vertex.z = P.z + radius * normal.z;
-
-            vertices.push(vertex.x, vertex.y, vertex.z);
-
-        }
-
-    }
-
-    function generateIndices() {
-        let i = 0, j = 0;
-
-        for (j = 1; j <= tubularSegments; j++) {
-
-            for (i = 1; i <= radialSegments; i++) {
-
-                const a = (radialSegments + 1) * (j - 1) + (i - 1);
-                const b = (radialSegments + 1) * j + (i - 1);
-                const c = (radialSegments + 1) * j + i;
-                const d = (radialSegments + 1) * (j - 1) + i;
-
-                // faces
-
-                indices.push(a, b, d);
-                indices.push(b, c, d);
-
-            }
-
-        }
-
-    }
-
-    function generateUVs() {
-        let i = 0, j = 0;
-
-        for (i = 0; i <= tubularSegments; i++) {
-
-            const u = i / tubularSegments;
-
-            for (j = 0; j <= radialSegments; j++) {
-
-                const v = j / radialSegments;
-
-                uvs.push(u, v);
-
-            }
-
-        }
-
-    }
-
-
-    return geometry;
-}
-
-/**
- *
- * @param {Path} path
- * @returns {number}
- */
-function estimatePathLength(path) {
-
-    if (path.interpolation === InterpolationType.Linear) {
-        return path.getLength();
-    } else {
-        return estimatePathViaIterativeIntegral(path, 0.01);
-    }
-
-}
-
-/**
- *
- * @param {THREE.Vector3[]} points
- * @param {number} point_count
- * @param {TubePathStyle} style
- * @return {BufferGeometry}
- */
-function build_geometry_linear(points, point_count, style) {
-
-    const frames = computeFrenetFrames(points, false);
-
-    return makeTubeGeometry(points, frames.normals, frames.binormals, style.width, style.radial_resolution, false);
-}
-
-/**
- *
- * @param {THREE.Vector3[]} points
- * @param {number} point_count
- * @param {TubePathStyle} style
- * @return {BufferGeometry}
- */
-function build_geometry_catmullrom(points, point_count, style) {
-
-    const path = new CatmullRomCurve3(points, false, "centripetal");
-
-    return new TubeGeometry(path, style.resolution * point_count, style.width, style.radial_resolution, false);
-
-}
-
-export class TubePathBuilder {
-    constructor() {
-        /**
-         *
-         * @type {TubePathStyle|null}
-         */
-        this.style = null;
-
-        /**
-         *
-         * @type {Path|null}
-         */
-        this.path = null;
-
-        /**
-         *
-         * @type {MaterialManager|null}
-         */
-        this.materials = null;
-
-        /**
-         *
-         * @type {AssetManager|null}
-         */
-        this.assetManager = null;
-    }
-
-    setPath(path) {
-        this.path = path;
-    }
-
-    setStyle(style) {
-        this.style = style;
-    }
-
-    setMaterials(m) {
-        this.materials = m;
-    }
-
-    setAssetManager(assetManager) {
-        this.assetManager = assetManager;
-    }
-
-    /**
-     *
-     * @param {EntityBuilder[]} destination
-     */
-    build(destination) {
-        const style = this.style;
-
-        // generate three.js curve from path
-        const path_component = this.path;
-
-        const three_points = [];
-
-        const pointCount = path_component.getPointCount();
-
-        if (pointCount < 2) {
-            // no curve possible without at least 2 points
-            return;
-        }
-
-        for (let i = 0; i < pointCount; i++) {
-            const v3 = new Vector3();
-
-            path_component.getPosition(i, v3);
-
-            three_points.push(v3);
-        }
-
-
-        /**
-         * @type {THREE.BufferGeometry}
-         */
-        let geometry;
-
-        if (path_component.interpolation === InterpolationType.Linear) {
-            geometry = build_geometry_linear(three_points, pointCount, style);
-        } else if (path_component.interpolation === InterpolationType.CatmullRom) {
-            geometry = build_geometry_catmullrom(three_points, pointCount, style);
-        } else {
-            throw new Error(`Unsupported interpolation type '${path_component.interpolation}'`);
-        }
-
-
-        let material_def;
-
-        if (style.material_type === TubeMaterialType.Standard) {
-            material_def = new MeshStandardMaterial({
-                metalness: style.material.metalness,
-                roughness: style.material.roughness
-            });
-        } else if (style.material_type === TubeMaterialType.Matcap) {
-
-            material_def = new MeshMatcapMaterial();
-
-            this.assetManager.get(style.material.texture, GameAssetType.Texture, asset => {
-                material_def.matcap = asset.create();
-
-                material_def.needsUpdate = true;
-            }, console.error);
-
-        } else {
-            throw new Error(`Unsupported material type '${style.material_type}'`);
-        }
-
-        material_def.color.set(style.color.toUint());
-
-        if (style.opacity < 1) {
-            material_def.transparent = true;
-            material_def.opacity = style.opacity;
-        }
-
-        const entityBuilder = new EntityBuilder();
-
-        entityBuilder.add(new Transform());
-        entityBuilder.add(new Renderable(ThreeFactory.createMesh(geometry, material_def)));
-
-        destination.push(entityBuilder);
-    }
-}