tela.js 1.2.8 → 1.2.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tela.js",
-  "version": "1.2.8",
+  "version": "1.2.10",
   "author": "Pedroth",
   "repository": {
     "type": "git",

package/src/Geometry/Line.js

@@ -5,6 +5,8 @@ import { clamp } from "../Utils/Math.js";
 import Vec, { Vec2, Vec3 } from "../Vector/Vector.js";
 import { generateUniqueID } from "../Utils/Utils.js";
 
+const clamp01 = clamp();
+
 export default class Line {
     constructor({ name, positions, colors, texCoords, normals, texture, radius, emissive, material }) {
         this.name = name;
@@ -32,7 +34,9 @@ export default class Line {
     distanceToPoint(p) {
         const l = this.edge;
         const v = p.sub(this.positions[0]);
-        const h = clamp()(l.dot(v) / l.dot(l))
+        const sqLength = l.dot(l);
+        if(sqLength < 1e-6) return Number.MAX_VALUE
+        const h = clamp01(l.dot(v) / sqLength);
         return p.sub(this.positions[0].add(l.scale(h))).length() - this.radius;
     }
 

package/src/Geometry/Triangle.js

@@ -38,54 +38,99 @@ export default class Triangle {
         this.invU2 = Vec2(-c, a).scale(detInv);
     }
 
+    getBarycentricCoords(p) {
+        const r = p.sub(this.positions[0]);
+        const x = Vec2(this.tangents[0].dot(r), this.tangents[1].dot(r));
+        let alpha = Vec2(this.invU1.dot(x), this.invU2.dot(x));
+        const sum = alpha.fold((e, x) => e + x, 0)
+        return Vec3(alpha.x, alpha.y, 1 - sum);
+    }
+
     getBoundingBox() {
+        const n = this.positions[0].dim;
         if (this.boundingBox) return this.boundingBox;
-        this.boundingBox = this.positions.reduce((box, x) => box.add(new Box(x, x)), Box.EMPTY);
+        const r = Vec.ONES(n).scale(this.radius)
+        this.boundingBox = this.positions.reduce((box, x) => box.add(new Box(x.sub(r), x.add(r))), Box.EMPTY);
         return this.boundingBox;
     }
 
     distanceToPoint(p) {
-        const r = p.sub(this.positions[0]);
-        if (this.isDegenerate) return r.length() - this.radius;
-        const x = Vec2(this.tangents[0].dot(r), this.tangents[1].dot(r));
-        let alpha = Vec2(this.invU1.dot(x), this.invU2.dot(x)).map(x => x < 0 ? 0 : x);
-        const sum = alpha.fold((e, x) => e + x, 0)
-        if (sum > 1) {
-            alpha = alpha.scale(1 / sum);
-        }
+        let alpha = this.getBarycentricCoords(p).map(x => Math.max(0, x));
+        const sum = alpha.fold((e, x) => e + x, 0);
+
+        // if (sum === 1) {
+        //     const r0 = p.sub(this.positions[0]);
+        //     const r1 = p.sub(this.positions[1]);
+        //     const r2 = p.sub(this.positions[2]);
+        //     return -Math.min(
+        //         r0.sub(this.edges[0].scale(this.edges[0].dot(r0) / this.edges[0].dot(this.edges[0]))).length(),
+        //         r1.sub(this.edges[1].scale(this.edges[1].dot(r1) / this.edges[1].dot(this.edges[1]))).length(),
+        //         r2.sub(this.edges[2].scale(this.edges[2].dot(r2) / this.edges[2].dot(this.edges[2]))).length()
+        //     )
+        // }
+
+        alpha = alpha.scale(1 / sum);
         const pointOnTriangle = this.positions[0]
             .add(
                 this.tangents[0].scale(alpha.x)
-                    .add(
-                        this.tangents[1].scale(alpha.y)
-                    )
-            )
+                    .add(this.tangents[1].scale(alpha.y))
+            );
         return p.sub(pointOnTriangle).length() - this.radius;
     }
 
     normalToPoint(p) {
-        // fixes problem in ray tracing
-        const r = p.sub(this.positions[0]);
-        const dot = this.faceNormal.dot(r);
-        return dot < 1e-3 ? this.faceNormal : this.faceNormal.scale(-1);
+        if (this.radius === 0) {
+            const r = p.sub(this.positions[0]);
+            const dot = this.faceNormal.dot(r);
+            return dot < 1e-3 ? this.faceNormal : this.faceNormal.scale(-1);
+        }
+        const epsilon = 1e-6;
+        const f = this.distanceToPoint(p);
+        const sign = Math.sign(f);
+        const grad = Vec3(
+            this.distanceToPoint(p.add(Vec3(epsilon, 0, 0))) - f,
+            this.distanceToPoint(p.add(Vec3(0, epsilon, 0))) - f,
+            this.distanceToPoint(p.add(Vec3(0, 0, epsilon))) - f,
+        ).normalize();
+        return grad.scale(sign);
     }
 
     interceptWithRay(ray) {
-        const epsilon = 1e-9
-        const v = ray.dir;
-        const p = ray.init.sub(this.positions[0]);
-        const n = this.faceNormal;
-        const t = - n.dot(p) / n.dot(v);
-        if (t <= epsilon) return;
-        const x = ray.trace(t);
-        for (let i = 0; i < this.positions.length; i++) {
-            const xi = this.positions[i];
-            const u = x.sub(xi);
-            const ni = n.cross(this.edges[i]);
-            const dot = ni.dot(u);
-            if (dot <= epsilon) return;
+        if(this.radius === 0) {
+            const epsilon = 1e-9
+            const v = ray.dir;
+            const p = ray.init.sub(this.positions[0]);
+            const n = this.faceNormal;
+            const t = - n.dot(p) / n.dot(v);
+            if (t <= epsilon) return;
+            const x = ray.trace(t);
+            for (let i = 0; i < this.positions.length; i++) {
+                const xi = this.positions[i];
+                const u = x.sub(xi);
+                const ni = n.cross(this.edges[i]);
+                const dot = ni.dot(u);
+                if (dot <= epsilon) return;
+            }
+            return [t - epsilon, x, this];
+        }
+        const maxIte = 20;
+        const epsilon = 1e-3;
+        let p = ray.init;
+        let t = this.distanceToPoint(p);
+        let minT = t;
+        for (let i = 0; i < maxIte; i++) {
+            p = ray.trace(t);
+            const d = this.distanceToPoint(p);
+            t += d;
+            if (d < epsilon) {
+                return [t, p, this];
+            }
+            if (d > minT) {
+                break;
+            }
+            minT = d;
         }
-        return [t - epsilon, x, this];
+        return;
     }
 
     sample() {
@@ -138,7 +183,7 @@ class TriangleBuilder {
         this._colors = indx.map(() => Color.BLACK);
         this._positions = indx.map(() => Vec3());
         this._texCoords = [Vec2(), Vec2(1, 0), Vec2(0, 1)];
-        this._radius = 1;
+        this._radius = 0.0;
         this._emissive = false;
         this._material = Diffuse();
     }

package/src/Scene/KScene.js

@@ -139,7 +139,7 @@ export default class KScene extends NaiveScene {
         debugScene = debugScene || new NaiveScene();
         if (level === 0) {
             let maxLevels = Math.round(Math.log2(node.numberOfLeafs / this.k)) + 1;
-            maxLevels = maxLevels === 0 ? 1 : maxLevels;
+            maxLevels = maxLevels <= 0 ? 1 : maxLevels;
             for (let i = 0; i <= maxLevels; i++)
                 level2colors.push(
                     Color.RED.scale(1 - i / maxLevels).add(Color.BLUE.scale(i / maxLevels))
@@ -220,7 +220,7 @@ class Node {
     }
 
     distanceToPoint(p) {
-        if(!this.left && !this.right) return Number.MAX_VALUE;
+        if (!this.left && !this.right) return Number.MAX_VALUE;
         return this.getElementNear(p).distanceToPoint(p);
     }
 

package/src/Tela/telaWorker.js

@@ -3,6 +3,8 @@ import { memoize } from "../Utils/Utils.js";
 // necessary to load this even though is not used in the code, it might be used in the eval.
 import Color from "../Color/Color.js";
 import Box from "../Geometry/Box.js";
+import Triangle from "../Geometry/Triangle.js";
+import Line from "../Geometry/Line.js";
 import Vec, { Vec2, Vec3 } from "../Vector/Vector.js";
 import Camera from "../Camera/Camera.js";
 import Ray from "../Ray/Ray.js";
@@ -27,7 +29,7 @@ async function main(inputs) {
     for (let i = __startRow; i < __endRow; i++) {
         for (let x = 0; x < __width; x++) {
             const y = __height - 1 - i;
-            const color = func(x, y, __vars);
+            const color = await func(x, y, __vars);
             if (!color) continue;
             image[index++] = color.red;
             image[index++] = color.green;