@3driseai/3drise-core 1.0.1

package/dist/three/PathRendererV.js

@@ -0,0 +1,225 @@
+import * as THREE from 'three';
+import { smoothPathCorners, createPathSpline, sampleSplinePoints } from '../utils/pathUtils.js';
+export class PathRendererV {
+    parent;
+    group;
+    options;
+    pointMeshes = [];
+    lines = [];
+    geometryMeshes = [];
+    constructor(parent, options) {
+        this.parent = parent;
+        this.options = options;
+        this.group = new THREE.Group();
+        parent.add(this.group);
+        this.build();
+    }
+    build() {
+        const { pathConfig, color = '#ffa500', showPoints = true, showLine = true, showCurve = true, pointSize = 0.15, } = this.options;
+        const points = pathConfig.points || [];
+        if (points.length === 0)
+            return;
+        const curve = pathConfig.curve ?? 1;
+        const smoothCorners = pathConfig.smoothCorners ?? 0;
+        const hasCurve = curve > 1;
+        const hasSmoothCorners = smoothCorners > 0;
+        const smoothedPoints = hasSmoothCorners && points.length >= 3
+            ? smoothPathCorners(points, smoothCorners)
+            : points;
+        if (showPoints) {
+            const mat = new THREE.MeshStandardMaterial({ color, emissive: color, emissiveIntensity: 0.5, toneMapped: false });
+            const sphereGeo = new THREE.SphereGeometry(pointSize, 16, 16);
+            const dotGeo = new THREE.SphereGeometry(pointSize * 0.33, 8, 8);
+            const dotMat = new THREE.MeshBasicMaterial({ color: '#ffffff' });
+            for (const point of points) {
+                const sphere = new THREE.Mesh(sphereGeo, mat);
+                sphere.position.set(...point);
+                this.group.add(sphere);
+                this.pointMeshes.push(sphere);
+                const dot = new THREE.Mesh(dotGeo, dotMat);
+                dot.position.set(point[0], point[1] + pointSize * 1.67, point[2]);
+                this.group.add(dot);
+                this.pointMeshes.push(dot);
+            }
+        }
+        if (showLine && points.length > 1 && !hasCurve && !hasSmoothCorners) {
+            const line = this.makeLine(points, color, false);
+            this.group.add(line);
+            this.lines.push(line);
+        }
+        if (showCurve && points.length >= 2 && (hasCurve || hasSmoothCorners)) {
+            const spline = createPathSpline(hasSmoothCorners ? smoothedPoints : points, curve);
+            if (spline) {
+                const curvePoints = sampleSplinePoints(spline, smoothedPoints.length);
+                const curveLine = this.makeLine(curvePoints, color, false);
+                this.group.add(curveLine);
+                this.lines.push(curveLine);
+            }
+            if (showLine && points.length > 1) {
+                const dashed = this.makeLine(points, color, true);
+                this.group.add(dashed);
+                this.lines.push(dashed);
+            }
+        }
+        if (pathConfig.geometry && pathConfig.geometry.type !== 'none' && points.length >= 2) {
+            this.buildGeometry(points, curve, smoothCorners, pathConfig.geometry);
+        }
+    }
+    makeLine(points, color, dashed) {
+        const geo = new THREE.BufferGeometry().setFromPoints(points.map(p => new THREE.Vector3(p[0], p[1], p[2])));
+        const mat = dashed
+            ? new THREE.LineDashedMaterial({ color, dashSize: 0.1, gapSize: 0.1 })
+            : new THREE.LineBasicMaterial({ color });
+        const line = new THREE.Line(geo, mat);
+        if (dashed)
+            line.computeLineDistances();
+        return line;
+    }
+    buildGeometry(points, curve, smoothCorners, geometry) {
+        const { type, width = 2, radius = 0.5, segments = 8, numLanes = 0, color = '#555555', dividerColor = '#ffffff' } = geometry;
+        const smoothed = smoothPathCorners(points, smoothCorners);
+        const spline = createPathSpline(smoothed, curve);
+        if (!spline)
+            return;
+        const stdMat = (c) => new THREE.MeshStandardMaterial({ color: c, side: THREE.DoubleSide });
+        if (type === 'tube') {
+            const geo = new THREE.TubeGeometry(spline, points.length * 10, radius, segments, false);
+            const mesh = new THREE.Mesh(geo, stdMat(color));
+            this.group.add(mesh);
+            this.geometryMeshes.push(mesh);
+        }
+        if (type === 'road') {
+            const geo = this.buildRoadGeo(spline, points.length, width);
+            if (geo) {
+                const mesh = new THREE.Mesh(geo, stdMat(color));
+                this.group.add(mesh);
+                this.geometryMeshes.push(mesh);
+            }
+            if (numLanes > 0) {
+                this.buildLaneDividers(spline, points.length, width, numLanes, dividerColor)
+                    .forEach(l => { this.group.add(l); this.lines.push(l); });
+            }
+        }
+        if (type === 'walls') {
+            const geo = this.buildWallsGeo(spline, points.length, width);
+            if (geo) {
+                const mesh = new THREE.Mesh(geo, stdMat(color));
+                this.group.add(mesh);
+                this.geometryMeshes.push(mesh);
+            }
+        }
+    }
+    buildRoadGeo(spline, numPoints, width) {
+        const divisions = Math.max(numPoints * 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 tangent = spline.getTangentAt(t).normalize();
+            const perp = new THREE.Vector3().crossVectors(tangent, 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;
+    }
+    buildWallsGeo(spline, numPoints, width) {
+        const divisions = Math.max(numPoints * 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;
+    }
+    buildLaneDividers(spline, numPoints, width, numLanes, color) {
+        const divisions = Math.max(numPoints * 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, idx) => {
+            const pts = [];
+            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;
+                pts.push(dp);
+            }
+            const geo = new THREE.BufferGeometry().setFromPoints(pts);
+            const mat = idx === 0
+                ? new THREE.LineBasicMaterial({ color })
+                : new THREE.LineDashedMaterial({ color, dashSize: 0.5, gapSize: 0.3 });
+            const line = new THREE.Line(geo, mat);
+            if (idx !== 0)
+                line.computeLineDistances();
+            return line;
+        });
+    }
+    update(_elapsed, _delta) { }
+    updateConfig(options) {
+        this.dispose(false);
+        this.options = options;
+        this.build();
+    }
+    dispose(removeFromScene = true) {
+        const disposeMesh = (m) => {
+            m.geometry.dispose();
+            m.material.dispose();
+        };
+        const disposeLine = (l) => {
+            l.geometry.dispose();
+            l.material.dispose();
+        };
+        this.pointMeshes.forEach(disposeMesh);
+        this.lines.forEach(disposeLine);
+        this.geometryMeshes.forEach(disposeMesh);
+        this.pointMeshes = [];
+        this.lines = [];
+        this.geometryMeshes = [];
+        this.group.clear();
+        if (removeFromScene)
+            this.parent.remove(this.group);
+    }
+}

package/dist/three/PathV.d.ts

@@ -0,0 +1,27 @@
+import * as THREE from 'three';
+import type { CatmullRomCurve3 } from "three";
+export interface PathVOptions {
+    curve: CatmullRomCurve3;
+    targetCurve?: CatmullRomCurve3;
+    color?: string | number;
+    opacity?: number;
+    tubeRadius?: number;
+    duration?: number;
+}
+export declare class PathV {
+    private parent;
+    private group;
+    private mesh;
+    private targetMesh;
+    private animationProgress;
+    private basePositions;
+    private speed;
+    private config;
+    constructor(parent: THREE.Object3D, options: PathVOptions);
+    private build;
+    update(_elapsed: number, delta?: number): void;
+    updateCurves(curve: CatmullRomCurve3, targetCurve?: CatmullRomCurve3): void;
+    updateConfig(options: Partial<PathVOptions>): void;
+    dispose(removeFromScene?: boolean): void;
+}
+//# sourceMappingURL=PathV.d.ts.map

package/dist/three/PathV.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PathV.d.ts","sourceRoot":"","sources":["../../src/three/PathV.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,OAAO,CAAC;AAC9C,MAAM,WAAW,YAAY;IACzB,KAAK,EAAE,gBAAgB,CAAC;IACxB,WAAW,CAAC,EAAE,gBAAgB,CAAC;IAC/B,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACxB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACrB;AAGD,qBAAa,KAAK;IACd,OAAO,CAAC,MAAM,CAAC;IACf,OAAO,CAAC,KAAK,CAAC;IACd,OAAO,CAAC,IAAI,CAAQ;IACpB,OAAO,CAAC,UAAU,CAAQ;IAC1B,OAAO,CAAC,iBAAiB,CAAK;IAC9B,OAAO,CAAC,aAAa,CAAQ;IAC7B,OAAO,CAAC,KAAK,CAAC;IACd,OAAO,CAAC,MAAM,CAAC;gBACH,MAAM,EAAE,KAAK,CAAC,QAAQ,EAAE,OAAO,EAAE,YAAY;IAQzD,OAAO,CAAC,KAAK;IAmBb,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,GAAE,MAAc,GAAG,IAAI;IAgBrD,YAAY,CAAC,KAAK,EAAE,gBAAgB,EAAE,WAAW,CAAC,EAAE,gBAAgB,GAAG,IAAI;IAK3E,YAAY,CAAC,OAAO,EAAE,OAAO,CAAC,YAAY,CAAC,GAAG,IAAI;IAMlD,OAAO,CAAC,eAAe,GAAE,OAAc,GAAG,IAAI;CAgBjD"}

package/dist/three/PathV.js

@@ -0,0 +1,81 @@
+import * as THREE from 'three';
+export class PathV {
+    parent;
+    group;
+    mesh = null;
+    targetMesh = null;
+    animationProgress = 0;
+    basePositions = null;
+    speed;
+    config;
+    constructor(parent, options) {
+        this.parent = parent;
+        this.config = options;
+        this.speed = 1 / (options.duration || 1);
+        this.group = new THREE.Group();
+        parent.add(this.group);
+        this.build();
+    }
+    build() {
+        const { curve, targetCurve, color = '#4c00ff', opacity = 1, tubeRadius = 0.001 } = this.config;
+        const geometry = new THREE.TubeGeometry(curve, 64, tubeRadius, 8, false);
+        const material = new THREE.MeshBasicMaterial({
+            color: new THREE.Color(color),
+            transparent: opacity < 1,
+            opacity,
+        });
+        this.mesh = new THREE.Mesh(geometry, material);
+        this.group.add(this.mesh);
+        this.basePositions = new Float32Array(geometry.attributes.position.array);
+        if (targetCurve) {
+            const targetGeometry = new THREE.TubeGeometry(targetCurve, 64, tubeRadius, 8, false);
+            this.targetMesh = new THREE.Mesh(targetGeometry, new THREE.MeshBasicMaterial({ visible: false }));
+            this.targetMesh.position.y = -1000;
+            this.group.add(this.targetMesh);
+        }
+        this.animationProgress = 0;
+    }
+    update(_elapsed, delta = 0.016) {
+        if (!this.mesh || !this.targetMesh || !this.basePositions)
+            return;
+        this.animationProgress = Math.min(this.animationProgress + delta * this.speed, 1);
+        const currentGeom = this.mesh.geometry;
+        const targetPositions = this.targetMesh.geometry.attributes.position.array;
+        const currentPosAttr = currentGeom.attributes.position;
+        const arr = currentPosAttr.array;
+        const length = Math.min(this.basePositions.length, targetPositions.length);
+        for (let i = 0; i < length; i += 3) {
+            arr[i] = this.basePositions[i] + (targetPositions[i] - this.basePositions[i]) * this.animationProgress;
+            arr[i + 1] = this.basePositions[i + 1] + (targetPositions[i + 1] - this.basePositions[i + 1]) * this.animationProgress;
+            arr[i + 2] = this.basePositions[i + 2] + (targetPositions[i + 2] - this.basePositions[i + 2]) * this.animationProgress;
+        }
+        currentPosAttr.needsUpdate = true;
+    }
+    updateCurves(curve, targetCurve) {
+        this.config = { ...this.config, curve, targetCurve };
+        this.dispose(false);
+        this.build();
+    }
+    updateConfig(options) {
+        this.config = { ...this.config, ...options };
+        this.speed = 1 / (this.config.duration || 1);
+        this.dispose(false);
+        this.build();
+    }
+    dispose(removeFromScene = true) {
+        if (this.mesh) {
+            this.mesh.geometry.dispose();
+            this.mesh.material.dispose();
+            this.mesh = null;
+        }
+        if (this.targetMesh) {
+            this.targetMesh.geometry.dispose();
+            this.targetMesh.material.dispose();
+            this.targetMesh = null;
+        }
+        this.group.clear();
+        if (removeFromScene)
+            this.parent.remove(this.group);
+        this.basePositions = null;
+    }
+}

package/dist/three/ProjectLoaderV.d.ts

@@ -0,0 +1,18 @@
+import type { SceneBuilderVOptions } from './SceneBuilderV';
+import type { Project } from "../types/users";
+export interface ProjectLoaderVOptions extends SceneBuilderVOptions {
+    onLoaded?: (project: Project) => void;
+    onError?: (error: Error) => void;
+}
+export declare class ProjectLoaderV {
+    private container;
+    private sceneBuilder;
+    private options;
+    constructor(container: HTMLElement, projectId: string, options?: ProjectLoaderVOptions);
+    private load;
+    get scene(): any;
+    get camera(): any;
+    get renderer(): any;
+    dispose(): void;
+}
+//# sourceMappingURL=ProjectLoaderV.d.ts.map

package/dist/three/ProjectLoaderV.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProjectLoaderV.d.ts","sourceRoot":"","sources":["../../src/three/ProjectLoaderV.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAC5D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAC9C,MAAM,WAAW,qBAAsB,SAAQ,oBAAoB;IAC/D,QAAQ,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;IACtC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;CACpC;AAID,qBAAa,cAAc;IACvB,OAAO,CAAC,SAAS,CAAC;IAClB,OAAO,CAAC,YAAY,CAAQ;IAC5B,OAAO,CAAC,OAAO,CAAC;gBACJ,SAAS,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,GAAE,qBAA0B;YAK5E,IAAI;IA6BlB,IAAI,KAAK,QAA+C;IACxD,IAAI,MAAM,QAAgD;IAC1D,IAAI,QAAQ,QAAkD;IAC9D,OAAO,IAAI,IAAI;CAIlB"}

package/dist/three/ProjectLoaderV.js

@@ -0,0 +1,49 @@
+import { loadAssets } from '../utils/utils.js';
+import { SceneBuilderV } from './SceneBuilderV.js';
+const DATA_CENTER_SERVER = 'https://3d-rise.com/api/data/';
+export class ProjectLoaderV {
+    container;
+    sceneBuilder = null;
+    options;
+    constructor(container, projectId, options = {}) {
+        this.container = container;
+        this.options = options;
+        this.load(projectId);
+    }
+    async load(projectId) {
+        let project;
+        try {
+            const url = `${DATA_CENTER_SERVER}projects/${projectId}/view`;
+            const res = await fetch(url, { headers: { 'Content-Type': 'application/json' } });
+            if (!res.ok)
+                throw new Error(res.status === 404 ? 'Project not found' : `HTTP ${res.status}`);
+            project = await res.json();
+        }
+        catch (err) {
+            this.options.onError?.(err);
+            return;
+        }
+        const sceneObjects = project.sceneObjects ?? [];
+        const modelObjects = sceneObjects.filter(o => o.type === 'model');
+        if (modelObjects.length) {
+            try {
+                const models = modelObjects.map(o => ({ ...o.userData, id: o.id }));
+                await loadAssets(models);
+            }
+            catch {
+                // Non-fatal — build scene with whatever loaded
+            }
+        }
+        this.options.onLoaded?.(project);
+        this.sceneBuilder = new SceneBuilderV(this.container, project, {
+            onInitialized: this.options.onInitialized,
+        });
+    }
+    get scene() { return this.sceneBuilder?.scene ?? null; }
+    get camera() { return this.sceneBuilder?.camera ?? null; }
+    get renderer() { return this.sceneBuilder?.renderer ?? null; }
+    dispose() {
+        this.sceneBuilder?.dispose();
+        this.sceneBuilder = null;
+    }
+}

package/dist/three/RainV.d.ts

@@ -0,0 +1,21 @@
+import * as THREE from 'three';
+import type { RainSettings } from "../types/environment";
+export interface RainVOptions {
+    settings: RainSettings;
+}
+export declare class RainV {
+    private parent;
+    private points;
+    private geometry;
+    private material;
+    private velocities;
+    private particleCount;
+    private settings;
+    constructor(parent: THREE.Object3D, options: RainVOptions);
+    private build;
+    private teardown;
+    update(_elapsed: number, delta?: number): void;
+    updateConfig(options: RainVOptions): void;
+    dispose(removeFromScene?: boolean): void;
+}
+//# sourceMappingURL=RainV.d.ts.map

package/dist/three/RainV.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RainV.d.ts","sourceRoot":"","sources":["../../src/three/RainV.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACzD,MAAM,WAAW,YAAY;IACzB,QAAQ,EAAE,YAAY,CAAC;CAC1B;AAiDD,qBAAa,KAAK;IACd,OAAO,CAAC,MAAM,CAAC;IACf,OAAO,CAAC,MAAM,CAAQ;IACtB,OAAO,CAAC,QAAQ,CAAQ;IACxB,OAAO,CAAC,QAAQ,CAAQ;IACxB,OAAO,CAAC,UAAU,CAAQ;IAC1B,OAAO,CAAC,aAAa,CAAK;IAC1B,OAAO,CAAC,QAAQ,CAAC;gBACL,MAAM,EAAE,KAAK,CAAC,QAAQ,EAAE,OAAO,EAAE,YAAY;IAKzD,OAAO,CAAC,KAAK;IA6Cb,OAAO,CAAC,QAAQ;IAUhB,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,GAAE,MAAc,GAAG,IAAI;IA6CrD,YAAY,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI;IA6BzC,OAAO,CAAC,eAAe,GAAE,OAAc,GAAG,IAAI;CAWjD"}

package/dist/three/RainV.js

@@ -0,0 +1,201 @@
+import * as THREE from 'three';
+const DEG_TO_RAD = Math.PI / 180;
+const MAX_PARTICLES = 20000;
+const vertexShader = `
+  attribute float speed;
+  varying float vSpeed;
+  uniform float windAngle;
+  uniform float windTilt;
+  uniform float streakLength;
+
+  void main() {
+    vSpeed = speed;
+    vec4 mvPosition = modelViewMatrix * vec4(position, 1.0);
+    gl_PointSize = 12.0 * streakLength * (200.0 / -mvPosition.z);
+    gl_PointSize = clamp(gl_PointSize, 1.0, 64.0);
+    gl_Position = projectionMatrix * mvPosition;
+  }
+`;
+const fragmentShader = `
+  varying float vSpeed;
+  uniform vec3 uColor;
+  uniform float opacity;
+  uniform float windAngle;
+  uniform float windTilt;
+  uniform float streakLength;
+
+  void main() {
+    vec2 uv = gl_PointCoord - vec2(0.5);
+    float angle = windAngle * windTilt;
+    float ca = cos(angle);
+    float sa = sin(angle);
+    vec2 rotUv = vec2(
+      uv.x * ca - uv.y * sa,
+      uv.x * sa + uv.y * ca
+    );
+    float aspectRatio = max(streakLength, 1.0);
+    rotUv.x *= aspectRatio;
+    float dist = length(rotUv);
+    float core = 1.0 - smoothstep(0.0, 0.15, dist);
+    float glow = (1.0 - smoothstep(0.1, 0.4, dist)) * 0.3;
+    float alpha = (core + glow) * opacity;
+    float gradient = smoothstep(-0.5, 0.2, rotUv.y) * 0.3 + 0.7;
+    alpha *= gradient;
+    if (alpha < 0.01) discard;
+    gl_FragColor = vec4(uColor, alpha);
+  }
+`;
+export class RainV {
+    parent;
+    points = null;
+    geometry = null;
+    material = null;
+    velocities = null;
+    particleCount = 0;
+    settings;
+    constructor(parent, options) {
+        this.parent = parent;
+        this.settings = options.settings;
+        this.build();
+    }
+    build() {
+        const s = this.settings;
+        const cfg = s.config;
+        const mesh = s.meshSettings;
+        const areaSize = mesh.scale?.[0] ?? 200;
+        const halfArea = areaSize / 2;
+        const height = areaSize * 1.25;
+        this.particleCount = Math.min(Math.max(Math.round((cfg.density ?? 100) * 100), 100), MAX_PARTICLES);
+        const positions = new Float32Array(this.particleCount * 3);
+        const speeds = new Float32Array(this.particleCount);
+        const velocities = new Float32Array(this.particleCount);
+        for (let i = 0; i < this.particleCount; i++) {
+            const i3 = i * 3;
+            positions[i3] = Math.random() * areaSize - halfArea;
+            positions[i3 + 1] = Math.random() * height - height / 4;
+            positions[i3 + 2] = Math.random() * areaSize - halfArea;
+            const v = 0.8 + Math.random() * 0.4;
+            speeds[i] = v;
+            velocities[i] = v;
+        }
+        const geometry = new THREE.BufferGeometry();
+        geometry.setAttribute('position', new THREE.BufferAttribute(positions, 3));
+        geometry.setAttribute('speed', new THREE.BufferAttribute(speeds, 1));
+        const material = new THREE.ShaderMaterial({
+            vertexShader,
+            fragmentShader,
+            uniforms: {
+                uColor: { value: new THREE.Color(cfg.color || '#ffffff') },
+                opacity: { value: cfg.opacity ?? 0.5 },
+                windAngle: { value: (cfg.windDirection ?? 0) * DEG_TO_RAD },
+                windTilt: { value: cfg.windStrength ?? 0 },
+                streakLength: { value: Math.max((cfg.size ?? 0.1) * 30, 1.0) },
+            },
+            transparent: true,
+            depthWrite: false,
+        });
+        const points = new THREE.Points(geometry, material);
+        points.frustumCulled = false;
+        if (mesh.visible)
+            this.parent.add(points);
+        this.geometry = geometry;
+        this.material = material;
+        this.points = points;
+        this.velocities = velocities;
+    }
+    teardown() {
+        if (this.points?.parent)
+            this.parent.remove(this.points);
+        this.geometry?.dispose();
+        this.material?.dispose();
+        this.geometry = null;
+        this.material = null;
+        this.points = null;
+        this.velocities = null;
+    }
+    update(_elapsed, delta = 0.016) {
+        const s = this.settings;
+        const cfg = s.config;
+        const mesh = s.meshSettings;
+        if (!mesh.visible || !this.geometry || !this.velocities || !this.points)
+            return;
+        const posAttr = this.geometry.attributes.position;
+        const positions = posAttr.array;
+        const velocities = this.velocities;
+        const speed = (cfg.speed ?? 1) * 60;
+        const windStrength = (cfg.windStrength ?? 0) * 30;
+        const windAngle = (cfg.windDirection ?? 0) * DEG_TO_RAD;
+        const windX = Math.sin(windAngle) * windStrength;
+        const windZ = Math.cos(windAngle) * windStrength;
+        const turbulence = cfg.turbulence ?? 0;
+        const areaSize = mesh.scale?.[0] ?? 200;
+        const halfArea = areaSize / 2;
+        const height = areaSize * 1.25;
+        const groundY = -height / 4;
+        const dt = Math.min(delta, 0.05);
+        for (let i = 0; i < this.particleCount; i++) {
+            const i3 = i * 3;
+            const v = velocities[i];
+            const turbX = turbulence > 0 ? (Math.random() - 0.5) * turbulence * 10 * dt : 0;
+            const turbZ = turbulence > 0 ? (Math.random() - 0.5) * turbulence * 10 * dt : 0;
+            positions[i3] += (windX * v + turbX) * dt;
+            positions[i3 + 1] -= speed * v * dt;
+            positions[i3 + 2] += (windZ * v + turbZ) * dt;
+            if (positions[i3 + 1] < groundY) {
+                positions[i3] = Math.random() * areaSize - halfArea;
+                positions[i3 + 1] = height * 0.75;
+                positions[i3 + 2] = Math.random() * areaSize - halfArea;
+                velocities[i] = 0.8 + Math.random() * 0.4;
+            }
+            if (positions[i3] > halfArea)
+                positions[i3] -= areaSize;
+            if (positions[i3] < -halfArea)
+                positions[i3] += areaSize;
+            if (positions[i3 + 2] > halfArea)
+                positions[i3 + 2] -= areaSize;
+            if (positions[i3 + 2] < -halfArea)
+                positions[i3 + 2] += areaSize;
+        }
+        posAttr.needsUpdate = true;
+    }
+    updateConfig(options) {
+        const prev = this.settings;
+        this.settings = options.settings;
+        const cfg = options.settings.config;
+        const mesh = options.settings.meshSettings;
+        const needsRebuild = prev.config.density !== cfg.density ||
+            prev.meshSettings.scale?.[0] !== mesh.scale?.[0];
+        if (needsRebuild) {
+            this.teardown();
+            this.build();
+            return;
+        }
+        if (this.points) {
+            if (mesh.visible && !this.points.parent) {
+                this.parent.add(this.points);
+            }
+            else if (!mesh.visible && this.points.parent) {
+                this.parent.remove(this.points);
+            }
+        }
+        if (this.material) {
+            const u = this.material.uniforms;
+            u.uColor.value.set(cfg.color || '#ffffff');
+            u.opacity.value = cfg.opacity ?? 0.5;
+            u.streakLength.value = Math.max((cfg.size ?? 0.1) * 30, 1.0);
+            u.windAngle.value = (cfg.windDirection ?? 0) * DEG_TO_RAD;
+            u.windTilt.value = cfg.windStrength ?? 0;
+        }
+    }
+    dispose(removeFromScene = true) {
+        if (removeFromScene && this.points?.parent) {
+            this.parent.remove(this.points);
+        }
+        this.geometry?.dispose();
+        this.material?.dispose();
+        this.geometry = null;
+        this.material = null;
+        this.points = null;
+        this.velocities = null;
+    }
+}

package/dist/three/SceneBuilderV.d.ts

@@ -0,0 +1,26 @@
+import * as THREE from 'three';
+import { OrbitControls } from 'three/addons/controls/OrbitControls.js';
+import type { ProjectData } from "../types/types";
+export interface SceneBuilderVOptions {
+    onInitialized?: () => void;
+}
+export declare class SceneBuilderV {
+    readonly scene: THREE.Scene;
+    readonly renderer: THREE.WebGLRenderer;
+    readonly camera: THREE.PerspectiveCamera;
+    readonly controls: OrbitControls;
+    private container;
+    private lightsManager;
+    private environmentManager;
+    private updatables;
+    private animationId;
+    private resizeObserver;
+    private clock;
+    constructor(container: HTMLElement, project: ProjectData, options?: SceneBuilderVOptions);
+    private buildNode;
+    private buildObject;
+    private animate;
+    private handleResize;
+    dispose(): void;
+}
+//# sourceMappingURL=SceneBuilderV.d.ts.map

package/dist/three/SceneBuilderV.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SceneBuilderV.d.ts","sourceRoot":"","sources":["../../src/three/SceneBuilderV.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,EAAE,aAAa,EAAE,MAAM,wCAAwC,CAAC;AAUvE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAClD,MAAM,WAAW,oBAAoB;IACjC,aAAa,CAAC,EAAE,MAAM,IAAI,CAAC;CAC9B;AAGD,qBAAa,aAAa;IACtB,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,KAAK,CAAC,aAAa,CAAC;IACvC,QAAQ,CAAC,MAAM,EAAE,KAAK,CAAC,iBAAiB,CAAC;IACzC,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC;IACjC,OAAO,CAAC,SAAS,CAAC;IAClB,OAAO,CAAC,aAAa,CAAQ;IAC7B,OAAO,CAAC,kBAAkB,CAAQ;IAClC,OAAO,CAAC,UAAU,CAAM;IACxB,OAAO,CAAC,WAAW,CAAQ;IAC3B,OAAO,CAAC,cAAc,CAAQ;IAC9B,OAAO,CAAC,KAAK,CAAqB;gBACtB,SAAS,EAAE,WAAW,EAAE,OAAO,EAAE,WAAW,EAAE,OAAO,GAAE,oBAAyB;IAuG5F,OAAO,CAAC,SAAS;IA6BjB,OAAO,CAAC,WAAW;IA8EnB,OAAO,CAAC,OAAO;IASf,OAAO,CAAC,YAAY;IASpB,OAAO,IAAI,IAAI;CAWlB"}