@3driseai/3drise-core 1.0.1

package/dist/shaders/lineShaders/SolarFilamentMaterial.js

@@ -0,0 +1,104 @@
+import { Vector3 } from "three";
+import { extend } from "@react-three/fiber";
+import { shaderMaterial } from "@react-three/drei";
+const vertexShader = /*glsl*/ `
+  varying vec2 vUv;
+  varying vec3 vPosition;
+  void main() {
+    vUv = uv;
+    vPosition = position;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+  }
+`;
+const fragmentShader = /*glsl*/ `
+  uniform float u_time;
+  uniform vec3 u_coreColor;
+  uniform vec3 u_midColor;
+  uniform vec3 u_coolColor;
+  uniform vec3 u_flareColor;
+  uniform float u_speed;
+  uniform float u_turbulence;
+  varying vec2 vUv;
+  varying vec3 vPosition;
+
+  float hash(vec2 p) { return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5); }
+
+  float smoothNoise(vec2 p) {
+    vec2 i = floor(p); vec2 f = fract(p);
+    f = f * f * (3.0 - 2.0 * f);
+    float a = hash(i), b = hash(i + vec2(1, 0));
+    float c = hash(i + vec2(0, 1)), d = hash(i + vec2(1, 1));
+    return mix(mix(a, b, f.x), mix(c, d, f.x), f.y);
+  }
+
+  float fbm(vec2 p) {
+    float v = 0.0; float amp = 0.5; float freq = 1.0;
+    for (int i = 0; i < 6; i++) {
+      v += amp * smoothNoise(p * freq);
+      amp *= 0.5; freq *= 2.1;
+    }
+    return v;
+  }
+
+  void main() {
+    float t = u_time * u_speed;
+    float along = vUv.x;
+    float across = vUv.y - 0.5;
+
+    // Convective turbulence — large scale rolls
+    vec2 turbUV = vec2(along * 3.0 - t * 0.8, across * 2.0 + t * 0.3);
+    float turb = fbm(turbUV) * u_turbulence;
+
+    // Secondary smaller eddies
+    float eddy = fbm(turbUV * 3.0 + vec2(t * 0.5, -t * 0.2)) * u_turbulence * 0.4;
+
+    float displacement = (turb + eddy - 0.5) * 0.2;
+    float dist = abs(across - displacement);
+
+    // Temperature gradient from center outward — maps to color
+    float coreGrad = 1.0 - smoothstep(0.0, 0.08, dist);
+    float midGrad  = 1.0 - smoothstep(0.05, 0.2, dist);
+    float coolGrad = 1.0 - smoothstep(0.1, 0.35, dist);
+
+    // Spicules — thin jets shooting off the surface
+    float spiculePhase  = floor(along * 20.0 + t * 2.0);
+    float spiculeSeed   = hash(vec2(spiculePhase, 0.0));
+    float spiculeActive = step(0.6, spiculeSeed);
+    float spiculeX      = fract(along * 20.0 + t * 2.0);
+    float spiculeY      = across - 0.2;
+    float spicule = exp(-abs(spiculeX - 0.5) * 30.0) * exp(-abs(spiculeY) * 15.0)
+                    * spiculeActive * (1.0 - spiculeX);
+
+    // Flare — occasional intense brightening at a random spot
+    float flareTime      = floor(t * 0.3);
+    float flareSeed      = hash(vec2(flareTime, 1.0));
+    float flarePos       = flareSeed;
+    float flareIntensity = smoothstep(0.95, 1.0, fract(t * 0.3)) * 8.0;
+    float flare = exp(-abs(along - flarePos) * 15.0) * exp(-dist * 10.0) * flareIntensity;
+
+    vec3 col = u_coolColor * coolGrad;
+    col = mix(col, u_midColor, midGrad);
+    col = mix(col, u_coreColor, coreGrad);
+    col += u_flareColor * flare;
+    col += u_coreColor * spicule * 0.6;
+
+    // Brightness pulsing — magnetic reconnection events
+    float pulse = 0.85 + 0.15 * sin(t * 2.3 + along * 4.0) * sin(t * 1.7);
+    col *= pulse;
+
+    float alpha = clamp(coolGrad * 0.8 + flare * 0.5 + spicule * 0.4, 0.0, 1.0);
+
+    gl_FragColor = vec4(col, alpha);
+  }
+`;
+const SolarFilamentMaterial = shaderMaterial({
+    u_time: 0,
+    u_coreColor: new Vector3(1.0, 0.98, 0.7), // White-hot
+    u_midColor: new Vector3(1.0, 0.55, 0.05), // Solar orange
+    u_coolColor: new Vector3(0.7, 0.08, 0.02), // Deep plasma red
+    u_flareColor: new Vector3(1.0, 0.9, 0.3), // Bright yellow flare
+    u_speed: 0.5,
+    u_turbulence: 1.2,
+}, vertexShader, fragmentShader);
+extend({ SolarFilamentMaterial });
+export { SolarFilamentMaterial };

package/dist/shaders/lineShaders/TeslaArcMaterial.d.ts

@@ -0,0 +1,37 @@
+import { Vector2, Vector3 } from "three";
+export interface TeslaArcMaterialUniforms {
+    u_time: {
+        value: number;
+    };
+    u_resolution: {
+        value: Vector2;
+    };
+    u_arcColor: {
+        value: Vector3;
+    };
+    u_glowColor: {
+        value: Vector3;
+    };
+    u_speed: {
+        value: number;
+    };
+    u_intensity: {
+        value: number;
+    };
+    u_forkDensity: {
+        value: number;
+    };
+}
+declare const TeslaArcMaterial: import("@react-three/fiber").ConstructorRepresentation<import("three").ShaderMaterial & {
+    u_time: number;
+    u_resolution: Vector2;
+    u_arcColor: Vector3;
+    u_glowColor: Vector3;
+    u_speed: number;
+    u_intensity: number;
+    u_forkDensity: number;
+}> & {
+    key: string;
+};
+export { TeslaArcMaterial };
+//# sourceMappingURL=TeslaArcMaterial.d.ts.map

package/dist/shaders/lineShaders/TeslaArcMaterial.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TeslaArcMaterial.d.ts","sourceRoot":"","sources":["../../../src/shaders/lineShaders/TeslaArcMaterial.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAGzC,MAAM,WAAW,wBAAwB;IACrC,MAAM,EAAE;QACJ,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,YAAY,EAAE;QACV,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,UAAU,EAAE;QACR,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,WAAW,EAAE;QACT,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,OAAO,EAAE;QACL,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,WAAW,EAAE;QACT,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,aAAa,EAAE;QACX,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;CACL;AAiHD,QAAA,MAAM,gBAAgB;;;;;;;;;;CAQU,CAAC;AAEjC,OAAO,EAAE,gBAAgB,EAAE,CAAC"}

package/dist/shaders/lineShaders/TeslaArcMaterial.js

@@ -0,0 +1,125 @@
+import { Vector2, Vector3 } from "three";
+import { extend } from "@react-three/fiber";
+import { shaderMaterial } from "@react-three/drei";
+const vertexShader = /*glsl*/ `
+  varying vec2 vUv;
+  varying vec3 vPosition;
+  varying vec3 vWorldPos;
+  void main() {
+    vUv = uv;
+    vPosition = position;
+    vWorldPos = (modelMatrix * vec4(position, 1.0)).xyz;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+  }
+`;
+const fragmentShader = /*glsl*/ `
+  uniform float u_time;
+  uniform vec2 u_resolution;
+  uniform vec3 u_arcColor;
+  uniform vec3 u_glowColor;
+  uniform float u_speed;
+  uniform float u_intensity;
+  uniform float u_forkDensity;
+  varying vec2 vUv;
+  varying vec3 vPosition;
+  varying vec3 vWorldPos;
+
+  float hash(float n)  { return fract(sin(n) * 43758.5453123); }
+  float hash2(vec2 p)  { return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453); }
+
+  float vnoise(float x) {
+    float i = floor(x);
+    float f = fract(x);
+    f = f * f * (3.0 - 2.0 * f);
+    return mix(hash(i), hash(i + 1.0), f);
+  }
+
+  float fbm(float x) {
+    float v = 0.0; float amp = 0.5; float freq = 1.0;
+    for (int i = 0; i < 7; i++) {
+      v += amp * vnoise(x * freq);
+      amp *= 0.5; freq *= 2.17;
+    }
+    return v;
+  }
+
+  void main() {
+    float t = u_time * u_speed;
+    float along = vUv.x;
+    float across = vUv.y - 0.5; // -0.5 → +0.5 across the quad
+
+    vec3 col = vec3(0.0);
+    float totalAlpha = 0.0;
+
+    // ── 3 simultaneous arcs at staggered Y offsets ──────────────
+    // Each arc has its own base position, speed variation, and color tint
+    // so they look like independent discharge channels, not copies.
+
+    float arcBaseY[3];
+    arcBaseY[0] = -0.15;
+    arcBaseY[1] =  0.0;
+    arcBaseY[2] =  0.15;
+
+    vec3 arcTint[3];
+    arcTint[0] = vec3(0.3, 0.7, 1.0);   // cooler blue
+    arcTint[1] = vec3(0.6, 0.9, 1.0);   // bright cyan (brightest, center)
+    arcTint[2] = vec3(0.1, 0.5, 0.9);   // deeper blue
+
+    for (int k = 0; k < 3; k++) {
+      float kf = float(k);
+
+      // Each arc travels at a slightly different speed so they desync over time
+      float speed = t * (2.5 + kf * 0.4);
+
+      float phase = along * 8.0 + kf * 3.7 - speed;
+      float arc   = fbm(phase) - 0.5;
+      arc        += fbm(phase * 2.3 + 17.4) * 0.3;
+
+      // Per-arc flicker — different seeds so they don't strobe together
+      float flicker = hash(floor(t * 12.0) + floor(along * u_forkDensity) + kf * 31.0);
+      arc *= 0.9 + flicker * 0.2;
+
+      float baseY = arcBaseY[k];
+      float dist  = abs((across - baseY) - arc * 0.28);
+
+      float core      = exp(-dist * 90.0) * u_intensity * 2.0;
+      float innerGlow = exp(-dist * 28.0) * u_intensity * 0.7;
+      float halo      = exp(-dist * 9.0)  * u_intensity * 0.2;
+
+      // Micro-forks per arc
+      float forkT     = floor(along * u_forkDensity * 2.0);
+      float forkPhase = hash2(vec2(forkT + kf * 10.0, floor(t * 8.0)));
+      float forkAlong = fract(along * u_forkDensity * 2.0);
+      float forkDist  = abs((across - baseY) - (forkPhase - 0.5) * 0.4 * forkAlong);
+      float fork      = exp(-forkDist * 65.0) * (1.0 - forkAlong)
+                        * step(0.35, forkPhase) * u_intensity * 1.2;
+
+      // Rapid pulse — each arc has its own phase so they don't all dim at once
+      float pulse = 0.75 + 0.25 * sin(t * 28.0 + along * 18.0 + kf * 2.1);
+
+      col += arcTint[k] * (innerGlow + fork) * pulse;
+      col += u_glowColor * halo * pulse;
+      col += vec3(1.0) * core * pulse;   // white-hot core
+
+      totalAlpha += innerGlow + halo + core * 0.5 + fork * 0.3;
+    }
+
+    // Faint background glow connecting the three arcs — looks like
+    // the electric field between channels
+    float bgGlow = exp(-abs(across) * 8.0) * 0.04;
+    col += vec3(0.02, 0.05, 0.15) * bgGlow;
+
+    gl_FragColor = vec4(col, clamp(totalAlpha + bgGlow, 0.0, 1.0));
+  }
+`;
+const TeslaArcMaterial = shaderMaterial({
+    u_time: 0,
+    u_resolution: new Vector2(),
+    u_arcColor: new Vector3(0.4, 0.8, 1.0), // Electric cyan
+    u_glowColor: new Vector3(0.1, 0.3, 0.9), // Deep blue plasma
+    u_speed: 1.0,
+    u_intensity: 1.5,
+    u_forkDensity: 6.0,
+}, vertexShader, fragmentShader);
+extend({ TeslaArcMaterial });
+export { TeslaArcMaterial };

package/dist/shaders/lineShaders/VoidRiftMaterial.d.ts

@@ -0,0 +1,41 @@
+import { Vector2, Vector3 } from "three";
+export interface VoidRiftMaterialUniforms {
+    u_time: {
+        value: number;
+    };
+    u_resolution: {
+        value: Vector2;
+    };
+    u_riftColor: {
+        value: Vector3;
+    };
+    u_radiationColor: {
+        value: Vector3;
+    };
+    u_lensColor: {
+        value: Vector3;
+    };
+    u_speed: {
+        value: number;
+    };
+    u_riftWidth: {
+        value: number;
+    };
+    u_radiationDensity: {
+        value: number;
+    };
+}
+declare const VoidRiftMaterial: import("@react-three/fiber").ConstructorRepresentation<import("three").ShaderMaterial & {
+    u_time: number;
+    u_resolution: Vector2;
+    u_riftColor: Vector3;
+    u_radiationColor: Vector3;
+    u_lensColor: Vector3;
+    u_speed: number;
+    u_riftWidth: number;
+    u_radiationDensity: number;
+}> & {
+    key: string;
+};
+export { VoidRiftMaterial };
+//# sourceMappingURL=VoidRiftMaterial.d.ts.map

package/dist/shaders/lineShaders/VoidRiftMaterial.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VoidRiftMaterial.d.ts","sourceRoot":"","sources":["../../../src/shaders/lineShaders/VoidRiftMaterial.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAGzC,MAAM,WAAW,wBAAwB;IACrC,MAAM,EAAE;QACJ,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,YAAY,EAAE;QACV,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,WAAW,EAAE;QACT,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,gBAAgB,EAAE;QACd,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,WAAW,EAAE;QACT,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,OAAO,EAAE;QACL,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,WAAW,EAAE;QACT,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,kBAAkB,EAAE;QAChB,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;CACL;AAyGD,QAAA,MAAM,gBAAgB;;;;;;;;;;;CASU,CAAC;AAEjC,OAAO,EAAE,gBAAgB,EAAE,CAAC"}

package/dist/shaders/lineShaders/VoidRiftMaterial.js

@@ -0,0 +1,118 @@
+import { Vector2, Vector3 } from "three";
+import { extend } from "@react-three/fiber";
+import { shaderMaterial } from "@react-three/drei";
+const vertexShader = /*glsl*/ `
+  varying vec2 vUv;
+  varying vec3 vPosition;
+  void main() {
+    vUv = uv;
+    vPosition = position;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+  }
+`;
+const fragmentShader = /*glsl*/ `
+  uniform float u_time;
+  uniform vec2 u_resolution;
+  uniform vec3 u_riftColor;
+  uniform vec3 u_radiationColor;
+  uniform vec3 u_lensColor;
+  uniform float u_speed;
+  uniform float u_riftWidth;
+  uniform float u_radiationDensity;
+  varying vec2 vUv;
+
+  float hash(float n) { return fract(sin(n) * 43758.5453); }
+  float hash2d(vec2 p) { return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5); }
+
+  float smoothNoise(vec2 p) {
+    vec2 i = floor(p); vec2 f = fract(p); f = f * f * (3.0 - 2.0 * f);
+    float a = hash2d(i), b = hash2d(i + vec2(1, 0));
+    float c = hash2d(i + vec2(0, 1)), d = hash2d(i + vec2(1, 1));
+    return mix(mix(a, b, f.x), mix(c, d, f.x), f.y);
+  }
+
+  // Domain-warped noise for the rift edge — makes it breathe and writhe
+  float riftNoise(vec2 p, float t) {
+    vec2 q = vec2(smoothNoise(p + vec2(t * 0.3, t * 0.2)),
+                  smoothNoise(p + vec2(t * 0.2, -t * 0.4)));
+    vec2 r = vec2(smoothNoise(p + 4.0 * q + vec2(1.7, 9.2)),
+                  smoothNoise(p + 4.0 * q + vec2(8.3, 2.8)));
+    return smoothNoise(p + 4.0 * r);
+  }
+
+  void main() {
+    float t = u_time * u_speed;
+    float along = vUv.x;
+    float across = vUv.y - 0.5;
+
+    // Rift edge — domain-warped so it breathes and writhes
+    vec2 riftUV = vec2(along * 4.0 - t * 0.5, across * 2.0);
+    float riftWarp = riftNoise(riftUV, t) - 0.5;
+    float riftEdge = abs(across - riftWarp * 0.1);
+
+    float insideRift = 1.0 - smoothstep(0.0, u_riftWidth, riftEdge);
+
+    // Edge shimmer — lensing distortion halo
+    float lensing = exp(-riftEdge * 12.0) * (1.0 - insideRift * 0.7);
+    lensing *= 0.5 + 0.5 * sin(along * 30.0 - t * 5.0 + riftWarp * 10.0);
+
+    // Hawking radiation — sparse bright sparks ejected from the event horizon
+    vec3 radCol = vec3(0.0);
+    for (float i = 0.0; i < 12.0; i++) {
+      if (i >= u_radiationDensity) break;
+      float seed  = hash(i * 3.7 + floor(t * 2.0));
+      float pos   = seed;
+      float birth = fract(hash(i * 5.3 + floor(t * 4.0)) + t * 0.8);
+      float life  = 1.0 - birth;
+
+      // Spark drifts perpendicular to the rift as it ages
+      float drift     = (hash(i * 9.1) - 0.5) * life * 0.4;
+      float sparkDist = length(vec2((along - pos) * 6.0, (across - drift) * 8.0));
+      float spark     = exp(-sparkDist * sparkDist * 20.0) * life * (1.0 - life) * 4.0;
+
+      vec3 sparkColor = mix(u_radiationColor, vec3(1.0, 0.6, 0.2), life * 0.6);
+      radCol += sparkColor * spark;
+    }
+
+    // Dimensional bleed — strands of an alternate reality bleeding through
+    float bleedPhase = along * 15.0 + t * 1.5;
+    float bleed = sin(bleedPhase) * sin(bleedPhase * 1.618) * 0.5 + 0.5;
+    bleed *= insideRift * 0.3;
+    bleed *= smoothNoise(vec2(along * 8.0, t * 0.7));
+
+    // Dark matter texture inside the rift — not nothing, but OTHER
+    float darkMatter = smoothNoise(vec2(along * 20.0 - t, across * 10.0)) * insideRift;
+    float antimatter = smoothNoise(vec2(along * 35.0 + t * 1.3, across * 20.0 - t * 0.5)) * insideRift;
+
+    vec3 col = vec3(0.0);
+    col += u_riftColor * insideRift * (0.3 + darkMatter * 0.3 + antimatter * 0.15);
+    col += u_lensColor * lensing * 0.8;
+    col += vec3(0.6, 0.1, 0.9) * bleed;
+    col += radCol;
+
+    // Edge singularity line — ultra-bright thin line at the rift boundary
+    float singularity = exp(-riftEdge * 60.0) * 2.0;
+    singularity *= 0.7 + 0.3 * sin(along * 50.0 - t * 8.0);
+    col += mix(u_lensColor, vec3(1.0), 0.5) * singularity;
+
+    float alpha = clamp(
+      insideRift * 0.7 + lensing * 0.6 + singularity * 0.8
+      + (radCol.r + radCol.g + radCol.b) * 0.4,
+      0.0, 1.0
+    );
+
+    gl_FragColor = vec4(col, alpha);
+  }
+`;
+const VoidRiftMaterial = shaderMaterial({
+    u_time: 0,
+    u_resolution: new Vector2(),
+    u_riftColor: new Vector3(0.02, 0.0, 0.06), // Near-void purple-black
+    u_radiationColor: new Vector3(0.9, 0.95, 1.0), // Cool white radiation
+    u_lensColor: new Vector3(0.5, 0.2, 1.0), // Violet gravitational lens
+    u_speed: 0.4,
+    u_riftWidth: 0.12,
+    u_radiationDensity: 8.0,
+}, vertexShader, fragmentShader);
+extend({ VoidRiftMaterial });
+export { VoidRiftMaterial };

package/dist/shaders/lineShaders/index.d.ts

@@ -0,0 +1,11 @@
+export type { TeslaArcMaterialUniforms } from "./TeslaArcMaterial";
+export type { SerpentFlowMaterialUniforms } from "./SerpentFlowMaterial";
+export type { GhostSignalMaterialUniforms } from "./GhostSignalMaterial";
+export type { SolarFilamentMaterialUniforms } from "./SolarFilamentMaterial";
+export type { VoidRiftMaterialUniforms } from "./VoidRiftMaterial";
+export { TeslaArcMaterial } from "./TeslaArcMaterial";
+export { SerpentFlowMaterial } from "./SerpentFlowMaterial";
+export { GhostSignalMaterial } from "./GhostSignalMaterial";
+export { SolarFilamentMaterial } from "./SolarFilamentMaterial";
+export { VoidRiftMaterial } from "./VoidRiftMaterial";
+//# sourceMappingURL=index.d.ts.map

package/dist/shaders/lineShaders/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/shaders/lineShaders/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,wBAAwB,EAAE,MAAM,oBAAoB,CAAC;AAEnE,YAAY,EAAE,2BAA2B,EAAE,MAAM,uBAAuB,CAAC;AAEzE,YAAY,EAAE,2BAA2B,EAAE,MAAM,uBAAuB,CAAC;AAEzE,YAAY,EAAE,6BAA6B,EAAE,MAAM,yBAAyB,CAAC;AAE7E,YAAY,EAAE,wBAAwB,EAAE,MAAM,oBAAoB,CAAC;AAGnE,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/shaders/lineShaders/index.js

@@ -0,0 +1,7 @@
+// Line Shader Materials — barrel export
+// Usage: import { TeslaArcMaterial, SerpentFlowMaterial } from './shaders';
+export { TeslaArcMaterial } from "./TeslaArcMaterial.js";
+export { SerpentFlowMaterial } from "./SerpentFlowMaterial.js";
+export { GhostSignalMaterial } from "./GhostSignalMaterial.js";
+export { SolarFilamentMaterial } from "./SolarFilamentMaterial.js";
+export { VoidRiftMaterial } from "./VoidRiftMaterial.js";

package/dist/shaders/sunNoise.d.ts

@@ -0,0 +1,2 @@
+export declare const NOISE_GLSL = "\n  //  Simplex 3D noise (Ashima Arts / Stefan Gustavson, MIT)\n  vec4 permute(vec4 x){ return mod(((x*34.0)+1.0)*x, 289.0); }\n  vec4 taylorInvSqrt(vec4 r){ return 1.79284291400159 - 0.85373472095314 * r; }\n\n  float snoise(vec3 v){\n    const vec2 C = vec2(1.0/6.0, 1.0/3.0);\n    const vec4 D = vec4(0.0, 0.5, 1.0, 2.0);\n\n    vec3 i  = floor(v + dot(v, C.yyy));\n    vec3 x0 = v - i + dot(i, C.xxx);\n\n    vec3 g  = step(x0.yzx, x0.xyz);\n    vec3 l  = 1.0 - g;\n    vec3 i1 = min(g.xyz, l.zxy);\n    vec3 i2 = max(g.xyz, l.zxy);\n\n    vec3 x1 = x0 - i1 + 1.0 * C.xxx;\n    vec3 x2 = x0 - i2 + 2.0 * C.xxx;\n    vec3 x3 = x0 - 1.0 + 3.0 * C.xxx;\n\n    i = mod(i, 289.0);\n    vec4 p = permute(permute(permute(\n              i.z + vec4(0.0, i1.z, i2.z, 1.0))\n            + i.y + vec4(0.0, i1.y, i2.y, 1.0))\n            + i.x + vec4(0.0, i1.x, i2.x, 1.0));\n\n    float n_ = 1.0/7.0;\n    vec3 ns = n_ * D.wyz - D.xzx;\n\n    vec4 j = p - 49.0 * floor(p * ns.z * ns.z);\n\n    vec4 x_ = floor(j * ns.z);\n    vec4 y_ = floor(j - 7.0 * x_);\n\n    vec4 x = x_ * ns.x + ns.yyyy;\n    vec4 y = y_ * ns.x + ns.yyyy;\n    vec4 h = 1.0 - abs(x) - abs(y);\n\n    vec4 b0 = vec4(x.xy, y.xy);\n    vec4 b1 = vec4(x.zw, y.zw);\n\n    vec4 s0 = floor(b0)*2.0 + 1.0;\n    vec4 s1 = floor(b1)*2.0 + 1.0;\n    vec4 sh = -step(h, vec4(0.0));\n\n    vec4 a0 = b0.xzyw + s0.xzyw*sh.xxyy;\n    vec4 a1 = b1.xzyw + s1.xzyw*sh.zzww;\n\n    vec3 p0 = vec3(a0.xy, h.x);\n    vec3 p1 = vec3(a0.zw, h.y);\n    vec3 p2 = vec3(a1.xy, h.z);\n    vec3 p3 = vec3(a1.zw, h.w);\n\n    vec4 norm = taylorInvSqrt(vec4(dot(p0,p0), dot(p1,p1), dot(p2,p2), dot(p3,p3)));\n    p0 *= norm.x; p1 *= norm.y; p2 *= norm.z; p3 *= norm.w;\n\n    vec4 m = max(0.6 - vec4(dot(x0,x0), dot(x1,x1), dot(x2,x2), dot(x3,x3)), 0.0);\n    m = m * m;\n    return 42.0 * dot(m*m, vec4(dot(p0,x0), dot(p1,x1), dot(p2,x2), dot(p3,x3)));\n  }\n\n  float fbm(vec3 p) {\n    const mat3 R = mat3(\n       0.00,  0.80,  0.60,\n      -0.80,  0.36, -0.48,\n      -0.60, -0.48,  0.64\n    );\n    float f = 0.0;\n    float a = 0.5;\n    for (int i = 0; i < 5; i++) {\n      f += a * snoise(p);\n      p = R * p * 2.02 + vec3(0.0, 0.0, 0.07);\n      a *= 0.5;\n    }\n    return f;\n  }\n\n  float ridgedFbm(vec3 p) {\n    float f = 0.0;\n    float a = 0.55;\n    for (int i = 0; i < 4; i++) {\n      f += a * (1.0 - abs(snoise(p)));\n      p = p * 2.1 + vec3(1.7);\n      a *= 0.5;\n    }\n    return f;\n  }\n";
+//# sourceMappingURL=sunNoise.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sunNoise.d.ts","sourceRoot":"","sources":["../../src/shaders/sunNoise.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,UAAU,65EAwFtB,CAAC"}

package/dist/shaders/sunNoise.js

@@ -0,0 +1,91 @@
+// Shared GLSL noise chunk for the sun materials.
+// Provides: snoise (simplex 3D), fbm (5 octaves), ridgedFbm (4 octaves).
+export const NOISE_GLSL = /*glsl*/ `
+  //  Simplex 3D noise (Ashima Arts / Stefan Gustavson, MIT)
+  vec4 permute(vec4 x){ return mod(((x*34.0)+1.0)*x, 289.0); }
+  vec4 taylorInvSqrt(vec4 r){ return 1.79284291400159 - 0.85373472095314 * r; }
+
+  float snoise(vec3 v){
+    const vec2 C = vec2(1.0/6.0, 1.0/3.0);
+    const vec4 D = vec4(0.0, 0.5, 1.0, 2.0);
+
+    vec3 i  = floor(v + dot(v, C.yyy));
+    vec3 x0 = v - i + dot(i, C.xxx);
+
+    vec3 g  = step(x0.yzx, x0.xyz);
+    vec3 l  = 1.0 - g;
+    vec3 i1 = min(g.xyz, l.zxy);
+    vec3 i2 = max(g.xyz, l.zxy);
+
+    vec3 x1 = x0 - i1 + 1.0 * C.xxx;
+    vec3 x2 = x0 - i2 + 2.0 * C.xxx;
+    vec3 x3 = x0 - 1.0 + 3.0 * C.xxx;
+
+    i = mod(i, 289.0);
+    vec4 p = permute(permute(permute(
+              i.z + vec4(0.0, i1.z, i2.z, 1.0))
+            + i.y + vec4(0.0, i1.y, i2.y, 1.0))
+            + i.x + vec4(0.0, i1.x, i2.x, 1.0));
+
+    float n_ = 1.0/7.0;
+    vec3 ns = n_ * D.wyz - D.xzx;
+
+    vec4 j = p - 49.0 * floor(p * ns.z * ns.z);
+
+    vec4 x_ = floor(j * ns.z);
+    vec4 y_ = floor(j - 7.0 * x_);
+
+    vec4 x = x_ * ns.x + ns.yyyy;
+    vec4 y = y_ * ns.x + ns.yyyy;
+    vec4 h = 1.0 - abs(x) - abs(y);
+
+    vec4 b0 = vec4(x.xy, y.xy);
+    vec4 b1 = vec4(x.zw, y.zw);
+
+    vec4 s0 = floor(b0)*2.0 + 1.0;
+    vec4 s1 = floor(b1)*2.0 + 1.0;
+    vec4 sh = -step(h, vec4(0.0));
+
+    vec4 a0 = b0.xzyw + s0.xzyw*sh.xxyy;
+    vec4 a1 = b1.xzyw + s1.xzyw*sh.zzww;
+
+    vec3 p0 = vec3(a0.xy, h.x);
+    vec3 p1 = vec3(a0.zw, h.y);
+    vec3 p2 = vec3(a1.xy, h.z);
+    vec3 p3 = vec3(a1.zw, h.w);
+
+    vec4 norm = taylorInvSqrt(vec4(dot(p0,p0), dot(p1,p1), dot(p2,p2), dot(p3,p3)));
+    p0 *= norm.x; p1 *= norm.y; p2 *= norm.z; p3 *= norm.w;
+
+    vec4 m = max(0.6 - vec4(dot(x0,x0), dot(x1,x1), dot(x2,x2), dot(x3,x3)), 0.0);
+    m = m * m;
+    return 42.0 * dot(m*m, vec4(dot(p0,x0), dot(p1,x1), dot(p2,x2), dot(p3,x3)));
+  }
+
+  float fbm(vec3 p) {
+    const mat3 R = mat3(
+       0.00,  0.80,  0.60,
+      -0.80,  0.36, -0.48,
+      -0.60, -0.48,  0.64
+    );
+    float f = 0.0;
+    float a = 0.5;
+    for (int i = 0; i < 5; i++) {
+      f += a * snoise(p);
+      p = R * p * 2.02 + vec3(0.0, 0.0, 0.07);
+      a *= 0.5;
+    }
+    return f;
+  }
+
+  float ridgedFbm(vec3 p) {
+    float f = 0.0;
+    float a = 0.55;
+    for (int i = 0; i < 4; i++) {
+      f += a * (1.0 - abs(snoise(p)));
+      p = p * 2.1 + vec3(1.7);
+      a *= 0.5;
+    }
+    return f;
+  }
+`;

package/dist/three/AnimatedObjectV.d.ts

@@ -0,0 +1,71 @@
+import * as THREE from 'three';
+import type { PathConfig } from "../types/animations";
+export interface AnimatedObjectVOptions {
+    position?: [number, number, number];
+    scale?: [number, number, number];
+    rotation?: [number, number, number];
+}
+export interface TransitionOptions {
+    from?: {
+        position?: [number, number, number];
+        scale?: [number, number, number];
+        rotation?: [number, number, number];
+    };
+    to: {
+        position?: [number, number, number];
+        scale?: [number, number, number];
+        rotation?: [number, number, number];
+    };
+    duration?: number;
+    ease?: string;
+    onComplete?: () => void;
+}
+export interface PathAnimationOptions {
+    ease?: string;
+    loop?: boolean;
+    yoyo?: boolean;
+    speed?: number;
+    faceDirection?: boolean;
+    applyRotation?: boolean;
+    offset?: [number, number, number];
+    onComplete?: () => void;
+}
+export declare class AnimatedObjectV {
+    readonly group: THREE.Group;
+    private parent;
+    private fromPos;
+    private fromScale;
+    private fromRot;
+    private toPos;
+    private toScale;
+    private toRot;
+    private transProgress;
+    private transDuration;
+    private transEase;
+    private transElapsed;
+    private transOnComplete;
+    private pathPoints;
+    private pathSpline;
+    private pathProgress;
+    private pathDuration;
+    private pathSpeed;
+    private pathEase;
+    private pathLoop;
+    private pathYoyo;
+    private pathDirection;
+    private pathActive;
+    private pathFaceDir;
+    private pathApplyRot;
+    private pathOffset;
+    private pathOnComplete;
+    private targetQuat;
+    constructor(parent: THREE.Object3D, options?: AnimatedObjectVOptions);
+    startTransition(options: TransitionOptions): void;
+    startPathAnimation(pathConfig: PathConfig, duration: number, options?: PathAnimationOptions): boolean;
+    stopAnimation(): void;
+    private updateTransition;
+    private updatePath;
+    update(_elapsed: number, delta?: number): void;
+    dispose(removeFromScene?: boolean): void;
+}
+//# sourceMappingURL=AnimatedObjectV.d.ts.map

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

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