@3driseai/3drise-viewer 0.1.1

package/dist/utils/shaderUtils.js

@@ -0,0 +1,151 @@
+import { Color } from 'three';
+export function update3driseShaderUniforms(uniforms, effects, u_time, pointer) {
+    if (!uniforms)
+        return;
+    if (uniforms.u_time)
+        uniforms.u_time.value = u_time;
+    if (uniforms.u_pointer)
+        uniforms.u_pointer.value = pointer;
+    if (effects.pointer) {
+        const { global, vertex, fragment } = effects.pointer;
+        if (global) {
+            if (uniforms.uPointerEffectRadius)
+                uniforms.uPointerEffectRadius.value = global.radius;
+        }
+        if (vertex) {
+            if (uniforms.uRippleEnabled && vertex.ripple)
+                uniforms.uRippleEnabled.value = vertex.ripple.enabled;
+            if (uniforms.uRippleIntensity && vertex.ripple)
+                uniforms.uRippleIntensity.value = vertex.ripple.intensity;
+            if (uniforms.uRippleSpeed && vertex.ripple)
+                uniforms.uRippleSpeed.value = vertex.ripple.speed;
+            if (uniforms.uGeneralRippleFrequency && vertex.ripple)
+                uniforms.uGeneralRippleFrequency.value = vertex.ripple.frequency;
+            if (uniforms.uDisplacementEnabled && vertex.displacement)
+                uniforms.uDisplacementEnabled.value = vertex.displacement.enabled;
+            if (uniforms.uDisplacementIntensity && vertex.displacement)
+                uniforms.uDisplacementIntensity.value = vertex.displacement.intensity;
+            if (uniforms.uScaleEnabled && vertex.scale)
+                uniforms.uScaleEnabled.value = vertex.scale.enabled;
+            if (uniforms.uScaleIntensity && vertex.scale)
+                uniforms.uScaleIntensity.value = vertex.scale.intensity;
+            if (uniforms.uMinScale && vertex.scale)
+                uniforms.uMinScale.value = vertex.scale.minScale;
+            if (uniforms.uMaxScale && vertex.scale)
+                uniforms.uMaxScale.value = vertex.scale.maxScale;
+            if (uniforms.uVortexEnabled && vertex.vortex)
+                uniforms.uVortexEnabled.value = vertex.vortex.enabled;
+            if (uniforms.uVortexIntensity && vertex.vortex)
+                uniforms.uVortexIntensity.value = vertex.vortex.intensity;
+            if (uniforms.uVortexSpeed && vertex.vortex)
+                uniforms.uVortexSpeed.value = vertex.vortex.speed;
+            if (uniforms.uWaveEnabled && vertex.wave)
+                uniforms.uWaveEnabled.value = vertex.wave.enabled;
+            if (uniforms.uWaveIntensity && vertex.wave)
+                uniforms.uWaveIntensity.value = vertex.wave.intensity;
+            if (uniforms.uWaveFrequency && vertex.wave)
+                uniforms.uWaveFrequency.value = vertex.wave.frequency;
+        }
+        if (fragment) {
+            if (uniforms.uGlowEnabled && fragment.glow)
+                uniforms.uGlowEnabled.value = fragment.glow.enabled;
+            if (uniforms.uGlowIntensity && fragment.glow)
+                uniforms.uGlowIntensity.value = fragment.glow.intensity;
+            if (uniforms.uGlowColor && fragment.glow)
+                uniforms.uGlowColor.value = new Color(fragment.glow.color);
+            if (uniforms.uColorShiftEnabled && fragment.colorShift)
+                uniforms.uColorShiftEnabled.value = fragment.colorShift.enabled;
+            if (uniforms.uColorShiftIntensity && fragment.colorShift)
+                uniforms.uColorShiftIntensity.value = fragment.colorShift.intensity;
+            if (uniforms.uColorShiftTarget && fragment.colorShift)
+                uniforms.uColorShiftTarget.value = new Color(fragment.colorShift.targetColor);
+            if (uniforms.uBrightnessEnabled && fragment.brightness)
+                uniforms.uBrightnessEnabled.value = fragment.brightness.enabled;
+            if (uniforms.uBrightnessIntensity && fragment.brightness)
+                uniforms.uBrightnessIntensity.value = fragment.brightness.intensity;
+            if (uniforms.uPulseEnabled && fragment.pulse)
+                uniforms.uPulseEnabled.value = fragment.pulse.enabled;
+            if (uniforms.uPulseIntensity && fragment.pulse)
+                uniforms.uPulseIntensity.value = fragment.pulse.intensity;
+            if (uniforms.uPulseSpeed && fragment.pulse)
+                uniforms.uPulseSpeed.value = fragment.pulse.speed;
+            if (uniforms.uPointerGrayscaleEnabled && fragment.grayscale)
+                uniforms.uPointerGrayscaleEnabled.value = fragment.grayscale.enabled;
+            if (uniforms.uPointerGrayscaleIntensity && fragment.grayscale)
+                uniforms.uPointerGrayscaleIntensity.value = fragment.grayscale.intensity;
+            if (uniforms.uPointerGrayscaleContrast && fragment.grayscale)
+                uniforms.uPointerGrayscaleContrast.value = fragment.grayscale.contrast;
+            if (uniforms.uPointerGrayscaleBrightness && fragment.grayscale)
+                uniforms.uPointerGrayscaleBrightness.value = fragment.grayscale.brightness;
+        }
+    }
+    if (effects.general) {
+        const { wave, vortex, ripple, grayscale } = effects.general;
+        if (uniforms.uGeneralWaveEnabled && wave)
+            uniforms.uGeneralWaveEnabled.value = wave.enabled;
+        if (uniforms.uGeneralWaveIntensity && wave)
+            uniforms.uGeneralWaveIntensity.value = wave.intensity;
+        if (uniforms.uGeneralWaveFrequency && wave)
+            uniforms.uGeneralWaveFrequency.value = wave.frequency;
+        if (uniforms.uGeneralWaveSpeed && wave)
+            uniforms.uGeneralWaveSpeed.value = wave.speed;
+        if (uniforms.uGeneralWaveDirection && wave) {
+            uniforms.uGeneralWaveDirection.value =
+                wave.direction === 'horizontal' ? 0.0 :
+                    wave.direction === 'vertical' ? 1.0 : 2.0;
+        }
+        if (uniforms.uGeneralVortexEnabled && vortex)
+            uniforms.uGeneralVortexEnabled.value = vortex.enabled;
+        if (uniforms.uGeneralVortexIntensity && vortex)
+            uniforms.uGeneralVortexIntensity.value = vortex.intensity;
+        if (uniforms.uGeneralVortexSpeed && vortex)
+            uniforms.uGeneralVortexSpeed.value = vortex.speed;
+        if (uniforms.uGeneralVortexCenterX && vortex)
+            uniforms.uGeneralVortexCenterX.value = vortex.centerX;
+        if (uniforms.uGeneralVortexCenterY && vortex)
+            uniforms.uGeneralVortexCenterY.value = vortex.centerY;
+        if (uniforms.uGeneralRippleEnabled && ripple)
+            uniforms.uGeneralRippleEnabled.value = ripple.enabled;
+        if (uniforms.uGeneralRippleIntensity && ripple)
+            uniforms.uGeneralRippleIntensity.value = ripple.intensity;
+        if (uniforms.uGeneralRippleFrequency && ripple)
+            uniforms.uGeneralRippleFrequency.value = ripple.frequency;
+        if (uniforms.uGeneralRippleSpeed && ripple)
+            uniforms.uGeneralRippleSpeed.value = ripple.speed;
+        if (uniforms.uGeneralRippleCenterX && ripple)
+            uniforms.uGeneralRippleCenterX.value = ripple.centerX;
+        if (uniforms.uGeneralRippleCenterY && ripple)
+            uniforms.uGeneralRippleCenterY.value = ripple.centerY;
+        if (uniforms.uGeneralGrayscaleEnabled && grayscale)
+            uniforms.uGeneralGrayscaleEnabled.value = grayscale.enabled;
+        if (uniforms.uGeneralGrayscaleMode && grayscale) {
+            uniforms.uGeneralGrayscaleMode.value =
+                grayscale.mode === 'static' ? 0.0 :
+                    grayscale.mode === 'wave' ? 1.0 :
+                        grayscale.mode === 'pulse' ? 2.0 : 3.0;
+        }
+        if (uniforms.uGeneralGrayscaleIntensity && grayscale)
+            uniforms.uGeneralGrayscaleIntensity.value = grayscale.intensity;
+        if (uniforms.uGeneralGrayscaleContrast && grayscale)
+            uniforms.uGeneralGrayscaleContrast.value = grayscale.contrast;
+        if (uniforms.uGeneralGrayscaleBrightness && grayscale)
+            uniforms.uGeneralGrayscaleBrightness.value = grayscale.brightness;
+        if (uniforms.uGeneralGrayscaleWaveFreq && grayscale)
+            uniforms.uGeneralGrayscaleWaveFreq.value = grayscale.waveFrequency;
+        if (uniforms.uGeneralGrayscaleWaveSpeed && grayscale)
+            uniforms.uGeneralGrayscaleWaveSpeed.value = grayscale.waveSpeed;
+        if (uniforms.uGeneralGrayscaleWaveDir && grayscale) {
+            uniforms.uGeneralGrayscaleWaveDir.value =
+                grayscale.waveDirection === 'horizontal' ? 0.0 :
+                    grayscale.waveDirection === 'vertical' ? 1.0 : 2.0;
+        }
+        if (uniforms.uGeneralGrayscalePulseSpeed && grayscale)
+            uniforms.uGeneralGrayscalePulseSpeed.value = grayscale.pulseSpeed;
+        if (uniforms.uGeneralGrayscaleRippleSpeed && grayscale)
+            uniforms.uGeneralGrayscaleRippleSpeed.value = grayscale.rippleSpeed;
+        if (uniforms.uGeneralGrayscaleRippleCenterX && grayscale)
+            uniforms.uGeneralGrayscaleRippleCenterX.value = grayscale.rippleCenterX;
+        if (uniforms.uGeneralGrayscaleRippleCenterY && grayscale)
+            uniforms.uGeneralGrayscaleRippleCenterY.value = grayscale.rippleCenterY;
+    }
+}

package/dist/utils/shapes.d.ts

@@ -0,0 +1,74 @@
+import { BufferGeometry } from 'three';
+export type ShapeName = 'heart' | 'box' | 'star' | 'polygon' | 'gear' | 'flower' | 'spade' | 'club' | 'diamond' | 'droplet' | 'lightning' | 'sparkle' | 'shield' | 'pawPrint' | 'superformula' | 'sphere' | 'cylinder' | 'cone' | 'torus' | 'plane' | 'ring' | 'arcPlane' | 'bentPlane' | 'bentPlaneInverse' | 'capsule' | 'icosahedron' | 'octahedron' | 'tetrahedron' | 'dodecahedron' | 'text' | 'point' | 'custom' | 'infinity';
+export interface ShapeOptions {
+    type: ShapeName;
+    curveSegments?: number;
+    subdivisions?: number;
+    segments?: number;
+    rings?: number;
+    /** counts */
+    points?: number;
+    sides?: number;
+    petals?: number;
+    teeth?: number;
+    bumps?: number;
+    widthSegments?: number;
+    heightSegments?: number;
+    radialSegments?: number;
+    tubularSegments?: number;
+    thetaSegments?: number;
+    phiSegments?: number;
+    capSegments?: number;
+    detail?: number;
+    /** radii */
+    outer?: number;
+    inner?: number;
+    hole?: number;
+    radiusTop?: number;
+    radiusBottom?: number;
+    innerRadius?: number;
+    outerRadius?: number;
+    /** rect-like footprint */
+    width?: number;
+    height?: number;
+    radius?: number;
+    length?: number;
+    arc?: number;
+    startAngle?: number;
+    endAngle?: number;
+    tube?: number;
+    size?: number;
+    text?: string;
+    vertices?: number[];
+    indices?: number[];
+    normals?: number[];
+    uvs?: number[];
+    /** misc shape controls */
+    offset?: number;
+    taper?: number;
+    tail?: number;
+    vein?: boolean;
+    sharp?: number;
+    /** bevel (shared) */
+    bevelThickness?: number;
+    bevelSize?: number;
+    bevelSegments?: number;
+    /** superformula */
+    symmetry?: number;
+    roundness?: number;
+    twist1?: number;
+    twist2?: number;
+    stretchX?: number;
+    stretchY?: number;
+    samples?: number;
+    /** infinity */
+    waist?: number;
+    thickness?: number;
+}
+export type ShapeGenerator = (opts: ShapeOptions) => BufferGeometry;
+/**
+ * Extensible shape registry. Each generator returns the RAW geometry only.
+ * Centering, scaling / fit, and orientation are handled separately by the host.
+ */
+export declare const shapeGenerators: Record<ShapeName, ShapeGenerator>;
+//# sourceMappingURL=shapes.d.ts.map

package/dist/utils/shapes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shapes.d.ts","sourceRoot":"","sources":["../../src/utils/shapes.ts"],"names":[],"mappings":"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"}

package/dist/utils/shapes.js

@@ -0,0 +1,443 @@
+import { BoxGeometry, BufferGeometry, CapsuleGeometry, ConeGeometry, CylinderGeometry, DodecahedronGeometry, ExtrudeGeometry, Float32BufferAttribute, IcosahedronGeometry, OctahedronGeometry, Path, PlaneGeometry, RingGeometry, Shape, ShapeGeometry, SphereGeometry, TetrahedronGeometry, TorusGeometry, } from 'three';
+import { mergeGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
+const safeNumber = (value, fallback, min) => {
+    const num = typeof value === 'number' && !Number.isNaN(value) ? value : fallback;
+    return min !== undefined ? Math.max(num, min) : num;
+};
+/** Shared extrude wrapper — keeps the bevel boilerplate out of every generator. */
+function extrude(shape, curveSegments = 64, bevelThickness = 0.03, bevelSize = 0.03, bevelSegments = 3) {
+    return new ExtrudeGeometry(shape, {
+        curveSegments,
+        bevelEnabled: true,
+        bevelThickness,
+        bevelSize,
+        bevelSegments,
+    });
+}
+/**
+ * Extensible shape registry. Each generator returns the RAW geometry only.
+ * Centering, scaling / fit, and orientation are handled separately by the host.
+ */
+export const shapeGenerators = {
+    /* ---------------- basics ---------------- */
+    heart: ({ curveSegments, bevelThickness, bevelSize, bevelSegments }) => {
+        const s = new Shape();
+        s.moveTo(0.25, 0.25);
+        s.bezierCurveTo(0.25, 0.25, 0.20, 0, 0, 0);
+        s.bezierCurveTo(-0.30, 0, -0.30, 0.35, -0.30, 0.35);
+        s.bezierCurveTo(-0.30, 0.55, -0.10, 0.77, 0.25, 0.95);
+        s.bezierCurveTo(0.60, 0.77, 0.80, 0.55, 0.80, 0.35);
+        s.bezierCurveTo(0.80, 0.35, 0.80, 0, 0.50, 0);
+        s.bezierCurveTo(0.35, 0, 0.25, 0.25, 0.25, 0.25);
+        return extrude(s, curveSegments, bevelThickness, bevelSize, bevelSegments);
+    },
+    box: ({ subdivisions = 1 }) => new BoxGeometry(1, 1, 1, subdivisions, subdivisions, subdivisions),
+    sphere: ({ radius, segments, rings }) => {
+        const normalizedSegments = safeNumber(segments, 32, 3);
+        return new SphereGeometry(safeNumber(radius, 0.5, 0.0001), normalizedSegments, safeNumber(rings, normalizedSegments, 2));
+    },
+    infinity: ({ 
+    // overall scale (half the lemniscate's reach)
+    waist = 0.14, // half-height where the two lobes meet — smaller = sharper crossing
+    thickness = 0.12, // ribbon width; drives the leaf-hole size
+    samples = 220, // silhouette resolution
+    curveSegments = 64, bevelThickness = 0.02, bevelSize = 0.02, bevelSegments = 2, }) => {
+        // Lemniscate silhouette r² = a²·cos(2θ) + b² — pointed lobes, deep solid-center waist.
+        const a = 0.5;
+        const b = Math.sqrt(a * a + waist * waist);
+        const rOf = (th) => Math.sqrt(Math.max(a * a * Math.cos(2 * th) + b * b, 1e-6));
+        const s = new Shape();
+        for (let i = 0; i <= samples; i++) {
+            const th = (i / samples) * Math.PI * 2;
+            const r = rOf(th);
+            if (i === 0)
+                s.moveTo(r * Math.cos(th), r * Math.sin(th));
+            else
+                s.lineTo(r * Math.cos(th), r * Math.sin(th));
+        }
+        s.closePath();
+        // Two leaf "eyes" — one per lobe — sized to leave a ~constant ribbon of `thickness`.
+        const xTip = rOf(0);
+        let maxY = 0;
+        for (let i = 0; i <= 120; i++) {
+            const th = -Math.PI / 4 + (i / 120) * (Math.PI / 2);
+            maxY = Math.max(maxY, Math.abs(rOf(th) * Math.sin(th)));
+        }
+        const xIn = thickness * 1.2;
+        const xOut = xTip - thickness;
+        const xc = (xIn + xOut) / 2;
+        const Lx = Math.max((xOut - xIn) / 2, 0.02);
+        const Ly = Math.max(maxY - thickness, 0.02);
+        const eye = (cx) => {
+            const h = new Path();
+            h.moveTo(cx - Lx, 0);
+            h.quadraticCurveTo(cx, Ly, cx + Lx, 0);
+            h.quadraticCurveTo(cx, -Ly, cx - Lx, 0);
+            h.closePath();
+            return h;
+        };
+        s.holes.push(eye(xc), eye(-xc));
+        return extrude(s, curveSegments, bevelThickness, bevelSize, bevelSegments);
+    },
+    cylinder: ({ radiusTop, radiusBottom, height, radialSegments }) => new CylinderGeometry(safeNumber(radiusTop, 0.5, 0.0001), safeNumber(radiusBottom, 0.5, 0.0001), safeNumber(height, 1, 0.0001), safeNumber(radialSegments, 32, 3)),
+    cone: ({ radius, height, radialSegments }) => new ConeGeometry(safeNumber(radius, 0.5, 0.0001), safeNumber(height, 1, 0.0001), safeNumber(radialSegments, 32, 3)),
+    torus: ({ radius, tube, radialSegments, tubularSegments }) => new TorusGeometry(safeNumber(radius, 0.5, 0.0001), safeNumber(tube, 0.2, 0.0001), safeNumber(radialSegments, 16, 3), safeNumber(tubularSegments, 100, 3)),
+    plane: ({ width, height, widthSegments, heightSegments }) => new PlaneGeometry(safeNumber(width, 1, 0.0001), safeNumber(height, 1, 0.0001), safeNumber(widthSegments, 1, 1), safeNumber(heightSegments, 1, 1)),
+    ring: ({ innerRadius, outerRadius, thetaSegments, phiSegments }) => new RingGeometry(safeNumber(innerRadius, 0.3, 0.0001), safeNumber(outerRadius, 0.8, 0.0001), safeNumber(thetaSegments, 32, 3), safeNumber(phiSegments, 8, 1)),
+    arcPlane: ({ radius, startAngle, endAngle, width, segments }) => {
+        const safeRadius = safeNumber(radius, 1, 0.0001);
+        const safeWidth = safeNumber(width, 0.2, 0.0001);
+        const safeStart = safeNumber(startAngle, 0);
+        const safeEnd = safeNumber(endAngle, Math.PI);
+        const shape = new Shape();
+        shape.absarc(0, 0, safeRadius, safeStart, safeEnd, false);
+        shape.lineTo(Math.cos(safeEnd) * (safeRadius - safeWidth), Math.sin(safeEnd) * (safeRadius - safeWidth));
+        shape.absarc(0, 0, safeRadius - safeWidth, safeEnd, safeStart, true);
+        shape.closePath();
+        return new ShapeGeometry(shape, safeNumber(segments, 32, 3));
+    },
+    bentPlane: ({ height = 1, radius = 2, arc = Math.PI / 2, widthSegments = 32, heightSegments = 1 }) => {
+        const geometry = new BufferGeometry();
+        const vertices = [];
+        const indices = [];
+        const uvs = [];
+        const safeHeight = safeNumber(height, 1, 0.0001);
+        const safeRadius = safeNumber(radius, 2, 0.0001);
+        const safeArc = safeNumber(arc, Math.PI / 2, 0.0001);
+        const safeWidthSegments = safeNumber(widthSegments, 32, 1);
+        const safeHeightSegments = safeNumber(heightSegments, 1, 1);
+        const startAngle = -safeArc / 2;
+        const endAngle = safeArc / 2;
+        for (let j = 0; j <= safeHeightSegments; j++) {
+            const v = j / safeHeightSegments;
+            const y = (v - 0.5) * safeHeight;
+            for (let i = 0; i <= safeWidthSegments; i++) {
+                const u = i / safeWidthSegments;
+                const angle = startAngle + (endAngle - startAngle) * u;
+                vertices.push(Math.sin(angle) * safeRadius, y, Math.cos(angle) * safeRadius - safeRadius);
+                uvs.push(u, v);
+            }
+        }
+        for (let j = 0; j < safeHeightSegments; j++) {
+            for (let i = 0; i < safeWidthSegments; i++) {
+                const a = i + (safeWidthSegments + 1) * j;
+                const b = i + (safeWidthSegments + 1) * (j + 1);
+                const c = (i + 1) + (safeWidthSegments + 1) * (j + 1);
+                const d = (i + 1) + (safeWidthSegments + 1) * j;
+                indices.push(a, b, d, b, c, d);
+            }
+        }
+        geometry.setAttribute('position', new Float32BufferAttribute(vertices, 3));
+        geometry.setAttribute('uv', new Float32BufferAttribute(uvs, 2));
+        geometry.setIndex(indices);
+        geometry.computeVertexNormals();
+        return geometry;
+    },
+    bentPlaneInverse: ({ height = 1, radius = 2, arc = Math.PI / 2, widthSegments = 32, heightSegments = 1 }) => {
+        const geometry = new BufferGeometry();
+        const vertices = [];
+        const indices = [];
+        const uvs = [];
+        const safeHeight = safeNumber(height, 1, 0.0001);
+        const safeRadius = safeNumber(radius, 2, 0.0001);
+        const safeArc = safeNumber(arc, Math.PI / 2, 0.0001);
+        const safeWidthSegments = safeNumber(widthSegments, 32, 1);
+        const safeHeightSegments = safeNumber(heightSegments, 1, 1);
+        const startAngle = -safeArc / 2;
+        const endAngle = safeArc / 2;
+        for (let j = 0; j <= safeHeightSegments; j++) {
+            const v = j / safeHeightSegments;
+            const y = (v - 0.5) * safeHeight;
+            for (let i = 0; i <= safeWidthSegments; i++) {
+                const u = i / safeWidthSegments;
+                const angle = startAngle + (endAngle - startAngle) * u;
+                vertices.push(Math.sin(angle) * safeRadius, y, -Math.cos(angle) * safeRadius + safeRadius);
+                uvs.push(u, v);
+            }
+        }
+        for (let j = 0; j < safeHeightSegments; j++) {
+            for (let i = 0; i < safeWidthSegments; i++) {
+                const a = i + (safeWidthSegments + 1) * j;
+                const b = i + (safeWidthSegments + 1) * (j + 1);
+                const c = (i + 1) + (safeWidthSegments + 1) * (j + 1);
+                const d = (i + 1) + (safeWidthSegments + 1) * j;
+                indices.push(a, b, d, b, c, d);
+            }
+        }
+        geometry.setAttribute('position', new Float32BufferAttribute(vertices, 3));
+        geometry.setAttribute('uv', new Float32BufferAttribute(uvs, 2));
+        geometry.setIndex(indices);
+        geometry.computeVertexNormals();
+        return geometry;
+    },
+    capsule: ({ radius, length, capSegments, radialSegments }) => new CapsuleGeometry(safeNumber(radius, 0.3, 0.0001), safeNumber(length, 1.0, 0.0001), safeNumber(capSegments, 4, 1), safeNumber(radialSegments, 8, 3)),
+    icosahedron: ({ radius, detail }) => new IcosahedronGeometry(safeNumber(radius, 0.5, 0.0001), safeNumber(detail, 0, 0)),
+    octahedron: ({ radius, detail }) => new OctahedronGeometry(safeNumber(radius, 0.5, 0.0001), safeNumber(detail, 0, 0)),
+    tetrahedron: ({ radius, detail }) => new TetrahedronGeometry(safeNumber(radius, 0.5, 0.0001), safeNumber(detail, 0, 0)),
+    dodecahedron: ({ radius, detail }) => new DodecahedronGeometry(safeNumber(radius, 0.5, 0.0001), safeNumber(detail, 0, 0)),
+    text: ({ text = 'Hello', size, height }) => new BoxGeometry(text.length * safeNumber(size, 1, 0.0001) * 0.6, safeNumber(size, 1, 0.0001), safeNumber(height, 0.2, 0.0001)),
+    point: ({ size }) => new SphereGeometry(safeNumber(size, 0.1, 0.0001), 16, 16),
+    custom: ({ vertices = [], indices = [], normals, uvs }) => {
+        console.log('custom shape generator called with vertices:', vertices.length, 'indices:', indices.length, 'normals:', normals?.length, 'uvs:', uvs?.length);
+        const geometry = new BufferGeometry();
+        if (vertices.length > 0) {
+            geometry.setAttribute('position', new Float32BufferAttribute(vertices, 3));
+        }
+        if (indices.length > 0) {
+            geometry.setIndex(indices);
+        }
+        if (normals && normals.length === vertices.length) {
+            geometry.setAttribute('normal', new Float32BufferAttribute(normals, 3));
+        }
+        else {
+            geometry.computeVertexNormals();
+        }
+        if (uvs && uvs.length === (vertices.length / 3) * 2) {
+            geometry.setAttribute('uv', new Float32BufferAttribute(uvs, 2));
+        }
+        else if (vertices.length > 0) {
+            const vertexCount = vertices.length / 3;
+            const autoUvs = new Float32Array(vertexCount * 2);
+            let minX = Infinity;
+            let maxX = -Infinity;
+            let minZ = Infinity;
+            let maxZ = -Infinity;
+            for (let i = 0; i < vertexCount; i++) {
+                const x = vertices[i * 3];
+                const z = vertices[i * 3 + 2];
+                minX = Math.min(minX, x);
+                maxX = Math.max(maxX, x);
+                minZ = Math.min(minZ, z);
+                maxZ = Math.max(maxZ, z);
+            }
+            const rangeX = maxX - minX || 1;
+            const rangeZ = maxZ - minZ || 1;
+            for (let i = 0; i < vertexCount; i++) {
+                autoUvs[i * 2] = (vertices[i * 3] - minX) / rangeX;
+                autoUvs[i * 2 + 1] = (vertices[i * 3 + 2] - minZ) / rangeZ;
+            }
+            geometry.setAttribute('uv', new Float32BufferAttribute(autoUvs, 2));
+        }
+        return geometry;
+    },
+    star: ({ points = 5, outer = 0.5, inner = 0.2, curveSegments, bevelThickness, bevelSize, bevelSegments }) => {
+        const s = new Shape();
+        for (let i = 0; i < points * 2; i++) {
+            const r = i % 2 === 0 ? outer : inner;
+            const a = (i / (points * 2)) * Math.PI * 2 + Math.PI / 2;
+            if (i === 0)
+                s.moveTo(Math.cos(a) * r, Math.sin(a) * r);
+            else
+                s.lineTo(Math.cos(a) * r, Math.sin(a) * r);
+        }
+        s.closePath();
+        return extrude(s, curveSegments, bevelThickness, bevelSize, bevelSegments);
+    },
+    polygon: ({ sides = 6, curveSegments, bevelThickness, bevelSize, bevelSegments }) => {
+        const s = new Shape();
+        for (let i = 0; i < sides; i++) {
+            const a = (i / sides) * Math.PI * 2 + Math.PI / 2;
+            if (i === 0)
+                s.moveTo(Math.cos(a) * 0.5, Math.sin(a) * 0.5);
+            else
+                s.lineTo(Math.cos(a) * 0.5, Math.sin(a) * 0.5);
+        }
+        s.closePath();
+        return extrude(s, curveSegments, bevelThickness, bevelSize, bevelSegments);
+    },
+    gear: ({ teeth = 12, outer = 0.5, inner = 0.38, hole = 0.16, curveSegments, bevelThickness = 0.02, bevelSize = 0.02, bevelSegments = 2 }) => {
+        const s = new Shape();
+        const step = (Math.PI * 2) / teeth;
+        for (let i = 0; i < teeth; i++) {
+            const a = i * step + Math.PI / 2;
+            const ang = [a + step * 0.2, a + step * 0.35, a + step * 0.65, a + step * 0.8];
+            const rad = [inner, outer, outer, inner];
+            for (let j = 0; j < 4; j++) {
+                const x = Math.cos(ang[j]) * rad[j];
+                const y = Math.sin(ang[j]) * rad[j];
+                if (i === 0 && j === 0)
+                    s.moveTo(x, y);
+                else
+                    s.lineTo(x, y);
+            }
+        }
+        s.closePath();
+        const h = new Path();
+        h.absarc(0, 0, hole, 0, Math.PI * 2, true);
+        s.holes.push(h);
+        return extrude(s, curveSegments, bevelThickness, bevelSize, bevelSegments);
+    },
+    flower: ({ petals = 6, outer = 0.5, inner = 0.26, sharp = 0.7, curveSegments, bevelThickness = 0.02, bevelSize = 0.02, bevelSegments = 2 }) => {
+        const s = new Shape();
+        const N = Math.max(96, petals * 24);
+        for (let i = 0; i <= N; i++) {
+            const t = (i / N) * Math.PI * 2;
+            const k = 0.5 + 0.5 * Math.cos(petals * t);
+            const r = inner + (outer - inner) * Math.pow(k, sharp);
+            const a = t + Math.PI / 2;
+            if (i === 0)
+                s.moveTo(Math.cos(a) * r, Math.sin(a) * r);
+            else
+                s.lineTo(Math.cos(a) * r, Math.sin(a) * r);
+        }
+        s.closePath();
+        return extrude(s, curveSegments, bevelThickness, bevelSize, bevelSegments);
+    },
+    /* ---------------- symbolic ---------------- */
+    spade: ({ curveSegments, bevelThickness, bevelSize, bevelSegments }) => {
+        const s = new Shape();
+        s.moveTo(0, 0.5); // apex
+        s.bezierCurveTo(-0.05, 0.30, -0.45, 0.18, -0.45, -0.05);
+        s.bezierCurveTo(-0.45, -0.28, -0.18, -0.30, -0.05, -0.12);
+        s.bezierCurveTo(-0.10, -0.28, -0.16, -0.34, -0.18, -0.42); // stem flare
+        s.lineTo(0.18, -0.42);
+        s.bezierCurveTo(0.16, -0.34, 0.10, -0.28, 0.05, -0.12);
+        s.bezierCurveTo(0.18, -0.30, 0.45, -0.28, 0.45, -0.05);
+        s.bezierCurveTo(0.45, 0.18, 0.05, 0.30, 0, 0.5);
+        s.closePath();
+        return extrude(s, curveSegments, bevelThickness, bevelSize, bevelSegments);
+    },
+    club: ({ curveSegments, bevelThickness = 0.02, bevelSize = 0.02, bevelSegments = 2 }) => {
+        const R = 0.32;
+        const A = 0.18;
+        const gap = (18 * Math.PI) / 180; // bottom gap for the stem
+        const start = Math.PI * 1.5 + gap; // just past bottom, CCW
+        const sweep = Math.PI * 2 - 2 * gap;
+        const N = 200;
+        const s = new Shape();
+        for (let i = 0; i <= N; i++) {
+            const t = start + (i / N) * sweep;
+            const r = R + A * Math.cos(3 * (t - Math.PI / 2));
+            if (i === 0)
+                s.moveTo(Math.cos(t) * r, Math.sin(t) * r);
+            else
+                s.lineTo(Math.cos(t) * r, Math.sin(t) * r);
+        }
+        // stem across the bottom gap
+        s.lineTo(-0.07, -0.5);
+        s.lineTo(0.07, -0.5);
+        s.closePath();
+        return extrude(s, curveSegments, bevelThickness, bevelSize, bevelSegments);
+    },
+    diamond: ({ curveSegments, bevelThickness, bevelSize, bevelSegments }) => {
+        const w = 1 / 2;
+        const h = 1;
+        const s = new Shape();
+        s.moveTo(0, h);
+        s.lineTo(w, 0);
+        s.lineTo(0, -h);
+        s.lineTo(-w, 0);
+        s.closePath();
+        return extrude(s, curveSegments, bevelThickness, bevelSize, bevelSegments);
+    },
+    droplet: ({ width = 0.5, taper = 1, curveSegments, bevelThickness = 0.02, bevelSize = 0.02, bevelSegments = 2 }) => {
+        const w = width / 2;
+        const top = 0.55 * taper;
+        const bot = -0.45;
+        const s = new Shape();
+        s.moveTo(0, top);
+        s.bezierCurveTo(w * 0.2, top * 0.55, w, (top + bot) * 0.5, w, bot * 0.45);
+        s.bezierCurveTo(w, bot, w * 0.5, bot * 1.25, 0, bot * 1.25);
+        s.bezierCurveTo(-w * 0.5, bot * 1.25, -w, bot, -w, bot * 0.45);
+        s.bezierCurveTo(-w, (top + bot) * 0.5, -w * 0.2, top * 0.55, 0, top);
+        s.closePath();
+        return extrude(s, curveSegments, bevelThickness, bevelSize, bevelSegments);
+    },
+    lightning: ({ width = 0.6, height = 1, curveSegments, bevelThickness = 0.015, bevelSize = 0.015, bevelSegments = 1 }) => {
+        const pts = [
+            [0.10, 0.50], [-0.25, 0.05], [-0.05, 0.05], [-0.20, -0.50], [0.25, 0.0], [0.05, 0.0],
+        ];
+        const s = new Shape();
+        pts.forEach(([x, y], i) => {
+            const px = x * width;
+            const py = y * height;
+            if (i === 0)
+                s.moveTo(px, py);
+            else
+                s.lineTo(px, py);
+        });
+        s.closePath();
+        return extrude(s, curveSegments, bevelThickness, bevelSize, bevelSegments);
+    },
+    sparkle: ({ points = 4, outer = 0.5, inner = 0.14, curveSegments, bevelThickness = 0.015, bevelSize = 0.015, bevelSegments = 1 }) => {
+        const step = (Math.PI * 2) / points;
+        const tip = (k) => {
+            const a = k * step + Math.PI / 2;
+            return [Math.cos(a) * outer, Math.sin(a) * outer];
+        };
+        const ctrl = (k) => {
+            const a = (k + 0.5) * step + Math.PI / 2;
+            return [Math.cos(a) * inner, Math.sin(a) * inner];
+        };
+        const s = new Shape();
+        const [x0, y0] = tip(0);
+        s.moveTo(x0, y0);
+        for (let i = 0; i < points; i++) {
+            const [cx, cy] = ctrl(i);
+            const [tx, ty] = tip((i + 1) % points);
+            s.quadraticCurveTo(cx, cy, tx, ty);
+        }
+        s.closePath();
+        return extrude(s, curveSegments, bevelThickness, bevelSize, bevelSegments);
+    },
+    shield: ({ width = 0.8, curveSegments, bevelThickness, bevelSize, bevelSegments }) => {
+        const w = width / 2;
+        const top = 1 / 2;
+        const bot = -1 / 2;
+        const s = new Shape();
+        s.moveTo(-w, top);
+        s.lineTo(w, top);
+        s.lineTo(w, top * 0.1);
+        s.bezierCurveTo(w, bot * 0.5, w * 0.5, bot * 0.9, 0, bot);
+        s.bezierCurveTo(-w * 0.5, bot * 0.9, -w, bot * 0.5, -w, top * 0.1);
+        s.closePath();
+        return extrude(s, curveSegments, bevelThickness, bevelSize, bevelSegments);
+    },
+    pawPrint: ({ curveSegments, bevelThickness = 0.02, bevelSize = 0.02, bevelSegments = 2 }) => {
+        const blob = (cx, cy, rx, ry) => {
+            const sh = new Shape();
+            const seg = 48;
+            for (let i = 0; i <= seg; i++) {
+                const a = (i / seg) * Math.PI * 2;
+                const x = cx + Math.cos(a) * rx;
+                const y = cy + Math.sin(a) * ry;
+                if (i === 0)
+                    sh.moveTo(x, y);
+                else
+                    sh.lineTo(x, y);
+            }
+            sh.closePath();
+            return extrude(sh, curveSegments, bevelThickness, bevelSize, bevelSegments);
+        };
+        return mergeGeometries([
+            blob(0, -0.18, 0.30, 0.24), // pad
+            blob(-0.26, 0.10, 0.11, 0.14),
+            blob(-0.09, 0.26, 0.11, 0.15),
+            blob(0.09, 0.26, 0.11, 0.15),
+            blob(0.26, 0.10, 0.11, 0.14),
+        ], false);
+    },
+    /* ---------------- parametric ---------------- */
+    superformula: ({ symmetry = 6, // was m  — rotational symmetry (lobe / corner count)
+    roundness = 0.3, // was n1 — overall inflation: lower = puffier, higher = pinched/spikier
+    twist1 = 0.3, // was n2 — exponent on the cosine term
+    twist2 = 0.3, // was n3 — exponent on the sine term
+    stretchX = 1, // was a  — scales the cosine term (horizontal stretch)
+    stretchY = 1, // was b  — scales the sine term (vertical stretch)
+    samples = 256, curveSegments, bevelThickness = 0.02, bevelSize = 0.02, bevelSegments = 2, }) => {
+        const s = new Shape();
+        for (let i = 0; i <= samples; i++) {
+            const phi = (i / samples) * Math.PI * 2;
+            const t1 = Math.pow(Math.abs(Math.cos((symmetry * phi) / 4) / stretchX), twist1);
+            const t2 = Math.pow(Math.abs(Math.sin((symmetry * phi) / 4) / stretchY), twist2);
+            const r = Math.pow(t1 + t2, -1 / roundness);
+            const ang = phi + Math.PI / 2;
+            if (i === 0)
+                s.moveTo(Math.cos(ang) * r, Math.sin(ang) * r);
+            else
+                s.lineTo(Math.cos(ang) * r, Math.sin(ang) * r);
+        }
+        s.closePath();
+        return extrude(s, curveSegments, bevelThickness, bevelSize, bevelSegments);
+    },
+};