@3driseai/3drise-core 1.0.1

package/dist/data/shaders.d.ts

@@ -0,0 +1,12 @@
+type DbShader = {
+    name: string;
+    description: string;
+    materialType: string;
+    vertex: string;
+    fragment: string;
+    uniforms: Record<string, any>;
+};
+export declare const shaders: DbShader[];
+export declare const getShaderByName: (name: string) => DbShader | undefined;
+export {};
+//# sourceMappingURL=shaders.d.ts.map

package/dist/data/shaders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shaders.d.ts","sourceRoot":"","sources":["../../src/data/shaders.ts"],"names":[],"mappings":"AAAA,KAAK,QAAQ,GAAG;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CACjC,CAAC;AACF,eAAO,MAAM,OAAO,EAAE,QAAQ,EAoV7B,CAAC;AACF,eAAO,MAAM,eAAe,GAAI,MAAM,MAAM,KAAG,QAAQ,GAAG,SAA+C,CAAC"}

package/dist/data/shaders.js

@@ -0,0 +1,342 @@
+export const shaders = [
+    {
+        name: 'Sand',
+        description: 'A realistic sand shader with dynamic ripples and wind effects.',
+        materialType: 'sand',
+        vertex: `
+  varying vec3 vWorldPos;
+  varying vec3 vWorldNormal;
+
+  void main() {
+    vec4 wp = modelMatrix * vec4(position, 1.0);
+    vWorldPos = wp.xyz;
+    // NOTE: mat3(modelMatrix) is correct for uniform scale. If you put sand on a
+    // non-uniformly scaled mesh, swap for a proper inverse-transpose normal mat.
+    vWorldNormal = normalize(mat3(modelMatrix) * normal);
+    gl_Position = projectionMatrix * viewMatrix * wp;
+  }
+`,
+        fragment: `
+  precision highp float;
+
+  uniform float u_time;
+  uniform vec3  u_color;
+  uniform float u_colorVariation;
+  uniform float u_scale;
+  uniform float u_rippleScale;
+  uniform float u_rippleStrength;
+  uniform float u_rippleAsymmetry;
+  uniform vec2  u_windDir;
+  uniform float u_grainDensity;
+  uniform float u_grainStrength;
+  uniform float u_roughness;
+  uniform vec3  u_sunDirection;
+  uniform vec3  u_sunColor;
+  uniform float u_sunIntensity;
+  uniform float u_ambient;
+  uniform vec3  u_skyColor;
+  uniform vec3  u_groundColor;
+  uniform float u_windSpeed;
+  uniform vec3  u_mouse;
+  uniform float u_mouseRadius;
+  uniform float u_mouseStrength;
+  uniform float u_mouseSwirl;
+
+  varying vec3 vWorldPos;
+  varying vec3 vWorldNormal;
+
+  // ── hashing & noise ─────────────────────────────────────────────────────
+  float hash21(vec2 p) {
+    p = fract(p * vec2(123.34, 456.21));
+    p += dot(p, p + 45.32);
+    return fract(p.x * p.y);
+  }
+  float hash13(vec3 p) {
+    p = fract(p * 0.1031);
+    p += dot(p, p.zyx + 31.32);
+    return fract((p.x + p.y) * p.z);
+  }
+  float vnoise(vec2 p) {
+    vec2 i = floor(p), f = fract(p);
+    vec2 u = f * f * (3.0 - 2.0 * f);
+    return mix(
+      mix(hash21(i),                  hash21(i + vec2(1.0, 0.0)), u.x),
+      mix(hash21(i + vec2(0.0, 1.0)), hash21(i + vec2(1.0, 1.0)), u.x),
+      u.y
+    );
+  }
+
+  const mat2 ROT = mat2(0.8, 0.6, -0.6, 0.8);
+
+  float fbm(vec2 p) {
+    float s = 0.0, a = 0.5;
+    for (int i = 0; i < 5; i++) {
+      s += a * vnoise(p);
+      p = ROT * p * 2.03 + vec2(1.7);
+      a *= 0.5;
+    }
+    return s;
+  }
+
+  // Triplanar fBm — projected from the 3 world planes, blended by the
+  // geometric normal so it never stretches on steep faces.
+  float triFbm(vec3 p) {
+    vec3 w = pow(abs(vWorldNormal), vec3(4.0));
+    w /= (w.x + w.y + w.z + 1e-5);
+    return fbm(p.zy) * w.x + fbm(p.xz) * w.y + fbm(p.xy) * w.z;
+  }
+
+  // ── wind ripples ────────────────────────────────────────────────────────
+  // Crests perpendicular to wind, sinuous, with an asymmetric tent profile
+  // (gentle windward, steep lee). The whole pattern MIGRATES downwind over time
+  // (u_time * u_windSpeed) — windward face erodes, lee face builds — which is
+  // how real ripples crawl. Returns a height in [0,1].
+  float rippleField(vec2 xz, vec2 w) {
+    vec2 perp = vec2(-w.y, w.x);
+    float drift = u_time * u_windSpeed;            // world-distance the pattern has crawled
+    float along = dot(xz, w) - drift;
+    float across = dot(xz, perp);
+
+    float wob = (fbm(vec2(across * 0.6, along * 0.15) * u_rippleScale) - 0.5) * 1.4;
+    float k = mix(0.5, 0.82, clamp(u_rippleAsymmetry, 0.0, 1.0));
+
+    float ph  = fract(along * u_rippleScale * 0.6 + wob);
+    float crest = min(smoothstep(0.0, k, ph), 1.0 - smoothstep(k, 1.0, ph));
+    crest = pow(crest, 0.8);
+
+    // amplitude breathes along the crest so ripples merge & fade naturally
+    float amp = 0.55 + 0.45 * fbm(vec2(across * 0.25, along * 0.05) * u_rippleScale + 7.0);
+
+    // finer secondary ripple set riding on the primary
+    float ph2 = fract(along * u_rippleScale * 1.7 + wob * 0.6);
+    float crest2 = min(smoothstep(0.0, k, ph2), 1.0 - smoothstep(k, 1.0, ph2));
+
+    return crest * amp * 0.8 + crest2 * 0.2;
+  }
+
+  // Smooth falloff of the cursor gust at this fragment (0 outside the radius).
+  float mouseGust(vec3 wp) {
+    if (u_mouseStrength <= 0.001) return 0.0;
+    float d = length(wp.xz - u_mouse.xz);
+    return smoothstep(u_mouseRadius, 0.0, d) * u_mouseStrength;
+  }
+
+  // World-space sand height. Single scalar field -> derivative bump below.
+  // Ripples are gated to up-facing surfaces (they only form on wind-exposed flats).
+  float sandHeight(vec3 wp, vec3 gN) {
+    vec2 w = normalize(u_windDir + vec2(1e-5));
+
+    // Wind-blown grit: the medium detail layer crawls gently downwind too.
+    vec3 flow = vec3(w.x, 0.0, w.y) * (u_time * u_windSpeed * 0.5);
+    float dunes = triFbm(wp * (0.6 * u_scale));            // coarse undulation (static)
+    float micro = triFbm((wp - flow) * (3.0 * u_scale));  // medium grit (advected)
+
+    float up = clamp(gN.y, 0.0, 1.0);
+    up *= up;
+
+    // ── interactive gust: shove + swirl the ripple sampling away from the
+    //    cursor, and flatten the disturbed core (freshly blown sand). ──
+    vec2 xz = wp.xz;
+    float gust = mouseGust(wp);
+    if (gust > 0.0) {
+      vec2 d2 = wp.xz - u_mouse.xz;
+      vec2 dir = d2 / (length(d2) + 1e-4);
+      vec2 tang = vec2(-dir.y, dir.x);
+      xz += (dir + tang * u_mouseSwirl) * gust * u_mouseRadius * 0.18;
+    }
+
+    float ripples = rippleField(xz, w) * up * (1.0 - 0.6 * gust);
+    return dunes * 0.10 + micro * 0.025 + ripples * (0.14 * u_rippleStrength);
+  }
+
+  // Schüler surface-gradient bump: perturb N from a height field using screen
+  // derivatives of world position — no tangents needed, works on any mesh.
+  vec3 perturbNormal(vec3 pos, vec3 N, float h, float scale) {
+    vec3 dpdx = dFdx(pos);
+    vec3 dpdy = dFdy(pos);
+    vec3 r1 = cross(dpdy, N);
+    vec3 r2 = cross(N, dpdx);
+    float det = dot(dpdx, r1);
+    vec3 grad = sign(det) * (dFdx(h) * r1 + dFdy(h) * r2);
+    return normalize(abs(det) * N - scale * grad);
+  }
+
+  // Qualitative Oren-Nayar — the rough, matte, slightly retro look of powder.
+  float orenNayar(vec3 L, vec3 V, vec3 N, float rough) {
+    float r2 = rough * rough;
+    float A = 1.0 - 0.5 * r2 / (r2 + 0.33);
+    float B = 0.45 * r2 / (r2 + 0.09);
+    float NdotL = clamp(dot(N, L), 1e-3, 1.0);
+    float NdotV = clamp(dot(N, V), 1e-3, 1.0);
+    float ga = max(0.0, dot(normalize(V - N * NdotV), normalize(L - N * NdotL)));
+    float aL = acos(NdotL);
+    float aV = acos(NdotV);
+    float alpha = max(aL, aV);
+    float beta  = min(aL, aV);
+    return NdotL * (A + B * ga * sin(alpha) * tan(min(beta, 1.4)));
+  }
+
+  // Sparse, view-dependent micro-facet glints. A small fraction of grain cells
+  // catch the half-vector, so the surface twinkles as the camera moves. Built to
+  // stay stable on large meshes:
+  //  - Cell ids are WRAPPED before hashing. Hashing world coords directly blows
+  //    up to the hundreds-of-thousands on a big plane, where float32 has no
+  //    fractional precision left and the pattern strobes. The ~11-unit tile is
+  //    invisible under sparse random glints.
+  //  - Glints are ANTI-ALIASED by their screen footprint: once a grain cell is
+  //    sub-pixel (far away) it can't be resolved and is faded out, instead of
+  //    flickering every frame.
+  //  - A smooth per-grain pulse keeps static frames alive without a hard re-roll.
+  float sparkle(vec3 wp, vec3 N, vec3 H) {
+    float density = clamp(u_grainDensity, 0.0, 4.0);
+    float cellScale = 60.0 * (0.5 + density);
+
+    // grain cells per pixel; >1 means the glint is sub-pixel -> fade to avoid aliasing
+    vec3 fw = fwidth(wp) * cellScale;
+    float footprint = max(max(fw.x, fw.y), fw.z);
+    float aa = clamp(1.5 - footprint, 0.0, 1.0);
+    if (aa <= 0.0) return 0.0;
+
+    vec3 id = mod(floor(wp * cellScale), 1024.0);   // bounded -> precision-safe
+    float r1 = hash13(id);
+    float r2 = hash13(id + 17.13);
+    float r3 = hash13(id + 41.71);
+
+    vec3 tx = normalize(cross(N, vec3(0.0, 1.0, 0.0)) + vec3(1e-4));
+    vec3 ty = cross(N, tx);
+    vec3 mn = normalize(N + (tx * (r1 - 0.5) + ty * (r2 - 0.5)) * 0.9);
+
+    float s = pow(max(dot(mn, H), 0.0), 900.0);
+    float gate = step(0.93 - 0.06 * density, r3);
+    float twinkle = 0.65 + 0.35 * sin(u_time * 1.8 + r3 * 6.2831);
+
+    return s * gate * twinkle * aa;
+  }
+
+  void main() {
+    vec3 wp = vWorldPos;
+    vec3 gN = normalize(vWorldNormal);
+
+    float h = sandHeight(wp, gN);
+    vec3 N = perturbNormal(wp, gN, h, 1.0);
+
+    vec3 V = normalize(cameraPosition - wp);
+    vec3 L = normalize(u_sunDirection);
+    vec3 Hh = normalize(L + V);
+
+    // ── albedo: iron-oxide tonal variation + trough darkening ──
+    float tone = triFbm(wp * (0.2 * u_scale) + 11.0);
+    vec3 cool = u_color * vec3(0.82, 0.80, 0.74);
+    vec3 warm = u_color * vec3(1.07, 0.99, 0.85);
+    vec3 albedo = mix(u_color, mix(cool, warm, tone), clamp(u_colorVariation, 0.0, 1.0));
+    albedo *= mix(0.86, 1.06, smoothstep(0.0, 0.16, h));      // cavity in troughs
+    albedo *= 0.97 + 0.06 * triFbm(wp * (6.0 * u_scale));     // faint grit speckle
+
+    // ── lighting ──
+    float NdotL = max(dot(N, L), 0.0);
+    float diff = orenNayar(L, V, N, clamp(u_roughness, 0.04, 1.0));
+    vec3 sun = u_sunColor * u_sunIntensity;
+    vec3 color = albedo * sun * diff;
+
+    float hemi = N.y * 0.5 + 0.5;
+    vec3 amb = mix(u_groundColor, u_skyColor, hemi) * u_ambient;
+    color += albedo * amb;
+
+    // ── grain sparkle (only on the lit side; freshly blown grains glint more) ──
+    float gust = mouseGust(wp);
+    float glint = sparkle(wp, N, Hh) * NdotL;
+    color += glint * (1.0 + 1.5 * gust) * (u_sunColor * 0.7 + 0.3);
+
+    // ── lofted-sand sheen: disturbed sand catches a little extra light ──
+    color += albedo * gust * 0.22;
+
+    gl_FragColor = vec4(color, 1.0);
+  }
+`,
+        uniforms: {
+            u_time: 0,
+            u_color: [0.78, 0.66, 0.46],
+            u_colorVariation: 0.5,
+            u_scale: 1.0,
+            u_rippleScale: 1.0,
+            u_rippleStrength: 1.0,
+            u_rippleAsymmetry: 0.6,
+            u_windDir: [1, 0],
+            u_grainDensity: 1.0,
+            u_roughness: 0.88,
+            u_sunDirection: [0.5, 0.82, 0.28],
+            u_sunColor: [1.0, 0.93, 0.82],
+            u_sunIntensity: 1.0,
+            u_ambient: 1.0,
+            u_skyColor: [0.55, 0.68, 0.92],
+            u_groundColor: [0.45, 0.33, 0.22],
+            u_windSpeed: 0.15,
+            u_mouse: [0, -1000, 0],
+            u_mouseRadius: 3.0,
+            u_mouseStrength: 0.0,
+            u_mouseSwirl: 0.5,
+        }
+    },
+    {
+        name: 'Molecules',
+        description: 'A shader for rendering glowing molecular structures.',
+        materialType: 'particles',
+        vertex: `
+  attribute float aPhase;
+  attribute float aSize;
+
+  uniform float u_time;
+  uniform float uPointSize;
+  uniform float uIntensity;
+
+  varying float vAlpha;
+  varying vec3  vColor;
+
+  vec3 hsv2rgb(float h, float s, float v){
+    vec3 rgb=clamp(abs(mod(h*6.+vec3(0.,4.,2.),6.)-3.)-1.,0.,1.);
+    return v*mix(vec3(1.),rgb,s);
+  }
+
+  void main() {
+    // Each node has independent color + pulse
+    float hue    = mod(aPhase + u_time * 0.08, 1.0);
+    float pulse  = 0.5 + 0.5 * sin(u_time * 2.5 + aPhase * 6.28);
+    vColor       = hsv2rgb(hue, 0.85, 1.0);
+    vAlpha       = 0.55 + 0.45 * pulse;
+
+    vec4 mv       = modelViewMatrix * vec4(position, 1.0);
+    gl_PointSize  = uPointSize * aSize * (0.6 + 0.4 * pulse) * uIntensity * (250.0 / -mv.z);
+    gl_Position   = projectionMatrix * mv;
+  }
+`, fragment: `
+  varying float vAlpha;
+  varying vec3  vColor;
+  uniform float uOpacity;
+
+  void main() {
+    vec2  coord = gl_PointCoord - vec2(0.5);
+    float dist  = length(coord);
+    if (dist > 0.5) discard;
+
+    // Gaussian core glow
+    float glow = exp(-dist * dist * 8.0);
+    // Four-point diffraction spike (like a bright star)
+    float cx   = exp(-abs(coord.x) * 20.0) * exp(-coord.y*coord.y * 36.0);
+    float cy   = exp(-abs(coord.y) * 20.0) * exp(-coord.x*coord.x * 36.0);
+    float spike = (cx + cy) * 0.5;
+    // White-hot centre
+    float core  = exp(-dist * dist * 80.0);
+
+    vec3 col = mix(vColor, vec3(1.0), core * 0.8 + spike * 0.2);
+    gl_FragColor = vec4(col, vAlpha * uOpacity * (glow + spike * 0.6 + core));
+  }
+`,
+        uniforms: {
+            u_time: 0,
+            uPointSize: 1.0,
+            uIntensity: 1.0,
+            uOpacity: 1.0,
+        }
+    }
+];
+export const getShaderByName = (name) => shaders.find(s => s.name === name);

package/dist/data/shapeConfig.d.ts

@@ -0,0 +1,3 @@
+import type { ShapeConfig } from "../types/particles";
+export declare const shapeConfig: ShapeConfig;
+//# sourceMappingURL=shapeConfig.d.ts.map

package/dist/data/shapeConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shapeConfig.d.ts","sourceRoot":"","sources":["../../src/data/shapeConfig.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEtD,eAAO,MAAM,WAAW,EAAE,WA4BzB,CAAC"}

package/dist/data/shapeConfig.js

@@ -0,0 +1,29 @@
+export const shapeConfig = {
+    line: { startPosition: [-0.5, 0, 0], endPosition: [0.5, 0, 0] },
+    box: { meshSize: [1, 1, 1] },
+    sphere: { radius: 0.5 },
+    grid: { spacing: 0.1 },
+    circle: { radius: 0.5 },
+    square: { width: 1, height: 1 },
+    triangle: { size: 1 },
+    helix: { radius: 1, turns: 3, height: 4 },
+    torus: { majorRadius: 1, minorRadius: 1 },
+    cylinder: { radius: 0.5, height: 1 },
+    cone: { baseRadius: 1, height: 4 },
+    wave: { amplitude: 2, frequency: 2, spread: 6 },
+    dnaHelix: { radius: 2, turns: 4, height: 6 },
+    heart: { scale: 2 },
+    star: { points: 5, outerRadius: 3, innerRadius: 1.5 },
+    flower: { petals: 6, petalSize: 2 },
+    knot: { scale: 1 },
+    galaxy: { arms: 2, armSpread: 3, coreRadius: 0.5 },
+    crystal: { layers: 5, crystalSize: 3 },
+    tree: { branches: 8, treeHeight: 4, spread: 2 },
+    text: { text: 'HELLO', letterSize: 2, spacing: 2.5 },
+    dragonCurve: { iterations: 10, scale: 3 },
+    lotus: { petals: 8, layers: 5, maxRadius: 3 },
+    infinity: { scale: 1, thickness: 0.3 },
+    stars: { count: 100 },
+    mesh: { meshId: null, scale: 1.0, centerGeometry: true, sampleMethod: 'surface', densityMultiplier: 1.0 },
+    tube: { radius: 1, height: 4, radialSegments: 8, heightSegments: 1 },
+};

package/dist/index.d.ts

@@ -0,0 +1,72 @@
+export type { FrameVOptions } from './three/FrameV';
+export type { ImageGeometryVOptions } from './three/ImageGeometryV';
+export type { LetterVOptions } from './three/LetterV';
+export type { Text3DVOptions } from './three/Text3DV';
+export type { Text2DVOptions } from './three/Text2DV';
+export type { PathRendererVOptions } from './three/PathRendererV';
+export type { AnimatedObjectVOptions, TransitionOptions, PathAnimationOptions } from './three/AnimatedObjectV';
+export type { GridHelperVOptions } from './three/GridHelperV';
+export type { PathVOptions } from './three/PathV';
+export type { LinesVOptions } from './three/LinesV';
+export type { ParticlesVOptions } from './three/ParticlesV';
+export type { SkyboxVOptions } from './three/SkyboxV';
+export type { LensflareVOptions } from './three/LensflareV';
+export type { SunLightVOptions } from './three/SunLightV';
+export type { CloudsVOptions } from './three/CloudsV';
+export type { StarsVOptions } from './three/StarsV';
+export type { SkyControllerVOptions } from './three/SkyControllerV';
+export type { SkySystemVOptions } from './three/SkySystemV';
+export type { EnvironmentManagerVOptions } from './three/EnvironmentManagerV';
+export type { RainVOptions } from './three/RainV';
+export type { SceneBuilderVOptions } from './three/SceneBuilderV';
+export type { ProjectLoaderVOptions } from './three/ProjectLoaderV';
+export { defaultMoonSettings } from './types/environment';
+export { DEFAULT_HDR_TRANSITION_SETTINGS, getTransitionSettings } from './utils/environmentUtils';
+export * from './types/index';
+export * from './utils/index';
+export * from './services/index';
+export * from './data/index';
+export * from './constants/index';
+export * from './shaders/index';
+export { LightsManagerV } from './three/LightsManagerV';
+export { FrameV } from './three/FrameV';
+export { ImageGeometryV } from './three/ImageGeometryV';
+export { LetterV } from './three/LetterV';
+export { Text3DV } from './three/Text3DV';
+export { Text2DV } from './three/Text2DV';
+export { PathRendererV } from './three/PathRendererV';
+export { AnimatedObjectV } from './three/AnimatedObjectV';
+export { GridHelperV } from './three/GridHelperV';
+export { PathV } from './three/PathV';
+export { LinesV } from './three/LinesV';
+export { ParticlesV } from './three/ParticlesV';
+export { SkyboxV } from './three/SkyboxV';
+export { LensflareV } from './three/LensflareV';
+export { SunLightV } from './three/SunLightV';
+export { CloudsV } from './three/CloudsV';
+export { StarsV } from './three/StarsV';
+export { SkyControllerV } from './three/SkyControllerV';
+export { SkySystemV } from './three/SkySystemV';
+export { EnvironmentManagerV } from './three/EnvironmentManagerV';
+export { RainV } from './three/RainV';
+export { SceneBuilderV } from './three/SceneBuilderV';
+export { ProjectLoaderV } from './three/ProjectLoaderV';
+export { AuraEffectV } from './three/effects/AuraEffectV';
+export { OrbEffectV } from './three/effects/OrbEffectV';
+export { SmokePlumeEffectV } from './three/effects/SmokePlumeEffectV';
+export { VolumetricFogEffectV } from './three/effects/VolumetricFogEffectV';
+export { SmokeRingEffectV } from './three/effects/SmokeRingEffectV';
+export { PortalEffectV } from './three/effects/PortalEffectV';
+export { BlackHoleEffectV } from './three/effects/BlackHoleEffectV';
+export { ForcefieldEffectV } from './three/effects/ForcefieldEffectV';
+export { DataStreamEffectV } from './three/effects/DataStreamEffectV';
+export { HologramEffectV } from './three/effects/HologramEffectV';
+export { AuroraEffectV } from './three/effects/AuroraEffectV';
+export { ShockwaveEffectV } from './three/effects/ShockwaveEffectV';
+export { ConstellationEffectV } from './three/effects/ConstellationEffectV';
+export { MoleculesEffectV } from './three/effects/MoleculesEffectV';
+export { DnaHelixEffectV } from './three/effects/DnaHelixEffectV';
+export { IceCrystalsEffectV } from './three/effects/IceCrystalsEffectV';
+export { LightningEffectV } from './three/effects/LightningEffectV';
+export { NeuralNetworkEffectV } from './three/effects/NeuralNetworkEffectV';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

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

package/dist/index.js

@@ -0,0 +1,70 @@
+export { defaultMoonSettings } from './types/environment.js';
+export { DEFAULT_HDR_TRANSITION_SETTINGS, getTransitionSettings } from './utils/environmentUtils.js';
+// Barrel exports
+export * from './types/index.js';
+export * from './utils/index.js';
+export * from './services/index.js';
+export * from './data/index.js';
+export * from './constants/index.js';
+export * from './shaders/index.js';
+// Three.js vanilla classes
+export { LightsManagerV } from './three/LightsManagerV.js';
+export { FrameV } from './three/FrameV.js';
+// ImageGeometry vanilla class
+export { ImageGeometryV } from './three/ImageGeometryV.js';
+// Letter vanilla class
+export { LetterV } from './three/LetterV.js';
+// Text vanilla classes
+export { Text3DV } from './three/Text3DV.js';
+export { Text2DV } from './three/Text2DV.js';
+// Path vanilla class
+export { PathRendererV } from './three/PathRendererV.js';
+// AnimatedObject vanilla class
+export { AnimatedObjectV } from './three/AnimatedObjectV.js';
+// GridHelper vanilla class
+export { GridHelperV } from './three/GridHelperV.js';
+// Path and Lines vanilla classes
+export { PathV } from './three/PathV.js';
+export { LinesV } from './three/LinesV.js';
+// Particles vanilla class
+export { ParticlesV } from './three/ParticlesV.js';
+// Skybox vanilla class
+export { SkyboxV } from './three/SkyboxV.js';
+// Lensflare vanilla class
+export { LensflareV } from './three/LensflareV.js';
+// SunLight vanilla class
+export { SunLightV } from './three/SunLightV.js';
+// Clouds vanilla class
+export { CloudsV } from './three/CloudsV.js';
+// Stars vanilla class
+export { StarsV } from './three/StarsV.js';
+// SkyController vanilla class (Three.js Sky shader + sun light + time)
+export { SkyControllerV } from './three/SkyControllerV.js';
+// SkySystem vanilla orchestrator
+export { SkySystemV } from './three/SkySystemV.js';
+// EnvironmentManager vanilla class
+export { EnvironmentManagerV } from './three/EnvironmentManagerV.js';
+// Rain vanilla class
+export { RainV } from './three/RainV.js';
+// Scene orchestration vanilla classes
+export { SceneBuilderV } from './three/SceneBuilderV.js';
+export { ProjectLoaderV } from './three/ProjectLoaderV.js';
+// Vanilla effect classes
+export { AuraEffectV } from './three/effects/AuraEffectV.js';
+export { OrbEffectV } from './three/effects/OrbEffectV.js';
+export { SmokePlumeEffectV } from './three/effects/SmokePlumeEffectV.js';
+export { VolumetricFogEffectV } from './three/effects/VolumetricFogEffectV.js';
+export { SmokeRingEffectV } from './three/effects/SmokeRingEffectV.js';
+export { PortalEffectV } from './three/effects/PortalEffectV.js';
+export { BlackHoleEffectV } from './three/effects/BlackHoleEffectV.js';
+export { ForcefieldEffectV } from './three/effects/ForcefieldEffectV.js';
+export { DataStreamEffectV } from './three/effects/DataStreamEffectV.js';
+export { HologramEffectV } from './three/effects/HologramEffectV.js';
+export { AuroraEffectV } from './three/effects/AuroraEffectV.js';
+export { ShockwaveEffectV } from './three/effects/ShockwaveEffectV.js';
+export { ConstellationEffectV } from './three/effects/ConstellationEffectV.js';
+export { MoleculesEffectV } from './three/effects/MoleculesEffectV.js';
+export { DnaHelixEffectV } from './three/effects/DnaHelixEffectV.js';
+export { IceCrystalsEffectV } from './three/effects/IceCrystalsEffectV.js';
+export { LightningEffectV } from './three/effects/LightningEffectV.js';
+export { NeuralNetworkEffectV } from './three/effects/NeuralNetworkEffectV.js';

package/dist/presets/cloudsPresets.d.ts

@@ -0,0 +1,32 @@
+export interface CloudPreset {
+    name: string;
+    type: string;
+    category: string;
+    description: string;
+    tags: string[];
+    materialType: string;
+    settings: Record<string, any>;
+}
+/**
+ * Cloud preset definitions
+ * 3 variations for each of the 7 cloud types from MaterialRegistry (21 presets total)
+ */
+export declare const defaultCloudsUrl = "https://3d-rise.sfo3.digitaloceanspaces.com/app/images/clouds/clouds.jpg";
+export declare const cloudsPresets: CloudPreset[];
+/**
+ * Get a cloud preset by name
+ */
+export declare function getCloudPresetByName(name: string): CloudPreset | undefined;
+/**
+ * Get all cloud preset names
+ */
+export declare function getCloudPresetNames(): string[];
+/**
+ * Get cloud presets by material type
+ */
+export declare function getCloudPresetsByMaterialType(materialType: string): CloudPreset[];
+/**
+ * Search cloud presets by tags
+ */
+export declare function searchCloudPresetsByTags(tags: string[]): CloudPreset[];
+//# sourceMappingURL=cloudsPresets.d.ts.map

package/dist/presets/cloudsPresets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloudsPresets.d.ts","sourceRoot":"","sources":["../../src/presets/cloudsPresets.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,WAAW;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CACjC;AACD;;;GAGG;AACH,eAAO,MAAM,gBAAgB,6EAA6E,CAAC;AAC3G,eAAO,MAAM,aAAa,EAAE,WAAW,EAkOtC,CAAC;AACF;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS,CAE1E;AACD;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,MAAM,EAAE,CAE9C;AACD;;GAEG;AACH,wBAAgB,6BAA6B,CAAC,YAAY,EAAE,MAAM,GAAG,WAAW,EAAE,CAEjF;AACD;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,WAAW,EAAE,CAGtE"}