@3driseai/3drise-core 1.0.1

package/dist/utils/objectTreeUtils.js

@@ -0,0 +1,115 @@
+/**
+ * Build a tree structure from flat array of objects using parentId relationships
+ */
+export function buildObjectTree(objects) {
+    const objectMap = new Map();
+    const roots = [];
+    // First pass: create tree nodes for all objects
+    objects.forEach(obj => {
+        objectMap.set(obj.id, { objectId: obj.id, createdObject: obj, children: [] });
+    });
+    // Second pass: build parent-child relationships
+    objects.forEach(obj => {
+        const node = objectMap.get(obj.id);
+        if (obj.parentId && objectMap.has(obj.parentId)) {
+            const parent = objectMap.get(obj.parentId);
+            parent.children.push(node);
+        }
+        else {
+            // No parent or parent doesn't exist - this is a root object
+            roots.push(node);
+        }
+    });
+    return roots;
+}
+/**
+ * Get all descendant IDs of an object (children, grandchildren, etc.)
+ */
+export function getDescendantIds(objectId, objects) {
+    const descendants = [];
+    const queue = objects.filter(obj => obj.parentId === objectId);
+    while (queue.length > 0) {
+        const current = queue.shift();
+        descendants.push(current.id);
+        // Add children of current to queue
+        objects.filter(obj => obj.parentId === current.id).forEach(child => {
+            queue.push(child);
+        });
+    }
+    return descendants;
+}
+/**
+ * Get all ancestor IDs of an object (parent, grandparent, etc. up to root)
+ */
+export function getAncestorIds(objectId, objects) {
+    const ancestors = [];
+    let current = objects.find(obj => obj.id === objectId);
+    while (current && current.parentId) {
+        ancestors.push(current.parentId);
+        current = objects.find(obj => obj.id === current.parentId);
+    }
+    return ancestors;
+}
+/**
+ * Check if dropping an object onto a target would create a circular reference
+ */
+export function wouldCreateCircularReference(objectId, targetParentId, objects) {
+    // Can't parent to self
+    if (objectId === targetParentId)
+        return true;
+    // Check if target is a descendant of object
+    const descendants = getDescendantIds(objectId, objects);
+    return descendants.includes(targetParentId);
+}
+/**
+ * Get the depth of an object in the tree (0 = root)
+ */
+export function getObjectDepth(objectId, objects) {
+    return getAncestorIds(objectId, objects).length;
+}
+/**
+ * Flatten a tree back to array (useful for iteration in render order)
+ */
+export function flattenTree(nodes) {
+    const result = [];
+    function traverse(node) {
+        result.push(node.objectId);
+        node.children.forEach(traverse);
+    }
+    nodes.forEach(traverse);
+    return result;
+}
+/**
+ * Sort objects so parents come before children (for proper Three.js rendering)
+ */
+export function sortByHierarchy(objects) {
+    const tree = buildObjectTree(objects);
+    return flattenTree(tree);
+}
+/**
+ * Get object type icon name for UI display
+ */
+export function getObjectTypeIcon(type) {
+    const icons = {
+        mesh: 'cube',
+        model: 'box',
+        particles: 'sparkles',
+        path: 'route',
+        gallery: 'image',
+        custom_primitive: 'shapes',
+        text: 'type',
+        group: 'folder',
+        grid: 'grid-3x3',
+        effect: 'wand2',
+        light: 'lightbulb',
+        clouds: 'cloud',
+        rain: 'cloud-rain',
+        water: 'waves',
+        stars: 'star',
+        fog: 'cloud',
+        solarSystem: 'solar-system',
+        shootingStars: 'shooting-star',
+        earth: 'globe',
+    };
+    return icons[type] || 'circle';
+}

package/dist/utils/optionalProperties.d.ts

@@ -0,0 +1,36 @@
+export interface OptionalProperty {
+    name: string;
+    description: string;
+    type: 'number' | 'string' | 'boolean' | 'color' | 'vector3' | 'vector2' | 'select';
+    min?: number;
+    max?: number;
+    step?: number;
+    options?: string[];
+}
+export type EnvironmentType = keyof typeof environmentOptionalProperties;
+export declare const skyOptionalProperties: OptionalProperty[];
+export declare const oceanOptionalProperties: OptionalProperty[];
+export declare const terrainOptionalProperties: OptionalProperty[];
+export declare const textOptionalProperties: OptionalProperty[];
+export declare const plainOptionalProperties: OptionalProperty[];
+export declare const meshOptionalProperties: OptionalProperty[];
+export declare const rainOptionalProperties: OptionalProperty[];
+export declare const fogOptionalProperties: OptionalProperty[];
+export declare const starsOptionalProperties: OptionalProperty[];
+export declare const shootingStarsOptionalProperties: OptionalProperty[];
+export declare const hdrOptionalProperties: OptionalProperty[];
+export declare const cloudsOptionalProperties: OptionalProperty[];
+export declare const environmentOptionalProperties: {
+    sky: OptionalProperty[];
+    ocean: OptionalProperty[];
+    terrain: OptionalProperty[];
+    text: OptionalProperty[];
+    plain: OptionalProperty[];
+    mesh: OptionalProperty[];
+    rain: OptionalProperty[];
+    fog: OptionalProperty[];
+    stars: OptionalProperty[];
+    hdr: OptionalProperty[];
+    clouds: OptionalProperty[];
+};
+//# sourceMappingURL=optionalProperties.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"optionalProperties.d.ts","sourceRoot":"","sources":["../../src/utils/optionalProperties.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,gBAAgB;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,GAAG,SAAS,GAAG,QAAQ,CAAC;IACnF,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;CACtB;AAED,MAAM,MAAM,eAAe,GAAG,MAAM,OAAO,6BAA6B,CAAC;AACzE,eAAO,MAAM,qBAAqB,EAAE,gBAAgB,EA8CnD,CAAC;AACF,eAAO,MAAM,uBAAuB,EAAE,gBAAgB,EAmCrD,CAAC;AACF,eAAO,MAAM,yBAAyB,EAAE,gBAAgB,EASvD,CAAC;AACF,eAAO,MAAM,sBAAsB,EAAE,gBAAgB,EAgEpD,CAAC;AACF,eAAO,MAAM,uBAAuB,EAAE,gBAAgB,EAqGrD,CAAC;AACF,eAAO,MAAM,sBAAsB,EAAE,gBAAgB,EA6BpD,CAAC;AACF,eAAO,MAAM,sBAAsB,EAAE,gBAAgB,EAsCpD,CAAC;AACF,eAAO,MAAM,qBAAqB,EAAE,gBAAgB,EAsBnD,CAAC;AACF,eAAO,MAAM,uBAAuB,EAAE,gBAAgB,EAsCrD,CAAC;AACF,eAAO,MAAM,+BAA+B,EAAE,gBAAgB,EA8C7D,CAAC;AACF,eAAO,MAAM,qBAAqB,EAAE,gBAAgB,EAYnD,CAAC;AACF,eAAO,MAAM,wBAAwB,EAAE,gBAAgB,EAqBtD,CAAC;AAEF,eAAO,MAAM,6BAA6B;;;;;;;;;;;;CAYzC,CAAC"}

package/dist/utils/optionalProperties.js

@@ -0,0 +1,487 @@
+export const skyOptionalProperties = [
+    {
+        name: 'elevation',
+        description: 'Height of the sun above the horizon',
+        type: 'number',
+        min: 0,
+        max: 90,
+    },
+    {
+        name: 'azimuth',
+        description: 'Compass direction of the sun',
+        type: 'number',
+        min: 0,
+        max: 360,
+    },
+    {
+        name: 'turbidity',
+        description: 'Atmospheric haze, affects sky color and sun intensity',
+        type: 'number',
+        min: 0,
+        max: 10,
+    },
+    {
+        name: 'rayleigh',
+        description: 'Rayleigh scattering coefficient for blue light',
+        type: 'number',
+        min: 0,
+        max: 4,
+        step: 0.1,
+    },
+    {
+        name: 'mieCoefficient',
+        description: 'Mie scattering coefficient for particles in atmosphere',
+        type: 'number',
+        min: 0,
+        max: 0.1,
+        step: 0.001,
+    },
+    {
+        name: 'mieDirectionalG',
+        description: 'Directional intensity of Mie scattering',
+        type: 'number',
+        min: 0,
+        max: 1,
+        step: 0.01,
+    }
+];
+export const oceanOptionalProperties = [
+    {
+        name: 'sunColor',
+        description: 'Color of the sun reflection on water',
+        type: 'color',
+    },
+    {
+        name: 'waterColor',
+        description: 'Base color of the water',
+        type: 'color',
+    },
+    {
+        name: 'distortionScale',
+        description: 'Intensity of water surface distortion',
+        type: 'number',
+        min: 0,
+        max: 20,
+        step: 0.1,
+    },
+    {
+        name: 'waveHeight',
+        description: 'Height of the water waves',
+        type: 'number',
+        min: 0,
+        max: 10,
+        step: 0.1,
+    },
+    {
+        name: 'speed',
+        description: 'Speed of water movement animation',
+        type: 'number',
+        min: 0,
+        max: 2,
+        step: 0.01,
+    }
+];
+export const terrainOptionalProperties = [
+    {
+        name: 'displacementScale',
+        description: 'Intensity of terrain height displacement',
+        type: 'number',
+        min: 0,
+        max: 2,
+        step: 0.01,
+    }
+];
+export const textOptionalProperties = [
+    {
+        name: 'text',
+        description: 'Text content to display',
+        type: 'string',
+    },
+    {
+        name: 'height',
+        description: 'Extrusion depth of the 3D text',
+        type: 'number',
+        min: 0,
+        max: 1,
+        step: 0.01,
+    },
+    {
+        name: 'position',
+        description: 'Position of the text in 3D space',
+        type: 'vector3',
+    },
+    {
+        name: 'scale',
+        description: 'Scale of the text object',
+        type: 'vector3',
+    },
+    {
+        name: 'bevelSize',
+        description: 'Size of the text bevel',
+        type: 'number',
+        min: 0,
+        max: 10,
+        step: 0.1,
+    },
+    {
+        name: 'bevelSegments',
+        description: 'Number of bevel segments for smoother edges',
+        type: 'number',
+        min: 1,
+        max: 20,
+        step: 1,
+    },
+    {
+        name: 'curveSegments',
+        description: 'Number of segments for text curves',
+        type: 'number',
+        min: 1,
+        max: 256,
+        step: 1,
+    },
+    {
+        name: 'bevelThickness',
+        description: 'Thickness of the text bevel',
+        type: 'number',
+        min: 0,
+        max: 0.1,
+        step: 0.001,
+    },
+    {
+        name: 'letterSpacing',
+        description: 'Spacing between letters',
+        type: 'number',
+        min: 0,
+        max: 1,
+        step: 0.01,
+    }
+];
+export const plainOptionalProperties = [
+    {
+        name: 'materialType',
+        description: 'Type of material for the plane',
+        type: 'select',
+        options: ['reflector', 'refraction', 'transmission', 'wobble', 'distort', 'standard', 'physical', 'basic', 'lambert', 'phong', 'toon', 'normal', 'matcap'],
+    },
+    {
+        name: 'position',
+        description: 'Position of the plane in 3D space',
+        type: 'vector3',
+    },
+    {
+        name: 'rotation',
+        description: 'Rotation of the plane',
+        type: 'vector3',
+    },
+    {
+        name: 'scale',
+        description: 'Scale of the plane',
+        type: 'vector3',
+    },
+    {
+        name: 'size',
+        description: 'Width and height of the plane',
+        type: 'vector2',
+    },
+    {
+        name: 'color',
+        description: 'Base color of the plane',
+        type: 'color',
+    },
+    {
+        name: 'blur',
+        description: 'Blur amount for reflective materials',
+        type: 'vector2',
+    },
+    {
+        name: 'resolution',
+        description: 'Resolution for reflective materials',
+        type: 'number',
+        min: 256,
+        max: 4096,
+        step: 256,
+    },
+    {
+        name: 'mixBlur',
+        description: 'Mix factor for blur effect',
+        type: 'number',
+        min: 0,
+        max: 10,
+        step: 0.1,
+    },
+    {
+        name: 'mixStrength',
+        description: 'Strength of the reflection mix',
+        type: 'number',
+        min: 0,
+        max: 100,
+        step: 1,
+    },
+    {
+        name: 'roughness',
+        description: 'Surface roughness of the material',
+        type: 'number',
+        min: 0,
+        max: 1,
+        step: 0.01,
+    },
+    {
+        name: 'metalness',
+        description: 'Metallic property of the material',
+        type: 'number',
+        min: 0,
+        max: 1,
+        step: 0.01,
+    },
+    {
+        name: 'depthScale',
+        description: 'Scale factor for depth-based effects',
+        type: 'number',
+        min: 0,
+        max: 5,
+        step: 0.1,
+    },
+    {
+        name: 'minDepthThreshold',
+        description: 'Minimum depth threshold for effects',
+        type: 'number',
+        min: 0,
+        max: 1,
+        step: 0.01,
+    },
+    {
+        name: 'maxDepthThreshold',
+        description: 'Maximum depth threshold for effects',
+        type: 'number',
+        min: 0,
+        max: 5,
+        step: 0.01,
+    }
+];
+export const meshOptionalProperties = [
+    {
+        name: 'position',
+        description: 'Position of the mesh in 3D space',
+        type: 'vector3',
+    },
+    {
+        name: 'rotation',
+        description: 'Rotation of the mesh in radians',
+        type: 'vector3',
+    },
+    {
+        name: 'scale',
+        description: 'Scale factor for each axis',
+        type: 'vector3',
+    },
+    {
+        name: 'color',
+        description: 'Base color of the mesh material',
+        type: 'color',
+    },
+    {
+        name: 'opacity',
+        description: 'Transparency of the mesh material',
+        type: 'number',
+        min: 0,
+        max: 1,
+        step: 0.01,
+    }
+];
+export const rainOptionalProperties = [
+    {
+        name: 'color',
+        description: 'Color of rain particles',
+        type: 'color',
+    },
+    {
+        name: 'size',
+        description: 'Size of individual rain particles',
+        type: 'number',
+        min: 0.01,
+        max: 1,
+        step: 0.01,
+    },
+    {
+        name: 'opacity',
+        description: 'Transparency of rain particles',
+        type: 'number',
+        min: 0,
+        max: 1,
+        step: 0.01,
+    },
+    {
+        name: 'speed',
+        description: 'Speed of falling rain',
+        type: 'number',
+        min: 0.1,
+        max: 5,
+        step: 0.1,
+    },
+    {
+        name: 'density',
+        description: 'Number of rain particles',
+        type: 'number',
+        min: 10,
+        max: 1000,
+        step: 10,
+    }
+];
+export const fogOptionalProperties = [
+    {
+        name: 'color',
+        description: 'Color of the fog',
+        type: 'color',
+    },
+    {
+        name: 'near',
+        description: 'Distance where fog starts to appear',
+        type: 'number',
+        min: 0.1,
+        max: 100,
+        step: 0.1,
+    },
+    {
+        name: 'far',
+        description: 'Distance where fog reaches maximum density',
+        type: 'number',
+        min: 1,
+        max: 1000,
+        step: 1,
+    }
+];
+export const starsOptionalProperties = [
+    {
+        name: 'rotateSpeed',
+        description: 'Speed of stars rotation',
+        type: 'number',
+        min: 0,
+        max: 2,
+        step: 0.01,
+    },
+    {
+        name: 'count',
+        description: 'Number of stars to display',
+        type: 'number',
+        min: 10,
+        max: 1000,
+        step: 10,
+    },
+    {
+        name: 'sep',
+        description: 'Separation distance between stars',
+        type: 'number',
+        min: 1,
+        max: 20,
+        step: 0.1,
+    },
+    {
+        name: 'color',
+        description: 'Color of the stars',
+        type: 'color',
+    },
+    {
+        name: 'size',
+        description: 'Size of individual stars',
+        type: 'number',
+        min: 0.01,
+        max: 1,
+        step: 0.01,
+    }
+];
+export const shootingStarsOptionalProperties = [
+    {
+        name: 'count',
+        description: 'Number of shooting stars active at once',
+        type: 'number',
+        min: 1,
+        max: 50,
+        step: 1,
+    },
+    {
+        name: 'speedRange',
+        description: 'Min and max speed of shooting stars',
+        type: 'vector2',
+        min: 0,
+        max: 1,
+        step: 0.01,
+    },
+    {
+        name: 'lengthRange',
+        description: 'Min and max length of shooting star trails',
+        type: 'vector2',
+        min: 1,
+        max: 500,
+        step: 1,
+    },
+    {
+        name: 'intervalRange',
+        description: 'Min and max seconds between new shooting stars',
+        type: 'vector2',
+        min: 0.1,
+        max: 30,
+        step: 0.1,
+    },
+    {
+        name: 'trailLengthRange',
+        description: 'Min and max trail fade length',
+        type: 'vector2',
+        min: 1,
+        max: 300,
+        step: 1,
+    },
+    {
+        name: 'followMouse',
+        description: 'Shooting stars aim toward mouse cursor',
+        type: 'boolean',
+    },
+];
+export const hdrOptionalProperties = [
+    {
+        name: 'name',
+        description: 'HDR environment name',
+        type: 'select',
+        options: ['apartment', 'city', 'forest', 'dawn', 'lobby', 'night', 'park', 'studio', 'sunset', 'warehouse'],
+    },
+    {
+        name: 'url',
+        description: 'Custom HDR environment URL',
+        type: 'string',
+    }
+];
+export const cloudsOptionalProperties = [
+    {
+        name: 'cloudColor',
+        description: 'Color of the clouds',
+        type: 'color',
+    },
+    {
+        name: 'lightColor',
+        description: 'Color of the lightning',
+        type: 'color',
+    },
+    {
+        name: 'speed',
+        description: 'Speed of cloud movement',
+        type: 'number',
+    },
+    {
+        name: 'scroll',
+        description: 'Scroll factor for cloud texture',
+        type: 'number',
+    }
+];
+// Export all optional properties as a collection for easy access
+export const environmentOptionalProperties = {
+    sky: skyOptionalProperties,
+    ocean: oceanOptionalProperties,
+    terrain: terrainOptionalProperties,
+    text: textOptionalProperties,
+    plain: plainOptionalProperties,
+    mesh: meshOptionalProperties,
+    rain: rainOptionalProperties,
+    fog: fogOptionalProperties,
+    stars: starsOptionalProperties,
+    hdr: hdrOptionalProperties,
+    clouds: cloudsOptionalProperties
+};

package/dist/utils/particleAnimations.d.ts

@@ -0,0 +1,3 @@
+import type { Points } from "three";
+export declare const handleShapeAnimation: (delta: number, speed: number, animationProgress: React.RefObject<number>, pointsRef: React.RefObject<Points | null>, basePositions: React.RefObject<Float32Array | null>, targetPositions: React.RefObject<Float32Array | null>) => void;
+//# sourceMappingURL=particleAnimations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"particleAnimations.d.ts","sourceRoot":"","sources":["../../src/utils/particleAnimations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,OAAO,CAAC;AAEpC,eAAO,MAAM,oBAAoB,GAAI,OAAO,MAAM,EAAE,OAAO,MAAM,EAAE,mBAAmB,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,WAAW,KAAK,CAAC,SAAS,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,eAAe,KAAK,CAAC,SAAS,CAAC,YAAY,GAAG,IAAI,CAAC,EAAE,iBAAiB,KAAK,CAAC,SAAS,CAAC,YAAY,GAAG,IAAI,CAAC,KAAG,IAgBtQ,CAAC"}

package/dist/utils/particleAnimations.js

@@ -0,0 +1,17 @@
+export const handleShapeAnimation = (delta, speed, animationProgress, pointsRef, basePositions, targetPositions) => {
+    if (!pointsRef.current || !basePositions.current)
+        return;
+    const progress = Math.min(animationProgress.current + delta * speed, 1);
+    const geometry = pointsRef.current.geometry;
+    const posAttr = geometry.attributes.position;
+    if (targetPositions.current) {
+        const galPos = targetPositions.current;
+        for (let i = 0; i < basePositions.current.length; i += 3) {
+            posAttr.array[i] = basePositions.current[i] + (galPos[i] - basePositions.current[i]) * progress;
+            posAttr.array[i + 1] = basePositions.current[i + 1] + (galPos[i + 1] - basePositions.current[i + 1]) * progress;
+            posAttr.array[i + 2] = basePositions.current[i + 2] + (galPos[i + 2] - basePositions.current[i + 2]) * progress;
+        }
+    }
+    animationProgress.current = progress;
+    posAttr.needsUpdate = true;
+};

package/dist/utils/pathUtils.d.ts

@@ -0,0 +1,19 @@
+import * as THREE from 'three';
+import type { Vector3Array } from "../types/scene3d";
+export declare const createCurves: (paths?: number[][] | null, pointsPaths?: THREE.Vector3[][] | null) => THREE.CatmullRomCurve3[];
+export declare const randomRange: (min: number, max: number) => number;
+/**
+ * Smooths corners by adding interpolated points around each corner using quadratic bezier curves.
+ * smoothness 0-100: 0 = sharp corners, 100 = maximum rounding
+ */
+export declare const smoothPathCorners: (points: Vector3Array[], smoothness: number) => Vector3Array[];
+/**
+ * Creates a CatmullRomCurve3 spline from points.
+ * curve 1-100: 1 = sharp/tight, 100 = smoothest
+ */
+export declare const createPathSpline: (points: Vector3Array[], curve: number) => THREE.CatmullRomCurve3 | null;
+/**
+ * Samples evenly-spaced points along a spline for rendering.
+ */
+export declare const sampleSplinePoints: (spline: THREE.CatmullRomCurve3, numPoints: number) => Vector3Array[];
+//# sourceMappingURL=pathUtils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pathUtils.d.ts","sourceRoot":"","sources":["../../src/utils/pathUtils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAErD,eAAO,MAAM,YAAY,GAAI,QAAQ,MAAM,EAAE,EAAE,GAAG,IAAI,EAAE,cAAc,KAAK,CAAC,OAAO,EAAE,EAAE,GAAG,IAAI,KAAG,KAAK,CAAC,gBAAgB,EAiBtH,CAAC;AACF,eAAO,MAAM,WAAW,GAAI,KAAK,MAAM,EAAE,KAAK,MAAM,KAAG,MAA2C,CAAC;AACnG;;;GAGG;AACH,eAAO,MAAM,iBAAiB,GAAI,QAAQ,YAAY,EAAE,EAAE,YAAY,MAAM,KAAG,YAAY,EA8B1F,CAAC;AACF;;;GAGG;AACH,eAAO,MAAM,gBAAgB,GAAI,QAAQ,YAAY,EAAE,EAAE,OAAO,MAAM,KAAG,KAAK,CAAC,gBAAgB,GAAG,IAMjG,CAAC;AACF;;GAEG;AACH,eAAO,MAAM,kBAAkB,GAAI,QAAQ,KAAK,CAAC,gBAAgB,EAAE,WAAW,MAAM,KAAG,YAAY,EAGlG,CAAC"}