@remotion/svg-3d-engine 4.0.363 → 4.0.365

package/dist/cjs/matrix.js

@@ -0,0 +1,308 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sub4d = exports.multiplyMatrix = exports.mulScalar = exports.translateZ = exports.translateY = exports.translateX = exports.dot = exports.normalize4d = exports.normalize = exports.scaleY = exports.scaleX = exports.scaled = exports.interpolateMatrix4d = exports.makeMatrix3dTransform = exports.aroundCenterPoint = exports.reduceMatrices = exports.multiplyMatrices = exports.rotateZ = exports.translated4d = exports.rotateY = exports.rotateX = exports.m44multiply = exports.identity4 = exports.stride = void 0;
+exports.multiplyMatrixAndSvgInstruction = multiplyMatrixAndSvgInstruction;
+const truthy_1 = require("./truthy");
+const stride = function ({ v, m, width, offset, colStride, }) {
+    for (let i = 0; i < v.length; i++) {
+        m[i * width + // Column
+            ((i * colStride + offset + width) % width) // Row
+        ] = v[i];
+    }
+    return m;
+};
+exports.stride = stride;
+const identity4 = function () {
+    const n = 4;
+    let size = n * n;
+    const m = new Array(size);
+    while (size--) {
+        m[size] = size % (n + 1) === 0 ? 1.0 : 0.0;
+    }
+    return m;
+};
+exports.identity4 = identity4;
+const m44multiply = (...matrices) => {
+    return multiplyMany(4, matrices);
+};
+exports.m44multiply = m44multiply;
+// Accept an integer indicating the size of the matrices being multiplied (3 for 3x3), and any
+// number of matrices following it.
+function multiplyMany(size, listOfMatrices) {
+    if (listOfMatrices.length < 2) {
+        throw new Error('multiplication expected two or more matrices');
+    }
+    let result = mul(listOfMatrices[0], listOfMatrices[1], size);
+    let next = 2;
+    while (next < listOfMatrices.length) {
+        result = mul(result, listOfMatrices[next], size);
+        next++;
+    }
+    return result;
+}
+function mul(m1, m2, size) {
+    if (m1.length !== m2.length) {
+        throw new Error(`Undefined for matrices of different sizes. m1.length=${m1.length}, m2.length=${m2.length}`);
+    }
+    if (size * size !== m1.length) {
+        throw new Error(`Undefined for non-square matrices. array size was ${size}`);
+    }
+    const result = Array(m1.length);
+    for (let r = 0; r < size; r++) {
+        for (let c = 0; c < size; c++) {
+            // Accumulate a sum of m1[r,k]*m2[k, c]
+            let acc = 0;
+            for (let k = 0; k < size; k++) {
+                acc += m1[size * r + k] * m2[size * k + c];
+            }
+            result[r * size + c] = acc;
+        }
+    }
+    return result;
+}
+const rotated = function (axisVec, radians) {
+    return rotatedUnitSinCos((0, exports.normalize)(axisVec), Math.sin(radians), Math.cos(radians));
+};
+const rotateX = (radians) => {
+    return rotated([1, 0, 0], radians);
+};
+exports.rotateX = rotateX;
+const rotateY = (radians) => {
+    return rotated([0, 1, 0], radians);
+};
+exports.rotateY = rotateY;
+const translated4d = function (vec) {
+    return (0, exports.stride)({ v: vec, m: (0, exports.identity4)(), width: 4, offset: 3, colStride: 0 });
+};
+exports.translated4d = translated4d;
+const rotateZ = (radians) => {
+    return rotated([0, 0, 1], radians);
+};
+exports.rotateZ = rotateZ;
+const multiplyMatrices = (matrix1, matrix2) => {
+    const result = new Array(16).fill(0);
+    for (let i = 0; i < 4; i++) {
+        for (let j = 0; j < 4; j++) {
+            for (let k = 0; k < 4; k++) {
+                result[i * 4 + j] += matrix1[i * 4 + k] * matrix2[k * 4 + j];
+            }
+        }
+    }
+    return result;
+};
+exports.multiplyMatrices = multiplyMatrices;
+const reduceMatrices = (matrices) => {
+    return matrices
+        .filter(truthy_1.truthy)
+        .slice()
+        .reverse()
+        .reduce((acc, cur) => {
+        return (0, exports.multiplyMatrices)(acc, cur);
+    }, (0, exports.identity4)());
+};
+exports.reduceMatrices = reduceMatrices;
+const aroundCenterPoint = ({ matrix, x, y, z, }) => {
+    return (0, exports.reduceMatrices)([
+        (0, exports.translateX)(-x),
+        (0, exports.translateY)(-y),
+        (0, exports.translateZ)(-z),
+        matrix,
+        (0, exports.translateX)(x),
+        (0, exports.translateY)(y),
+        (0, exports.translateZ)(z),
+    ]);
+};
+exports.aroundCenterPoint = aroundCenterPoint;
+const makeMatrix3dTransform = function (matrix) {
+    return `matrix3d(${[
+        matrix[0],
+        matrix[4],
+        matrix[8],
+        matrix[12], // First column
+        matrix[1],
+        matrix[5],
+        matrix[9],
+        matrix[13], // Second column
+        matrix[2],
+        matrix[6],
+        matrix[10],
+        matrix[14], // Third column
+        matrix[3],
+        matrix[7],
+        matrix[11],
+        matrix[15], // Fourth column
+    ].join(', ')}`;
+};
+exports.makeMatrix3dTransform = makeMatrix3dTransform;
+const interpolate = (a, b, t) => {
+    return a + (b - a) * t;
+};
+const interpolateMatrix4d = (input, matrix1, matrix2) => {
+    return [
+        interpolate(matrix1[0], matrix2[0], input),
+        interpolate(matrix1[1], matrix2[1], input),
+        interpolate(matrix1[2], matrix2[2], input),
+        interpolate(matrix1[3], matrix2[3], input),
+        interpolate(matrix1[4], matrix2[4], input),
+        interpolate(matrix1[5], matrix2[5], input),
+        interpolate(matrix1[6], matrix2[6], input),
+        interpolate(matrix1[7], matrix2[7], input),
+        interpolate(matrix1[8], matrix2[8], input),
+        interpolate(matrix1[9], matrix2[9], input),
+        interpolate(matrix1[10], matrix2[10], input),
+        interpolate(matrix1[11], matrix2[11], input),
+        interpolate(matrix1[12], matrix2[12], input),
+        interpolate(matrix1[13], matrix2[13], input),
+        interpolate(matrix1[14], matrix2[14], input),
+        interpolate(matrix1[15], matrix2[15], input),
+    ];
+};
+exports.interpolateMatrix4d = interpolateMatrix4d;
+const scaled = function (value) {
+    const vec = typeof value === 'number' ? [value, value, value] : value;
+    return (0, exports.stride)({ v: vec, m: (0, exports.identity4)(), width: 4, offset: 0, colStride: 1 });
+};
+exports.scaled = scaled;
+const scaleX = (x) => {
+    return (0, exports.scaled)([x, 1, 1]);
+};
+exports.scaleX = scaleX;
+const scaleY = (y) => {
+    return (0, exports.scaled)([1, y, 1]);
+};
+exports.scaleY = scaleY;
+const rotatedUnitSinCos = function (axisVec, sinAngle, cosAngle) {
+    const x = axisVec[0];
+    const y = axisVec[1];
+    const z = axisVec[2];
+    const c = cosAngle;
+    const s = sinAngle;
+    const t = 1 - c;
+    return [
+        t * x * x + c,
+        t * x * y - s * z,
+        t * x * z + s * y,
+        0,
+        t * x * y + s * z,
+        t * y * y + c,
+        t * y * z - s * x,
+        0,
+        t * x * z - s * y,
+        t * y * z + s * x,
+        t * z * z + c,
+        0,
+        0,
+        0,
+        0,
+        1,
+    ];
+};
+const normalize = function (v) {
+    return (0, exports.mulScalar)(v, 1 / vectorLength(v));
+};
+exports.normalize = normalize;
+const normalize4d = function (v) {
+    return (0, exports.mulScalar)(v, 1 / vectorLength(v));
+};
+exports.normalize4d = normalize4d;
+const vectorLength = function (v) {
+    return Math.sqrt(lengthSquared(v));
+};
+const lengthSquared = function (v) {
+    return (0, exports.dot)(v, v);
+};
+const dot = function (a, b) {
+    if (a.length !== b.length) {
+        throw new Error(`Cannot perform dot product on arrays of different length (${a.length} vs ${b.length})`);
+    }
+    return a
+        .map((v, i) => {
+        return v * b[i];
+    })
+        .reduce((acc, cur) => {
+        return acc + cur;
+    });
+};
+exports.dot = dot;
+const translated = function (vec) {
+    return (0, exports.stride)({
+        v: vec,
+        m: (0, exports.identity4)(),
+        width: 4,
+        offset: 3,
+        colStride: 0,
+    });
+};
+const translateX = (x) => {
+    return translated([x, 0, 0]);
+};
+exports.translateX = translateX;
+const translateY = (y) => {
+    return translated([0, y, 0]);
+};
+exports.translateY = translateY;
+const translateZ = (z) => {
+    return translated([0, 0, z]);
+};
+exports.translateZ = translateZ;
+const mulScalar = function (v, s) {
+    return v.map((i) => {
+        return i * s;
+    });
+};
+exports.mulScalar = mulScalar;
+function multiplyMatrixAndSvgInstruction(matrix, point) {
+    if (point.type === 'C') {
+        return {
+            type: 'C',
+            cp1: (0, exports.multiplyMatrix)(matrix, point.cp1),
+            cp2: (0, exports.multiplyMatrix)(matrix, point.cp2),
+            point: (0, exports.multiplyMatrix)(matrix, point.point),
+        };
+    }
+    if (point.type === 'Q') {
+        return {
+            type: 'Q',
+            cp: (0, exports.multiplyMatrix)(matrix, point.cp),
+            point: (0, exports.multiplyMatrix)(matrix, point.point),
+        };
+    }
+    if (point.type === 'M') {
+        return {
+            type: 'M',
+            point: (0, exports.multiplyMatrix)(matrix, point.point),
+        };
+    }
+    if (point.type === 'L') {
+        return {
+            type: 'L',
+            point: (0, exports.multiplyMatrix)(matrix, point.point),
+        };
+    }
+    if (point.type === 'Z') {
+        return {
+            type: 'Z',
+            point: (0, exports.multiplyMatrix)(matrix, point.point),
+        };
+    }
+    throw new Error('Unknown instruction type: ' + JSON.stringify(point));
+}
+const multiplyMatrix = (matrix, point) => {
+    if (matrix.length !== 16 || point.length !== 4) {
+        throw new Error('Invalid matrix or vector dimension');
+    }
+    const result = [0, 0, 0, 0];
+    for (let i = 0; i < 4; i++) {
+        for (let j = 0; j < 4; j++) {
+            result[i] += matrix[i * 4 + j] * point[j];
+        }
+    }
+    return result;
+};
+exports.multiplyMatrix = multiplyMatrix;
+const sub4d = function (a, b) {
+    return a.map((v, i) => {
+        return v - b[i];
+    });
+};
+exports.sub4d = sub4d;

package/dist/cjs/subdivide-instructions.d.ts

@@ -0,0 +1,4 @@
+import type { Instruction } from '@remotion/paths';
+import type { ThreeDReducedInstruction } from './3d-svg';
+export declare const subdivide2DCInstruction: (fromX: number, fromY: number, instruction: Instruction, t: number) => [Instruction, Instruction];
+export declare const subdivideInstructions: (instructions: ThreeDReducedInstruction[]) => ThreeDReducedInstruction[];

package/dist/cjs/subdivide-instructions.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.subdivideInstructions = exports.subdivide2DCInstruction = void 0;
+const subdivideLOrMInstruction = (from, instruction) => {
+    if (instruction.type !== 'L' && instruction.type !== 'M') {
+        throw new Error('Expected L or M instruction');
+    }
+    const t = 0.5;
+    const q0 = [
+        (1 - t) * from[0] + t * instruction.point[0],
+        (1 - t) * from[1] + t * instruction.point[1],
+        (1 - t) * from[2] + t * instruction.point[2],
+        (1 - t) * from[3] + t * instruction.point[3],
+    ];
+    const curves = [
+        { type: instruction.type, point: q0 },
+        { type: instruction.type, point: instruction.point },
+    ];
+    return curves;
+};
+const subdivide2DCInstruction = (fromX, fromY, instruction, t) => {
+    if (instruction.type !== 'C') {
+        throw new Error('Expected C instruction');
+    }
+    const q0 = [
+        (1 - t) * fromX + t * instruction.cp1x,
+        (1 - t) * fromY + t * instruction.cp1y,
+    ];
+    const q1 = [
+        (1 - t) * instruction.cp1x + t * instruction.cp2x,
+        (1 - t) * instruction.cp1y + t * instruction.cp2y,
+    ];
+    const q2 = [
+        (1 - t) * instruction.cp2x + t * instruction.x,
+        (1 - t) * instruction.cp2y + t * instruction.y,
+    ];
+    const r0 = [
+        (1 - t) * q0[0] + t * q1[0],
+        (1 - t) * q0[1] + t * q1[1],
+    ];
+    const r1 = [
+        (1 - t) * q1[0] + t * q2[0],
+        (1 - t) * q1[1] + t * q2[1],
+    ];
+    const s0 = [
+        (1 - t) * r0[0] + t * r1[0],
+        (1 - t) * r0[1] + t * r1[1],
+    ];
+    const curves = [
+        {
+            type: 'C',
+            x: s0[0],
+            y: s0[1],
+            cp1x: q0[0],
+            cp1y: q0[1],
+            cp2x: r0[0],
+            cp2y: r0[1],
+        },
+        {
+            type: 'C',
+            x: instruction.x,
+            y: instruction.y,
+            cp1x: r1[0],
+            cp1y: r1[1],
+            cp2x: q2[0],
+            cp2y: q2[1],
+        },
+    ];
+    return curves;
+};
+exports.subdivide2DCInstruction = subdivide2DCInstruction;
+const subdivide3DCInstruction = (from, instruction) => {
+    if (instruction.type !== 'C') {
+        throw new Error('Expected C instruction');
+    }
+    const t = 0.5;
+    const q0 = [
+        (1 - t) * from[0] + t * instruction.cp1[0],
+        (1 - t) * from[1] + t * instruction.cp1[1],
+        (1 - t) * from[2] + t * instruction.cp1[2],
+        (1 - t) * from[3] + t * instruction.cp1[3],
+    ];
+    const q1 = [
+        (1 - t) * instruction.cp1[0] + t * instruction.cp2[0],
+        (1 - t) * instruction.cp1[1] + t * instruction.cp2[1],
+        (1 - t) * instruction.cp1[2] + t * instruction.cp2[2],
+        (1 - t) * instruction.cp1[3] + t * instruction.cp2[3],
+    ];
+    const q2 = [
+        (1 - t) * instruction.cp2[0] + t * instruction.point[0],
+        (1 - t) * instruction.cp2[1] + t * instruction.point[1],
+        (1 - t) * instruction.cp2[2] + t * instruction.point[2],
+        (1 - t) * instruction.cp2[3] + t * instruction.point[3],
+    ];
+    const r0 = [
+        (1 - t) * q0[0] + t * q1[0],
+        (1 - t) * q0[1] + t * q1[1],
+        (1 - t) * q0[2] + t * q1[2],
+        (1 - t) * q0[3] + t * q1[3],
+    ];
+    const r1 = [
+        (1 - t) * q1[0] + t * q2[0],
+        (1 - t) * q1[1] + t * q2[1],
+        (1 - t) * q1[2] + t * q2[2],
+        (1 - t) * q1[3] + t * q2[3],
+    ];
+    const s0 = [
+        (1 - t) * r0[0] + t * r1[0],
+        (1 - t) * r0[1] + t * r1[1],
+        (1 - t) * r0[2] + t * r1[2],
+        (1 - t) * r0[3] + t * r1[3],
+    ];
+    const curves = [
+        { type: 'C', point: s0, cp1: q0, cp2: r0 },
+        { type: 'C', point: instruction.point, cp1: r1, cp2: q2 },
+    ];
+    return curves;
+};
+const subdivideQInstruction = (from, instruction) => {
+    if (instruction.type !== 'Q') {
+        throw new Error('Expected Q instruction');
+    }
+    const t = 0.5;
+    const q0 = [
+        (1 - t) * from[0] + t * instruction.cp[0],
+        (1 - t) * from[1] + t * instruction.cp[1],
+        (1 - t) * from[2] + t * instruction.cp[2],
+        (1 - t) * from[3] + t * instruction.cp[3],
+    ];
+    const q1 = [
+        (1 - t) * instruction.cp[0] + t * instruction.point[0],
+        (1 - t) * instruction.cp[1] + t * instruction.point[1],
+        (1 - t) * instruction.cp[2] + t * instruction.point[2],
+        (1 - t) * instruction.cp[3] + t * instruction.point[3],
+    ];
+    const r0 = [
+        (1 - t) * q0[0] + t * q1[0],
+        (1 - t) * q0[1] + t * q1[1],
+        (1 - t) * q0[2] + t * q1[2],
+        (1 - t) * q0[3] + t * q1[3],
+    ];
+    const newInstructions = [
+        { type: 'Q', point: r0, cp: q0 },
+        { type: 'Q', point: instruction.point, cp: q1 },
+    ];
+    return newInstructions;
+};
+const subdivideInstruction = (from, instruction) => {
+    if (instruction.type === 'C') {
+        return subdivide3DCInstruction(from, instruction);
+    }
+    if (instruction.type === 'L' || instruction.type === 'M') {
+        return subdivideLOrMInstruction(from, instruction);
+    }
+    if (instruction.type === 'Q') {
+        return subdivideQInstruction(from, instruction);
+    }
+    if (instruction.type === 'Z') {
+        return [instruction];
+    }
+    throw new Error('Cannot subdivide instruction');
+};
+const subdivideInstructions = (instructions) => {
+    const newInstructions = [];
+    instructions.forEach((instruction, i) => {
+        if (instruction.type === 'M') {
+            newInstructions.push(instruction);
+            return;
+        }
+        if (instruction.type === 'Z') {
+            newInstructions.push(instruction);
+            return;
+        }
+        const previousInstruction = instructions[i - 1];
+        const subdivided = subdivideInstruction(previousInstruction.point, instruction);
+        newInstructions.push(...subdivided);
+    });
+    return newInstructions;
+};
+exports.subdivideInstructions = subdivideInstructions;

package/dist/cjs/truthy.d.ts

@@ -0,0 +1,3 @@
+type Truthy<T> = T extends false | '' | 0 | null | undefined ? never : T;
+export declare function truthy<T>(value: T): value is Truthy<T>;
+export {};

package/dist/cjs/truthy.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.truthy = truthy;
+function truthy(value) {
+    return Boolean(value);
+}