@3driseai/3drise-viewer 0.1.1

package/dist/components/ParticlesR3f.js

@@ -0,0 +1,110 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useMemo, useRef } from 'react';
+import { useFrame } from '@react-three/fiber';
+import { useParticlePositions } from '../hooks/useParticlePositions.js';
+import { useParticlesColors } from '../hooks/useParticlesColors.js';
+import { useParticlesTextures } from '../hooks/useParticlesTextures.js';
+import { handleShapeAnimation, buildShaderEffectsMaterial, structureKey } from '@3driseai/3drise-core';
+import { update3driseShaderUniforms } from '../hooks/use3driseShader.js';
+function normalizeEffects(raw) {
+    return Array.isArray(raw) ? raw : [];
+}
+const ParticlesR3f = ({ particlesSettings, duration = 1, transitionSettings, }) => {
+    const materialRef = useRef(null);
+    const pointsRef = useRef(null);
+    const { name, config, meshSettings } = particlesSettings;
+    const { count, shapeType, outlines, texture } = config;
+    const color = particlesSettings.materialSettings && 'color' in particlesSettings.materialSettings
+        ? particlesSettings.materialSettings.color
+        : '#ffffff';
+    const opacity = particlesSettings.materialSettings && 'opacity' in particlesSettings.materialSettings
+        ? particlesSettings.materialSettings.opacity
+        : 1.0;
+    const pointSize = particlesSettings.materialSettings && 'pointSize' in particlesSettings.materialSettings
+        ? particlesSettings.materialSettings.pointSize
+        : 5.0;
+    const targetShape = (transitionSettings?.shapeType && typeof transitionSettings.shapeType === 'string')
+        ? transitionSettings.shapeType
+        : shapeType;
+    const targetOutLines = transitionSettings?.outlines !== undefined
+        ? transitionSettings.outlines
+        : (outlines || false);
+    const targetColor = transitionSettings?.color || color;
+    const aspectRatio = 16 / 9;
+    const nbLines = Math.round(Math.sqrt(count / 3 / aspectRatio));
+    const nbColumns = Math.round(aspectRatio * nbLines);
+    const particleUVScale = 1.0 / Math.max(nbColumns, nbLines);
+    const { basePositions, targetPositions, animationProgress, uvs } = useParticlePositions({
+        shapeType,
+        targetShape,
+        count,
+        outlines: outlines || false,
+        targetOutLines,
+        pointsRef,
+    });
+    const { handleColorsAnimation } = useParticlesColors({ color, targetColor });
+    const { currentTexture, prevTexture, loadTexture, textureProgress, handleTextureAnimation } = useParticlesTextures();
+    useEffect(() => {
+        if (texture && texture.trim() !== '') {
+            textureProgress.current = 0;
+            loadTexture(texture);
+        }
+    }, [texture, loadTexture]);
+    useEffect(() => {
+        const points = pointsRef.current;
+        if (!points)
+            return;
+        const applyTexture = (url) => {
+            if (!url)
+                return;
+            textureProgress.current = 0;
+            loadTexture(url);
+        };
+        points.userData.applyTexture = applyTexture;
+        return () => {
+            delete points.userData.applyTexture;
+        };
+    }, [loadTexture, textureProgress]);
+    const speed = 1 / duration;
+    const activeEffects = useMemo(() => normalizeEffects(particlesSettings.animations?.material?.shaderEffects), [particlesSettings.animations?.material?.shaderEffects]);
+    const pointerRadius = particlesSettings.animations?.material
+        ?.shaderEffectsPointerRadius ?? 0.4;
+    const effectsKey = useMemo(() => structureKey(activeEffects), [activeEffects]);
+    const material = useMemo(() => buildShaderEffectsMaterial({
+        effects: activeEffects,
+        initialColor: color,
+        initialOpacity: opacity,
+        initialPointSize: pointSize,
+        initialParticleUVScale: particleUVScale,
+        initialPointerEffectRadius: pointerRadius,
+    }), 
+    // Rebuild when the structural set of effects changes; not on parameter tweaks.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [effectsKey]);
+    useEffect(() => {
+        materialRef.current = material;
+        return () => {
+            material.dispose();
+        };
+    }, [material]);
+    useFrame((state, delta) => {
+        const mat = materialRef.current;
+        if (!mat || !pointsRef.current || !basePositions.current)
+            return;
+        if (meshSettings.visible) {
+            handleShapeAnimation(delta, speed, animationProgress, pointsRef, basePositions, targetPositions);
+            handleColorsAnimation(materialRef, delta, speed);
+        }
+        if (prevTexture.current)
+            mat.uniforms.uTexture.value = prevTexture.current;
+        if (currentTexture.current)
+            mat.uniforms.uTargetTexture.value = currentTexture.current;
+        mat.uniforms.uHasTexture.value = !!currentTexture.current;
+        handleTextureAnimation(materialRef, delta, speed);
+        update3driseShaderUniforms(mat.uniforms, activeEffects, state.clock.getElapsedTime(), { x: state.pointer.x, y: state.pointer.y }, { pointerRadius });
+    });
+    if (!basePositions.current)
+        return null;
+    return (_jsxs("points", { name: name, ref: pointsRef, raycast: () => null, position: [0, 0, 0], rotation: [0, 0, 0], scale: [1, 1, 1], children: [_jsxs("bufferGeometry", { children: [_jsx("bufferAttribute", { attach: "attributes-position", count: basePositions.current.length / 3, array: basePositions.current, itemSize: 3, args: [basePositions.current, 3] }), uvs && (_jsx("bufferAttribute", { attach: "attributes-aUV", count: uvs.length / 2, array: uvs, itemSize: 2, args: [uvs, 2] }))] }), _jsx("primitive", { object: material, attach: "material" })] }));
+};
+export default ParticlesR3f;

package/dist/components/Path.d.ts

@@ -0,0 +1,13 @@
+import React from "react";
+import type { CatmullRomCurve3 } from "three";
+interface PathProps {
+    curve: CatmullRomCurve3;
+    targetCurve: CatmullRomCurve3;
+    duration?: number;
+    color?: string;
+    opacity?: number;
+    tubeRadius?: number;
+}
+declare const Path: React.FC<PathProps>;
+export default Path;
+//# sourceMappingURL=Path.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Path.d.ts","sourceRoot":"","sources":["../../src/components/Path.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,OAAO,CAAC;AAC9C,UAAU,SAAS;IACf,KAAK,EAAE,gBAAgB,CAAC;IACxB,WAAW,EAAE,gBAAgB,CAAC;IAC9B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB;AAGD,QAAA,MAAM,IAAI,EAAE,KAAK,CAAC,EAAE,CAAC,SAAS,CAoC7B,CAAC;AACF,eAAe,IAAI,CAAC"}

package/dist/components/Path.js

@@ -0,0 +1,41 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useRef, useEffect } from 'react';
+import { useFrame } from '@react-three/fiber';
+const Path = ({ curve, targetCurve, duration = 1, color = '#4c00ff', opacity = 1, tubeRadius = 0.001, }) => {
+    const tubeRef = useRef(null);
+    const targetTubeRef = useRef(null);
+    const meshRef = useRef(null);
+    const animationProgress = useRef(0);
+    const basePositions = useRef(null);
+    const speed = 1 / duration;
+    useEffect(() => {
+        if (tubeRef.current) {
+            basePositions.current = new Float32Array(tubeRef.current.attributes.position.array);
+        }
+        animationProgress.current = 0;
+    }, [curve, targetCurve]);
+    useEffect(() => {
+        return () => {
+            tubeRef.current?.dispose();
+            targetTubeRef.current?.dispose();
+        };
+    }, []);
+    useFrame((_, delta) => {
+        if (!meshRef.current || !tubeRef.current || !targetTubeRef.current || !basePositions.current)
+            return;
+        const progress = Math.min(animationProgress.current + delta * speed, 1);
+        const currentGeom = tubeRef.current;
+        const targetPositions = targetTubeRef.current.attributes.position.array;
+        const currentPosAttr = currentGeom.attributes.position;
+        const length = Math.min(basePositions.current.length, targetPositions.length);
+        for (let i = 0; i < length; i += 3) {
+            currentPosAttr.array[i] = basePositions.current[i] + (targetPositions[i] - basePositions.current[i]) * progress;
+            currentPosAttr.array[i + 1] = basePositions.current[i + 1] + (targetPositions[i + 1] - basePositions.current[i + 1]) * progress;
+            currentPosAttr.array[i + 2] = basePositions.current[i + 2] + (targetPositions[i + 2] - basePositions.current[i + 2]) * progress;
+        }
+        animationProgress.current = progress;
+        currentPosAttr.needsUpdate = true;
+    });
+    return (_jsxs(_Fragment, { children: [_jsxs("mesh", { ref: meshRef, children: [_jsx("tubeGeometry", { ref: tubeRef, args: [curve, 64, tubeRadius, 8, false] }), _jsx("meshBasicMaterial", { color: color, transparent: opacity < 1, opacity: opacity })] }), _jsx("mesh", { position: [0, -1000, 0], children: _jsx("tubeGeometry", { ref: targetTubeRef, args: [targetCurve, 64, tubeRadius, 8, false] }) })] }));
+};
+export default Path;

package/dist/components/PathGeometry.d.ts

@@ -0,0 +1,11 @@
+import type { PathGeometrySettings, Vector3Array } from '@3driseai/3drise-core';
+import React from "react";
+interface PathGeometryProps {
+    points: Vector3Array[];
+    curve: number;
+    smoothCorners?: number;
+    geometry: PathGeometrySettings;
+}
+declare const PathGeometry: React.FC<PathGeometryProps>;
+export default PathGeometry;
+//# sourceMappingURL=PathGeometry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PathGeometry.d.ts","sourceRoot":"","sources":["../../src/components/PathGeometry.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,oBAAoB,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAChF,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,UAAU,iBAAiB;IACvB,MAAM,EAAE,YAAY,EAAE,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,EAAE,oBAAoB,CAAC;CAClC;AAGD,QAAA,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC,iBAAiB,CAsG7C,CAAC;AACF,eAAe,YAAY,CAAC"}

package/dist/components/PathGeometry.js

@@ -0,0 +1,109 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useMemo } from 'react';
+import * as THREE from 'three';
+import { Line } from '@react-three/drei';
+import { smoothPathCorners, createPathSpline } from '@3driseai/3drise-core';
+const PathGeometry = ({ points, curve, smoothCorners = 0, geometry, }) => {
+    const { type, width = 2, radius = 0.5, segments = 8, numLanes = 0, color = '#555555', dividerColor = '#ffffff' } = geometry;
+    const smoothedPoints = useMemo(() => smoothPathCorners(points, smoothCorners), [points, smoothCorners]);
+    const spline = useMemo(() => {
+        if (smoothedPoints.length < 2)
+            return null;
+        return createPathSpline(smoothedPoints, curve);
+    }, [smoothedPoints, curve]);
+    const tubeGeometry = useMemo(() => {
+        if (!spline || type !== 'tube')
+            return null;
+        return new THREE.TubeGeometry(spline, points.length * 10, radius, segments, false);
+    }, [spline, type, radius, segments, points.length]);
+    const roadGeometry = useMemo(() => {
+        if (!spline || type !== 'road')
+            return null;
+        const divisions = Math.max(points.length * 20, 100);
+        const vertices = [];
+        const indices = [];
+        const uvs = [];
+        const halfWidth = width / 2;
+        const up = new THREE.Vector3(0, 1, 0);
+        for (let i = 0; i <= divisions; i++) {
+            const t = i / divisions;
+            const point = spline.getPointAt(t);
+            const perp = new THREE.Vector3().crossVectors(spline.getTangentAt(t).normalize(), up).normalize();
+            const left = new THREE.Vector3().copy(point).addScaledVector(perp, -halfWidth);
+            const right = new THREE.Vector3().copy(point).addScaledVector(perp, halfWidth);
+            left.y += 0.01;
+            right.y += 0.01;
+            vertices.push(left.x, left.y, left.z, right.x, right.y, right.z);
+            uvs.push(0, t, 1, t);
+            if (i < divisions) {
+                const b = i * 2;
+                indices.push(b, b + 1, b + 2, b + 1, b + 3, b + 2);
+            }
+        }
+        const geo = new THREE.BufferGeometry();
+        geo.setAttribute('position', new THREE.Float32BufferAttribute(vertices, 3));
+        geo.setAttribute('uv', new THREE.Float32BufferAttribute(uvs, 2));
+        geo.setIndex(indices);
+        geo.computeVertexNormals();
+        return geo;
+    }, [spline, type, width, points.length]);
+    const wallsGeometry = useMemo(() => {
+        if (!spline || type !== 'walls')
+            return null;
+        const divisions = Math.max(points.length * 20, 100);
+        const wallHeight = 2;
+        const halfWidth = width / 2;
+        const vertices = [];
+        const indices = [];
+        const uvs = [];
+        const up = new THREE.Vector3(0, 1, 0);
+        for (let i = 0; i <= divisions; i++) {
+            const t = i / divisions;
+            const point = spline.getPointAt(t);
+            const perp = new THREE.Vector3().crossVectors(spline.getTangentAt(t).normalize(), up).normalize();
+            const lb = new THREE.Vector3().copy(point).addScaledVector(perp, -halfWidth);
+            const lt = lb.clone().setY(lb.y + wallHeight);
+            const rb = new THREE.Vector3().copy(point).addScaledVector(perp, halfWidth);
+            const rt = rb.clone().setY(rb.y + wallHeight);
+            vertices.push(lb.x, lb.y, lb.z, lt.x, lt.y, lt.z, rb.x, rb.y, rb.z, rt.x, rt.y, rt.z);
+            uvs.push(0, t, 0, t, 1, t, 1, t);
+            if (i < divisions) {
+                const b = i * 4, n = (i + 1) * 4;
+                indices.push(b, b + 1, n, b + 1, n + 1, n, b + 2, n + 2, b + 3, b + 3, n + 2, n + 3, b + 1, b + 3, n + 1, b + 3, n + 3, n + 1, b, n, b + 2, b + 2, n, n + 2);
+            }
+        }
+        const geo = new THREE.BufferGeometry();
+        geo.setAttribute('position', new THREE.Float32BufferAttribute(vertices, 3));
+        geo.setAttribute('uv', new THREE.Float32BufferAttribute(uvs, 2));
+        geo.setIndex(indices);
+        geo.computeVertexNormals();
+        return geo;
+    }, [spline, type, width, points.length]);
+    const laneDividerLines = useMemo(() => {
+        if (!spline || type !== 'road' || numLanes <= 0)
+            return null;
+        const divisions = Math.max(points.length * 20, 100);
+        const laneWidth = width / (numLanes * 2);
+        const offsets = [0];
+        for (let lane = 1; lane < numLanes; lane++) {
+            offsets.push(-lane * laneWidth, lane * laneWidth);
+        }
+        const up = new THREE.Vector3(0, 1, 0);
+        return offsets.map(offset => {
+            const line = [];
+            for (let i = 0; i <= divisions; i++) {
+                const t = i / divisions;
+                const point = spline.getPointAt(t);
+                const perp = new THREE.Vector3().crossVectors(spline.getTangentAt(t).normalize(), up).normalize();
+                const dp = new THREE.Vector3().copy(point).addScaledVector(perp, offset);
+                dp.y += 0.02;
+                line.push([dp.x, dp.y, dp.z]);
+            }
+            return line;
+        });
+    }, [spline, type, width, numLanes, points.length]);
+    if (!spline || type === 'none')
+        return null;
+    return (_jsxs("group", { children: [type === 'tube' && tubeGeometry && (_jsx("mesh", { geometry: tubeGeometry, children: _jsx("meshStandardMaterial", { color: color, side: THREE.DoubleSide }) })), type === 'road' && roadGeometry && (_jsx("mesh", { geometry: roadGeometry, children: _jsx("meshStandardMaterial", { color: color, side: THREE.DoubleSide }) })), type === 'road' && laneDividerLines?.map((line, index) => (_jsx(Line, { points: line, color: dividerColor, lineWidth: 2, dashed: index !== 0, dashSize: 0.5, gapSize: 0.3, raycast: () => null }, `lane-${index}`))), type === 'walls' && wallsGeometry && (_jsx("mesh", { geometry: wallsGeometry, children: _jsx("meshStandardMaterial", { color: color, side: THREE.DoubleSide }) }))] }));
+};
+export default PathGeometry;

package/dist/components/PathRenderer.d.ts

@@ -0,0 +1,12 @@
+import type { PathConfig } from '@3driseai/3drise-core';
+import React from "react";
+export interface PathRendererProps {
+    pathSettings: PathConfig;
+    color?: string;
+    showPoints?: boolean;
+    showLine?: boolean;
+    showCurve?: boolean;
+}
+declare const PathRenderer: React.FC<PathRendererProps>;
+export default PathRenderer;
+//# sourceMappingURL=PathRenderer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PathRenderer.d.ts","sourceRoot":"","sources":["../../src/components/PathRenderer.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAExD,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,MAAM,WAAW,iBAAiB;IAC9B,YAAY,EAAE,UAAU,CAAC;IACzB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,SAAS,CAAC,EAAE,OAAO,CAAC;CACvB;AAGD,QAAA,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC,iBAAiB,CA6B7C,CAAC;AACF,eAAe,YAAY,CAAC"}

package/dist/components/PathRenderer.js

@@ -0,0 +1,36 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useMemo } from 'react';
+import { Sphere, Line } from '@react-three/drei';
+import { smoothPathCorners, createPathSpline, sampleSplinePoints } from '@3driseai/3drise-core';
+import PathGeometry from './PathGeometry.js';
+const PathRenderer = ({ pathSettings, color = '#ffa500', showPoints = true, showLine = true, showCurve = true, }) => {
+    console.log("Rendering Path with settings:", pathSettings);
+    const pointSize = pathSettings.pointSize ?? 0.1;
+    const lineWidth = pathSettings.lineWidth ?? 2;
+    const points = pathSettings?.points || [];
+    const curve = pathSettings?.curve ?? 1;
+    const smoothCorners = pathSettings?.smoothCorners ?? 0;
+    const geometry = pathSettings?.geometry;
+    const hasCurve = curve > 1;
+    const hasSmoothCorners = smoothCorners > 0;
+    const smoothedPoints = useMemo(() => {
+        if (!hasSmoothCorners || points.length < 3)
+            return points;
+        return smoothPathCorners(points, smoothCorners);
+    }, [points, smoothCorners, hasSmoothCorners]);
+    const curvePoints = useMemo(() => {
+        if (!showCurve || points.length < 2)
+            return null;
+        if (!hasCurve && !hasSmoothCorners)
+            return null;
+        const basePoints = hasSmoothCorners ? smoothedPoints : points;
+        const spline = createPathSpline(basePoints, curve);
+        if (!spline)
+            return null;
+        return sampleSplinePoints(spline, basePoints.length);
+    }, [points, smoothedPoints, curve, smoothCorners, showCurve, hasCurve, hasSmoothCorners]);
+    if (points.length === 0)
+        return null;
+    return (_jsxs("group", { children: [showPoints && points.map((point, index) => (_jsxs("group", { position: point, children: [_jsx(Sphere, { args: [pointSize, 16, 16], children: _jsx("meshStandardMaterial", { color: color, emissive: color, emissiveIntensity: 0.5, toneMapped: false }) }), _jsx(Sphere, { args: [pointSize * 0.33, 8, 8], position: [0, pointSize * 1.67, 0], children: _jsx("meshBasicMaterial", { color: "#ffffff" }) })] }, `path-point-${index}`))), showLine && points.length > 1 && !hasCurve && !hasSmoothCorners && (_jsx(Line, { points: points, color: color, lineWidth: lineWidth, raycast: () => null })), showCurve && curvePoints && curvePoints.length > 1 && (_jsx(Line, { points: curvePoints, color: color, lineWidth: lineWidth, raycast: () => null })), showLine && showCurve && (hasCurve || hasSmoothCorners) && points.length > 1 && (_jsx(Line, { points: points, color: color, lineWidth: 1, dashed: true, dashSize: 0.1, gapSize: 0.1, raycast: () => null })), geometry && geometry.type !== 'none' && points.length >= 2 && (_jsx(PathGeometry, { points: points, curve: curve, smoothCorners: smoothCorners, geometry: geometry }))] }));
+};
+export default PathRenderer;

package/dist/components/Planet.d.ts

@@ -0,0 +1,16 @@
+import type { Mesh } from 'three';
+import React from "react";
+export type PlanetType = 'moon' | 'sun' | 'mercury' | 'venus' | 'mars' | 'jupiter' | 'saturn' | 'uranus' | 'neptune';
+export interface PlanetProps {
+    type?: PlanetType;
+    position?: [number, number, number];
+    scale?: number;
+    rotation?: [number, number, number];
+    visible?: boolean;
+    emissiveIntensity?: number;
+    shininess?: number;
+    onMeshReady?: (mesh: Mesh) => void;
+}
+declare const Planet: React.FC<PlanetProps>;
+export default Planet;
+//# sourceMappingURL=Planet.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Planet.d.ts","sourceRoot":"","sources":["../../src/components/Planet.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC;AAElC,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,KAAK,GAAG,SAAS,GAAG,OAAO,GAAG,MAAM,GAAG,SAAS,GAAG,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAAC;AAErH,MAAM,WAAW,WAAW;IACxB,IAAI,CAAC,EAAE,UAAU,CAAC;IAClB,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI,CAAC;CACtC;AA0CD,QAAA,MAAM,MAAM,EAAE,KAAK,CAAC,EAAE,CAAC,WAAW,CAcjC,CAAC;AAEF,eAAe,MAAM,CAAC"}

package/dist/components/Planet.js

@@ -0,0 +1,60 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useRef, useEffect, useMemo, useCallback } from 'react';
+import { RingGeometry, DoubleSide, Vector3, SRGBColorSpace, } from 'three';
+import { useTexture } from '@react-three/drei';
+const CDN = 'https://3d-rise.sfo3.cdn.digitaloceanspaces.com/app/images/planets';
+const PLANET_TEXTURES = {
+    moon: `${CDN}/2k_moon.jpg`,
+    sun: `${CDN}/2k_sun.jpg`,
+    mercury: `${CDN}/2k_mercury.jpg`,
+    venus: `${CDN}/2k_venus_surface.jpg`,
+    mars: `${CDN}/2k_mars.jpg`,
+    jupiter: `${CDN}/2k_jupiter.jpg`,
+    saturn: `${CDN}/2k_saturn.jpg`,
+    uranus: `${CDN}/2k_uranus.jpg`,
+    neptune: `${CDN}/2k_neptune.jpg`,
+};
+const saturnRingTextureUrl = `${CDN}/2k_saturn_ring_alpha.png`;
+const RING_INNER = 1.3;
+const RING_OUTER = 2.3;
+function createRingGeometry(inner, outer, segments = 128) {
+    const geom = new RingGeometry(inner, outer, segments);
+    // RingGeometry's default UVs go around the ring. Remap so the radial axis
+    // (inner → outer) maps to U (0 → 1) so a strip-style ring texture displays correctly.
+    const pos = geom.attributes.position;
+    const uv = geom.attributes.uv;
+    const v = new Vector3();
+    for (let i = 0; i < pos.count; i++) {
+        v.fromBufferAttribute(pos, i);
+        const r = v.length();
+        const t = (r - inner) / (outer - inner);
+        uv.setXY(i, t, 0.5);
+    }
+    uv.needsUpdate = true;
+    return geom;
+}
+const SaturnRing = () => {
+    const ringTexture = useTexture(saturnRingTextureUrl);
+    useEffect(() => {
+        ringTexture.colorSpace = SRGBColorSpace;
+    }, [ringTexture]);
+    const ringGeometry = useMemo(() => createRingGeometry(RING_INNER, RING_OUTER), []);
+    return (_jsx("mesh", { geometry: ringGeometry, rotation: [-Math.PI / 2, 0, 0], children: _jsx("meshBasicMaterial", { map: ringTexture, alphaMap: ringTexture, transparent: true, side: DoubleSide, depthWrite: false }) }));
+};
+const Planet = ({ type = 'moon', position = [0, 0, 0], scale = 5, rotation = [0, 0, 0], visible = true, emissiveIntensity = 0, shininess = 30, onMeshReady, }) => {
+    const meshRef = useRef(null);
+    const texture = useTexture(PLANET_TEXTURES[type]);
+    useEffect(() => {
+        texture.colorSpace = SRGBColorSpace;
+        texture.anisotropy = 8;
+    }, [texture]);
+    const handleMeshRef = useCallback((mesh) => {
+        if (mesh) {
+            meshRef.current = mesh;
+            onMeshReady?.(mesh);
+        }
+    }, [onMeshReady]);
+    return (_jsxs("group", { userData: { id: `3drise-planet-${type}` }, position: position, rotation: rotation, scale: scale, visible: visible, children: [_jsxs("mesh", { ref: handleMeshRef, children: [_jsx("sphereGeometry", { args: [1, 64, 64] }), _jsx("meshPhongMaterial", { map: texture, color: '#ffffff', emissive: '#ffffff', emissiveMap: texture, emissiveIntensity: emissiveIntensity, shininess: shininess })] }), type === 'saturn' && _jsx(SaturnRing, {})] }));
+};
+Planet.displayName = 'Planet';
+export default Planet;

package/dist/components/PointCloud.d.ts

@@ -0,0 +1,10 @@
+import type { MaterialSettings, ObjectAnimations } from '@3driseai/3drise-core';
+import React from "react";
+interface PointCloudProps {
+    positions: Float32Array;
+    materialSettings: MaterialSettings;
+    animations?: ObjectAnimations;
+}
+declare const PointCloud: React.FC<PointCloudProps>;
+export default PointCloud;
+//# sourceMappingURL=PointCloud.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PointCloud.d.ts","sourceRoot":"","sources":["../../src/components/PointCloud.tsx"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAEhF,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,UAAU,eAAe;IACrB,SAAS,EAAE,YAAY,CAAC;IACxB,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,UAAU,CAAC,EAAE,gBAAgB,CAAC;CACjC;AAyBD,QAAA,MAAM,UAAU,EAAE,KAAK,CAAC,EAAE,CAAC,eAAe,CAkFzC,CAAC;AACF,eAAe,UAAU,CAAC"}

package/dist/components/PointCloud.js

@@ -0,0 +1,113 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useMemo, useRef } from 'react';
+import { useFrame } from '@react-three/fiber';
+import { useParticlesColors } from '../hooks/useParticlesColors.js';
+import { useParticlesTextures } from '../hooks/useParticlesTextures.js';
+import { buildShaderEffectsMaterial, structureKey } from '@3driseai/3drise-core';
+import { update3driseShaderUniforms } from '../hooks/use3driseShader.js';
+function normalizeEffects(raw) {
+    return Array.isArray(raw) ? raw : [];
+}
+function generateUVsFromPositions(positions) {
+    const count = positions.length / 3;
+    let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;
+    for (let i = 0; i < positions.length; i += 3) {
+        minX = Math.min(minX, positions[i]);
+        maxX = Math.max(maxX, positions[i]);
+        minY = Math.min(minY, positions[i + 1]);
+        maxY = Math.max(maxY, positions[i + 1]);
+    }
+    const rangeX = maxX - minX || 1;
+    const rangeY = maxY - minY || 1;
+    const uvs = new Float32Array(count * 2);
+    for (let i = 0; i < positions.length; i += 3) {
+        const idx = (i / 3) * 2;
+        uvs[idx] = (positions[i] - minX) / rangeX;
+        uvs[idx + 1] = (positions[i + 1] - minY) / rangeY;
+    }
+    return uvs;
+}
+const PointCloud = ({ positions, materialSettings, animations, }) => {
+    const materialRef = useRef(null);
+    const pointsRef = useRef(null);
+    const color = materialSettings && 'color' in materialSettings
+        ? materialSettings.color
+        : '#ffffff';
+    const opacity = materialSettings && 'opacity' in materialSettings
+        ? materialSettings.opacity
+        : 1.0;
+    const pointSize = materialSettings && 'pointSize' in materialSettings
+        ? materialSettings.pointSize
+        : 5.0;
+    const texture = materialSettings && 'map' in materialSettings
+        ? materialSettings.map
+        : null;
+    const count = positions.length / 3;
+    const aspectRatio = 16 / 9;
+    const nbLines = Math.round(Math.sqrt(count / 3 / aspectRatio));
+    const nbColumns = Math.round(aspectRatio * nbLines);
+    const particleUVScale = 1.0 / Math.max(nbColumns, nbLines);
+    const uvs = useMemo(() => generateUVsFromPositions(positions), [positions]);
+    const { handleColorsAnimation } = useParticlesColors({ color, targetColor: color });
+    const { currentTexture, prevTexture, loadTexture, textureProgress, handleTextureAnimation } = useParticlesTextures();
+    useEffect(() => {
+        if (texture && texture.trim() !== '') {
+            textureProgress.current = 0;
+            loadTexture(texture);
+        }
+    }, [texture, loadTexture]);
+    useEffect(() => {
+        const points = pointsRef.current;
+        if (!points)
+            return;
+        const applyTexture = (url) => {
+            if (!url)
+                return;
+            textureProgress.current = 0;
+            loadTexture(url);
+        };
+        points.userData.applyTexture = applyTexture;
+        return () => {
+            delete points.userData.applyTexture;
+        };
+    }, [loadTexture, textureProgress]);
+    const speed = 1;
+    const activeEffects = useMemo(() => normalizeEffects(animations?.material?.shaderEffects), [animations?.material?.shaderEffects]);
+    const pointerRadius = animations?.material
+        ?.shaderEffectsPointerRadius ?? 0.4;
+    const effectsKey = useMemo(() => structureKey(activeEffects), [activeEffects]);
+    const material = useMemo(() => buildShaderEffectsMaterial({
+        effects: activeEffects,
+        initialColor: color,
+        initialOpacity: opacity,
+        initialPointSize: pointSize,
+        initialParticleUVScale: particleUVScale,
+        initialPointerEffectRadius: pointerRadius,
+    }), 
+    // Rebuild when the structural set of effects changes; not on parameter tweaks.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [effectsKey]);
+    useEffect(() => {
+        materialRef.current = material;
+        return () => {
+            material.dispose();
+        };
+    }, [material]);
+    useFrame((state, delta) => {
+        const mat = materialRef.current;
+        if (!mat || !pointsRef.current)
+            return;
+        handleColorsAnimation(materialRef, delta, speed);
+        if (prevTexture.current)
+            mat.uniforms.uTexture.value = prevTexture.current;
+        if (currentTexture.current)
+            mat.uniforms.uTargetTexture.value = currentTexture.current;
+        mat.uniforms.uHasTexture.value = !!currentTexture.current;
+        handleTextureAnimation(materialRef, delta, speed);
+        update3driseShaderUniforms(mat.uniforms, activeEffects, state.clock.getElapsedTime(), { x: state.pointer.x, y: state.pointer.y }, { pointerRadius });
+    });
+    if (!positions)
+        return null;
+    return (_jsxs("points", { ref: pointsRef, raycast: () => null, position: [0, 0, 0], rotation: [0, 0, 0], scale: [1, 1, 1], children: [_jsxs("bufferGeometry", { children: [_jsx("bufferAttribute", { attach: "attributes-position", count: positions.length / 3, array: positions, itemSize: 3, args: [positions, 3] }), uvs && (_jsx("bufferAttribute", { attach: "attributes-aUV", count: uvs.length / 2, array: uvs, itemSize: 2, args: [uvs, 2] }))] }), _jsx("primitive", { object: material, attach: "material" })] }));
+};
+export default PointCloud;

package/dist/components/ProductionScene.d.ts

@@ -0,0 +1,5 @@
+import React from "react";
+import type { ProductionSceneProps } from "@3driseai/3drise-core";
+declare const ProductionScene: React.FC<ProductionSceneProps>;
+export default ProductionScene;
+//# sourceMappingURL=ProductionScene.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ProductionScene.d.ts","sourceRoot":"","sources":["../../src/components/ProductionScene.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAElE,QAAA,MAAM,eAAe,EAAE,KAAK,CAAC,EAAE,CAAC,oBAAoB,CAGnD,CAAC;AACF,eAAe,eAAe,CAAC"}

package/dist/components/ProductionScene.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Physics } from "@react-three/rapier";
+const ProductionScene = ({ physicsSettings, children, }) => {
+    // Interaction hook
+    return (_jsx(Physics, { gravity: physicsSettings.gravity, paused: !physicsSettings.enabled, debug: physicsSettings.debug, children: children }));
+};
+export default ProductionScene;

package/dist/components/ProjectLoader.d.ts

@@ -0,0 +1,16 @@
+import type { CreatedObjectSettings, HtmlElement } from '@3driseai/3drise-core';
+import React from "react";
+import { Object3D } from "three";
+import { type ThreeEvent } from "@react-three/fiber";
+type ProjectProps = {
+    projectId: string;
+    loadingIndicator?: React.ReactNode;
+    onObjectClick?: (object: CreatedObjectSettings, ref: Object3D, event: ThreeEvent<MouseEvent>) => void;
+    onObjectHover?: (object: CreatedObjectSettings, ref: Object3D) => void;
+    onElementClick?: (element: HtmlElement) => void;
+    onElementHover?: (element: HtmlElement | null) => void;
+    onSceneInitialized?: () => void;
+};
+declare const ProjectLoader: React.FC<ProjectProps>;
+export default ProjectLoader;
+//# sourceMappingURL=ProjectLoader.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ProjectLoader.d.ts","sourceRoot":"","sources":["../../src/components/ProjectLoader.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,qBAAqB,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAGhF,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AACjC,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAErD,KAAK,YAAY,GAAG;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,gBAAgB,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IACnC,aAAa,CAAC,EAAE,CAAC,MAAM,EAAE,qBAAqB,EAAE,GAAG,EAAE,QAAQ,EAAE,KAAK,EAAE,UAAU,CAAC,UAAU,CAAC,KAAK,IAAI,CAAC;IACtG,aAAa,CAAC,EAAE,CAAC,MAAM,EAAE,qBAAqB,EAAE,GAAG,EAAE,QAAQ,KAAK,IAAI,CAAC;IACvE,cAAc,CAAC,EAAE,CAAC,OAAO,EAAE,WAAW,KAAK,IAAI,CAAC;IAChD,cAAc,CAAC,EAAE,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI,KAAK,IAAI,CAAC;IACvD,kBAAkB,CAAC,EAAE,MAAM,IAAI,CAAC;CACnC,CAAC;AAIF,QAAA,MAAM,aAAa,EAAE,KAAK,CAAC,EAAE,CAAC,YAAY,CA2EzC,CAAC;AACF,eAAe,aAAa,CAAC"}