@vib3code/sdk 2.0.1

package/src/geometry/generators/Wave.js

@@ -0,0 +1,341 @@
+/**
+ * Wave Geometry Generator
+ *
+ * Generates sinusoidal interference patterns in 4D space.
+ * Models wave phenomena, standing waves, and interference patterns.
+ */
+
+import { Vec4 } from '../../math/Vec4.js';
+
+/**
+ * Generate 4D standing wave pattern
+ * @param {number} amplitude - Wave amplitude
+ * @param {number} frequency - Wave frequency
+ * @param {number} segments - Resolution per axis
+ * @returns {Vec4[]} Vertices
+ */
+export function generateStandingWave4D(amplitude = 0.5, frequency = 2, segments = 16) {
+    const vertices = [];
+    const step = (2 * Math.PI) / segments;
+
+    for (let i = 0; i <= segments; i++) {
+        const u = i * step;
+        for (let j = 0; j <= segments; j++) {
+            const v = j * step;
+            for (let k = 0; k <= Math.floor(segments / 2); k++) {
+                const t = (k / (segments / 2)) * Math.PI;
+
+                // Standing wave in 4D
+                const x = Math.cos(u);
+                const y = Math.sin(u) * Math.cos(v);
+                const z = Math.sin(u) * Math.sin(v) * Math.cos(t);
+                const w = amplitude * Math.sin(frequency * u) *
+                         Math.sin(frequency * v) *
+                         Math.cos(frequency * t);
+
+                vertices.push(new Vec4(x, y, z, w));
+            }
+        }
+    }
+
+    return vertices;
+}
+
+/**
+ * Generate interference pattern from two 4D wave sources
+ * @param {Vec4} source1 - First wave source position
+ * @param {Vec4} source2 - Second wave source position
+ * @param {number} wavelength - Wave wavelength
+ * @param {number} gridSize - Sampling grid size
+ * @param {number} segments - Resolution
+ * @returns {Vec4[]} Vertices with W as amplitude
+ */
+export function generateInterferencePattern(
+    source1 = new Vec4(-1, 0, 0, 0),
+    source2 = new Vec4(1, 0, 0, 0),
+    wavelength = 0.5,
+    gridSize = 2,
+    segments = 20
+) {
+    const vertices = [];
+    const k = (2 * Math.PI) / wavelength;
+    const step = (2 * gridSize) / segments;
+
+    for (let i = 0; i <= segments; i++) {
+        const x = -gridSize + i * step;
+        for (let j = 0; j <= segments; j++) {
+            const y = -gridSize + j * step;
+            for (let l = 0; l <= Math.floor(segments / 2); l++) {
+                const z = -gridSize / 2 + l * step;
+
+                // Distance from each source
+                const pos = new Vec4(x, y, z, 0);
+                const d1 = pos.distanceTo(source1);
+                const d2 = pos.distanceTo(source2);
+
+                // Superposition of waves
+                const wave1 = Math.sin(k * d1) / Math.max(d1, 0.1);
+                const wave2 = Math.sin(k * d2) / Math.max(d2, 0.1);
+                const amplitude = (wave1 + wave2) * 0.5;
+
+                vertices.push(new Vec4(x, y, z, amplitude));
+            }
+        }
+    }
+
+    return vertices;
+}
+
+/**
+ * Generate 4D ripple surface
+ * @param {number} radius - Surface radius
+ * @param {number} frequency - Ripple frequency
+ * @param {number} decay - Amplitude decay rate
+ * @param {number} segments - Resolution
+ * @returns {Vec4[]} Vertices
+ */
+export function generateRippleSurface(radius = 2, frequency = 4, decay = 0.5, segments = 32) {
+    const vertices = [];
+
+    for (let i = 0; i <= segments; i++) {
+        const u = (i / segments) * Math.PI * 2;
+        for (let j = 0; j <= segments; j++) {
+            const r = (j / segments) * radius;
+
+            const x = r * Math.cos(u);
+            const y = r * Math.sin(u);
+
+            // Ripple in Z and W dimensions
+            const ripple = Math.sin(frequency * r) * Math.exp(-decay * r);
+            const z = ripple * 0.5;
+            const w = ripple * Math.cos(u * 2) * 0.3;
+
+            vertices.push(new Vec4(x, y, z, w));
+        }
+    }
+
+    return vertices;
+}
+
+/**
+ * Generate sinusoidal helix in 4D
+ * @param {number} radius - Helix radius
+ * @param {number} pitch - Helix pitch
+ * @param {number} turns - Number of turns
+ * @param {number} segments - Resolution
+ * @returns {Vec4[]} Vertices
+ */
+export function generateWaveHelix4D(radius = 1, pitch = 0.5, turns = 3, segments = 100) {
+    const vertices = [];
+    const totalAngle = turns * 2 * Math.PI;
+
+    for (let i = 0; i <= segments; i++) {
+        const t = (i / segments) * totalAngle;
+
+        const x = radius * Math.cos(t);
+        const y = radius * Math.sin(t);
+        const z = pitch * t / (2 * Math.PI);
+        // W oscillates creating a 4D wave pattern
+        const w = 0.3 * Math.sin(t * 3);
+
+        vertices.push(new Vec4(x, y, z, w));
+    }
+
+    return vertices;
+}
+
+/**
+ * Generate plane wave in 4D
+ * @param {Vec4} direction - Wave propagation direction (normalized)
+ * @param {number} wavelength - Wavelength
+ * @param {number} amplitude - Wave amplitude
+ * @param {number} gridSize - Sampling region size
+ * @param {number} segments - Resolution
+ * @returns {Vec4[]} Vertices
+ */
+export function generatePlaneWave4D(
+    direction = new Vec4(1, 0, 0, 0).normalize(),
+    wavelength = 1,
+    amplitude = 0.5,
+    gridSize = 2,
+    segments = 16
+) {
+    const vertices = [];
+    const k = (2 * Math.PI) / wavelength;
+    const step = (2 * gridSize) / segments;
+
+    for (let i = 0; i <= segments; i++) {
+        const x = -gridSize + i * step;
+        for (let j = 0; j <= segments; j++) {
+            const y = -gridSize + j * step;
+            for (let l = 0; l <= segments; l++) {
+                const z = -gridSize + l * step;
+
+                // Phase based on dot product with direction
+                const pos = new Vec4(x, y, z, 0);
+                const phase = k * pos.dot(direction);
+                const w = amplitude * Math.sin(phase);
+
+                vertices.push(new Vec4(x, y, z, w));
+            }
+        }
+    }
+
+    return vertices;
+}
+
+/**
+ * Generate spherical wave emanating from origin in 4D
+ * @param {number} maxRadius - Maximum radius
+ * @param {number} frequency - Wave frequency
+ * @param {number} segments - Resolution
+ * @returns {Vec4[]} Vertices
+ */
+export function generateSphericalWave4D(maxRadius = 2, frequency = 3, segments = 24) {
+    const vertices = [];
+
+    // Use 4D spherical coordinates
+    for (let i = 0; i <= segments; i++) {
+        const phi1 = (i / segments) * Math.PI;
+        for (let j = 0; j <= segments; j++) {
+            const phi2 = (j / segments) * Math.PI;
+            for (let k = 0; k <= segments * 2; k++) {
+                const phi3 = (k / (segments * 2)) * Math.PI * 2;
+
+                // Radius varies with wave
+                const baseR = (i / segments) * maxRadius;
+                const wave = 0.1 * Math.sin(frequency * baseR);
+                const r = baseR + wave;
+
+                // 4D hyperspherical coordinates
+                const x = r * Math.sin(phi1) * Math.sin(phi2) * Math.cos(phi3);
+                const y = r * Math.sin(phi1) * Math.sin(phi2) * Math.sin(phi3);
+                const z = r * Math.sin(phi1) * Math.cos(phi2);
+                const w = r * Math.cos(phi1);
+
+                vertices.push(new Vec4(x, y, z, w));
+            }
+        }
+    }
+
+    return vertices;
+}
+
+/**
+ * Generate wave edges (connect sequential points)
+ * @param {Vec4[]} vertices
+ * @param {number} stride - Connection stride
+ * @returns {number[][]} Edge pairs
+ */
+export function generateWaveEdges(vertices, stride = 1) {
+    const edges = [];
+
+    for (let i = 0; i < vertices.length - stride; i += stride) {
+        edges.push([i, i + stride]);
+    }
+
+    return edges;
+}
+
+/**
+ * Generate grid edges for wave surface
+ * @param {number} uSegments
+ * @param {number} vSegments
+ * @returns {number[][]} Edge pairs
+ */
+export function generateWaveGridEdges(uSegments, vSegments) {
+    const edges = [];
+
+    for (let i = 0; i < uSegments; i++) {
+        for (let j = 0; j < vSegments; j++) {
+            const idx = i * (vSegments + 1) + j;
+            const nextU = (i + 1) * (vSegments + 1) + j;
+            const nextV = i * (vSegments + 1) + j + 1;
+
+            if (i < uSegments - 1) edges.push([idx, nextU]);
+            if (j < vSegments) edges.push([idx, nextV]);
+        }
+    }
+
+    return edges;
+}
+
+/**
+ * Generate complete wave geometry
+ * @param {string} type - 'standing', 'interference', 'ripple', 'helix', 'plane', 'spherical'
+ * @param {object} params - Type-specific parameters
+ * @returns {object} Geometry
+ */
+export function generateWave(type = 'standing', params = {}) {
+    const {
+        amplitude = 0.5,
+        frequency = 2,
+        segments = 16,
+        radius = 1
+    } = params;
+
+    let vertices, edges;
+
+    switch (type) {
+        case 'standing':
+            vertices = generateStandingWave4D(amplitude, frequency, segments);
+            edges = generateWaveEdges(vertices);
+            break;
+
+        case 'interference':
+            vertices = generateInterferencePattern(
+                params.source1,
+                params.source2,
+                params.wavelength || 0.5,
+                params.gridSize || 2,
+                segments
+            );
+            edges = generateWaveEdges(vertices);
+            break;
+
+        case 'ripple':
+            vertices = generateRippleSurface(radius, frequency, params.decay || 0.5, segments);
+            edges = generateWaveGridEdges(segments, segments);
+            break;
+
+        case 'helix':
+            vertices = generateWaveHelix4D(radius, params.pitch || 0.5, params.turns || 3, segments * 6);
+            edges = generateWaveEdges(vertices);
+            break;
+
+        case 'plane':
+            vertices = generatePlaneWave4D(
+                params.direction,
+                params.wavelength || 1,
+                amplitude,
+                params.gridSize || 2,
+                segments
+            );
+            edges = [];
+            break;
+
+        case 'spherical':
+            vertices = generateSphericalWave4D(radius, frequency, Math.floor(segments / 2));
+            edges = [];
+            break;
+
+        default:
+            vertices = generateStandingWave4D(amplitude, frequency, segments);
+            edges = generateWaveEdges(vertices);
+    }
+
+    return {
+        name: `wave_${type}`,
+        vertices,
+        edges,
+        faces: [],
+        vertexCount: vertices.length,
+        edgeCount: edges.length,
+        faceCount: 0,
+        waveType: type,
+        frequency,
+        amplitude
+    };
+}
+
+export default generateWave;

package/src/geometry/index.js

@@ -0,0 +1,142 @@
+/**
+ * Geometry Module
+ *
+ * Complete 4D geometry generation system with 24 variants.
+ *
+ * Encoding: geometry = coreIndex * 8 + baseIndex
+ *
+ * Base Geometries (0-7):
+ *   0: Tetrahedron - 5-cell (pentatope)
+ *   1: Hypercube - Tesseract
+ *   2: Sphere - 4D hypersphere
+ *   3: Torus - Clifford torus
+ *   4: Klein Bottle - Non-orientable 4D surface
+ *   5: Fractal - Recursive 4D structures
+ *   6: Wave - Sinusoidal 4D patterns
+ *   7: Crystal - Crystalline lattices
+ *
+ * Core Types:
+ *   0: Base (0-7) - Pure geometry
+ *   1: Hypersphere (8-15) - Wrapped in 4D sphere
+ *   2: Hypertetrahedron (16-23) - Wrapped in 5-cell
+ */
+
+// Main factory
+export {
+    GeometryFactory,
+    defaultFactory,
+    generateGeometry,
+    generateBaseGeometry,
+    applyWarp,
+    decodeGeometry,
+    encodeGeometry,
+    getGeometryName,
+    getAllGeometryNames,
+    BASE_GEOMETRIES,
+    CORE_TYPES
+} from './GeometryFactory.js';
+
+// Base generators
+export { default as generateTesseract } from './generators/Tesseract.js';
+export {
+    generateTesseractVertices,
+    generateTesseractEdges,
+    generateTesseractFaces
+} from './generators/Tesseract.js';
+
+export {
+    generate5Cell,
+    generate5CellVertices,
+    generate5CellEdges,
+    generateTetrahedronLattice
+} from './generators/Tetrahedron.js';
+
+export {
+    default as generateHypersphere,
+    generateHypersphereVertices,
+    generateHypersphereFibonacci,
+    generateHypersphereLatitudes
+} from './generators/Sphere.js';
+
+export {
+    generateCliffordTorus,
+    generate4DTorus,
+    generateTorusEdges
+} from './generators/Torus.js';
+
+export {
+    default as generateKleinBottle,
+    generateKleinBottleVertices,
+    generateKleinBottleBottle,
+    generateKleinBottleEdges,
+    generateMobiusStrip
+} from './generators/KleinBottle.js';
+
+export {
+    default as generateFractal,
+    generateSierpinskiPentatope,
+    generateMengerHypersponge,
+    generateFractalTree4D,
+    generateCantorDust4D
+} from './generators/Fractal.js';
+
+export {
+    default as generateWave,
+    generateStandingWave4D,
+    generateInterferencePattern,
+    generateRippleSurface,
+    generateWaveHelix4D,
+    generatePlaneWave4D,
+    generateSphericalWave4D
+} from './generators/Wave.js';
+
+export {
+    default as generateCrystal,
+    generate16CellVertices,
+    generate16CellEdges,
+    generate24CellVertices,
+    generate24CellEdges,
+    generateCubicLattice4D,
+    generateFCCLattice4D,
+    generateDiamondCrystal4D,
+    generateQuasicrystal4D,
+    generateUnitCell4D
+} from './generators/Crystal.js';
+
+// Warp functions
+export {
+    warpHypersphereCore,
+    projectToHypersphere,
+    stereographicToHypersphere,
+    hopfFibration,
+    warpRadial,
+    warpStereographic,
+    warpHopf,
+    generateHypersphereSurface
+} from './warp/HypersphereCore.js';
+
+export {
+    warpHypertetraCore,
+    getPentatopeVertices,
+    getPentatopeEdges,
+    getPentatopeFaces,
+    getPentatopeCells,
+    warpTetrahedral,
+    warpToEdges,
+    warpToCells,
+    generatePentatope
+} from './warp/HypertetraCore.js';
+
+export { CORE_TYPES as WARP_CORE_TYPES, getCoreTypeName } from './warp/index.js';
+
+// Buffer utilities
+export {
+    buildVertexBuffer,
+    buildEdgeIndexBuffer,
+    buildFaceIndexBuffer,
+    buildInterleavedBuffer,
+    buildNormalBuffer,
+    generateWDepthColors,
+    generateRainbowColors,
+    buildGeometryBuffers
+} from './buffers/BufferBuilder.js';

package/src/geometry/warp/HypersphereCore.js

@@ -0,0 +1,211 @@
+/**
+ * Hypersphere Core Warp
+ *
+ * Warps base geometry onto a 4D hypersphere surface.
+ * Creates geometries 8-15 in the 24-variant encoding system.
+ *
+ * The warp projects points onto the 3-sphere (S³), which is the
+ * set of all unit vectors in 4D space.
+ */
+
+import { Vec4 } from '../../math/Vec4.js';
+
+/**
+ * Project a point onto the 3-sphere (hypersphere surface)
+ * @param {Vec4} point - Input point
+ * @param {number} radius - Hypersphere radius
+ * @returns {Vec4} Point on hypersphere
+ */
+export function projectToHypersphere(point, radius = 1) {
+    const len = point.length();
+    if (len < 0.0001) {
+        // Handle origin - project to north pole
+        return new Vec4(0, 0, 0, radius);
+    }
+    return point.scale(radius / len);
+}
+
+/**
+ * Inverse stereographic projection from R³ to S³
+ * Maps all of 3D space onto the 4D hypersphere
+ * @param {Vec4} point - Input point (uses x, y, z)
+ * @param {number} radius - Hypersphere radius
+ * @returns {Vec4} Point on hypersphere
+ */
+export function stereographicToHypersphere(point, radius = 1) {
+    const x = point.x;
+    const y = point.y;
+    const z = point.z;
+
+    const sumSq = x * x + y * y + z * z;
+    const denom = sumSq + 1;
+
+    return new Vec4(
+        (2 * x) / denom * radius,
+        (2 * y) / denom * radius,
+        (2 * z) / denom * radius,
+        (sumSq - 1) / denom * radius
+    );
+}
+
+/**
+ * Hopf fibration mapping
+ * Maps points on S² × [0, 2π] to S³
+ * Creates beautiful toroidal structures on the hypersphere
+ * @param {number} theta - Angle on base S² (0 to π)
+ * @param {number} phi - Azimuth on base S² (0 to 2π)
+ * @param {number} psi - Fiber angle (0 to 2π)
+ * @param {number} radius - Hypersphere radius
+ * @returns {Vec4} Point on hypersphere
+ */
+export function hopfFibration(theta, phi, psi, radius = 1) {
+    const cosTheta2 = Math.cos(theta / 2);
+    const sinTheta2 = Math.sin(theta / 2);
+
+    return new Vec4(
+        cosTheta2 * Math.cos((phi + psi) / 2) * radius,
+        cosTheta2 * Math.sin((phi + psi) / 2) * radius,
+        sinTheta2 * Math.cos((phi - psi) / 2) * radius,
+        sinTheta2 * Math.sin((phi - psi) / 2) * radius
+    );
+}
+
+/**
+ * Warp a geometry onto the hypersphere using radial projection
+ * @param {Vec4[]} vertices - Input vertices
+ * @param {number} radius - Hypersphere radius
+ * @param {number} blendFactor - How much to blend (0=original, 1=full sphere)
+ * @returns {Vec4[]} Warped vertices
+ */
+export function warpRadial(vertices, radius = 1, blendFactor = 1) {
+    return vertices.map(v => {
+        const onSphere = projectToHypersphere(v, radius);
+        return v.lerp(onSphere, blendFactor);
+    });
+}
+
+/**
+ * Warp geometry using stereographic projection
+ * Maps the entire geometry onto the hypersphere
+ * @param {Vec4[]} vertices - Input vertices
+ * @param {number} radius - Hypersphere radius
+ * @param {number} scale - Pre-scale factor before projection
+ * @returns {Vec4[]} Warped vertices
+ */
+export function warpStereographic(vertices, radius = 1, scale = 1) {
+    return vertices.map(v => {
+        const scaled = v.scale(scale);
+        return stereographicToHypersphere(scaled, radius);
+    });
+}
+
+/**
+ * Warp geometry along Hopf fibers
+ * Creates twisted, fibered structures
+ * @param {Vec4[]} vertices - Input vertices
+ * @param {number} radius - Hypersphere radius
+ * @param {number} twist - Twist factor along fiber
+ * @returns {Vec4[]} Warped vertices
+ */
+export function warpHopf(vertices, radius = 1, twist = 1) {
+    return vertices.map(v => {
+        // Convert to spherical-like coordinates
+        const r = v.length();
+        if (r < 0.0001) {
+            return new Vec4(0, 0, 0, radius);
+        }
+
+        // Use original angles but apply to Hopf structure
+        const theta = Math.acos(v.z / r);
+        const phi = Math.atan2(v.y, v.x);
+        const psi = v.w * twist + phi * 0.5;
+
+        return hopfFibration(theta, phi, psi, radius);
+    });
+}
+
+/**
+ * Main hypersphere core warp function
+ * Wraps base geometry in a 4D hypersphere structure
+ *
+ * @param {object} geometry - Base geometry with vertices and edges
+ * @param {object} options - Warp options
+ * @param {string} options.method - 'radial', 'stereographic', 'hopf'
+ * @param {number} options.radius - Hypersphere radius (default 1)
+ * @param {number} options.blend - Blend factor (default 1)
+ * @param {number} options.scale - Pre-scale factor (default 1)
+ * @param {number} options.twist - Hopf twist factor (default 1)
+ * @returns {object} Warped geometry
+ */
+export function warpHypersphereCore(geometry, options = {}) {
+    const {
+        method = 'radial',
+        radius = 1,
+        blend = 1,
+        scale = 1,
+        twist = 1
+    } = options;
+
+    let warpedVertices;
+
+    // Pre-scale vertices
+    const scaledVertices = geometry.vertices.map(v => v.scale(scale));
+
+    switch (method) {
+        case 'stereographic':
+            warpedVertices = warpStereographic(scaledVertices, radius, 1);
+            break;
+
+        case 'hopf':
+            warpedVertices = warpHopf(scaledVertices, radius, twist);
+            break;
+
+        case 'radial':
+        default:
+            warpedVertices = warpRadial(scaledVertices, radius, blend);
+            break;
+    }
+
+    return {
+        ...geometry,
+        name: `${geometry.name}_hypersphere`,
+        vertices: warpedVertices,
+        vertexCount: warpedVertices.length,
+        coreType: 'hypersphere',
+        warpMethod: method,
+        warpRadius: radius
+    };
+}
+
+/**
+ * Generate pure hypersphere surface (for reference)
+ * @param {number} radius - Hypersphere radius
+ * @param {number} segments - Resolution per angle
+ * @returns {Vec4[]} Vertices on hypersphere
+ */
+export function generateHypersphereSurface(radius = 1, segments = 16) {
+    const vertices = [];
+
+    // Use 3 angular parameters for S³
+    for (let i = 0; i <= segments; i++) {
+        const psi = (i / segments) * Math.PI;
+        for (let j = 0; j <= segments; j++) {
+            const theta = (j / segments) * Math.PI;
+            for (let k = 0; k <= segments * 2; k++) {
+                const phi = (k / (segments * 2)) * Math.PI * 2;
+
+                // Hyperspherical coordinates
+                const x = radius * Math.sin(psi) * Math.sin(theta) * Math.cos(phi);
+                const y = radius * Math.sin(psi) * Math.sin(theta) * Math.sin(phi);
+                const z = radius * Math.sin(psi) * Math.cos(theta);
+                const w = radius * Math.cos(psi);
+
+                vertices.push(new Vec4(x, y, z, w));
+            }
+        }
+    }
+
+    return vertices;
+}
+
+export default warpHypersphereCore;