@3driseai/3drise-viewer 0.1.1

package/dist/components/GeometryShape.d.ts

@@ -0,0 +1,54 @@
+import type { ReactNode } from 'react';
+import type { BufferGeometry } from 'three';
+import type { GeometryShapeConfig, MaterialSettings, ModeConfig, ObjectAnimations } from "@3driseai/3drise-core";
+type Pt = [number, number, number];
+type ModeData = {
+    kind: 'mesh';
+} | {
+    kind: 'points';
+    positions: Float32Array;
+} | {
+    kind: 'lines';
+    points: Pt[];
+} | {
+    kind: 'plexus';
+    positions: Float32Array;
+    segments: Pt[];
+};
+export interface GeometryMeshProps {
+    config: GeometryShapeConfig;
+    modeConfig?: ModeConfig;
+    materialSettings: MaterialSettings;
+    animations?: ObjectAnimations;
+    color?: string;
+    /** Material for the solid path (defaults to a standard material). */
+    children?: ReactNode;
+}
+export declare function useShapeGeometry(options: GeometryShapeConfig): BufferGeometry;
+/** interior fill via point-in-mesh ray-parity (closed meshes only) */
+export declare function volumeFill(geo: BufferGeometry, count: number, oversample?: number): Float32Array;
+/** area-weighted points on the skin — the keystone for the modes below */
+export declare function surfaceScatter(geo: BufferGeometry, count: number): Float32Array;
+/** fold into one wedge, mirror, rotate-copy around Z → kaleidoscope */
+export declare function symmetricScatter(geo: BufferGeometry, count: number, sym: number): Float32Array;
+/** blue-noise: oversample then reject anything closer than minDist (grid-hashed) */
+export declare function evenScatter(geo: BufferGeometry, count: number, spacing: number): Float32Array;
+export declare function meshVertices(geo: BufferGeometry): Float32Array;
+export declare function edges3D(geo: BufferGeometry, angleDeg: number): Pt[];
+export declare function contour2D(geo: BufferGeometry): Pt[];
+export declare function wireframe(geo: BufferGeometry): Pt[];
+/** slice at stepped heights, draw each triangle's cross-section segment (axis: 0=x 1=y 2=z) */
+export declare function contourSlices(geo: BufferGeometry, slices: number, axis?: number): Pt[];
+export declare function plexus(geo: BufferGeometry, count: number, radiusMul: number, maxLinks?: number): {
+    positions: Float32Array;
+    segments: Pt[];
+};
+export declare function computeMode(geo: BufferGeometry, c: ModeConfig): ModeData;
+export declare function GeometryMesh({ config, materialSettings, animations, modeConfig, color, children }: GeometryMeshProps): import("react").JSX.Element;
+export declare function FitGroup({ geometry, radius, children }: {
+    geometry: BufferGeometry;
+    radius?: number;
+    children?: ReactNode;
+}): any;
+export {};
+//# sourceMappingURL=GeometryShape.d.ts.map

package/dist/components/GeometryShape.d.ts.map

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

package/dist/components/GeometryShape.js

@@ -0,0 +1,318 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useMemo } from 'react';
+import { EdgesGeometry, WireframeGeometry, Mesh, MeshBasicMaterial, Raycaster, Vector3, DoubleSide, } from 'three';
+import { Line } from '@react-three/drei';
+// ── Wire these to your project ───────────────────────────────────────────────
+import { shapeGenerators } from '../utils/shapes.js';
+import PointCloud from './PointCloud.js';
+// import type { ShapeConfig, DisplayMode } from './GeometryShapeController';
+/* ════════════════════════════════════════════════════════════════════════════
+ * Geometry — one source the modes all read from.
+ * ══════════════════════════════════════════════════════════════════════════ */
+export function useShapeGeometry(options) {
+    const key = JSON.stringify(options);
+    const geometry = useMemo(() => shapeGenerators[options.type](options), [options.type, key]); // eslint-disable-line react-hooks/exhaustive-deps
+    useEffect(() => () => geometry.dispose(), [geometry]);
+    return geometry;
+}
+function getTriangles(geo) {
+    const pos = geo.attributes.position;
+    const idx = geo.index;
+    const tris = [];
+    const n = idx ? idx.count : pos.count;
+    for (let i = 0; i < n; i += 3) {
+        const a = idx ? idx.getX(i) : i, b = idx ? idx.getX(i + 1) : i + 1, c = idx ? idx.getX(i + 2) : i + 2;
+        tris.push([pos.getX(a), pos.getY(a), pos.getZ(a), pos.getX(b), pos.getY(b), pos.getZ(b), pos.getX(c), pos.getY(c), pos.getZ(c)]);
+    }
+    return tris;
+}
+function triArea(t) {
+    const ux = t[3] - t[0], uy = t[4] - t[1], uz = t[5] - t[2], vx = t[6] - t[0], vy = t[7] - t[1], vz = t[8] - t[2];
+    return 0.5 * Math.hypot(uy * vz - uz * vy, uz * vx - ux * vz, ux * vy - uy * vx);
+}
+function bboxDiag(geo) {
+    geo.computeBoundingBox();
+    const b = geo.boundingBox;
+    return Math.hypot(b.max.x - b.min.x, b.max.y - b.min.y, b.max.z - b.min.z) || 1;
+}
+function toPairs(arr) {
+    const out = [];
+    for (let i = 0; i < arr.length; i += 3)
+        out.push([arr[i], arr[i + 1], arr[i + 2]]);
+    return out;
+}
+/* ════════════════════════════════════════════════════════════════════════════
+ * POINT transforms → Float32Array of xyz.
+ * ══════════════════════════════════════════════════════════════════════════ */
+/** interior fill via point-in-mesh ray-parity (closed meshes only) */
+export function volumeFill(geo, count, oversample = 80) {
+    const probe = new Mesh(geo, new MeshBasicMaterial({ side: DoubleSide }));
+    probe.updateMatrixWorld(true);
+    geo.computeBoundingBox();
+    const bb = geo.boundingBox;
+    const sx = bb.max.x - bb.min.x, sy = bb.max.y - bb.min.y, sz = bb.max.z - bb.min.z;
+    const ray = new Raycaster();
+    const dir = new Vector3(0, 0, 1);
+    const p = new Vector3();
+    const out = new Float32Array(count * 3);
+    let i = 0, tries = 0;
+    const max = count * oversample;
+    while (i < count && tries < max) {
+        tries++;
+        p.set(bb.min.x + Math.random() * sx, bb.min.y + Math.random() * sy, bb.min.z + Math.random() * sz);
+        ray.set(p, dir);
+        if (ray.intersectObject(probe, false).length % 2 === 1) {
+            out[i * 3] = p.x;
+            out[i * 3 + 1] = p.y;
+            out[i * 3 + 2] = p.z;
+            i++;
+        }
+    }
+    probe.material.dispose();
+    return i === count ? out : out.slice(0, i * 3);
+}
+/** area-weighted points on the skin — the keystone for the modes below */
+export function surfaceScatter(geo, count) {
+    const tris = getTriangles(geo);
+    if (!tris.length)
+        return new Float32Array(0);
+    const cum = [];
+    let total = 0;
+    for (const t of tris) {
+        total += triArea(t);
+        cum.push(total);
+    }
+    const out = new Float32Array(count * 3);
+    for (let i = 0; i < count; i++) {
+        const r = Math.random() * total;
+        let lo = 0, hi = cum.length - 1;
+        while (lo < hi) {
+            const m = (lo + hi) >> 1;
+            if (cum[m] < r)
+                lo = m + 1;
+            else
+                hi = m;
+        }
+        const t = tris[lo];
+        let u = Math.random(), v = Math.random();
+        if (u + v > 1) {
+            u = 1 - u;
+            v = 1 - v;
+        }
+        const w = 1 - u - v;
+        out[i * 3] = t[0] * w + t[3] * u + t[6] * v;
+        out[i * 3 + 1] = t[1] * w + t[4] * u + t[7] * v;
+        out[i * 3 + 2] = t[2] * w + t[5] * u + t[8] * v;
+    }
+    return out;
+}
+/** fold into one wedge, mirror, rotate-copy around Z → kaleidoscope */
+export function symmetricScatter(geo, count, sym) {
+    const base = surfaceScatter(geo, Math.max(1, Math.floor(count / (2 * sym))));
+    const w = (Math.PI * 2) / sym;
+    const out = [];
+    for (let i = 0; i < base.length; i += 3) {
+        const x = base[i], y = base[i + 1], z = base[i + 2];
+        const rr = Math.hypot(x, y);
+        let a = ((Math.atan2(y, x) % w) + w) % w;
+        if (a > w / 2)
+            a = w - a;
+        for (let k = 0; k < sym; k++)
+            for (const s of [1, -1]) {
+                const ang = k * w + s * a;
+                out.push(rr * Math.cos(ang), rr * Math.sin(ang), z);
+            }
+    }
+    return new Float32Array(out);
+}
+/** blue-noise: oversample then reject anything closer than minDist (grid-hashed) */
+export function evenScatter(geo, count, spacing) {
+    const cand = surfaceScatter(geo, count * 6);
+    const minD = (spacing * bboxDiag(geo)) / Math.sqrt(count);
+    const minD2 = minD * minD;
+    const cell = minD || 1;
+    const grid = new Map();
+    const out = [];
+    const key = (a, b, c) => `${a},${b},${c}`;
+    for (let i = 0; i < cand.length && out.length < count * 3; i += 3) {
+        const x = cand[i], y = cand[i + 1], z = cand[i + 2];
+        const cx = Math.floor(x / cell), cy = Math.floor(y / cell), cz = Math.floor(z / cell);
+        let ok = true;
+        for (let dx = -1; dx <= 1 && ok; dx++)
+            for (let dy = -1; dy <= 1 && ok; dy++)
+                for (let dz = -1; dz <= 1 && ok; dz++) {
+                    const arr = grid.get(key(cx + dx, cy + dy, cz + dz));
+                    if (arr)
+                        for (const p of arr) {
+                            const ex = p[0] - x, ey = p[1] - y, ez = p[2] - z;
+                            if (ex * ex + ey * ey + ez * ez < minD2) {
+                                ok = false;
+                                break;
+                            }
+                        }
+                }
+        if (ok) {
+            const k = key(cx, cy, cz);
+            (grid.get(k) ?? grid.set(k, []).get(k)).push([x, y, z]);
+            out.push(x, y, z);
+        }
+    }
+    return new Float32Array(out);
+}
+export function meshVertices(geo) {
+    const pos = geo.attributes.position;
+    const out = new Float32Array(pos.count * 3);
+    for (let i = 0; i < pos.count; i++) {
+        out[i * 3] = pos.getX(i);
+        out[i * 3 + 1] = pos.getY(i);
+        out[i * 3 + 2] = pos.getZ(i);
+    }
+    return out;
+}
+/* ════════════════════════════════════════════════════════════════════════════
+ * LINE transforms → segment endpoint pairs (Pt[]).
+ * ══════════════════════════════════════════════════════════════════════════ */
+export function edges3D(geo, angleDeg) {
+    const e = new EdgesGeometry(geo, angleDeg);
+    const pts = toPairs(e.attributes.position.array);
+    e.dispose();
+    return pts;
+}
+export function contour2D(geo) {
+    const e = new EdgesGeometry(geo, 1);
+    const a = e.attributes.position.array;
+    let maxZ = -Infinity, minZ = Infinity;
+    for (let i = 2; i < a.length; i += 3) {
+        if (a[i] > maxZ)
+            maxZ = a[i];
+        if (a[i] < minZ)
+            minZ = a[i];
+    }
+    const eps = Math.max((maxZ - minZ) * 1e-3, 1e-4);
+    const out = [];
+    for (let i = 0; i < a.length; i += 6) {
+        if (Math.abs(a[i + 2] - maxZ) < eps && Math.abs(a[i + 5] - maxZ) < eps)
+            out.push([a[i], a[i + 1], 0], [a[i + 3], a[i + 4], 0]);
+    }
+    e.dispose();
+    return out;
+}
+export function wireframe(geo) {
+    const wg = new WireframeGeometry(geo);
+    const pts = toPairs(wg.attributes.position.array);
+    wg.dispose();
+    return pts;
+}
+/** slice at stepped heights, draw each triangle's cross-section segment (axis: 0=x 1=y 2=z) */
+export function contourSlices(geo, slices, axis = 1) {
+    const tris = getTriangles(geo);
+    geo.computeBoundingBox();
+    const lo = geo.boundingBox.min.getComponent(axis), hi = geo.boundingBox.max.getComponent(axis);
+    const out = [];
+    for (let s = 0; s < slices; s++) {
+        const h = lo + ((s + 0.5) / slices) * (hi - lo);
+        for (const t of tris) {
+            const P = [[t[0], t[1], t[2]], [t[3], t[4], t[5]], [t[6], t[7], t[8]]];
+            const hit = [];
+            for (let e = 0; e < 3; e++) {
+                const A = P[e], B = P[(e + 1) % 3];
+                const da = A[axis] - h, db = B[axis] - h;
+                if (da * db < 0) {
+                    const tt = da / (da - db);
+                    hit.push([A[0] + (B[0] - A[0]) * tt, A[1] + (B[1] - A[1]) * tt, A[2] + (B[2] - A[2]) * tt]);
+                }
+            }
+            if (hit.length === 2)
+                out.push(hit[0], hit[1]);
+        }
+    }
+    return out;
+}
+/* ════════════════════════════════════════════════════════════════════════════
+ * PLEXUS → points + links to near neighbours.
+ * ══════════════════════════════════════════════════════════════════════════ */
+export function plexus(geo, count, radiusMul, maxLinks = 6) {
+    const pts = surfaceScatter(geo, count);
+    const n = pts.length / 3;
+    const radius = radiusMul * bboxDiag(geo);
+    const r2 = radius * radius;
+    const cell = radius || 1;
+    const grid = new Map();
+    const key = (a, b, c) => `${a},${b},${c}`;
+    for (let i = 0; i < n; i++) {
+        const k = key(Math.floor(pts[i * 3] / cell), Math.floor(pts[i * 3 + 1] / cell), Math.floor(pts[i * 3 + 2] / cell));
+        (grid.get(k) ?? grid.set(k, []).get(k)).push(i);
+    }
+    const segments = [];
+    for (let i = 0; i < n; i++) {
+        const x = pts[i * 3], y = pts[i * 3 + 1], z = pts[i * 3 + 2];
+        const cx = Math.floor(x / cell), cy = Math.floor(y / cell), cz = Math.floor(z / cell);
+        let links = 0;
+        for (let dx = -1; dx <= 1 && links < maxLinks; dx++)
+            for (let dy = -1; dy <= 1 && links < maxLinks; dy++)
+                for (let dz = -1; dz <= 1 && links < maxLinks; dz++) {
+                    const arr = grid.get(key(cx + dx, cy + dy, cz + dz));
+                    if (!arr)
+                        continue;
+                    for (const j of arr) {
+                        if (j <= i)
+                            continue;
+                        const ex = pts[j * 3] - x, ey = pts[j * 3 + 1] - y, ez = pts[j * 3 + 2] - z;
+                        if (ex * ex + ey * ey + ez * ez < r2) {
+                            segments.push([x, y, z], [pts[j * 3], pts[j * 3 + 1], pts[j * 3 + 2]]);
+                            if (++links >= maxLinks)
+                                break;
+                        }
+                    }
+                }
+    }
+    return { positions: pts, segments };
+}
+export function computeMode(geo, c) {
+    switch (c.mode) {
+        case 'volume': return { kind: 'points', positions: volumeFill(geo, c.count) };
+        case 'surface': return { kind: 'points', positions: surfaceScatter(geo, c.count) };
+        case 'symmetric': return { kind: 'points', positions: symmetricScatter(geo, c.count, c.symmetry) };
+        case 'evenScatter': return { kind: 'points', positions: evenScatter(geo, c.count, c.spacing) };
+        case 'vertices': return { kind: 'points', positions: meshVertices(geo) };
+        case 'edges3d': return { kind: 'lines', points: edges3D(geo, c.angle) };
+        case 'profile2d': return { kind: 'lines', points: contour2D(geo) };
+        case 'wireframe': return { kind: 'lines', points: wireframe(geo) };
+        case 'contourSlices': return { kind: 'lines', points: contourSlices(geo, c.slices) };
+        case 'plexus': {
+            const p = plexus(geo, Math.min(c.count, 2500), c.linkRadius);
+            return { kind: 'plexus', positions: p.positions, segments: p.segments };
+        }
+        case 'solid':
+        default: return { kind: 'mesh' };
+    }
+}
+function useModeData(geometry, config) {
+    console.log('useModeData', config);
+    const key = [config.mode, config.count, config.symmetry, config.spacing, config.slices, config.linkRadius, config.angle].join('|');
+    return useMemo(() => computeMode(geometry, config), [geometry, key]); // eslint-disable-line react-hooks/exhaustive-deps
+}
+const defaultModeConfig = { mode: 'solid', count: 1000, symmetry: 3, spacing: 0.1, slices: 8, linkRadius: 0.05, angle: 18, lineWidth: 1 };
+export function GeometryMesh({ config, materialSettings, animations, modeConfig = defaultModeConfig, color = '#ffffff', children }) {
+    const geometry = useShapeGeometry(config);
+    const data = useModeData(geometry, modeConfig);
+    // if (data.kind === 'points') return <PointCloud positions={data.positions} color={color} size={modeConfig.mode === 'vertices' ? 0.035 : 0.02} />;
+    if (data.kind === 'points')
+        return _jsx(PointCloud, { positions: data.positions, animations: animations, materialSettings: materialSettings });
+    if (data.kind === 'lines')
+        return data.points.length ? _jsx(Line, { points: data.points, segments: true, color: color, lineWidth: modeConfig.lineWidth }) : null;
+    if (data.kind === 'plexus')
+        return (_jsxs("group", { children: [_jsx(PointCloud, { positions: data.positions, animations: animations, materialSettings: materialSettings }), data.segments.length > 0 && _jsx(Line, { points: data.segments, segments: true, color: color, lineWidth: modeConfig.lineWidth, transparent: true, opacity: 0.45 })] }));
+    return (_jsx("mesh", { geometry: geometry, children: children ?? _jsx("meshPhongMaterial", { color: color, side: DoubleSide }) }));
+}
+/* ── Optional host-owned auto-fit (generators return raw geometry). ── */
+export function FitGroup({ geometry, radius = 1.7, children }) {
+    const { scale, position } = useMemo(() => {
+        geometry.computeBoundingSphere();
+        const c = geometry.boundingSphere.center;
+        const r = geometry.boundingSphere.radius || 1;
+        const s = radius / r;
+        return { scale: s, position: [-c.x * s, -c.y * s, -c.z * s] };
+    }, [geometry, radius]);
+    return _jsx("group", { scale: scale, position: position, children: children });
+}

package/dist/components/Glyphs.d.ts

@@ -0,0 +1,9 @@
+import type { GlyphsConfig } from '@3driseai/3drise-core';
+import React from "react";
+export interface GlyphsProps {
+    config: GlyphsConfig;
+    boundingRadius?: number;
+}
+declare const Glyphs: React.FC<GlyphsProps>;
+export default Glyphs;
+//# sourceMappingURL=Glyphs.d.ts.map

package/dist/components/Glyphs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Glyphs.d.ts","sourceRoot":"","sources":["../../src/components/Glyphs.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAC1D,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,MAAM,WAAW,WAAW;IACxB,MAAM,EAAE,YAAY,CAAC;IACrB,cAAc,CAAC,EAAE,MAAM,CAAC;CAC3B;AAGD,QAAA,MAAM,MAAM,EAAE,KAAK,CAAC,EAAE,CAAC,WAAW,CAmDjC,CAAC;AACF,eAAe,MAAM,CAAC"}

package/dist/components/Glyphs.js

@@ -0,0 +1,58 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useMemo } from 'react';
+import { useFrame } from '@react-three/fiber';
+import * as THREE from 'three';
+import { GlyphRingMaterial } from '@3driseai/3drise-core';
+const Glyphs = ({ config, boundingRadius }) => {
+    // The ring sits at r=0.55 within UV space, so the plane must span 2 * ringRadius / 0.55
+    // for the ring's outer edge to land at the configured `ringRadius` in world units.
+    const planeSize = useMemo(() => {
+        const r = Math.max(0.05, (boundingRadius ?? config.ringRadius ?? 1) * 2);
+        return (2 * r) / 0.55;
+    }, [boundingRadius, config.ringRadius]);
+    console.log("Rendering Glyphs with config:", config, "and boundingRadius:", boundingRadius, "resulting in planeSize:", planeSize);
+    const geometry = useMemo(() => new THREE.PlaneGeometry(planeSize, planeSize, 1, 1), [planeSize]);
+    const material = useMemo(() => {
+        const m = new GlyphRingMaterial();
+        m.transparent = true;
+        m.depthWrite = false;
+        m.side = THREE.DoubleSide;
+        m.blending = THREE.AdditiveBlending;
+        return m;
+    }, []);
+    useEffect(() => {
+        const u = material.uniforms;
+        u.uRingColor.value.set(config.ringColor ?? '#88ccff');
+        u.uGlyphsColor.value.set(config.glyphsColor ?? '#88ccff');
+        u.uShadesMultiplier.value = config.shadesMultiplier ?? 0.0;
+        u.uHoverColor.value.set(config.hoverColor ?? '#ffffff');
+        u.uHoverRadius.value = config.hoverRadius ?? 0.3;
+        u.uHoverIntensity.value = config.hoverIntensity ?? 0.0;
+        u.uGlyphCount.value = Math.max(3, config.glyphCount ?? 12);
+        u.uMorphSpeed.value = config.morphSpeed ?? 0.4;
+        u.uIntensity.value = config.intensity ?? 1.5;
+        u.uOpacity.value = config.opacity ?? 1.0;
+    }, [
+        config.ringColor,
+        config.glyphsColor,
+        config.shadesMultiplier,
+        config.hoverColor,
+        config.hoverRadius,
+        config.hoverIntensity,
+        config.glyphCount,
+        config.morphSpeed,
+        config.intensity,
+        config.opacity,
+        material,
+    ]);
+    useEffect(() => () => { geometry.dispose(); material.dispose(); }, [geometry, material]);
+    useFrame((state, delta) => {
+        material.uniforms.uTime.value = state.clock.getElapsedTime();
+        const rotSpeed = config.rotationSpeed ?? 0.5;
+        material.uniforms.uRotation.value += delta * rotSpeed * 0.15;
+    });
+    if (!config.enabled)
+        return null;
+    return _jsx("mesh", { geometry: geometry, material: material, frustumCulled: false });
+};
+export default Glyphs;

package/dist/components/GridHelper.d.ts

@@ -0,0 +1,23 @@
+import * as THREE from 'three';
+import React from "react";
+export interface GridHelperProps {
+    cellSize?: number;
+    cellThickness?: number;
+    cellColor?: THREE.ColorRepresentation;
+    sectionSize?: number;
+    sectionThickness?: number;
+    sectionColor?: THREE.ColorRepresentation;
+    followCamera?: boolean;
+    infiniteGrid?: boolean;
+    fadeDistance?: number;
+    fadeStrength?: number;
+    fadeFrom?: number;
+    side?: THREE.Side;
+    position?: [number, number, number];
+    rotation?: [number, number, number];
+    visible?: boolean;
+    device?: 'desktop' | 'tablet' | 'mobile';
+}
+declare const GridHelper: React.FC<GridHelperProps>;
+export default GridHelper;
+//# sourceMappingURL=GridHelper.d.ts.map

package/dist/components/GridHelper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GridHelper.d.ts","sourceRoot":"","sources":["../../src/components/GridHelper.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,MAAM,WAAW,eAAe;IAC5B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,SAAS,CAAC,EAAE,KAAK,CAAC,mBAAmB,CAAC;IACtC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,YAAY,CAAC,EAAE,KAAK,CAAC,mBAAmB,CAAC;IACzC,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,KAAK,CAAC,IAAI,CAAC;IAClB,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,SAAS,GAAG,QAAQ,GAAG,QAAQ,CAAC;CAC5C;AAcD,QAAA,MAAM,UAAU,EAAE,KAAK,CAAC,EAAE,CAAC,eAAe,CAmBzC,CAAC;AACF,eAAe,UAAU,CAAC"}

package/dist/components/GridHelper.js

@@ -0,0 +1,36 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useRef, useMemo } from 'react';
+import { Grid } from '@react-three/drei';
+import * as THREE from 'three';
+const cleanColor = (color) => {
+    if (typeof color !== 'string')
+        return color;
+    if (color.length === 9 && color.startsWith('#'))
+        return color.slice(0, 7);
+    const rgba = color.match(/rgba?\((\d+),\s*(\d+),\s*(\d+)/);
+    if (rgba) {
+        return new THREE.Color(+rgba[1] / 255, +rgba[2] / 255, +rgba[3] / 255).convertSRGBToLinear();
+    }
+    return color;
+};
+const GridHelper = ({ cellSize = 1, cellThickness = 1, cellColor = '#000000', sectionSize = 10, sectionThickness = 1.5, sectionColor = '#000000', followCamera = false, infiniteGrid = true, fadeDistance = 30, fadeStrength = 1, fadeFrom = 0, side = THREE.DoubleSide, position = [0, 0, 0], rotation = [0, 0, 0], visible = true, device = 'desktop', }) => {
+    const gridRef = useRef(null);
+    const targetY = useRef(position[1]);
+    const responsiveScale = useMemo(() => {
+        if (device === 'mobile')
+            return [0.7, 0.7, 0.7];
+        if (device === 'tablet')
+            return [0.85, 0.85, 0.85];
+        return [1, 1, 1];
+    }, [device]);
+    // Animate Y position toward target (replaces GSAP fade-in/out)
+    // useFrame((_s, delta) => {
+    //   if (!gridRef.current) return;
+    //   targetY.current = visible ? position[1] : position[1] - 2;
+    //   gridRef.current.position.y += (targetY.current - gridRef.current.position.y) * Math.min(delta * 4, 1);
+    // });
+    if (!visible)
+        return null;
+    return (_jsx(Grid, { ref: gridRef, cellSize: cellSize, cellThickness: cellThickness, cellColor: cleanColor(cellColor), sectionSize: sectionSize, sectionThickness: sectionThickness, sectionColor: cleanColor(sectionColor), followCamera: followCamera, infiniteGrid: infiniteGrid, fadeDistance: fadeDistance, fadeStrength: fadeStrength, fadeFrom: fadeFrom, side: side, position: position, rotation: rotation, scale: responsiveScale, castShadow: false, receiveShadow: false, userData: { id: '3drise-grid' } }));
+};
+export default GridHelper;

package/dist/components/GridsGenerator.d.ts

@@ -0,0 +1,10 @@
+import React from "react";
+import type { GridConfig, MyGridConfig } from "@3driseai/3drise-core";
+type GridGeneratorProps = {
+    config: (GridConfig | MyGridConfig) & {
+        type: string;
+    };
+};
+declare const GridGenerator: React.FC<GridGeneratorProps>;
+export default GridGenerator;
+//# sourceMappingURL=GridsGenerator.d.ts.map

package/dist/components/GridsGenerator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GridsGenerator.d.ts","sourceRoot":"","sources":["../../src/components/GridsGenerator.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACtE,KAAK,kBAAkB,GAAG;IACtB,MAAM,EAAE,CAAC,UAAU,GAAG,YAAY,CAAC,GAAG;QAClC,IAAI,EAAE,MAAM,CAAC;KAChB,CAAC;CACL,CAAC;AAGF,QAAA,MAAM,aAAa,EAAE,KAAK,CAAC,EAAE,CAAC,kBAAkB,CAS/C,CAAC;AACF,eAAe,aAAa,CAAC"}

package/dist/components/GridsGenerator.js

@@ -0,0 +1,14 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import GridHelper from "./GridHelper.js";
+import { MyGrid } from "./MyGrid.js";
+const GridGenerator = ({ config }) => {
+    switch (config.type) {
+        case "basic":
+            return _jsx(GridHelper, { ...config, side: 2 });
+        case "superGrid":
+            return _jsx(MyGrid, { config: config });
+        default:
+            return _jsx("gridHelper", { ...config });
+    }
+};
+export default GridGenerator;

package/dist/components/HdrPlaylistRenderer.d.ts

@@ -0,0 +1,10 @@
+import type { HdrTransitionSettings } from "@3driseai/3drise-core";
+export interface HdrPlaylistRendererProps {
+    /** Two or more equirect HDR URLs to cycle through. Caller ensures length >= 2. */
+    urls: string[];
+    /** Fully resolved transition settings (defaults already merged). */
+    transition: HdrTransitionSettings;
+}
+declare const HdrPlaylistRenderer: React.FC<HdrPlaylistRendererProps>;
+export default HdrPlaylistRenderer;
+//# sourceMappingURL=HdrPlaylistRenderer.d.ts.map

package/dist/components/HdrPlaylistRenderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HdrPlaylistRenderer.d.ts","sourceRoot":"","sources":["../../src/components/HdrPlaylistRenderer.tsx"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AACnE,MAAM,WAAW,wBAAwB;IACrC,kFAAkF;IAClF,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,oEAAoE;IACpE,UAAU,EAAE,qBAAqB,CAAC;CACrC;AAwJD,QAAA,MAAM,mBAAmB,EAAE,KAAK,CAAC,EAAE,CAAC,wBAAwB,CA+M3D,CAAC;AACF,eAAe,mBAAmB,CAAC"}