three-stdlib 2.14.1 → 2.15.0

package/geometries/ParametricGeometries.js

@@ -1,4 +1,5 @@
-import { Vector3, ParametricGeometry, BufferGeometry, Curve } from 'three';
+import { Vector3, Curve } from 'three';
+import { ParametricGeometry } from './ParametricGeometry.js';
 
 /**
  * Experimenting of primitive geometry creation using Surface Parametric equations
@@ -9,7 +10,7 @@ const ParametricGeometries = {
     u *= Math.PI;
     v *= 2 * Math.PI;
     u = u * 2;
-    let x, y, z;
+    let x, z;
 
     if (u < Math.PI) {
       x = 3 * Math.cos(u) * (1 + Math.sin(u)) + 2 * (1 - Math.cos(u) / 2) * Math.cos(u) * Math.cos(v);
@@ -19,11 +20,11 @@ const ParametricGeometries = {
       z = -8 * Math.sin(u);
     }
 
-    y = -2 * (1 - Math.cos(u) / 2) * Math.sin(v);
+    const y = -2 * (1 - Math.cos(u) / 2) * Math.sin(v);
     target.set(x, y, z);
   },
   plane: function (width, height) {
-    return (u, v, target) => {
+    return function (u, v, target) {
       const x = u * width;
       const y = 0;
       const z = v * height;
@@ -35,11 +36,10 @@ const ParametricGeometries = {
     // http://www.wolframalpha.com/input/?i=M%C3%B6bius+strip+parametric+equations&lk=1&a=ClashPrefs_*Surface.MoebiusStrip.SurfaceProperty.ParametricEquations-
     u = u - 0.5;
     const v = 2 * Math.PI * t;
-    let x, y, z;
     const a = 2;
-    x = Math.cos(v) * (a + u * Math.cos(v / 2));
-    y = Math.sin(v) * (a + u * Math.cos(v / 2));
-    z = u * Math.sin(v / 2);
+    const x = Math.cos(v) * (a + u * Math.cos(v / 2));
+    const y = Math.sin(v) * (a + u * Math.cos(v / 2));
+    const z = u * Math.sin(v / 2);
     target.set(x, y, z);
   },
   mobius3d: function (u, t, target) {
@@ -51,10 +51,9 @@ const ParametricGeometries = {
     const major = 2.25,
           a = 0.125,
           b = 0.65;
-    let x, y, z;
-    x = a * Math.cos(t) * Math.cos(phi) - b * Math.sin(t) * Math.sin(phi);
-    z = a * Math.cos(t) * Math.sin(phi) + b * Math.sin(t) * Math.cos(phi);
-    y = (major + x) * Math.sin(u);
+    let x = a * Math.cos(t) * Math.cos(phi) - b * Math.sin(t) * Math.sin(phi);
+    const z = a * Math.cos(t) * Math.sin(phi) + b * Math.sin(t) * Math.cos(phi);
+    const y = (major + x) * Math.sin(u);
     x = (major + x) * Math.cos(u);
     target.set(x, y, z);
   }
@@ -65,123 +64,116 @@ const ParametricGeometries = {
  *
  *********************************************/
 
-ParametricGeometries.TubeGeometry = function (path, segments, radius, segmentsRadius, closed) {
-  this.path = path;
-  this.segments = segments || 64;
-  this.radius = radius || 1;
-  this.segmentsRadius = segmentsRadius || 8;
-  this.closed = closed || false;
-  const scope = this,
-        numpoints = this.segments + 1;
-  const frames = path.computeFrenetFrames(segments, closed),
-        tangents = frames.tangents,
-        normals = frames.normals,
-        binormals = frames.binormals; // proxy internals
-
-  this.tangents = tangents;
-  this.normals = normals;
-  this.binormals = binormals;
-  const position = new Vector3();
-
-  const ParametricTube = (u, v, target) => {
-    v *= 2 * Math.PI;
-    let i = u * (numpoints - 1);
-    i = Math.floor(i);
-    path.getPointAt(u, position);
-    const normal = normals[i];
-    const binormal = binormals[i];
-    const cx = -scope.radius * Math.cos(v); // TODO: Hack: Negating it so it faces outside.
-
-    const cy = scope.radius * Math.sin(v);
-    position.x += cx * normal.x + cy * binormal.x;
-    position.y += cx * normal.y + cy * binormal.y;
-    position.z += cx * normal.z + cy * binormal.z;
-    target.copy(position);
-  };
-
-  ParametricGeometry.call(this, ParametricTube, segments, segmentsRadius);
-};
+ParametricGeometries.TubeGeometry = class TubeGeometry extends ParametricGeometry {
+  constructor(path, segments = 64, radius = 1, segmentsRadius = 8, closed = false) {
+    const numpoints = segments + 1;
+    const frames = path.computeFrenetFrames(segments, closed),
+          tangents = frames.tangents,
+          normals = frames.normals,
+          binormals = frames.binormals;
+    const position = new Vector3();
+
+    function ParametricTube(u, v, target) {
+      v *= 2 * Math.PI;
+      const i = Math.floor(u * (numpoints - 1));
+      path.getPointAt(u, position);
+      const normal = normals[i];
+      const binormal = binormals[i];
+      const cx = -radius * Math.cos(v); // TODO: Hack: Negating it so it faces outside.
+
+      const cy = radius * Math.sin(v);
+      position.x += cx * normal.x + cy * binormal.x;
+      position.y += cx * normal.y + cy * binormal.y;
+      position.z += cx * normal.z + cy * binormal.z;
+      target.copy(position);
+    }
+
+    super(ParametricTube, segments, segmentsRadius); // proxy internals
+
+    this.tangents = tangents;
+    this.normals = normals;
+    this.binormals = binormals;
+    this.path = path;
+    this.segments = segments;
+    this.radius = radius;
+    this.segmentsRadius = segmentsRadius;
+    this.closed = closed;
+  }
 
-ParametricGeometries.TubeGeometry.prototype = Object.create(BufferGeometry.prototype);
-ParametricGeometries.TubeGeometry.prototype.constructor = ParametricGeometries.TubeGeometry;
+};
 /*********************************************
  *
  * Parametric Replacement for TorusKnotGeometry
  *
  *********************************************/
 
-ParametricGeometries.TorusKnotGeometry = function (radius, tube, segmentsT, segmentsR, p, q) {
-  this.radius = radius || 200;
-  this.tube = tube || 40;
-  this.segmentsT = segmentsT || 64;
-  this.segmentsR = segmentsR || 8;
-  this.p = p || 2;
-  this.q = q || 3;
-
-  class TorusKnotCurve extends Curve {
-    constructor() {
-      super();
-    }
+ParametricGeometries.TorusKnotGeometry = class TorusKnotGeometry extends ParametricGeometries.TubeGeometry {
+  constructor(radius = 200, tube = 40, segmentsT = 64, segmentsR = 8, p = 2, q = 3) {
+    class TorusKnotCurve extends Curve {
+      getPoint(t, optionalTarget = new Vector3()) {
+        const point = optionalTarget;
+        t *= Math.PI * 2;
+        const r = 0.5;
+        const x = (1 + r * Math.cos(q * t)) * Math.cos(p * t);
+        const y = (1 + r * Math.cos(q * t)) * Math.sin(p * t);
+        const z = r * Math.sin(q * t);
+        return point.set(x, y, z).multiplyScalar(radius);
+      }
 
-    getPoint(t, optionalTarget) {
-      const point = optionalTarget || new Vector3();
-      t *= Math.PI * 2;
-      const r = 0.5;
-      const x = (1 + r * Math.cos(q * t)) * Math.cos(p * t);
-      const y = (1 + r * Math.cos(q * t)) * Math.sin(p * t);
-      const z = r * Math.sin(q * t);
-      return point.set(x, y, z).multiplyScalar(radius);
     }
 
+    const segments = segmentsT;
+    const radiusSegments = segmentsR;
+    const extrudePath = new TorusKnotCurve();
+    super(extrudePath, segments, tube, radiusSegments, true, false);
+    this.radius = radius;
+    this.tube = tube;
+    this.segmentsT = segmentsT;
+    this.segmentsR = segmentsR;
+    this.p = p;
+    this.q = q;
   }
 
-  const segments = segmentsT;
-  const radiusSegments = segmentsR;
-  const extrudePath = new TorusKnotCurve();
-  ParametricGeometries.TubeGeometry.call(this, extrudePath, segments, tube, radiusSegments, true, false);
 };
-
-ParametricGeometries.TorusKnotGeometry.prototype = Object.create(BufferGeometry.prototype);
-ParametricGeometries.TorusKnotGeometry.prototype.constructor = ParametricGeometries.TorusKnotGeometry;
 /*********************************************
  *
  * Parametric Replacement for SphereGeometry
  *
  *********************************************/
 
-ParametricGeometries.SphereGeometry = function (size, u, v) {
-  function sphere(u, v, target) {
-    u *= Math.PI;
-    v *= 2 * Math.PI;
-    const x = size * Math.sin(u) * Math.cos(v);
-    const y = size * Math.sin(u) * Math.sin(v);
-    const z = size * Math.cos(u);
-    target.set(x, y, z);
+ParametricGeometries.SphereGeometry = class SphereGeometry extends ParametricGeometry {
+  constructor(size, u, v) {
+    function sphere(u, v, target) {
+      u *= Math.PI;
+      v *= 2 * Math.PI;
+      const x = size * Math.sin(u) * Math.cos(v);
+      const y = size * Math.sin(u) * Math.sin(v);
+      const z = size * Math.cos(u);
+      target.set(x, y, z);
+    }
+
+    super(sphere, u, v);
   }
 
-  ParametricGeometry.call(this, sphere, u, v);
 };
-
-ParametricGeometries.SphereGeometry.prototype = Object.create(BufferGeometry.prototype);
-ParametricGeometries.SphereGeometry.prototype.constructor = ParametricGeometries.SphereGeometry;
 /*********************************************
  *
  * Parametric Replacement for PlaneGeometry
  *
  *********************************************/
 
-ParametricGeometries.PlaneGeometry = function (width, depth, segmentsWidth, segmentsDepth) {
-  function plane(u, v, target) {
-    const x = u * width;
-    const y = 0;
-    const z = v * depth;
-    target.set(x, y, z);
+ParametricGeometries.PlaneGeometry = class PlaneGeometry extends ParametricGeometry {
+  constructor(width, depth, segmentsWidth, segmentsDepth) {
+    function plane(u, v, target) {
+      const x = u * width;
+      const y = 0;
+      const z = v * depth;
+      target.set(x, y, z);
+    }
+
+    super(plane, segmentsWidth, segmentsDepth);
   }
 
-  ParametricGeometry.call(this, plane, segmentsWidth, segmentsDepth);
 };
 
-ParametricGeometries.PlaneGeometry.prototype = Object.create(BufferGeometry.prototype);
-ParametricGeometries.PlaneGeometry.prototype.constructor = ParametricGeometries.PlaneGeometry;
-
 export { ParametricGeometries };

package/geometries/ParametricGeometry.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var t=require("three");class e extends t.BufferGeometry{constructor(e=((t,e,s)=>s.set(t,e,Math.cos(t)*Math.sin(e))),s=8,r=8){super(),this.type="ParametricGeometry",this.parameters={func:e,slices:s,stacks:r};const o=[],u=[],c=[],i=[],n=1e-5,a=new t.Vector3,f=new t.Vector3,h=new t.Vector3,l=new t.Vector3,p=new t.Vector3,b=s+1;for(let t=0;t<=r;t++){const o=t/r;for(let t=0;t<=s;t++){const r=t/s;e(r,o,f),u.push(f.x,f.y,f.z),r-n>=0?(e(r-n,o,h),l.subVectors(f,h)):(e(r+n,o,h),l.subVectors(h,f)),o-n>=0?(e(r,o-n,h),p.subVectors(f,h)):(e(r,o+n,h),p.subVectors(h,f)),a.crossVectors(l,p).normalize(),c.push(a.x,a.y,a.z),i.push(r,o)}}for(let t=0;t<r;t++)for(let e=0;e<s;e++){const s=t*b+e,r=t*b+e+1,u=(t+1)*b+e+1,c=(t+1)*b+e;o.push(s,r,c),o.push(r,u,c)}this.setIndex(o),this.setAttribute("position",new t.Float32BufferAttribute(u,3)),this.setAttribute("normal",new t.Float32BufferAttribute(c,3)),this.setAttribute("uv",new t.Float32BufferAttribute(i,2))}}exports.ParametricGeometry=e;

package/geometries/ParametricGeometry.d.ts

@@ -0,0 +1,18 @@
+import { Vector3, BufferGeometry } from 'three';
+
+export class ParametricGeometry extends BufferGeometry {
+    constructor(func?: (u: number, v: number, target: Vector3) => void, slices?: number, stacks?: number);
+
+    /**
+     * @default 'ParametricGeometry'
+     */
+    type: string;
+
+    parameters: {
+        func: (u: number, v: number, dest: Vector3) => void;
+        slices: number;
+        stacks: number;
+    };
+}
+
+export { ParametricGeometry as ParametricBufferGeometry };

package/geometries/ParametricGeometry.js

@@ -0,0 +1,87 @@
+import { BufferGeometry, Vector3, Float32BufferAttribute } from 'three';
+
+/**
+ * Parametric Surfaces Geometry
+ * based on the brilliant article by @prideout https://prideout.net/blog/old/blog/index.html@p=44.html
+ */
+
+class ParametricGeometry extends BufferGeometry {
+  constructor(func = (u, v, target) => target.set(u, v, Math.cos(u) * Math.sin(v)), slices = 8, stacks = 8) {
+    super();
+    this.type = 'ParametricGeometry';
+    this.parameters = {
+      func: func,
+      slices: slices,
+      stacks: stacks
+    }; // buffers
+
+    const indices = [];
+    const vertices = [];
+    const normals = [];
+    const uvs = [];
+    const EPS = 0.00001;
+    const normal = new Vector3();
+    const p0 = new Vector3(),
+          p1 = new Vector3();
+    const pu = new Vector3(),
+          pv = new Vector3(); // generate vertices, normals and uvs
+
+    const sliceCount = slices + 1;
+
+    for (let i = 0; i <= stacks; i++) {
+      const v = i / stacks;
+
+      for (let j = 0; j <= slices; j++) {
+        const u = j / slices; // vertex
+
+        func(u, v, p0);
+        vertices.push(p0.x, p0.y, p0.z); // normal
+        // approximate tangent vectors via finite differences
+
+        if (u - EPS >= 0) {
+          func(u - EPS, v, p1);
+          pu.subVectors(p0, p1);
+        } else {
+          func(u + EPS, v, p1);
+          pu.subVectors(p1, p0);
+        }
+
+        if (v - EPS >= 0) {
+          func(u, v - EPS, p1);
+          pv.subVectors(p0, p1);
+        } else {
+          func(u, v + EPS, p1);
+          pv.subVectors(p1, p0);
+        } // cross product of tangent vectors returns surface normal
+
+
+        normal.crossVectors(pu, pv).normalize();
+        normals.push(normal.x, normal.y, normal.z); // uv
+
+        uvs.push(u, v);
+      }
+    } // generate indices
+
+
+    for (let i = 0; i < stacks; i++) {
+      for (let j = 0; j < slices; j++) {
+        const a = i * sliceCount + j;
+        const b = i * sliceCount + j + 1;
+        const c = (i + 1) * sliceCount + j + 1;
+        const d = (i + 1) * sliceCount + j; // faces one and two
+
+        indices.push(a, b, d);
+        indices.push(b, c, d);
+      }
+    } // build geometry
+
+
+    this.setIndex(indices);
+    this.setAttribute('position', new Float32BufferAttribute(vertices, 3));
+    this.setAttribute('normal', new Float32BufferAttribute(normals, 3));
+    this.setAttribute('uv', new Float32BufferAttribute(uvs, 2));
+  }
+
+}
+
+export { ParametricGeometry };