tela.js 1.0.0

package/src/Vector/Vector.js

@@ -0,0 +1,495 @@
+//========================================================================================
+/*                                                                                      *
+ *                                         UTILS                                        *
+ *                                                                                      */
+//========================================================================================
+
+const ARRAY_TYPES = {
+  Float32Array: Float32Array,
+  Float64Array: Float64Array,
+};
+//stateful function
+function _sanitize_input(arrayIn, arrayOut) {
+  for (let i = 0; i < arrayIn.length; i++) {
+    const z = arrayIn[i];
+    const zIsNumber = z !== null && z !== undefined && typeof z === "number";
+    arrayOut[i] = zIsNumber ? z : 0;
+  }
+  return arrayOut;
+}
+
+function sameSizeOrError(a, b) {
+  if (a.n === b.n) {
+    return true;
+  }
+  throw new VectorException("Vector must have same size");
+}
+
+//========================================================================================
+/*                                                                                      *
+ *                                        VECTOR                                        *
+ *                                                                                      */
+//========================================================================================
+
+/** Dense Vector data structure
+ *
+ * Immutable class, not managing exceptions
+ * For is faster than reduce, forEach, maps, perf here: https://replit.com/@pedroth/forVsForEach#index.js
+ * Didn't use private vars because of performance
+ */
+export default class Vec {
+  constructor(array) {
+    this._vec = array;
+    this._n = this._vec.length;
+  }
+
+  get n() {
+    return this._n;
+  }
+
+  get dim() {
+    return this._n;
+  }
+
+  size = () => this._n;
+  shape = () => [this._n];
+
+  clone() {
+    return new Vec(COPY_VEC(this._vec));
+  }
+
+  /**index starts at zero */
+  get(i) {
+    return this._vec[i];
+  }
+
+  toArray() {
+    return COPY_VEC(this._vec);
+  }
+
+  toString() {
+    return "[" + this._vec.join(", ") + "]";
+  }
+
+  serialize() {
+    return this._vec.join(", ");
+  }
+
+  add(u) {
+    return this.op(u, (a, b) => a + b);
+  }
+
+  sub(u) {
+    return this.op(u, (a, b) => a - b);
+  }
+
+  mul(u) {
+    return this.op(u, (a, b) => a * b);
+  }
+
+  div(u) {
+    return this.op(u, (a, b) => a / b);
+  }
+
+  dot(u) {
+    // didn't use reduce because this is faster
+    let acc = 0;
+    for (let i = 0; i < this._n; i++) {
+      acc += this._vec[i] * u._vec[i];
+    }
+    return acc;
+  }
+
+  squareLength() {
+    return this.dot(this);
+  }
+
+  length() {
+    return Math.sqrt(this.dot(this));
+  }
+
+  normalize() {
+    return this.scale(1 / this.length());
+  }
+
+  scale(r) {
+    return this.map((z) => z * r);
+  }
+
+  map(lambda) {
+    const ans = BUILD_VEC(this._n);
+    for (let i = 0; i < this._n; i++) {
+      ans[i] = lambda(this._vec[i], i);
+    }
+    return new Vec(ans);
+  }
+
+  /**
+   *
+   * @param {*} u: Vec
+   * @param {*} operation: (a,b) => op(a,b)
+   */
+  op(u, operation) {
+    sameSizeOrError(this, u);
+    const ans = BUILD_VEC(this._n);
+    for (let i = 0; i < this._n; i++) {
+      ans[i] = operation(this._vec[i], u._vec[i]);
+    }
+    return new Vec(ans);
+  }
+
+  reduce(fold, init = 0) {
+    let acc = init;
+    for (let i = 0; i < this._n; i++) {
+      acc = fold(acc, this._vec[i], i);
+    }
+    return acc;
+  }
+
+  fold = this.reduce;
+  foldLeft = this.fold;
+
+  equals(u, precision = 1e-5) {
+    if (!(u instanceof Vec)) return false;
+    return this.sub(u).length() < precision;
+  }
+
+  take(n = 0, m = this._vec.length) {
+    return new Vec(this._vec.slice(n, m));
+  }
+
+  findIndex(predicate) {
+    for (let i = 0; i < this._n; i++) {
+      if (predicate(this._vec[i])) return i;
+    }
+    return -1;
+  }
+
+  static fromArray(array) {
+    if (array.length === 2) return Vector2.fromArray(array);
+    if (array.length === 3) return Vector3.fromArray(array);
+    return new Vec(_sanitize_input(array, BUILD_VEC(array.length)));
+  }
+
+  static of(...values) {
+    if (values.length === 2) return Vector2.of(...values);
+    if (values.length === 3) return Vector3.of(...values);
+    return new Vec(_sanitize_input(values, BUILD_VEC(values.length)));
+  }
+
+  static ZERO = (n) =>
+    n === 3 ? new Vector3() : n === 2 ? new Vector2() : new Vec(BUILD_VEC(n));
+
+  static ONES = (n) => {
+    if (n === 2) return Vector2.ONES;
+    if (n === 3) return Vector3.ONES;
+    return Vec.ZERO(n).map(() => 1);
+  };
+
+  static e = (n) => (i) => {
+    if (n === 2) return Vector2.e(i);
+    if (n === 3) return Vector3.e(i);
+    const vec = BUILD_VEC(n);
+    if (i >= 0 && i < n) {
+      vec[i] = 1;
+    }
+    return new Vec(vec);
+  };
+
+  static RANDOM = (n) => {
+    if (n === 2) return Vector2.RANDOM();
+    if (n === 3) return Vector3.RANDOM();
+    const v = BUILD_VEC(n);
+    for (let i = 0; i < n; i++) {
+      v[i] = Math.random();
+    }
+    return new Vec(v);
+  };
+}
+
+export const BUILD_VEC = (n) => new ARRAY_TYPES.Float64Array(n);
+export const COPY_VEC = (array) => ARRAY_TYPES.Float64Array.from(array);
+export class VectorException extends Error { }
+
+export const Vec3 = (x = 0, y = 0, z = 0) => new Vector3(x, y, z);
+export const Vec2 = (x = 0, y = 0) => new Vector2(x, y);
+
+class Vector3 {
+  constructor(x = 0, y = 0, z = 0) {
+    this.x = x;
+    this.y = y;
+    this.z = z;
+
+  }
+
+  get n() {
+    return 3;
+  }
+
+  get dim() {
+    return 3;
+  }
+
+  size = () => 3;
+  shape = () => [3];
+
+  clone() {
+    return new Vector3(this.x, this.y, this.z);
+  }
+
+  /**index starts at zero */
+  get(i) {
+    return [this.x, this.y, this.z][i]
+  }
+
+  toArray() {
+    return [this.x, this.y, this.z];
+  }
+
+  toString() {
+    return "[" + this.toArray().join(", ") + "]";
+  }
+
+  serialize() {
+    return this.toArray().join(", ");
+  }
+
+  add(u) {
+    return this.op(u, (a, b) => a + b);
+  }
+
+  sub(u) {
+    return this.op(u, (a, b) => a - b);
+  }
+
+  mul(u) {
+    return this.op(u, (a, b) => a * b);
+  }
+
+  div(u) {
+    return this.op(u, (a, b) => a / b);
+  }
+
+  dot(u) {
+    return this.x * u.x + this.y * u.y + this.z * u.z;
+  }
+
+  squareLength() {
+    return this.dot(this);
+  }
+
+  length() {
+    return Math.sqrt(this.dot(this));
+  }
+
+  normalize() {
+    return this.scale(1 / this.length());
+  }
+
+  scale(r) {
+    return this.map((z) => z * r);
+  }
+
+  map(lambda) {
+    return new Vector3(lambda(this.x, 0), lambda(this.y, 1), lambda(this.z, 2));
+  }
+
+  /**
+   *
+   * @param {*} y: Vec
+   * @param {*} operation: (a,b) => op(a,b)
+   */
+  op(u, operation) {
+    return new Vector3(
+      operation(this.x, u.x),
+      operation(this.y, u.y),
+      operation(this.z, u.z)
+    );
+  }
+
+  reduce(fold, init = 0) {
+    let acc = init;
+    acc = fold(acc, this.x);
+    acc = fold(acc, this.y);
+    acc = fold(acc, this.z);
+    return acc;
+  }
+
+  fold = this.reduce;
+  foldLeft = this.fold;
+
+  equals(u, precision = 1e-5) {
+    if (!(u instanceof Vector3)) return false;
+    return this.sub(u).length() < precision;
+  }
+
+  take(n = 0, m = 3) {
+    const array = [this.x, this.y, this.z].slice(n, m);
+    if (array.length === 2) return Vector2.fromArray(array);
+    if (array.length === 3) return Vector3.fromArray(array);
+    return Vec.fromArray(array);
+  }
+
+  findIndex(predicate) {
+    if (predicate(this.x)) return 0;
+    if (predicate(this.y)) return 1;
+    if (predicate(this.z)) return 2;
+    return -1;
+  }
+
+  static fromArray(array) {
+    return new Vector3(...array);
+  }
+
+  static of(...values) {
+    return new Vector3(...values);
+  }
+
+  static e = (i) => {
+    if (i === 0) return new Vector3(1, 0, 0);
+    if (i === 1) return new Vector3(0, 1, 0);
+    if (i === 2) return new Vector3(0, 0, 1);
+    return new Vec3();
+  };
+
+  static RANDOM = () => {
+    return new Vector3(Math.random(), Math.random(), Math.random());
+  };
+
+  static ONES = new Vector3(1, 1, 1);
+}
+
+class Vector2 {
+  constructor(x = 0, y = 0) {
+    this.x = x;
+    this.y = y;
+  }
+
+  get n() {
+    return 2;
+  }
+
+  get dim() {
+    return 2;
+  }
+
+  size = () => 2;
+  shape = () => [2];
+
+  clone() {
+    return new Vector2(this.x, this.y);
+  }
+
+  /**index starts at zero */
+  get(i) {
+    return [this.x, this.y][i]
+  }
+
+  toArray() {
+    return [this.x, this.y];
+  }
+
+  toString() {
+    return "[" + this.toArray().join(", ") + "]";
+  }
+
+  serialize() {
+    return this.toArray().join(", ");
+  }
+
+  add(u) {
+    return this.op(u, (a, b) => a + b);
+  }
+
+  sub(u) {
+    return this.op(u, (a, b) => a - b);
+  }
+
+  mul(u) {
+    return this.op(u, (a, b) => a * b);
+  }
+
+  div(u) {
+    return this.op(u, (a, b) => a / b);
+  }
+
+  dot(u) {
+    return this.x * u.x + this.y * u.y;
+  }
+
+  squareLength() {
+    return this.dot(this);
+  }
+
+  length() {
+    return Math.sqrt(this.dot(this));
+  }
+
+  normalize() {
+    return this.scale(1 / this.length());
+  }
+
+  scale(r) {
+    return this.map((z) => z * r);
+  }
+
+  map(lambda) {
+    return new Vector2(lambda(this.x, 0), lambda(this.y, 1));
+  }
+
+  /**
+   *
+   * @param {*} y: Vec
+   * @param {*} operation: (a,b) => op(a,b)
+   */
+  op(u, operation) {
+    return new Vector2(operation(this.x, u.x), operation(this.y, u.y));
+  }
+
+  reduce(fold, init = 0) {
+    let acc = init;
+    acc = fold(acc, this.x);
+    acc = fold(acc, this.y);
+    return acc;
+  }
+
+  fold = this.reduce;
+  foldLeft = this.fold;
+
+  equals(u, precision = 1e-5) {
+    if (!(u instanceof Vector2)) return false;
+    return this.sub(u).length() < precision;
+  }
+
+  take(n = 0, m = 2) {
+    const array = [this.x, this.y].slice(n, m);
+    if (array.length === 2) return Vector2.fromArray(array);
+    return Vec.fromArray(array);
+  }
+
+  findIndex(predicate) {
+    if (predicate(this.x)) return 0;
+    if (predicate(this.y)) return 1;
+    return -1;
+  }
+
+  static fromArray(array) {
+    return new Vector2(...array);
+  }
+
+  static of(...values) {
+    return new Vector2(...values);
+  }
+
+  static e = (i) => {
+    if (i === 0) return new Vector2(1, 0);
+    if (i === 1) return new Vector2(0, 1);
+    return new Vector2();
+  };
+
+  static RANDOM = () => {
+    return new Vector2(Math.random(), Math.random());
+  };
+
+  static ONES = new Vector2(1, 1);
+}

package/src/index.js

@@ -0,0 +1,32 @@
+import Animation from "./Animation/Animation.js"
+import Canvas from "./Canvas/Canvas.js"
+import Color from "./Color/Color.js"
+import DOM from "./DomBuilder/DomBuilder.js"
+import Stream from "./Stream/Stream.js"
+import Camera from "./Camera/Camera.js"
+import Scene from "./Scene/Scene.js"
+import NaiveScene from "./Scene/NaiveScene.js"
+import Vec, { Vec2, Vec3 } from "./Vector/Vector.js"
+import Box from "./Box/Box.js"
+import Point from "./Scene/Point.js"
+import Mesh from "./Scene/Mesh.js"
+
+export {
+    Box,
+    DOM,
+    Vec,
+    Mesh,
+    Vec2,
+    Vec3,
+    Color,
+    Point,
+    Scene,
+    Canvas,
+    Camera,
+    Stream,
+    Animation,
+    NaiveScene,
+}
+
+export * as Utils from "./Utils/Utils.js";
+export * as Monads from "./Monads/Monads.js";

package/src/index.node.js

@@ -0,0 +1,5 @@
+export * from "./index.js";
+import * as IO from "./IO/IO.js"
+import Image from "./Image/Image.js"
+
+export { IO, Image };

package/test/node/amazing_shader.js

@@ -0,0 +1,56 @@
+import { Color, Image, Stream, IO, Utils } from "../../dist/node/index.js";
+const { measureTime } = Utils;
+const { saveStreamToFile } = IO;
+
+const width = 640;
+const height = 480;
+const clamp = x => Math.max(Math.min(1, x), 0);
+function palette(t) {
+    let a = [0.5, 0.5, 0.5];
+    let b = [0.5, 0.5, 0.5];
+    let c = [1.0, 1.0, 1.0];
+    let d = [0.263, 0.416, 0.557];
+    return [a[0] + b[0] * Math.cos(6.28318 * (c[0] * t + d[0])), a[1] + b[1] * Math.cos(6.28318 * (c[1] * t + d[1])), a[2] + b[2] * Math.cos(6.28318 * (c[2] * t + d[2]))];
+}
+
+const imageStream = new Stream(
+    { time: 0, image: Image.ofSize(width, height) },
+    ({ time, image }) => {
+        const dt = 0.01; // 100 FPS
+        return {
+            time: time + dt,
+            image: image
+                .map((x, y) => {
+                    let u = (2 * x - width) / height
+                    let v = (2 * y - height) / height;
+                    const u0 = u;
+                    const v0 = v;
+                    let finalColor = [0, 0, 0]
+                    for (let i = 0; i < 4; i++) {
+                        u = (u * 1.5 - Math.floor(u * 1.5)) - 0.5;
+                        v = (v * 1.5 - Math.floor(v * 1.5)) - 0.5;
+                        const d0 = -Math.sqrt(u0 * u0 + v0 * v0);
+                        let d = Math.sqrt(u * u + v * v) * Math.exp(d0);
+                        const col = palette(d0 + i * 0.4 + time * 0.4);
+                        d = Math.sin(d * 8 + time) / 8;
+                        d = Math.abs(d);
+                        d = Math.pow(0.01 / d, 1.2);
+
+                        finalColor = [finalColor[0] + col[0] * d, finalColor[1] + col[1] * d, finalColor[2] + col[2] * d]
+                    }
+                    return Color.ofRGB(clamp(finalColor[0]), clamp(finalColor[1]), clamp(finalColor[2]));
+                })
+        }
+    }
+)
+
+console.log(
+    "Video created in: ",
+    measureTime(() => {
+        saveStreamToFile(
+            "./amazing.mp4",
+            imageStream,
+            { fps: 100 }
+        ).until(({ time }) => time < 5)
+    })
+)

package/test/node/bunny.js

@@ -0,0 +1,55 @@
+import { Color, Image, Stream, IO, Utils, Mesh, Vec3, Scene, Camera } from "../../dist/node/index.js";
+import { readFileSync } from "fs"
+
+const { measureTime } = Utils;
+const { saveStreamToFile } = IO;
+
+const measureTime2 = lambda => {
+    const t = performance.now();
+    const ans = lambda()
+    return [ans, 1e-3 * (performance.now() - t)];
+}
+
+const width = 640;
+const height = 480;
+
+// scene
+const scene = new Scene()
+const camera = new Camera({ sphericalCoords: Vec3(5, 0, 0) });
+const stanfordBunnyObj = readFileSync("./assets/bunny.obj", { encoding: "utf-8" });
+let bunnyMesh = Mesh.readObj(stanfordBunnyObj);
+const bunnyBox = bunnyMesh.getBoundingBox();
+bunnyMesh = bunnyMesh
+    .mapVertices(v => v.sub(bunnyBox.min).div(bunnyBox.diagonal).scale(2).sub(Vec3(1, 1, 1)))
+    .mapVertices(v => Vec3(-v.y, v.x, v.z))
+    .mapVertices(v => Vec3(v.z, v.y, -v.x))
+    .mapColors(v => Color.ofRGB(...v.map(x => Math.max(0, Math.min(1, 0.5 * (x + 1)))).toArray()));
+scene.add(...bunnyMesh.asPoints("bunny", 0.05));
+
+const imageStream = new Stream(
+    { time: 0, image: camera.sceneShot(scene).to(Image.ofSize(width, height)) },
+    ({ time, image }) => {
+        const dt = 0.04; // 25 FPS
+        const theta = Math.PI / 4 * time;
+        camera.sphericalCoords = Vec3(camera.sphericalCoords.get(0), theta, 0);
+        camera.orbit();
+        const [newImage, t] = measureTime2(() => camera.sceneShot(scene).to(image));
+        console.log(`Image took ${t}s`);
+        return {
+            time: time + dt,
+            image: newImage
+        };
+    }
+)
+
+console.log(
+    "Video created in: ",
+    measureTime(() => {
+        saveStreamToFile(
+            "./bunny_stream.mp4",
+            imageStream,
+            { fps: 25 }
+        ).until(({ time }) => time < 10);
+    })
+)
+