@3driseai/3drise-core 1.0.1

package/dist/shaders/CoronaMaterial.js

@@ -0,0 +1,54 @@
+import { Vector3 } from "three";
+import { extend } from "@react-three/fiber";
+import { shaderMaterial } from "@react-three/drei";
+// Vertex shader
+const vertexShader = /*glsl*/ `
+  varying vec3 vNormal;
+  varying vec3 vViewDir;
+  void main() {
+    vNormal = normalize(normalMatrix * normal);
+    vec4 mv = modelViewMatrix * vec4(position, 1.0);
+    vViewDir = normalize(-mv.xyz);
+    gl_Position = projectionMatrix * mv;
+  }
+`;
+// Fragment shader
+const fragmentShader = /*glsl*/ `
+  uniform float u_time;
+  uniform float u_intensity;
+  uniform float u_falloff;
+  uniform float u_pulseSpeed;
+  uniform float u_pulseAmount;
+  uniform float u_shellScale;
+  uniform vec3 u_innerColor;
+  uniform vec3 u_outerColor;
+  varying vec3 vNormal;
+  varying vec3 vViewDir;
+  void main() {
+    // Rendered on a BackSide shell: visible fragments face AWAY from the
+    // camera, so the dot is negative. -dot is 0 at the outer silhouette and
+    // maximal at the core limb. The max depends on the shell scale, so it is
+    // derived from u_shellScale: sqrt(1 - 1/scale^2).
+    float facing = -dot(normalize(vNormal), normalize(vViewDir));
+    float maxFacing = sqrt(max(1.0 - 1.0 / (u_shellScale * u_shellScale), 0.05));
+    float t2 = clamp(facing / maxFacing, 0.0, 1.0);
+    float intensity = pow(t2, u_falloff);
+    intensity *= (1.0 - u_pulseAmount) + u_pulseAmount * (0.5 + 0.5 * sin(u_time * u_pulseSpeed));
+    vec3 col = mix(u_innerColor, u_outerColor, t2);
+    gl_FragColor = vec4(col * intensity * u_intensity, intensity);
+  }
+`;
+// Create the shader material with uniforms
+const CoronaMaterial = shaderMaterial({
+    u_time: 0,
+    u_intensity: 1.5,
+    u_falloff: 1.8,
+    u_pulseSpeed: 0.7,
+    u_pulseAmount: 0.3,
+    u_shellScale: 1.25,
+    u_innerColor: new Vector3(1.0, 0.3, 0.03),
+    u_outerColor: new Vector3(1.0, 0.62, 0.22)
+}, vertexShader, fragmentShader);
+// Extend the material for use in React Three Fiber
+extend({ CoronaMaterial });
+export { CoronaMaterial };

package/dist/shaders/CustomShaderMaterial.d.ts

@@ -0,0 +1,10 @@
+import { ShaderMaterial } from "three";
+export interface CustomShaderMaterialProps {
+    uniforms: {
+        [uniform: string]: any;
+    };
+    vertexShader: string;
+    fragmentShader: string;
+}
+export declare function createCustomShaderMaterial({ uniforms, vertexShader, fragmentShader }: CustomShaderMaterialProps): typeof ShaderMaterial;
+//# sourceMappingURL=CustomShaderMaterial.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"CustomShaderMaterial.d.ts","sourceRoot":"","sources":["../../src/shaders/CustomShaderMaterial.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AACvC,MAAM,WAAW,yBAAyB;IACtC,QAAQ,EAAE;QACN,CAAC,OAAO,EAAE,MAAM,GAAG,GAAG,CAAC;KAC1B,CAAC;IACF,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;CAC1B;AAGD,wBAAgB,0BAA0B,CAAC,EAAE,QAAQ,EAAE,YAAY,EAAE,cAAc,EAAE,EAAE,yBAAyB,GAAG,OAAO,cAAc,CAOvI"}

package/dist/shaders/CustomShaderMaterial.js

@@ -0,0 +1,10 @@
+import { shaderMaterial } from "@react-three/drei";
+export function createCustomShaderMaterial({ uniforms, vertexShader, fragmentShader }) {
+    // Create the shader material using drei's shaderMaterial helper
+    const CustomMaterial = shaderMaterial(uniforms, vertexShader, fragmentShader);
+    //   console.log({CustomMaterial})
+    // Extend the material for use in React Three Fiber
+    //   extend({ CustomMaterial });
+    return CustomMaterial;
+}
+// export { createCustomShaderMaterial as CustomShaderMaterial };

package/dist/shaders/EarthAtmosphereMaterial.d.ts

@@ -0,0 +1,28 @@
+import * as THREE from "three";
+export interface EarthAtmosphereMaterialUniforms {
+    uSunDirection: {
+        value: THREE.Vector3;
+    };
+    uAtmosphereDayColor: {
+        value: THREE.Color;
+    };
+    uAtmosphereTwilightColor: {
+        value: THREE.Color;
+    };
+}
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            earthAtmosphereMaterial: any;
+        }
+    }
+}
+declare const EarthAtmosphereMaterial: import("@react-three/fiber").ConstructorRepresentation<THREE.ShaderMaterial & {
+    uSunDirection: THREE.Vector3;
+    uAtmosphereDayColor: THREE.Color;
+    uAtmosphereTwilightColor: THREE.Color;
+}> & {
+    key: string;
+};
+export { EarthAtmosphereMaterial };
+//# sourceMappingURL=EarthAtmosphereMaterial.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"EarthAtmosphereMaterial.d.ts","sourceRoot":"","sources":["../../src/shaders/EarthAtmosphereMaterial.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,MAAM,WAAW,+BAA+B;IAC5C,aAAa,EAAE;QACX,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC;KACxB,CAAC;IACF,mBAAmB,EAAE;QACjB,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC;KACtB,CAAC;IACF,wBAAwB,EAAE;QACtB,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC;KACtB,CAAC;CACL;AAED,OAAO,CAAC,MAAM,CAAC;IACX,UAAU,GAAG,CAAC;QACV,UAAU,iBAAiB;YACvB,uBAAuB,EAAE,GAAG,CAAC;SAChC;KACJ;CACJ;AA+CD,QAAA,MAAM,uBAAuB;;;;;;CAIG,CAAC;AAEjC,OAAO,EAAE,uBAAuB,EAAE,CAAC"}

package/dist/shaders/EarthAtmosphereMaterial.js

@@ -0,0 +1,55 @@
+import { extend } from "@react-three/fiber";
+import { shaderMaterial } from "@react-three/drei";
+import * as THREE from "three";
+const vertexShader = /*glsl*/ `
+  varying vec3 vWorldNormal;
+  varying vec3 vWorldPosition;
+
+  void main() {
+    vWorldNormal = normalize(mat3(modelMatrix) * normal);
+    vec4 worldPos = modelMatrix * vec4(position, 1.0);
+    vWorldPosition = worldPos.xyz;
+    gl_Position = projectionMatrix * viewMatrix * worldPos;
+  }
+`;
+const fragmentShader = /*glsl*/ `
+  uniform vec3 uSunDirection;
+  uniform vec3 uAtmosphereDayColor;
+  uniform vec3 uAtmosphereTwilightColor;
+
+  varying vec3 vWorldNormal;
+  varying vec3 vWorldPosition;
+
+  float remap(float v, float inMin, float inMax, float outMin, float outMax) {
+    float t = clamp((v - inMin) / (inMax - inMin), 0.0, 1.0);
+    return mix(outMin, outMax, t);
+  }
+
+  void main() {
+    vec3 normal = normalize(vWorldNormal);
+    vec3 sunDir = normalize(uSunDirection);
+
+    vec3 viewDir = normalize(vWorldPosition - cameraPosition);
+    float fresnel = 1.0 - abs(dot(viewDir, normal));
+
+    float sunOrientation = dot(normal, sunDir);
+
+    vec3 color = mix(
+      uAtmosphereTwilightColor,
+      uAtmosphereDayColor,
+      smoothstep(-0.25, 0.75, sunOrientation)
+    );
+
+    float alpha = pow(remap(fresnel, 0.73, 1.0, 1.0, 0.0), 3.0);
+    alpha *= smoothstep(-0.5, 1.0, sunOrientation);
+
+    gl_FragColor = vec4(color, alpha);
+  }
+`;
+const EarthAtmosphereMaterial = shaderMaterial({
+    uSunDirection: new THREE.Vector3(0, 0, 1),
+    uAtmosphereDayColor: new THREE.Color('#4db2ff'),
+    uAtmosphereTwilightColor: new THREE.Color('#bc490b'),
+}, vertexShader, fragmentShader);
+extend({ EarthAtmosphereMaterial });
+export { EarthAtmosphereMaterial };

package/dist/shaders/EarthMaterial.d.ts

@@ -0,0 +1,40 @@
+import * as THREE from "three";
+export interface EarthMaterialUniforms {
+    uDayMap: {
+        value: THREE.Texture | null;
+    };
+    uNightMap: {
+        value: THREE.Texture | null;
+    };
+    uBumpRoughnessClouds: {
+        value: THREE.Texture | null;
+    };
+    uSunDirection: {
+        value: THREE.Vector3;
+    };
+    uAtmosphereDayColor: {
+        value: THREE.Color;
+    };
+    uAtmosphereTwilightColor: {
+        value: THREE.Color;
+    };
+}
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            earthMaterial: any;
+        }
+    }
+}
+declare const EarthMaterial: import("@react-three/fiber").ConstructorRepresentation<THREE.ShaderMaterial & {
+    uDayMap: any;
+    uNightMap: any;
+    uBumpRoughnessClouds: any;
+    uSunDirection: THREE.Vector3;
+    uAtmosphereDayColor: THREE.Color;
+    uAtmosphereTwilightColor: THREE.Color;
+}> & {
+    key: string;
+};
+export { EarthMaterial };
+//# sourceMappingURL=EarthMaterial.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"EarthMaterial.d.ts","sourceRoot":"","sources":["../../src/shaders/EarthMaterial.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,MAAM,WAAW,qBAAqB;IAClC,OAAO,EAAE;QACL,KAAK,EAAE,KAAK,CAAC,OAAO,GAAG,IAAI,CAAC;KAC/B,CAAC;IACF,SAAS,EAAE;QACP,KAAK,EAAE,KAAK,CAAC,OAAO,GAAG,IAAI,CAAC;KAC/B,CAAC;IACF,oBAAoB,EAAE;QAClB,KAAK,EAAE,KAAK,CAAC,OAAO,GAAG,IAAI,CAAC;KAC/B,CAAC;IACF,aAAa,EAAE;QACX,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC;KACxB,CAAC;IACF,mBAAmB,EAAE;QACjB,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC;KACtB,CAAC;IACF,wBAAwB,EAAE;QACtB,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC;KACtB,CAAC;CACL;AAED,OAAO,CAAC,MAAM,CAAC;IACX,UAAU,GAAG,CAAC;QACV,UAAU,iBAAiB;YACvB,aAAa,EAAE,GAAG,CAAC;SACtB;KACJ;CACJ;AA0DD,QAAA,MAAM,aAAa;;;;;;;;;CAOa,CAAC;AAEjC,OAAO,EAAE,aAAa,EAAE,CAAC"}

package/dist/shaders/EarthMaterial.js

@@ -0,0 +1,69 @@
+import { extend } from "@react-three/fiber";
+import { shaderMaterial } from "@react-three/drei";
+import * as THREE from "three";
+const vertexShader = /*glsl*/ `
+  varying vec2 vUv;
+  varying vec3 vWorldNormal;
+  varying vec3 vWorldPosition;
+
+  void main() {
+    vUv = uv;
+    vWorldNormal = normalize(mat3(modelMatrix) * normal);
+    vec4 worldPos = modelMatrix * vec4(position, 1.0);
+    vWorldPosition = worldPos.xyz;
+    gl_Position = projectionMatrix * viewMatrix * worldPos;
+  }
+`;
+const fragmentShader = /*glsl*/ `
+  uniform sampler2D uDayMap;
+  uniform sampler2D uNightMap;
+  uniform sampler2D uBumpRoughnessClouds;
+  uniform vec3 uSunDirection;
+  uniform vec3 uAtmosphereDayColor;
+  uniform vec3 uAtmosphereTwilightColor;
+
+  varying vec2 vUv;
+  varying vec3 vWorldNormal;
+  varying vec3 vWorldPosition;
+
+  void main() {
+    vec3 normal = normalize(vWorldNormal);
+    vec3 sunDir = normalize(uSunDirection);
+
+    vec3 dayTex   = texture2D(uDayMap, vUv).rgb;
+    vec3 nightTex = texture2D(uNightMap, vUv).rgb;
+    vec3 brc      = texture2D(uBumpRoughnessClouds, vUv).rgb;
+
+    float cloudsStrength = smoothstep(0.2, 1.0, brc.b);
+    vec3 dayColor = mix(dayTex, vec3(1.0), clamp(cloudsStrength * 2.0, 0.0, 1.0));
+
+    float sunOrientation = dot(normal, sunDir);
+    float dayStrength = smoothstep(-0.25, 0.5, sunOrientation);
+
+    vec3 viewDir = normalize(vWorldPosition - cameraPosition);
+    float fresnel = 1.0 - abs(dot(viewDir, normal));
+
+    vec3 atmosphereColor = mix(
+      uAtmosphereTwilightColor,
+      uAtmosphereDayColor,
+      smoothstep(-0.25, 0.75, sunOrientation)
+    );
+    float atmosphereDayStrength = smoothstep(-0.5, 1.0, sunOrientation);
+    float atmosphereMix = clamp(atmosphereDayStrength * pow(fresnel, 2.0), 0.0, 1.0);
+
+    vec3 finalColor = mix(nightTex, dayColor, dayStrength);
+    finalColor = mix(finalColor, atmosphereColor, atmosphereMix);
+
+    gl_FragColor = vec4(finalColor, 1.0);
+  }
+`;
+const EarthMaterial = shaderMaterial({
+    uDayMap: null,
+    uNightMap: null,
+    uBumpRoughnessClouds: null,
+    uSunDirection: new THREE.Vector3(0, 0, 1),
+    uAtmosphereDayColor: new THREE.Color('#4db2ff'),
+    uAtmosphereTwilightColor: new THREE.Color('#bc490b'),
+}, vertexShader, fragmentShader);
+extend({ EarthMaterial });
+export { EarthMaterial };

package/dist/shaders/FireMaterial.d.ts

@@ -0,0 +1,30 @@
+import * as THREE from 'three';
+export interface FireUniforms {
+    u_time: number;
+    u_intensity: number;
+    u_speed: number;
+    u_turbulence: number;
+    u_sway: number;
+    u_radius: number;
+    u_height: number;
+    u_tint: THREE.Color;
+}
+export type FireMaterialImpl = THREE.ShaderMaterial & FireUniforms;
+declare module '@react-three/fiber' {
+    interface ThreeElements {
+        fireMaterial: ThreeElements['shaderMaterial'] & Partial<FireUniforms>;
+    }
+}
+export declare const FireMaterial: import("@react-three/fiber").ConstructorRepresentation<THREE.ShaderMaterial & {
+    u_tint: THREE.Color;
+    u_time: number;
+    u_intensity: number;
+    u_speed: number;
+    u_turbulence: number;
+    u_sway: number;
+    u_radius: number;
+    u_height: number;
+}> & {
+    key: string;
+};
+//# sourceMappingURL=FireMaterial.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FireMaterial.d.ts","sourceRoot":"","sources":["../../src/shaders/FireMaterial.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B,MAAM,WAAW,YAAY;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,KAAK,CAAC,KAAK,CAAC;CACvB;AAED,MAAM,MAAM,gBAAgB,GAAG,KAAK,CAAC,cAAc,GAAG,YAAY,CAAC;AAEnE,OAAO,QAAQ,oBAAoB,CAAC;IAChC,UAAU,aAAa;QACnB,YAAY,EAAE,aAAa,CAAC,gBAAgB,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;KACzE;CACJ;AAgJD,eAAO,MAAM,YAAY;;;;;;;;;;;CAOvB,CAAC"}

package/dist/shaders/FireMaterial.js

@@ -0,0 +1,154 @@
+import * as THREE from 'three';
+import { shaderMaterial } from '@react-three/drei';
+import { extend } from '@react-three/fiber';
+const defaults = {
+    u_time: 0,
+    u_intensity: 1.0,
+    u_speed: 1.0,
+    u_turbulence: 1.5,
+    u_sway: 1.0,
+    u_radius: 1.0,
+    u_height: 2.5,
+    u_tint: new THREE.Color(1, 1, 1),
+};
+const vertexShader = /*glsl*/ `
+  attribute vec3 a_offset;
+  attribute vec2 a_size;
+  attribute float a_seed;
+
+  uniform float u_radius;
+  uniform float u_height;
+
+  varying vec2 vUv;
+  varying float vSeed;
+
+  void main() {
+    // x in [-1,1], y in [0,1] — flame-space coordinates, geometry-size independent.
+    vUv = vec2(uv.x * 2.0 - 1.0, uv.y);
+    vSeed = a_seed;
+
+    // Cylindrical world-space billboard around this tongue's anchor.
+    vec3 center   = (modelMatrix * vec4(a_offset, 1.0)).xyz;
+    vec3 camRight = vec3(viewMatrix[0][0], viewMatrix[1][0], viewMatrix[2][0]);
+    vec3 right    = normalize(vec3(camRight.x, 0.0, camRight.z) + vec3(1e-5));
+
+    vec3 world = center
+      + right * vUv.x * (a_size.x * u_radius)
+      + vec3(0.0, 1.0, 0.0) * vUv.y * (a_size.y * u_height);
+
+    gl_Position = projectionMatrix * viewMatrix * vec4(world, 1.0);
+  }
+`;
+const fragmentShader = /*glsl*/ `
+  precision highp float;
+
+  uniform float u_time;
+  uniform float u_intensity;
+  uniform float u_speed;
+  uniform float u_turbulence;
+  uniform float u_sway;
+  uniform vec3  u_tint;
+
+  varying vec2  vUv;
+  varying float vSeed;
+
+  float hash(vec2 p) {
+    p = fract(p * vec2(123.34, 456.21));
+    p += dot(p, p + 45.32);
+    return fract(p.x * p.y);
+  }
+
+  float vnoise(vec2 p) {
+    vec2 i = floor(p), f = fract(p);
+    vec2 u = f * f * (3.0 - 2.0 * f);
+    return mix(
+      mix(hash(i),                  hash(i + vec2(1.0, 0.0)), u.x),
+      mix(hash(i + vec2(0.0, 1.0)), hash(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;
+  }
+
+  // Blackbody-style temperature ramp.
+  vec3 blackbody(float t) {
+    t = clamp(t, 0.0, 1.0);
+    vec3 c = mix(vec3(0.015, 0.0, 0.0), vec3(0.85, 0.16, 0.01), smoothstep(0.00, 0.32, t));
+    c = mix(c, vec3(1.0, 0.55, 0.06), smoothstep(0.28, 0.62, t));
+    c = mix(c, vec3(1.0, 0.93, 0.55), smoothstep(0.58, 0.88, t));
+    c = mix(c, vec3(1.0, 1.0, 0.98),  smoothstep(0.85, 1.00, t));
+    return c;
+  }
+
+  // One advected, domain-warped flame layer. Returns occupancy in [0,1].
+  float flameLayer(vec2 uv, float t, float widthMul, float speedMul, vec2 seed, out float nOut) {
+    vec2 p = vec2(uv.x * 2.4, uv.y * 3.2 - t * speedMul) + seed;
+
+    float q = fbm(p);
+    vec2 r = vec2(
+      fbm(p + q + vec2(1.7, 9.2) - t * 0.25),
+      fbm(p + q + vec2(8.3, 2.8) - t * 0.45)
+    );
+    float n = fbm(p + u_turbulence * r);
+    nOut = n;
+
+    // Tapered half-width and tip sway that grows with height.
+    float w = mix(0.46, 0.05, pow(uv.y, 1.35)) * widthMul;
+    float x = uv.x + (n - 0.5) * (0.25 + uv.y * 1.15) * u_sway;
+
+    float body = 1.0 - smoothstep(0.0, w, abs(x));
+    float env  = smoothstep(-0.02, 0.12, uv.y)
+               * (1.0 - smoothstep(0.30, 0.98, uv.y - (n - 0.5) * 0.85));
+
+    return clamp(body * env, 0.0, 1.0);
+  }
+
+  void main() {
+    vec2 uv = vUv;
+
+    // Decorrelate tongues: each gets its own phase, speed, and noise seed.
+    float t = u_time * u_speed * (0.85 + 0.30 * fract(vSeed * 0.137));
+    vec2 sd = vec2(fract(vSeed * 0.731) * 19.0, fract(vSeed * 0.317) * 23.0);
+
+    float nA, nB;
+    float outer = flameLayer(uv, t, 1.0, 2.0, sd, nA);
+    float core  = flameLayer(vec2(uv.x, (uv.y - 0.02) * 1.25), t, 0.42, 2.6, sd + vec2(4.7, 1.3), nB);
+
+    // Temperature field
+    float T = pow(outer, 1.55) * (0.78 + 0.45 * nA);
+    T += pow(core, 1.8) * 0.85;
+    T *= u_intensity;
+
+    vec3 col = blackbody(T) * u_tint;
+
+    // Soft radiant halo around the body
+    float halo = (1.0 - smoothstep(0.0, 1.0, length(vec2(uv.x, (uv.y - 0.22) * 1.4)))) * 0.10;
+    col += vec3(0.55, 0.16, 0.02) * halo * u_intensity;
+
+    // Faint premixed-gas blue at the base
+    float blue = (1.0 - smoothstep(0.0, 0.16, uv.y)) * smoothstep(0.0, 0.25, outer);
+    col += vec3(0.10, 0.25, 0.90) * blue * 0.35 * u_intensity;
+
+    float alpha = clamp(T * 1.4 + halo, 0.0, 1.0);
+    gl_FragColor = vec4(col, alpha);
+  }
+`;
+export const FireMaterial = shaderMaterial({ ...defaults, u_tint: defaults.u_tint.clone() }, vertexShader, fragmentShader, (m) => {
+    if (!m)
+        return;
+    m.transparent = true;
+    m.blending = THREE.AdditiveBlending;
+    m.depthWrite = false;
+    m.side = THREE.DoubleSide;
+});
+extend({ FireMaterial });

package/dist/shaders/FireShellMaterial.d.ts

@@ -0,0 +1,34 @@
+import * as THREE from 'three';
+export interface FireShellUniforms {
+    u_time: number;
+    u_intensity: number;
+    u_speed: number;
+    u_turbulence: number;
+    u_freq: number;
+    u_shell: number;
+    u_coverage: number;
+    u_baseY: number;
+    u_spanY: number;
+    u_tint: THREE.Color;
+}
+export type FireShellMaterialImpl = THREE.ShaderMaterial & FireShellUniforms;
+declare module '@react-three/fiber' {
+    interface ThreeElements {
+        fireShellMaterial: ThreeElements['shaderMaterial'] & Partial<FireShellUniforms>;
+    }
+}
+export declare const FireShellMaterial: import("@react-three/fiber").ConstructorRepresentation<THREE.ShaderMaterial & {
+    u_tint: THREE.Color;
+    u_time: number;
+    u_intensity: number;
+    u_speed: number;
+    u_turbulence: number;
+    u_freq: number;
+    u_shell: number;
+    u_coverage: number;
+    u_baseY: number;
+    u_spanY: number;
+}> & {
+    key: string;
+};
+//# sourceMappingURL=FireShellMaterial.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FireShellMaterial.d.ts","sourceRoot":"","sources":["../../src/shaders/FireShellMaterial.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B,MAAM,WAAW,iBAAiB;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,KAAK,CAAC,KAAK,CAAC;CACvB;AAED,MAAM,MAAM,qBAAqB,GAAG,KAAK,CAAC,cAAc,GAAG,iBAAiB,CAAC;AAE7E,OAAO,QAAQ,oBAAoB,CAAC;IAChC,UAAU,aAAa;QACnB,iBAAiB,EAAE,aAAa,CAAC,gBAAgB,CAAC,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC;KACnF;CACJ;AA+HD,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;CAO5B,CAAC"}

package/dist/shaders/FireShellMaterial.js

@@ -0,0 +1,137 @@
+import * as THREE from 'three';
+import { shaderMaterial } from '@react-three/drei';
+import { extend } from '@react-three/fiber';
+const defaults = {
+    u_time: 0,
+    u_intensity: 1.0,
+    u_speed: 1.0,
+    u_turbulence: 1.5,
+    u_freq: 2.2,
+    u_shell: 0.05,
+    u_coverage: 0.8,
+    u_baseY: 0,
+    u_spanY: 1,
+    u_tint: new THREE.Color(1, 1, 1),
+};
+const vertexShader = /*glsl*/ `
+  uniform float u_time;
+  uniform float u_speed;
+  uniform float u_shell;
+
+  varying vec3  vWorldPos;
+  varying vec3  vWorldNormal;
+  varying float vWobble;
+
+  void main() {
+    vec3 wn = normalize(mat3(modelMatrix) * normal);
+    vec4 wp = modelMatrix * vec4(position, 1.0);
+
+    // Low-frequency lick: the shell breathes and drags upward.
+    float wob = 0.5 + 0.5 * sin(wp.y * 3.1 + u_time * u_speed * 4.0 + wp.x * 2.3 + wp.z * 1.7);
+
+    vec3 displaced = wp.xyz
+      + wn * u_shell * (0.7 + 0.6 * wob)          // inflate along normal
+      + vec3(0.0, u_shell * 1.6 * wob, 0.0);      // convective upward drag
+
+    vWorldPos = displaced;
+    vWorldNormal = wn;
+    vWobble = wob;
+
+    gl_Position = projectionMatrix * viewMatrix * vec4(displaced, 1.0);
+  }
+`;
+const fragmentShader = /*glsl*/ `
+  precision highp float;
+
+  uniform float u_time;
+  uniform float u_intensity;
+  uniform float u_speed;
+  uniform float u_turbulence;
+  uniform float u_freq;
+  uniform float u_coverage;
+  uniform float u_baseY;
+  uniform float u_spanY;
+  uniform vec3  u_tint;
+
+  varying vec3  vWorldPos;
+  varying vec3  vWorldNormal;
+  varying float vWobble;
+
+  float hash3(vec3 p) {
+    p = fract(p * 0.3183099 + vec3(0.1, 0.17, 0.13));
+    p *= 17.0;
+    return fract(p.x * p.y * p.z * (p.x + p.y + p.z));
+  }
+
+  float noise3(vec3 p) {
+    vec3 i = floor(p), f = fract(p);
+    vec3 u = f * f * (3.0 - 2.0 * f);
+    return mix(
+      mix(mix(hash3(i + vec3(0,0,0)), hash3(i + vec3(1,0,0)), u.x),
+          mix(hash3(i + vec3(0,1,0)), hash3(i + vec3(1,1,0)), u.x), u.y),
+      mix(mix(hash3(i + vec3(0,0,1)), hash3(i + vec3(1,0,1)), u.x),
+          mix(hash3(i + vec3(0,1,1)), hash3(i + vec3(1,1,1)), u.x), u.y),
+      u.z
+    );
+  }
+
+  float fbm3(vec3 p) {
+    float s = 0.0, a = 0.5;
+    for (int i = 0; i < 4; i++) {
+      s += a * noise3(p);
+      p = p * 2.04 + vec3(1.7);
+      a *= 0.5;
+    }
+    return s;
+  }
+
+  vec3 blackbody(float t) {
+    t = clamp(t, 0.0, 1.0);
+    vec3 c = mix(vec3(0.015, 0.0, 0.0), vec3(0.85, 0.16, 0.01), smoothstep(0.00, 0.32, t));
+    c = mix(c, vec3(1.0, 0.55, 0.06), smoothstep(0.28, 0.62, t));
+    c = mix(c, vec3(1.0, 0.93, 0.55), smoothstep(0.58, 0.88, t));
+    c = mix(c, vec3(1.0, 1.0, 0.98),  smoothstep(0.85, 1.00, t));
+    return c;
+  }
+
+  void main() {
+    // Rising, domain-warped temperature field in world space.
+    vec3 p = vWorldPos * u_freq;
+    p.y -= u_time * u_speed * 1.6;
+    float q = fbm3(p);
+    float n = fbm3(p + u_turbulence * vec3(q, q * 0.7, q));
+
+    // Fresnel: flames live on the silhouette → reads as a volume.
+    vec3 V = normalize(cameraPosition - vWorldPos);
+    float fres = pow(1.0 - abs(dot(V, normalize(vWorldNormal))), 1.5);
+
+    // Top-down coverage gate, eaten by noise so the burn line is ragged.
+    float hNorm = clamp((vWorldPos.y - u_baseY) / u_spanY, 0.0, 1.0);
+    float gate = smoothstep(
+      1.0 - u_coverage - 0.25,
+      1.0 - u_coverage + 0.25,
+      hNorm + (n - 0.5) * 0.7
+    );
+
+    float T = n * (0.35 + 0.65 * fres) * gate;
+    T = pow(clamp(T * 1.6, 0.0, 1.0), 1.7);
+    T *= u_intensity * (0.8 + 0.4 * vWobble);
+
+    vec3 col = blackbody(T) * u_tint;
+
+    // Faint ember glow on the burning region even where flames are thin.
+    col += vec3(0.5, 0.08, 0.0) * gate * fres * 0.18 * u_intensity;
+
+    float alpha = clamp(T * 1.5 + gate * fres * 0.12, 0.0, 1.0);
+    gl_FragColor = vec4(col, alpha);
+  }
+`;
+export const FireShellMaterial = shaderMaterial({ ...defaults, u_tint: defaults.u_tint.clone() }, vertexShader, fragmentShader, (m) => {
+    if (!m)
+        return;
+    m.transparent = true;
+    m.blending = THREE.AdditiveBlending;
+    m.depthWrite = false;
+    m.side = THREE.FrontSide;
+});
+extend({ FireShellMaterial });