@3driseai/3drise-core 1.0.1

package/dist/shaders/ReflectorMaterial.d.ts

@@ -0,0 +1,62 @@
+import { Vector3, Matrix4 } from "three";
+import type { Texture } from 'three';
+export interface ReflectorMaterialUniforms {
+    u_envMap: {
+        value: Texture | null;
+    };
+    u_reflectionTexture: {
+        value: Texture | null;
+    };
+    u_textureMatrix: {
+        value: Matrix4 | null;
+    };
+    u_useReflectionTexture: {
+        value: boolean;
+    };
+    u_reflectivity: {
+        value: number;
+    };
+    u_roughness: {
+        value: number;
+    };
+    u_metalness: {
+        value: number;
+    };
+    u_color: {
+        value: Vector3;
+    };
+    u_fresnelPower: {
+        value: number;
+    };
+    u_fresnelScale: {
+        value: number;
+    };
+    u_time: {
+        value: number;
+    };
+    u_mirror: {
+        value: number;
+    };
+    u_mixContrast: {
+        value: number;
+    };
+}
+declare const ReflectorMaterial: import("@react-three/fiber").ConstructorRepresentation<import("three").ShaderMaterial & {
+    u_envMap: any;
+    u_reflectionTexture: any;
+    u_textureMatrix: Matrix4;
+    u_useReflectionTexture: false;
+    u_reflectivity: number;
+    u_roughness: number;
+    u_metalness: number;
+    u_color: Vector3;
+    u_fresnelPower: number;
+    u_fresnelScale: number;
+    u_time: number;
+    u_mirror: number;
+    u_mixContrast: number;
+}> & {
+    key: string;
+};
+export { ReflectorMaterial };
+//# sourceMappingURL=ReflectorMaterial.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ReflectorMaterial.d.ts","sourceRoot":"","sources":["../../src/shaders/ReflectorMaterial.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AACzC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAGrC,MAAM,WAAW,yBAAyB;IACtC,QAAQ,EAAE;QACN,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;KACzB,CAAC;IACF,mBAAmB,EAAE;QACjB,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;KACzB,CAAC;IACF,eAAe,EAAE;QACb,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;KACzB,CAAC;IACF,sBAAsB,EAAE;QACpB,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,cAAc,EAAE;QACZ,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,WAAW,EAAE;QACT,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,WAAW,EAAE;QACT,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,OAAO,EAAE;QACL,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,cAAc,EAAE;QACZ,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,cAAc,EAAE;QACZ,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,MAAM,EAAE;QACJ,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,QAAQ,EAAE;QACN,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,aAAa,EAAE;QACX,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;CACL;AAoJD,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;;;;CAcS,CAAC;AAGjC,OAAO,EAAE,iBAAiB,EAAE,CAAC"}

package/dist/shaders/ReflectorMaterial.js

@@ -0,0 +1,167 @@
+import { Vector3, Matrix4 } from "three";
+import { extend } from "@react-three/fiber";
+import { shaderMaterial } from "@react-three/drei";
+// Vertex shader - calculate view and normal vectors
+const vertexShader = /*glsl*/ `
+  uniform mat4 u_textureMatrix;
+  
+  varying vec2 vUv;
+  varying vec3 vNormal;
+  varying vec3 vViewPosition;
+  varying vec3 vWorldNormal;
+  varying vec3 vWorldPosition;
+  varying vec4 vProjectedUv;
+  
+  void main() {
+    vUv = uv;
+    
+    // Transform normal to world space
+    vWorldNormal = normalize((modelMatrix * vec4(normal, 0.0)).xyz);
+    vNormal = normalize(normalMatrix * normal);
+    
+    // Calculate world position
+    vec4 worldPosition = modelMatrix * vec4(position, 1.0);
+    vWorldPosition = worldPosition.xyz;
+    
+    // Calculate view position
+    vec4 mvPosition = modelViewMatrix * vec4(position, 1.0);
+    vViewPosition = -mvPosition.xyz;
+    
+    // Calculate projected UV coordinates for planar reflection
+    vProjectedUv = u_textureMatrix * vec4(position, 1.0);
+    
+    gl_Position = projectionMatrix * mvPosition;
+  }
+`;
+// Fragment shader - calculate reflections with Fresnel effect
+const fragmentShader = /*glsl*/ `
+  uniform samplerCube u_envMap;
+  uniform sampler2D u_reflectionTexture;
+  uniform bool u_useReflectionTexture;
+  uniform float u_reflectivity;
+  uniform float u_roughness;
+  uniform float u_metalness;
+  uniform vec3 u_color;
+  uniform float u_fresnelPower;
+  uniform float u_fresnelScale;
+  uniform float u_time;
+  uniform float u_mirror;
+  uniform float u_mixContrast;
+  
+  varying vec2 vUv;
+  varying vec3 vNormal;
+  varying vec3 vViewPosition;
+  varying vec3 vWorldNormal;
+  varying vec3 vWorldPosition;
+  varying vec4 vProjectedUv;
+  
+  // Simple noise function for roughness simulation
+  float hash(vec3 p) {
+    p = fract(p * 0.3183099 + 0.1);
+    p *= 17.0;
+    return fract(p.x * p.y * p.z * (p.x + p.y + p.z));
+  }
+  
+  float noise(vec3 x) {
+    vec3 p = floor(x);
+    vec3 f = fract(x);
+    f = f * f * (3.0 - 2.0 * f);
+    
+    return mix(
+      mix(mix(hash(p + vec3(0,0,0)), hash(p + vec3(1,0,0)), f.x),
+          mix(hash(p + vec3(0,1,0)), hash(p + vec3(1,1,0)), f.x), f.y),
+      mix(mix(hash(p + vec3(0,0,1)), hash(p + vec3(1,0,1)), f.x),
+          mix(hash(p + vec3(0,1,1)), hash(p + vec3(1,1,1)), f.x), f.y),
+      f.z
+    );
+  }
+  
+  void main() {
+    // Normalize vectors
+    vec3 normal = normalize(vWorldNormal);
+    vec3 viewDir = normalize(cameraPosition - vWorldPosition);
+    
+    // Calculate reflection vector for environment map
+    vec3 reflectVec = reflect(-viewDir, normal);
+    
+    // Add roughness perturbation
+    if (u_roughness > 0.0) {
+      float noiseScale = 5.0;
+      vec3 noiseVec = vec3(
+        noise(vWorldPosition * noiseScale + u_time * 0.1),
+        noise(vWorldPosition * noiseScale * 1.3 + u_time * 0.1),
+        noise(vWorldPosition * noiseScale * 1.7 + u_time * 0.1)
+      );
+      noiseVec = (noiseVec - 0.5) * 2.0;
+      reflectVec = normalize(reflectVec + noiseVec * u_roughness * 0.5);
+    }
+    
+    // Sample environment map
+    vec4 envColor = textureCube(u_envMap, reflectVec);
+    
+    // Sample planar reflection if available
+    vec4 planarReflection = vec4(0.0);
+    if (u_useReflectionTexture) {
+      planarReflection = texture2DProj(u_reflectionTexture, vProjectedUv);
+      
+      // Apply contrast adjustment
+      planarReflection.rgb = (planarReflection.rgb - 0.5) * u_mixContrast + 0.5;
+    }
+    
+    // Calculate Fresnel effect
+    float fresnel = u_fresnelScale + (1.0 - u_fresnelScale) * pow(1.0 - max(dot(viewDir, normal), 0.0), u_fresnelPower);
+    
+    // Base color
+    vec3 baseColor = u_color;
+    
+    // Choose reflection source based on availability
+    vec3 reflectionColor;
+    if (u_useReflectionTexture) {
+      // Blend planar reflection with environment map
+      reflectionColor = mix(envColor.rgb, planarReflection.rgb, u_mirror);
+      reflectionColor *= u_reflectivity;
+    } else {
+      // Use only environment map
+      reflectionColor = envColor.rgb * u_reflectivity;
+    }
+    
+    // Mix between base color and reflection based on metalness
+    vec3 diffuseColor = mix(baseColor, vec3(0.0), u_metalness);
+    
+    // Apply Fresnel to reflections
+    reflectionColor *= fresnel;
+    
+    // Combine diffuse and reflection
+    vec3 finalColor = diffuseColor + reflectionColor;
+    
+    // Add some rim lighting for better definition
+    float rim = 1.0 - max(dot(viewDir, normal), 0.0);
+    rim = pow(rim, 3.0) * 0.3;
+    finalColor += vec3(rim);
+    
+    // Apply subtle tone mapping
+    finalColor = finalColor / (finalColor + vec3(1.0));
+    finalColor = pow(finalColor, vec3(0.4545)); // Gamma correction
+    
+    gl_FragColor = vec4(finalColor, 1.0);
+  }
+`;
+// Create the shader material with default uniforms
+const ReflectorMaterial = shaderMaterial({
+    u_envMap: null,
+    u_reflectionTexture: null,
+    u_textureMatrix: new Matrix4(),
+    u_useReflectionTexture: false,
+    u_reflectivity: 1.0,
+    u_roughness: 0.1,
+    u_metalness: 0.9,
+    u_color: new Vector3(0.2, 0.2, 0.2),
+    u_fresnelPower: 2.0,
+    u_fresnelScale: 0.1,
+    u_time: 0,
+    u_mirror: 0.5,
+    u_mixContrast: 1.0
+}, vertexShader, fragmentShader);
+// Extend the material for use in React Three Fiber
+extend({ ReflectorMaterial });
+export { ReflectorMaterial };

package/dist/shaders/SandMaterial.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"SandMaterial.d.ts","sourceRoot":"","sources":["../../src/shaders/SandMaterial.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B,MAAM,WAAW,YAAY;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,KAAK,CAAC,KAAK,CAAC;IACrB,gBAAgB,EAAE,MAAM,CAAC;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC;IACtB,gBAAgB,EAAE,MAAM,CAAC;IACzB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,SAAS,EAAE,KAAK,CAAC,OAAO,CAAC;IACzB,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,KAAK,CAAC,OAAO,CAAC;IAC9B,UAAU,EAAE,KAAK,CAAC,KAAK,CAAC;IACxB,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,KAAK,CAAC,KAAK,CAAC;IACxB,aAAa,EAAE,KAAK,CAAC,KAAK,CAAC;IAC3B,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,KAAK,CAAC,OAAO,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;IACxB,YAAY,EAAE,MAAM,CAAC;CACxB;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;AAyBD,eAAO,MAAM,YAAY,2bAYxB,CAAC;AACF,eAAO,MAAM,cAAc,4rTA4O1B,CAAC;AACF,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;CAkBvB,CAAC"}

package/dist/shaders/SandMaterial.js

@@ -0,0 +1,296 @@
+import * as THREE from 'three';
+import { shaderMaterial } from '@react-three/drei';
+import { extend } from '@react-three/fiber';
+const defaults = {
+    u_time: 0,
+    u_color: new THREE.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: new THREE.Vector2(1, 0),
+    u_grainDensity: 1.0,
+    u_roughness: 0.88,
+    u_sunDirection: new THREE.Vector3(0.5, 0.82, 0.28),
+    u_sunColor: new THREE.Color(1.0, 0.93, 0.82),
+    u_sunIntensity: 1.0,
+    u_ambient: 1.0,
+    u_skyColor: new THREE.Color(0.55, 0.68, 0.92),
+    u_groundColor: new THREE.Color(0.45, 0.33, 0.22),
+    u_windSpeed: 0.15,
+    u_mouse: new THREE.Vector3(0, -1000, 0),
+    u_mouseRadius: 3.0,
+    u_mouseStrength: 0.0,
+    u_mouseSwirl: 0.5,
+};
+export const vertexShader = /*glsl*/ `
+  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;
+  }
+`;
+export const fragmentShader = /*glsl*/ `
+  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);
+  }
+`;
+export const SandMaterial = shaderMaterial({
+    ...defaults,
+    u_color: defaults.u_color.clone(),
+    u_windDir: defaults.u_windDir.clone(),
+    u_sunDirection: defaults.u_sunDirection.clone(),
+    u_sunColor: defaults.u_sunColor.clone(),
+    u_skyColor: defaults.u_skyColor.clone(),
+    u_groundColor: defaults.u_groundColor.clone(),
+    u_mouse: defaults.u_mouse.clone(),
+}, vertexShader, fragmentShader, (m) => {
+    if (!m)
+        return;
+    // Opaque, lit surface (contrast with Fire's additive glow).
+    m.transparent = false;
+    m.depthWrite = true;
+    m.side = THREE.FrontSide;
+    // Required for dFdx/dFdy in the surface-gradient bump on WebGL1/GLSL ES 1.0.
+    m.extensions = { ...(m.extensions ?? {}), derivatives: true };
+});
+extend({ SandMaterial });