@vib3code/sdk 2.0.1 → 2.0.3-canary.75a3290

package/cpp/geometry/Sphere.cpp

@@ -0,0 +1,134 @@
+/**
+ * Sphere.cpp - 3-Sphere (S3) Surface Points
+ *
+ * Generates points on the 3-sphere (hypersphere) in 4D using
+ * Hopf coordinates (psi, theta, phi) parametrization.
+ */
+
+#include "math/Vec4.hpp"
+#include <vector>
+#include <cmath>
+#include <numbers>
+
+namespace vib3 {
+
+/**
+ * Generate points on S3 using Hopf coordinate parametrization.
+ *
+ * The 3-sphere is parametrized by three angles:
+ *   x = cos(psi) * cos(theta)
+ *   y = cos(psi) * sin(theta)
+ *   z = sin(psi) * cos(phi)
+ *   w = sin(psi) * sin(phi)
+ *
+ * where psi in [0, pi/2], theta in [0, 2pi), phi in [0, 2pi).
+ *
+ * @param resolution Controls sampling density. Total points = resolution^2 * resolution/2
+ * @return Vector of 4D points on the unit 3-sphere
+ */
+std::vector<Vec4> generateSphere(int resolution) noexcept {
+    if (resolution < 4) resolution = 4;
+
+    constexpr float pi = std::numbers::pi_v<float>;
+    constexpr float twoPi = 2.0f * std::numbers::pi_v<float>;
+    constexpr float halfPi = std::numbers::pi_v<float> / 2.0f;
+
+    // Number of steps for each angle
+    int psiSteps = resolution / 2;
+    int thetaSteps = resolution;
+    int phiSteps = resolution;
+
+    if (psiSteps < 2) psiSteps = 2;
+
+    std::vector<Vec4> vertices;
+    vertices.reserve(static_cast<size_t>(psiSteps) *
+                     static_cast<size_t>(thetaSteps) *
+                     static_cast<size_t>(phiSteps));
+
+    for (int ip = 0; ip < psiSteps; ++ip) {
+        float psi = halfPi * static_cast<float>(ip) / static_cast<float>(psiSteps - 1);
+        float cosPsi = std::cos(psi);
+        float sinPsi = std::sin(psi);
+
+        for (int it = 0; it < thetaSteps; ++it) {
+            float theta = twoPi * static_cast<float>(it) / static_cast<float>(thetaSteps);
+            float cosTheta = std::cos(theta);
+            float sinTheta = std::sin(theta);
+
+            for (int iphi = 0; iphi < phiSteps; ++iphi) {
+                float phi = twoPi * static_cast<float>(iphi) / static_cast<float>(phiSteps);
+                float cosPhi = std::cos(phi);
+                float sinPhi = std::sin(phi);
+
+                vertices.emplace_back(
+                    cosPsi * cosTheta,
+                    cosPsi * sinTheta,
+                    sinPsi * cosPhi,
+                    sinPsi * sinPhi
+                );
+            }
+        }
+    }
+
+    return vertices;
+}
+
+/**
+ * Generate points on S3 using the Hopf fibration structure.
+ *
+ * The Hopf fibration maps S3 -> S2, with each fiber being a great circle.
+ * This produces points organized along Hopf fibers, useful for
+ * visualizing the fibration structure.
+ *
+ * @param numFibers Number of base points on S2
+ * @param pointsPerFiber Number of points along each Hopf circle
+ * @return Vector of 4D points on the unit 3-sphere
+ */
+std::vector<Vec4> generateHopfFibration(int numFibers, int pointsPerFiber) noexcept {
+    if (numFibers < 4) numFibers = 4;
+    if (pointsPerFiber < 8) pointsPerFiber = 8;
+
+    constexpr float pi = std::numbers::pi_v<float>;
+    constexpr float twoPi = 2.0f * std::numbers::pi_v<float>;
+
+    // Distribute base points on S2 using a spiral
+    int sqrtFibers = static_cast<int>(std::sqrt(static_cast<float>(numFibers)));
+    if (sqrtFibers < 2) sqrtFibers = 2;
+
+    std::vector<Vec4> vertices;
+    vertices.reserve(static_cast<size_t>(numFibers) * static_cast<size_t>(pointsPerFiber));
+
+    for (int fi = 0; fi < sqrtFibers; ++fi) {
+        float baseTheta = pi * static_cast<float>(fi) / static_cast<float>(sqrtFibers - 1);
+
+        for (int fj = 0; fj < sqrtFibers; ++fj) {
+            float basePhi = twoPi * static_cast<float>(fj) / static_cast<float>(sqrtFibers);
+
+            // Base point on S2
+            float halfTheta = baseTheta * 0.5f;
+            float cosHalf = std::cos(halfTheta);
+            float sinHalf = std::sin(halfTheta);
+
+            // Trace the Hopf fiber (great circle in S3) for this base point
+            for (int p = 0; p < pointsPerFiber; ++p) {
+                float t = twoPi * static_cast<float>(p) / static_cast<float>(pointsPerFiber);
+
+                float cosT = std::cos(t);
+                float sinT = std::sin(t);
+                float cosBP = std::cos(basePhi + t);
+                float sinBP = std::sin(basePhi + t);
+
+                vertices.emplace_back(
+                    cosHalf * cosT,
+                    cosHalf * sinT,
+                    sinHalf * cosBP,
+                    sinHalf * sinBP
+                );
+            }
+        }
+    }
+
+    return vertices;
+}
+
+} // namespace vib3

package/cpp/geometry/Tesseract.cpp

@@ -0,0 +1,94 @@
+/**
+ * Tesseract.cpp - 4D Hypercube Geometry
+ *
+ * Generates the 16 vertices and 32 edges of a tesseract (4D cube).
+ * Vertices are at all combinations of (+-1, +-1, +-1, +-1).
+ */
+
+#include "math/Vec4.hpp"
+#include <vector>
+#include <cstdint>
+
+namespace vib3 {
+
+/**
+ * Generate the 16 vertices of a tesseract.
+ *
+ * A tesseract has vertices at every combination of (+-1, +-1, +-1, +-1).
+ */
+std::vector<Vec4> generateTesseractVertices() noexcept {
+    std::vector<Vec4> vertices;
+    vertices.reserve(16);
+
+    for (uint8_t i = 0; i < 16; ++i) {
+        float x = (i & 1) ? 1.0f : -1.0f;
+        float y = (i & 2) ? 1.0f : -1.0f;
+        float z = (i & 4) ? 1.0f : -1.0f;
+        float w = (i & 8) ? 1.0f : -1.0f;
+        vertices.emplace_back(x, y, z, w);
+    }
+
+    return vertices;
+}
+
+/**
+ * Edge pair for a tesseract (indices into vertex array).
+ */
+struct Edge {
+    int a, b;
+};
+
+/**
+ * Generate the 32 edges of a tesseract.
+ *
+ * Two vertices share an edge if and only if they differ in exactly one coordinate.
+ */
+std::vector<Edge> generateTesseractEdges() noexcept {
+    std::vector<Edge> edges;
+    edges.reserve(32);
+
+    for (int i = 0; i < 16; ++i) {
+        for (int bit = 0; bit < 4; ++bit) {
+            int j = i ^ (1 << bit);
+            if (j > i) {
+                edges.push_back({i, j});
+            }
+        }
+    }
+
+    return edges;
+}
+
+/**
+ * Generate tesseract geometry with edge interpolation.
+ *
+ * Returns vertices along all edges, creating a wireframe mesh.
+ * Each edge is subdivided into `resolution` segments, generating
+ * intermediate points via linear interpolation.
+ *
+ * @param resolution Number of subdivisions per edge (minimum 2)
+ * @return Vector of 4D points along all tesseract edges
+ */
+std::vector<Vec4> generateTesseract(int resolution) noexcept {
+    if (resolution < 2) resolution = 2;
+
+    auto baseVertices = generateTesseractVertices();
+    auto edges = generateTesseractEdges();
+
+    std::vector<Vec4> vertices;
+    vertices.reserve(static_cast<size_t>(edges.size()) * static_cast<size_t>(resolution));
+
+    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));
+        }
+    }
+
+    return vertices;
+}
+
+} // namespace vib3

package/cpp/geometry/Tetrahedron.cpp

@@ -0,0 +1,83 @@
+/**
+ * Tetrahedron.cpp - 3D Simplex Embedded in 4D
+ *
+ * Generates vertices and edge geometry for a regular tetrahedron
+ * embedded in 4D space (w = 0).
+ */
+
+#include "math/Vec4.hpp"
+#include <vector>
+#include <cmath>
+#include <numbers>
+
+namespace vib3 {
+
+/**
+ * Generate the 4 vertices of a regular tetrahedron in 4D.
+ *
+ * The tetrahedron is centered at the origin with unit edge length,
+ * embedded in the w=0 hyperplane. Vertices are placed so that the
+ * centroid lies at the origin.
+ */
+std::vector<Vec4> generateTetrahedronVertices() noexcept {
+    // Regular tetrahedron vertices centered at origin
+    // Using the standard construction: one vertex up, three forming
+    // an equilateral triangle below.
+    constexpr float a = 1.0f;
+    const float h = a * std::sqrt(2.0f / 3.0f);
+    const float r = a / std::sqrt(3.0f);
+
+    // Vertical offset to center at origin
+    const float yOff = -h / 4.0f;
+
+    std::vector<Vec4> vertices;
+    vertices.reserve(4);
+
+    // Top vertex
+    vertices.emplace_back(0.0f, 3.0f * h / 4.0f + yOff, 0.0f, 0.0f);
+
+    // Bottom triangle
+    vertices.emplace_back(0.0f, yOff, r, 0.0f);
+    vertices.emplace_back(-r * std::sqrt(3.0f) / 2.0f, yOff, -r / 2.0f, 0.0f);
+    vertices.emplace_back( r * std::sqrt(3.0f) / 2.0f, yOff, -r / 2.0f, 0.0f);
+
+    return vertices;
+}
+
+/**
+ * Generate tetrahedron geometry with edge interpolation.
+ *
+ * Subdivides each of the 6 edges into `resolution` segments and
+ * returns all interpolated points.
+ *
+ * @param resolution Number of subdivisions per edge (minimum 2)
+ * @return Vector of 4D points along all tetrahedron edges
+ */
+std::vector<Vec4> generateTetrahedron(int resolution) noexcept {
+    if (resolution < 2) resolution = 2;
+
+    auto baseVertices = generateTetrahedronVertices();
+
+    // 6 edges for a tetrahedron: every pair of 4 vertices
+    constexpr int edgePairs[6][2] = {
+        {0, 1}, {0, 2}, {0, 3},
+        {1, 2}, {1, 3}, {2, 3}
+    };
+
+    std::vector<Vec4> vertices;
+    vertices.reserve(6 * static_cast<size_t>(resolution));
+
+    for (const auto& pair : edgePairs) {
+        const Vec4& a = baseVertices[static_cast<size_t>(pair[0])];
+        const Vec4& b = baseVertices[static_cast<size_t>(pair[1])];
+
+        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));
+        }
+    }
+
+    return vertices;
+}
+
+} // namespace vib3

package/cpp/geometry/Torus.cpp

@@ -0,0 +1,65 @@
+/**
+ * Torus.cpp - Clifford Torus in 4D
+ *
+ * Generates points on the Clifford torus, which is the product of
+ * two circles embedded in 4D: S1 x S1 in R4.
+ *
+ * The Clifford torus is a flat torus that lies on the 3-sphere S3.
+ * Parametrization:
+ *   x = cos(u) * r1
+ *   y = sin(u) * r1
+ *   z = cos(v) * r2
+ *   w = sin(v) * r2
+ * where r1^2 + r2^2 = 1 for it to lie on S3 (r1 = r2 = 1/sqrt(2)).
+ */
+
+#include "math/Vec4.hpp"
+#include <vector>
+#include <cmath>
+#include <numbers>
+
+namespace vib3 {
+
+/**
+ * Generate the Clifford torus in 4D.
+ *
+ * Uses the standard parametrization with equal radii r1 = r2 = 1/sqrt(2),
+ * which places the torus on the unit 3-sphere. The two angles u and v
+ * each range over [0, 2*pi).
+ *
+ * @param resolution Number of subdivisions for each angle (total points = resolution^2)
+ * @return Vector of 4D points on the Clifford torus
+ */
+std::vector<Vec4> generateTorus(int resolution) noexcept {
+    if (resolution < 4) resolution = 4;
+
+    constexpr float twoPi = 2.0f * std::numbers::pi_v<float>;
+    // Equal radii for Clifford torus on S3
+    constexpr float r = 1.0f / std::numbers::sqrt2_v<float>;
+
+    std::vector<Vec4> vertices;
+    vertices.reserve(static_cast<size_t>(resolution) * static_cast<size_t>(resolution));
+
+    for (int iu = 0; iu < resolution; ++iu) {
+        float u = twoPi * static_cast<float>(iu) / static_cast<float>(resolution);
+        float cosU = std::cos(u);
+        float sinU = std::sin(u);
+
+        for (int iv = 0; iv < resolution; ++iv) {
+            float v = twoPi * static_cast<float>(iv) / static_cast<float>(resolution);
+            float cosV = std::cos(v);
+            float sinV = std::sin(v);
+
+            vertices.emplace_back(
+                r * cosU,
+                r * sinU,
+                r * cosV,
+                r * sinV
+            );
+        }
+    }
+
+    return vertices;
+}
+
+} // namespace vib3

package/cpp/geometry/WarpFunctions.cpp

@@ -0,0 +1,238 @@
+/**
+ * WarpFunctions.cpp - Core Type Warp Functions
+ *
+ * Provides warp transformations that modify base geometries to create
+ * the three core type variants (Base, Hypersphere, Hypertetrahedron).
+ *
+ * Core type 0 (Base, index 0-7):   No warp, pure base geometry.
+ * Core type 1 (Hypersphere, 8-15): Project onto 3-sphere surface.
+ * Core type 2 (Hypertetra, 16-23): Warp toward pentatope vertices.
+ */
+
+#include "math/Vec4.hpp"
+#include <vector>
+#include <cmath>
+#include <numbers>
+#include <algorithm>
+
+namespace vib3 {
+
+/**
+ * Project a 4D point onto the 3-sphere of given radius.
+ *
+ * Normalizes the point to lie on S3, then scales by `radius`.
+ * If the point is at the origin, returns a default point on the sphere.
+ *
+ * @param point  Input 4D point
+ * @param radius Radius of the target 3-sphere
+ * @return Point projected onto S3 * radius
+ */
+Vec4 warpHypersphere(Vec4 point, float radius) noexcept {
+    float len = point.length();
+
+    if (len < 1e-8f) {
+        // Degenerate case: return a default point on the sphere
+        return Vec4(radius, 0.0f, 0.0f, 0.0f);
+    }
+
+    return point * (radius / len);
+}
+
+/**
+ * Inverse stereographic projection from R3 to S3.
+ *
+ * Maps a 3D point (interpreted as x,y,z with w=0) onto the 3-sphere
+ * using inverse stereographic projection from the north pole (0,0,0,1).
+ *
+ * @param point Input 4D point (only x,y,z used)
+ * @return Point on unit S3
+ */
+Vec4 inverseStereographicToHypersphere(Vec4 point) noexcept {
+    float r2 = point.x * point.x + point.y * point.y + point.z * point.z;
+    float denom = 1.0f + r2;
+
+    return Vec4(
+        2.0f * point.x / denom,
+        2.0f * point.y / denom,
+        2.0f * point.z / denom,
+        (r2 - 1.0f) / denom
+    );
+}
+
+/**
+ * Apply Hopf fibration mapping.
+ *
+ * Given a point on S3, returns its base point on S2 (the Hopf projection)
+ * and the fiber angle. This is used to visualize toroidal structures
+ * inherent in the 3-sphere.
+ *
+ * @param point Point on S3
+ * @return Projected point (x,y,z = S2 base point, w = fiber angle)
+ */
+Vec4 hopfProject(Vec4 point) noexcept {
+    // Normalize to ensure on S3
+    Vec4 p = point.normalized();
+
+    // Hopf map S3 -> S2:
+    //   n1 = 2(x*z + y*w)
+    //   n2 = 2(y*z - x*w)
+    //   n3 = x^2 + y^2 - z^2 - w^2
+    float n1 = 2.0f * (p.x * p.z + p.y * p.w);
+    float n2 = 2.0f * (p.y * p.z - p.x * p.w);
+    float n3 = p.x * p.x + p.y * p.y - p.z * p.z - p.w * p.w;
+
+    // Fiber angle
+    float fiberAngle = std::atan2(p.y, p.x) - std::atan2(p.w, p.z);
+
+    return Vec4(n1, n2, n3, fiberAngle);
+}
+
+/**
+ * Batch warp: project all points in a geometry onto S3.
+ *
+ * @param points Input geometry vertices
+ * @param radius Radius of the target 3-sphere
+ * @return Warped vertices on the 3-sphere
+ */
+std::vector<Vec4> warpHypersphereBatch(const std::vector<Vec4>& points,
+                                        float radius) noexcept {
+    std::vector<Vec4> result;
+    result.reserve(points.size());
+
+    for (const auto& p : points) {
+        result.push_back(warpHypersphere(p, radius));
+    }
+
+    return result;
+}
+
+// ---- Hypertetrahedron (Pentatope) Warp ----
+
+namespace {
+
+/**
+ * The 5 vertices of a regular 5-cell (pentatope) in R4.
+ *
+ * These are the vertices of the simplest regular 4D polytope,
+ * the analogue of the tetrahedron in 4D.
+ */
+constexpr int kPentatopeVertexCount = 5;
+
+Vec4 getPentatopeVertex(int index) noexcept {
+    // Standard regular 5-cell vertices
+    // Constructed so that all pairwise distances are equal.
+    const float s = std::sqrt(2.0f / 5.0f);
+    const float t = std::sqrt(2.0f / 3.0f);
+    const float u = 1.0f / std::sqrt(3.0f);
+    const float v = 1.0f / std::sqrt(15.0f);
+
+    switch (index) {
+        case 0: return Vec4( t,         0.0f,     0.0f,     -v);
+        case 1: return Vec4(-u,         u,        0.0f,     -v);
+        case 2: return Vec4(-u,        -u,        0.0f,     -v);
+        case 3: return Vec4( 0.0f,      0.0f,     t,        -v);
+        case 4: return Vec4( 0.0f,      0.0f,     0.0f,  4.0f * v);
+        default: return Vec4::zero();
+    }
+}
+
+} // anonymous namespace
+
+/**
+ * Warp a 4D point toward the nearest pentatope vertex.
+ *
+ * Finds the closest vertex of the regular 5-cell and interpolates
+ * the point toward it, creating a tetrahedral clustering effect.
+ * The interpolation factor is based on the inverse distance to
+ * the nearest vertex, producing a gravitational pull effect.
+ *
+ * @param point Input 4D point
+ * @return Warped point attracted toward nearest pentatope vertex
+ */
+Vec4 warpHypertetra(Vec4 point) noexcept {
+    // Find nearest pentatope vertex
+    int nearestIdx = 0;
+    float nearestDist = point.distanceSquaredTo(getPentatopeVertex(0));
+
+    for (int i = 1; i < kPentatopeVertexCount; ++i) {
+        float dist = point.distanceSquaredTo(getPentatopeVertex(i));
+        if (dist < nearestDist) {
+            nearestDist = dist;
+            nearestIdx = i;
+        }
+    }
+
+    Vec4 nearest = getPentatopeVertex(nearestIdx);
+
+    // Warp factor based on distance (closer = stronger pull)
+    float dist = std::sqrt(nearestDist);
+    float warpStrength = 1.0f / (1.0f + dist * 2.0f);
+
+    // Interpolate toward the nearest pentatope vertex
+    return point.lerp(nearest, warpStrength);
+}
+
+/**
+ * Warp a 4D point onto the edges of the pentatope.
+ *
+ * Projects the point to the nearest edge of the 5-cell,
+ * producing a skeletal wireframe appearance.
+ *
+ * @param point Input 4D point
+ * @return Point projected onto nearest pentatope edge
+ */
+Vec4 warpToEdges(Vec4 point) noexcept {
+    // 10 edges of the pentatope (all pairs of 5 vertices)
+    constexpr int edgePairs[10][2] = {
+        {0, 1}, {0, 2}, {0, 3}, {0, 4},
+        {1, 2}, {1, 3}, {1, 4},
+        {2, 3}, {2, 4},
+        {3, 4}
+    };
+
+    Vec4 bestProjection = point;
+    float bestDist = 1e10f;
+
+    for (const auto& pair : edgePairs) {
+        Vec4 a = getPentatopeVertex(pair[0]);
+        Vec4 b = getPentatopeVertex(pair[1]);
+        Vec4 edge = b - a;
+        Vec4 toPoint = point - a;
+
+        // Project onto edge (clamped to [0,1])
+        float edgeLenSq = edge.dot(edge);
+        if (edgeLenSq < 1e-10f) continue;
+
+        float t = toPoint.dot(edge) / edgeLenSq;
+        t = std::max(0.0f, std::min(1.0f, t));
+
+        Vec4 projected = a.lerp(b, t);
+        float dist = point.distanceSquaredTo(projected);
+
+        if (dist < bestDist) {
+            bestDist = dist;
+            bestProjection = projected;
+        }
+    }
+
+    return bestProjection;
+}
+
+/**
+ * Batch warp: apply hypertetra warp to all points.
+ *
+ * @param points Input geometry vertices
+ * @return Warped vertices attracted toward pentatope vertices
+ */
+std::vector<Vec4> warpHypertetraBatch(const std::vector<Vec4>& points) noexcept {
+    std::vector<Vec4> result;
+    result.reserve(points.size());
+
+    for (const auto& p : points) {
+        result.push_back(warpHypertetra(p));
+    }
+
+    return result;
+}
+
+} // namespace vib3

package/cpp/geometry/Wave.cpp

@@ -0,0 +1,85 @@
+/**
+ * Wave.cpp - Sinusoidal Interference Pattern in 4D
+ *
+ * Generates a grid of 4D points with sinusoidal wave displacement.
+ * The base grid lies in the XZ plane, with Y and W components driven
+ * by interference of multiple wave sources.
+ */
+
+#include "math/Vec4.hpp"
+#include <vector>
+#include <cmath>
+#include <numbers>
+
+namespace vib3 {
+
+/**
+ * Generate a 4D sinusoidal interference pattern.
+ *
+ * Creates a resolution x resolution grid in the XZ plane, centered at
+ * the origin. The Y component is displaced by the sum of three wave
+ * sources with different frequencies, and the W component uses a
+ * cross-wave pattern, producing a rich 4D interference field.
+ *
+ * @param resolution Number of grid points along each axis (total = resolution^2)
+ * @return Vector of 4D points with wave displacement
+ */
+std::vector<Vec4> generateWave(int resolution) noexcept {
+    if (resolution < 4) resolution = 4;
+
+    constexpr float pi = std::numbers::pi_v<float>;
+
+    // Grid extends from -gridExtent to +gridExtent
+    constexpr float gridExtent = 2.0f;
+
+    // Wave parameters: {frequency, amplitude, phase offset X, phase offset Z}
+    struct WaveSource {
+        float freq;
+        float ampY;
+        float ampW;
+        float phaseX;
+        float phaseZ;
+    };
+
+    constexpr WaveSource waves[] = {
+        { 1.0f,  0.5f, 0.3f, 0.0f,        0.0f        },  // Primary wave
+        { 2.3f,  0.25f, 0.15f, pi * 0.5f,  pi * 0.25f  },  // Secondary wave
+        { 3.7f,  0.125f, 0.1f, pi * 0.75f, pi * 0.6f   },  // Tertiary wave
+    };
+    constexpr int numWaves = 3;
+
+    std::vector<Vec4> vertices;
+    vertices.reserve(static_cast<size_t>(resolution) * static_cast<size_t>(resolution));
+
+    float step = (2.0f * gridExtent) / static_cast<float>(resolution - 1);
+
+    for (int ix = 0; ix < resolution; ++ix) {
+        float x = -gridExtent + static_cast<float>(ix) * step;
+
+        for (int iz = 0; iz < resolution; ++iz) {
+            float z = -gridExtent + static_cast<float>(iz) * step;
+
+            float y = 0.0f;
+            float w = 0.0f;
+
+            // Sum contributions from all wave sources
+            for (int wi = 0; wi < numWaves; ++wi) {
+                const auto& ws = waves[wi];
+                float phX = ws.freq * x * pi + ws.phaseX;
+                float phZ = ws.freq * z * pi + ws.phaseZ;
+
+                // Y displacement: circular wave pattern
+                y += ws.ampY * std::sin(phX) * std::cos(phZ);
+
+                // W displacement: cross-interference pattern
+                w += ws.ampW * std::cos(phX + phZ);
+            }
+
+            vertices.emplace_back(x, y, z, w);
+        }
+    }
+
+    return vertices;
+}
+
+} // namespace vib3