@vib3code/sdk 2.0.1 → 2.0.3-canary.0a63e71

package/cpp/bindings/embind.cpp

@@ -0,0 +1,269 @@
+/**
+ * embind.cpp - Emscripten JavaScript Bindings
+ *
+ * Exposes VIB3+ C++ classes to JavaScript via WebAssembly.
+ */
+
+#include <emscripten/bind.h>
+#include "../math/Vec4.hpp"
+#include "../math/Rotor4D.hpp"
+#include "../math/Mat4x4.hpp"
+#include "../math/Projection.hpp"
+
+using namespace emscripten;
+using namespace vib3;
+
+// Helper to convert std::array to JS array
+template<typename T, size_t N>
+val arrayToVal(const std::array<T, N>& arr) {
+    val jsArray = val::array();
+    for (size_t i = 0; i < N; ++i) {
+        jsArray.call<void>("push", arr[i]);
+    }
+    return jsArray;
+}
+
+// Helper to convert JS array to std::array
+template<typename T, size_t N>
+std::array<T, N> valToArray(const val& jsArray) {
+    std::array<T, N> arr;
+    for (size_t i = 0; i < N; ++i) {
+        arr[i] = jsArray[i].as<T>();
+    }
+    return arr;
+}
+
+EMSCRIPTEN_BINDINGS(vib3_math) {
+    // ====== Vec4 ======
+
+    class_<Vec4>("Vec4")
+        .constructor<>()
+        .constructor<float, float, float, float>()
+        .constructor<float>()
+
+        // Properties
+        .property("x", &Vec4::x)
+        .property("y", &Vec4::y)
+        .property("z", &Vec4::z)
+        .property("w", &Vec4::w)
+
+        // Static factories
+        .class_function("zero", &Vec4::zero)
+        .class_function("one", &Vec4::one)
+        .class_function("unitX", &Vec4::unitX)
+        .class_function("unitY", &Vec4::unitY)
+        .class_function("unitZ", &Vec4::unitZ)
+        .class_function("unitW", &Vec4::unitW)
+        .class_function("randomUnit", &Vec4::randomUnit)
+
+        // Arithmetic
+        .function("add", select_overload<Vec4(const Vec4&) const>(&Vec4::operator+))
+        .function("sub", select_overload<Vec4(const Vec4&) const>(&Vec4::operator-))
+        .function("mul", select_overload<Vec4(float) const>(&Vec4::operator*))
+        .function("div", select_overload<Vec4(float) const>(&Vec4::operator/))
+        .function("neg", select_overload<Vec4() const>(&Vec4::operator-))
+
+        // Operations
+        .function("dot", &Vec4::dot)
+        .function("length", &Vec4::length)
+        .function("lengthSquared", &Vec4::lengthSquared)
+        .function("normalized", &Vec4::normalized)
+        .function("normalize", &Vec4::normalize)
+        .function("distanceTo", &Vec4::distanceTo)
+        .function("distanceSquaredTo", &Vec4::distanceSquaredTo)
+        .function("lerp", &Vec4::lerp)
+        .function("min", &Vec4::min)
+        .function("max", &Vec4::max)
+        .function("clamp", &Vec4::clamp)
+        .function("abs", &Vec4::abs)
+        .function("projectOnto", &Vec4::projectOnto)
+        .function("reflect", &Vec4::reflect)
+        .function("isZero", &Vec4::isZero)
+        .function("isNormalized", &Vec4::isNormalized)
+
+        // Projections
+        .function("projectPerspective", &Vec4::projectPerspective)
+        .function("projectStereographic", &Vec4::projectStereographic)
+        .function("projectOrthographic", &Vec4::projectOrthographic)
+
+        // Conversion
+        .function("toArray", optional_override([](const Vec4& self) {
+            return arrayToVal<float, 4>(self.data);
+        }))
+        ;
+
+    // Free function for Vec4 construction from array
+    function("vec4FromArray", optional_override([](const val& arr) {
+        return Vec4(arr[0].as<float>(), arr[1].as<float>(),
+                    arr[2].as<float>(), arr[3].as<float>());
+    }));
+
+    // ====== Rotor4D ======
+
+    enum_<RotationPlane>("RotationPlane")
+        .value("XY", RotationPlane::XY)
+        .value("XZ", RotationPlane::XZ)
+        .value("YZ", RotationPlane::YZ)
+        .value("XW", RotationPlane::XW)
+        .value("YW", RotationPlane::YW)
+        .value("ZW", RotationPlane::ZW)
+        ;
+
+    class_<Rotor4D>("Rotor4D")
+        .constructor<>()
+        .constructor<float, float, float, float, float, float, float, float>()
+
+        // Components
+        .property("s", &Rotor4D::s)
+        .property("xy", &Rotor4D::xy)
+        .property("xz", &Rotor4D::xz)
+        .property("yz", &Rotor4D::yz)
+        .property("xw", &Rotor4D::xw)
+        .property("yw", &Rotor4D::yw)
+        .property("zw", &Rotor4D::zw)
+        .property("xyzw", &Rotor4D::xyzw)
+
+        // Static factories
+        .class_function("identity", &Rotor4D::identity)
+        .class_function("fromPlaneAngle", &Rotor4D::fromPlaneAngle)
+        .class_function("fromEuler6", select_overload<Rotor4D(float, float, float, float, float, float)>(&Rotor4D::fromEuler6))
+
+        // Operations
+        .function("mul", select_overload<Rotor4D(const Rotor4D&) const>(&Rotor4D::operator*))
+        .function("reverse", &Rotor4D::reverse)
+        .function("magnitude", &Rotor4D::magnitude)
+        .function("magnitudeSquared", &Rotor4D::magnitudeSquared)
+        .function("normalized", &Rotor4D::normalized)
+        .function("normalize", &Rotor4D::normalize)
+        .function("inverse", &Rotor4D::inverse)
+        .function("isNormalized", &Rotor4D::isNormalized)
+
+        // Vector rotation
+        .function("rotate", &Rotor4D::rotate)
+
+        // Interpolation
+        .function("slerp", &Rotor4D::slerp)
+        .function("nlerp", &Rotor4D::nlerp)
+        .function("dot", &Rotor4D::dot)
+
+        // Matrix conversion
+        .function("toMatrix", &Rotor4D::toMatrix)
+
+        // Conversion
+        .function("toArray", optional_override([](const Rotor4D& self) {
+            return arrayToVal<float, 8>(self.toArray());
+        }))
+        ;
+
+    // Free function for rotor creation from angle array
+    function("rotorFromEuler6Array", optional_override([](const val& arr) {
+        return Rotor4D::fromEuler6(
+            arr[0].as<float>(), arr[1].as<float>(), arr[2].as<float>(),
+            arr[3].as<float>(), arr[4].as<float>(), arr[5].as<float>()
+        );
+    }));
+
+    // ====== Mat4x4 ======
+
+    class_<Mat4x4>("Mat4x4")
+        .constructor<>()
+        .constructor<float>()
+
+        // Static factories
+        .class_function("identity", &Mat4x4::identity)
+        .class_function("zero", &Mat4x4::zero)
+        .class_function("rotationXY", &Mat4x4::rotationXY)
+        .class_function("rotationXZ", &Mat4x4::rotationXZ)
+        .class_function("rotationYZ", &Mat4x4::rotationYZ)
+        .class_function("rotationXW", &Mat4x4::rotationXW)
+        .class_function("rotationYW", &Mat4x4::rotationYW)
+        .class_function("rotationZW", &Mat4x4::rotationZW)
+        .class_function("rotationFromAngles", select_overload<Mat4x4(float, float, float, float, float, float)>(&Mat4x4::rotationFromAngles))
+        .class_function("scale", select_overload<Mat4x4(float)>(&Mat4x4::scale))
+
+        // Element access
+        .function("at", select_overload<float&(size_t, size_t)>(&Mat4x4::at))
+        .function("column", &Mat4x4::column)
+        .function("row", &Mat4x4::row)
+
+        // Operations
+        .function("mulMat", select_overload<Mat4x4(const Mat4x4&) const>(&Mat4x4::operator*))
+        .function("mulVec", select_overload<Vec4(const Vec4&) const>(&Mat4x4::operator*))
+        .function("mulScalar", select_overload<Mat4x4(float) const>(&Mat4x4::operator*))
+        .function("add", select_overload<Mat4x4(const Mat4x4&) const>(&Mat4x4::operator+))
+        .function("sub", select_overload<Mat4x4(const Mat4x4&) const>(&Mat4x4::operator-))
+        .function("transposed", &Mat4x4::transposed)
+        .function("transpose", &Mat4x4::transpose)
+        .function("determinant", &Mat4x4::determinant)
+        .function("inverse", &Mat4x4::inverse)
+        .function("isOrthogonal", &Mat4x4::isOrthogonal)
+        .function("isIdentity", &Mat4x4::isIdentity)
+
+        // Conversion
+        .function("toArray", optional_override([](const Mat4x4& self) {
+            return arrayToVal<float, 16>(self.data);
+        }))
+        ;
+
+    // Free function for matrix from angles array
+    function("matrixFromAnglesArray", optional_override([](const val& arr) {
+        return Mat4x4::rotationFromAngles(
+            arr[0].as<float>(), arr[1].as<float>(), arr[2].as<float>(),
+            arr[3].as<float>(), arr[4].as<float>(), arr[5].as<float>()
+        );
+    }));
+
+    // ====== Projection ======
+
+    value_object<Projection3D>("Projection3D")
+        .field("x", &Projection3D::x)
+        .field("y", &Projection3D::y)
+        .field("z", &Projection3D::z)
+        ;
+
+    value_object<SliceResult>("SliceResult")
+        .field("point", &SliceResult::point)
+        .field("alpha", &SliceResult::alpha)
+        .field("valid", &SliceResult::valid)
+        ;
+
+    // Projection functions
+    function("projectPerspective", &projectPerspective);
+    function("projectStereographic", &projectStereographic);
+    function("projectOrthographic", &projectOrthographic);
+    function("projectOblique", &projectOblique);
+    function("projectSlice", &projectSlice);
+
+    // Batch projections (returns typed array for efficiency)
+    function("projectToFloatArray", optional_override([](const val& jsPoints, float distance) {
+        std::vector<Vec4> points;
+        size_t len = jsPoints["length"].as<size_t>();
+        points.reserve(len);
+
+        for (size_t i = 0; i < len; ++i) {
+            points.push_back(jsPoints[i].as<Vec4>());
+        }
+
+        auto result = projectToFloatArray(points, distance);
+
+        // Return as Float32Array for efficient GPU upload
+        return val::global("Float32Array").new_(typed_memory_view(result.size(), result.data()));
+    }));
+}
+
+// Module initialization
+EMSCRIPTEN_BINDINGS(vib3_module) {
+    // Version info
+    function("getVersion", optional_override([]() {
+        return std::string("1.0.0");
+    }));
+
+    // Feature detection
+    function("hasSimd", optional_override([]() {
+#if defined(VIB3_HAS_SSE41) || defined(__wasm_simd128__)
+        return true;
+#else
+        return false;
+#endif
+    }));
+}

package/cpp/build.sh

@@ -0,0 +1,129 @@
+#!/bin/bash
+#
+# VIB3+ WASM Build Script
+#
+# Usage:
+#   ./build.sh              # Build release WASM
+#   ./build.sh debug        # Build debug WASM
+#   ./build.sh native       # Build native (with tests)
+#   ./build.sh clean        # Clean build directory
+#
+# Requirements:
+#   - CMake 3.20+
+#   - Emscripten SDK (for WASM builds)
+#   - C++20 compiler (for native builds)
+#
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+BUILD_DIR="${SCRIPT_DIR}/build"
+DIST_DIR="${SCRIPT_DIR}/../dist/wasm"
+BUILD_TYPE="${1:-release}"
+NPROC=$(nproc 2>/dev/null || sysctl -n hw.ncpu 2>/dev/null || echo 4)
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+log() { echo -e "${GREEN}[VIB3]${NC} $*"; }
+warn() { echo -e "${YELLOW}[VIB3]${NC} $*"; }
+error() { echo -e "${RED}[VIB3]${NC} $*" >&2; }
+
+case "${BUILD_TYPE}" in
+    clean)
+        log "Cleaning build directory..."
+        rm -rf "${BUILD_DIR}"
+        log "Done."
+        exit 0
+        ;;
+
+    debug)
+        log "Building WASM (Debug)..."
+
+        if ! command -v emcmake &>/dev/null; then
+            error "Emscripten not found. Install emsdk and activate it:"
+            error "  git clone https://github.com/emscripten-core/emsdk.git"
+            error "  cd emsdk && ./emsdk install latest && ./emsdk activate latest"
+            error "  source emsdk_env.sh"
+            exit 1
+        fi
+
+        mkdir -p "${BUILD_DIR}/wasm-debug"
+        cd "${BUILD_DIR}/wasm-debug"
+
+        emcmake cmake "${SCRIPT_DIR}" \
+            -DCMAKE_BUILD_TYPE=Debug \
+            -DVIB3_BUILD_WASM=ON \
+            -DVIB3_BUILD_TESTS=OFF \
+            -DVIB3_ENABLE_SIMD=ON
+
+        cmake --build . -j"${NPROC}"
+
+        # Copy outputs
+        mkdir -p "${DIST_DIR}"
+        cp -f bin/vib3.js bin/vib3.wasm "${DIST_DIR}/"
+        [ -f bin/vib3.d.ts ] && cp -f bin/vib3.d.ts "${DIST_DIR}/"
+
+        log "Debug WASM build complete. Output: ${DIST_DIR}/"
+        ;;
+
+    release)
+        log "Building WASM (Release)..."
+
+        if ! command -v emcmake &>/dev/null; then
+            error "Emscripten not found. Install emsdk and activate it:"
+            error "  git clone https://github.com/emscripten-core/emsdk.git"
+            error "  cd emsdk && ./emsdk install latest && ./emsdk activate latest"
+            error "  source emsdk_env.sh"
+            exit 1
+        fi
+
+        mkdir -p "${BUILD_DIR}/wasm-release"
+        cd "${BUILD_DIR}/wasm-release"
+
+        emcmake cmake "${SCRIPT_DIR}" \
+            -DCMAKE_BUILD_TYPE=Release \
+            -DVIB3_BUILD_WASM=ON \
+            -DVIB3_BUILD_TESTS=OFF \
+            -DVIB3_ENABLE_SIMD=ON
+
+        cmake --build . -j"${NPROC}"
+
+        # Copy outputs
+        mkdir -p "${DIST_DIR}"
+        cp -f bin/vib3.js bin/vib3.wasm "${DIST_DIR}/"
+        [ -f bin/vib3.d.ts ] && cp -f bin/vib3.d.ts "${DIST_DIR}/"
+
+        log "Release WASM build complete. Output: ${DIST_DIR}/"
+        ls -lh "${DIST_DIR}/"
+        ;;
+
+    native)
+        log "Building native (with tests)..."
+
+        mkdir -p "${BUILD_DIR}/native"
+        cd "${BUILD_DIR}/native"
+
+        cmake "${SCRIPT_DIR}" \
+            -DCMAKE_BUILD_TYPE=Debug \
+            -DVIB3_BUILD_WASM=OFF \
+            -DVIB3_BUILD_TESTS=ON \
+            -DVIB3_ENABLE_SIMD=ON
+
+        cmake --build . -j"${NPROC}"
+
+        log "Running tests..."
+        ctest --output-on-failure
+
+        log "Native build and tests complete."
+        ;;
+
+    *)
+        error "Unknown build type: ${BUILD_TYPE}"
+        echo "Usage: $0 [release|debug|native|clean]"
+        exit 1
+        ;;
+esac

package/cpp/geometry/Crystal.cpp

@@ -0,0 +1,103 @@
+/**
+ * Crystal.cpp - Octahedral / Crystalline Structure in 4D
+ *
+ * Generates vertices and edge geometry for crystalline structures
+ * in 4D: the regular octahedron (cross-polytope) and its dual,
+ * extended with 4D vertices along the W axis.
+ *
+ * The 4D cross-polytope (hyperoctahedron / 16-cell) has 8 vertices
+ * at the 4 axis-aligned unit positions and their negations.
+ */
+
+#include "math/Vec4.hpp"
+#include <vector>
+#include <cmath>
+#include <numbers>
+
+namespace vib3 {
+
+/**
+ * Generate the 8 vertices of a 4D cross-polytope (hyperoctahedron / 16-cell).
+ *
+ * Vertices lie at (+-1, 0, 0, 0), (0, +-1, 0, 0), (0, 0, +-1, 0), (0, 0, 0, +-1).
+ */
+std::vector<Vec4> generateCrossPolytopeVertices() noexcept {
+    std::vector<Vec4> vertices;
+    vertices.reserve(8);
+
+    vertices.emplace_back( 1.0f,  0.0f,  0.0f,  0.0f);
+    vertices.emplace_back(-1.0f,  0.0f,  0.0f,  0.0f);
+    vertices.emplace_back( 0.0f,  1.0f,  0.0f,  0.0f);
+    vertices.emplace_back( 0.0f, -1.0f,  0.0f,  0.0f);
+    vertices.emplace_back( 0.0f,  0.0f,  1.0f,  0.0f);
+    vertices.emplace_back( 0.0f,  0.0f, -1.0f,  0.0f);
+    vertices.emplace_back( 0.0f,  0.0f,  0.0f,  1.0f);
+    vertices.emplace_back( 0.0f,  0.0f,  0.0f, -1.0f);
+
+    return vertices;
+}
+
+/**
+ * Generate crystalline geometry with edge interpolation.
+ *
+ * The 4D cross-polytope has 24 edges: every pair of non-antipodal vertices
+ * is connected (i.e., vertices i and j are connected unless they lie on
+ * the same axis). Each edge is subdivided into `resolution` segments.
+ *
+ * Additionally generates midpoint vertices for a dual-lattice structure
+ * (the 4D hypercube formed by the dual vertices at the edge midpoints).
+ *
+ * @param resolution Number of subdivisions per edge (minimum 2)
+ * @return Vector of 4D points forming the crystal wireframe
+ */
+std::vector<Vec4> generateCrystal(int resolution) noexcept {
+    if (resolution < 2) resolution = 2;
+
+    auto baseVertices = generateCrossPolytopeVertices();
+
+    // Edges of the 16-cell: connect every pair of vertices that are
+    // NOT antipodal (not on the same axis).
+    // 8 vertices, 24 edges total.
+    struct Edge { int a, b; };
+    std::vector<Edge> edges;
+    edges.reserve(24);
+
+    for (int i = 0; i < 8; ++i) {
+        for (int j = i + 1; j < 8; ++j) {
+            // Antipodal pairs: (0,1), (2,3), (4,5), (6,7)
+            // Skip if on same axis (differ by 1 and i is even)
+            if ((i ^ j) == 1 && (i % 2 == 0)) {
+                continue;
+            }
+            edges.push_back({i, j});
+        }
+    }
+
+    std::vector<Vec4> vertices;
+    vertices.reserve(edges.size() * static_cast<size_t>(resolution) + 16);
+
+    // Edge wireframe
+    for (const auto& edge : edges) {
+        const Vec4& a = baseVertices[static_cast<size_t>(edge.a)];
+        const Vec4& b = baseVertices[static_cast<size_t>(edge.b)];
+
+        for (int i = 0; i < resolution; ++i) {
+            float t = static_cast<float>(i) / static_cast<float>(resolution - 1);
+            vertices.push_back(a.lerp(b, t));
+        }
+    }
+
+    // Dual vertices (tesseract / hypercube dual): midpoints of faces
+    // These are the 16 vertices of the dual polytope at (+-0.5, +-0.5, +-0.5, +-0.5)
+    for (int i = 0; i < 16; ++i) {
+        float x = (i & 1) ? 0.5f : -0.5f;
+        float y = (i & 2) ? 0.5f : -0.5f;
+        float z = (i & 4) ? 0.5f : -0.5f;
+        float w = (i & 8) ? 0.5f : -0.5f;
+        vertices.emplace_back(x, y, z, w);
+    }
+
+    return vertices;
+}
+
+} // namespace vib3

package/cpp/geometry/Fractal.cpp

@@ -0,0 +1,136 @@
+/**
+ * Fractal.cpp - 4D Iterated Function System Fractal
+ *
+ * Generates recursive subdivision geometry in 4D using an IFS approach.
+ * Starts from an initial set of points and iteratively applies affine
+ * contractions toward attractor vertices, building a self-similar
+ * fractal structure (a 4D analogue of the Sierpinski tetrahedron).
+ */
+
+#include "math/Vec4.hpp"
+#include <vector>
+#include <cmath>
+#include <numbers>
+#include <cstdint>
+
+namespace vib3 {
+
+namespace {
+
+/**
+ * 4D Sierpinski-style attractor vertices.
+ *
+ * Five vertices of a regular 5-cell (pentatope) provide a natural
+ * set of contraction centers for a 4D IFS.
+ */
+constexpr int kNumAttractors = 5;
+
+Vec4 getAttractorVertex(int index) noexcept {
+    // Regular pentatope vertices (5-cell), embedded in R4
+    // These are the vertices of a regular simplex in 4D.
+    switch (index) {
+        case 0: return Vec4( 1.0f,  1.0f,  1.0f, -1.0f / std::numbers::sqrt2_v<float>);
+        case 1: return Vec4( 1.0f, -1.0f, -1.0f, -1.0f / std::numbers::sqrt2_v<float>);
+        case 2: return Vec4(-1.0f,  1.0f, -1.0f, -1.0f / std::numbers::sqrt2_v<float>);
+        case 3: return Vec4(-1.0f, -1.0f,  1.0f, -1.0f / std::numbers::sqrt2_v<float>);
+        case 4: return Vec4( 0.0f,  0.0f,  0.0f,  4.0f / std::numbers::sqrt2_v<float>);
+        default: return Vec4::zero();
+    }
+}
+
+/**
+ * Simple deterministic hash for reproducible pseudo-random attractor selection.
+ */
+constexpr uint32_t hashStep(uint32_t seed) noexcept {
+    seed ^= seed << 13;
+    seed ^= seed >> 17;
+    seed ^= seed << 5;
+    return seed;
+}
+
+} // anonymous namespace
+
+/**
+ * Generate a 4D IFS fractal via the chaos game.
+ *
+ * Uses the classic chaos game algorithm: starting from a seed point,
+ * repeatedly pick a random attractor and move halfway toward it.
+ * After a warm-up period, the trajectory traces out the fractal.
+ *
+ * @param resolution Controls the number of output points (resolution^2 points)
+ * @return Vector of 4D fractal points
+ */
+std::vector<Vec4> generateFractal(int resolution) noexcept {
+    if (resolution < 4) resolution = 4;
+
+    int numPoints = resolution * resolution;
+    constexpr int warmUp = 64;
+    constexpr float contractionFactor = 0.5f;
+
+    std::vector<Vec4> vertices;
+    vertices.reserve(static_cast<size_t>(numPoints));
+
+    // Start at the origin
+    Vec4 current = Vec4::zero();
+    uint32_t seed = 0xDEADBEEF;
+
+    // Warm-up iterations (discard to converge onto attractor)
+    for (int i = 0; i < warmUp; ++i) {
+        seed = hashStep(seed);
+        int attIdx = static_cast<int>(seed % kNumAttractors);
+        Vec4 target = getAttractorVertex(attIdx);
+        current = current.lerp(target, contractionFactor);
+    }
+
+    // Generate fractal points
+    for (int i = 0; i < numPoints; ++i) {
+        seed = hashStep(seed);
+        int attIdx = static_cast<int>(seed % kNumAttractors);
+        Vec4 target = getAttractorVertex(attIdx);
+        current = current.lerp(target, contractionFactor);
+        vertices.push_back(current);
+    }
+
+    return vertices;
+}
+
+/**
+ * Generate a 4D IFS fractal via recursive subdivision.
+ *
+ * Starts from attractor vertices and recursively subdivides midpoints
+ * to a given depth, producing a deterministic point set.
+ *
+ * @param depth Recursion depth (0 = just vertices, each level multiplies points by 5)
+ * @return Vector of 4D fractal points
+ */
+std::vector<Vec4> generateFractalSubdivision(int depth) noexcept {
+    if (depth < 0) depth = 0;
+    if (depth > 6) depth = 6; // Cap to avoid excessive memory
+
+    std::vector<Vec4> current;
+    current.reserve(static_cast<size_t>(kNumAttractors));
+
+    // Seed with attractor vertices
+    for (int i = 0; i < kNumAttractors; ++i) {
+        current.push_back(getAttractorVertex(i));
+    }
+
+    // Recursive subdivision
+    for (int d = 0; d < depth; ++d) {
+        std::vector<Vec4> next;
+        next.reserve(current.size() * static_cast<size_t>(kNumAttractors));
+
+        for (const auto& point : current) {
+            for (int a = 0; a < kNumAttractors; ++a) {
+                Vec4 target = getAttractorVertex(a);
+                next.push_back(point.lerp(target, 0.5f));
+            }
+        }
+
+        current = std::move(next);
+    }
+
+    return current;
+}
+
+} // namespace vib3