dataScript.js

const MAX_PARTICLES = 10000
const MAX_EDGES = 20000

const posX = new Float32Array(MAX_PARTICLES)
const posY = new Float32Array(MAX_PARTICLES)

const prevX = new Float32Array(MAX_PARTICLES)
const prevY = new Float32Array(MAX_PARTICLES)

const edgeSet = new Set()
const edgeA = new Uint16Array(MAX_EDGES)
const edgeB = new Uint16Array(MAX_EDGES)
const restLength = new Float32Array(MAX_EDGES)

const pinned = new Uint8Array(MAX_PARTICLES)

let pointCount = 0
let edgeCount = 0

const EPSILON = 1e-4

function RESET() {
    pointCount = 0
    edgeCount = 0
    edgeSet.clear()
}

function EDGE_KEY(a, b) {
    if (a > b) [a, b] = [b, a];
    return a * (MAX_PARTICLES * 2) + b;
}
function ADD_POINT(x, y, hooked = false) {
    if (pointCount >= MAX_PARTICLES) return -1

    const i = pointCount

    posX[i] = x
    posY[i] = y

    prevX[i] = x
    prevY[i] = y

    pinned[i] = hooked ? 1 : 0

    pointCount++
    return i
}

function NORMALIZE_EDGE(a, b) {
    return a < b ? [a, b] : [b, a];
}

function EDGE_KEY(a, b) {
    const [normA, normB] = NORMALIZE_EDGE(a, b);
    return normA * (MAX_PARTICLES * 2) + normB;
}

function SET_EDGE(i, a, b) {
    const [normA, normB] = NORMALIZE_EDGE(a, b);
    const key = EDGE_KEY(normA, normB);

    // Remove old edge from set if one existed!!!!
    if (i < edgeCount) {
        const [oldA, oldB] = NORMALIZE_EDGE(edgeA[i], edgeB[i]);
        edgeSet.delete(EDGE_KEY(oldA, oldB));
    }

    edgeA[i] = normA;
    edgeB[i] = normB;
    restLength[i] = Math.hypot(posX[normA] - posX[normB], posY[normA] - posY[normB]);

    edgeSet.add(key);
}

function ADD_EDGE(a, b) {

    if (
        edgeCount >= MAX_EDGES ||
        a === b ||
        a < 0 || b < 0 ||
        a >= pointCount || b >= pointCount
    ) return -1;

    const key = EDGE_KEY(a, b);
    if (edgeSet.has(key)) return -1;

    const i = edgeCount++;
    SET_EDGE(i, a, b);

    return i;
}

function SPLIT_EDGE(i) {
    if (edgeCount >= MAX_EDGES - 1) return -1;

    const a = edgeA[i];
    const b = edgeB[i];
    const originalRestLength = restLength[i];

    const mx = 0.5 * (posX[a] + posX[b]);
    const my = 0.5 * (posY[a] + posY[b]);

    // Create two separate points at the midpoint for the dangling
    const m1 = ADD_POINT(mx, my);
    if (m1 === -1) return -1;

    const m2 = ADD_POINT(mx, my);
    if (m2 === -1) return -1;

    // Set their previous positions for proper velocity,
    prevX[m1] = 0.5 * (prevX[a] + prevX[b]);
    prevY[m1] = 0.5 * (prevY[a] + prevY[b]);
    prevX[m2] = 0.5 * (prevX[a] + prevX[b]);
    prevY[m2] = 0.5 * (prevY[a] + prevY[b]);

    // Split rest length by HALF
    const halfRestLength = originalRestLength * 0.5;

    // Replace original edge (a, b) with (a, m1)
    const [normA, normM1] = NORMALIZE_EDGE(a, m1);
    edgeA[i] = normA;
    edgeB[i] = normM1;
    restLength[i] = halfRestLength;
    edgeSet.delete(EDGE_KEY(a, b));
    edgeSet.add(EDGE_KEY(normA, normM1));

    // Create new edge (m2, b)
    const j = edgeCount++;
    const [normM2, normB] = NORMALIZE_EDGE(m2, b);
    edgeA[j] = normM2;
    edgeB[j] = normB;
    restLength[j] = halfRestLength;
    edgeSet.add(EDGE_KEY(normM2, normB));

    return m1;
}