aether-engine 1.0.0

package/src/renderer/WaterMaterial.ts

@@ -0,0 +1,298 @@
+import { Material } from "./Material";
+
+export const WATER_SPRITE_VS = `
+  attribute vec4 aVertexPosition;
+  attribute vec2 aTextureCoord;
+  attribute vec3 aVertexNormal;
+
+  uniform mat4 uModelMatrix;
+  uniform mat4 uModelViewMatrix;
+  uniform mat4 uProjectionMatrix;
+  uniform vec2 uTexOffset;
+  uniform vec2 uTexScale;
+  uniform highp float uTime; // Passed automatically by WebGLRenderer
+  
+  varying highp vec2 vTextureCoord;
+  varying highp vec3 vWorldPos;
+  varying highp vec3 vNormal;
+  
+  varying highp vec2 vMinUV;
+  varying highp vec2 vMaxUV;
+
+  void main(void) {
+    // We strictly avoid vertex displacement because boundary tiles contain structural 
+    // ground graphics (grass) which should never physically undulate.
+    vec4 displacedPos = aVertexPosition;
+    
+    gl_Position = uProjectionMatrix * uModelViewMatrix * displacedPos;
+    vTextureCoord = (aTextureCoord * uTexScale) + uTexOffset;
+    
+    vMinUV = uTexOffset;
+    vMaxUV = uTexOffset + uTexScale;
+    
+    vWorldPos = (uModelMatrix * displacedPos).xyz;
+    vNormal = normalize(mat3(uModelMatrix) * aVertexNormal);
+  }
+`;
+
+export const WATER_SPRITE_FS = `
+  precision mediump float;
+  
+  varying highp vec2 vTextureCoord;
+  varying highp vec3 vWorldPos;
+  varying highp vec3 vNormal;
+  
+  uniform sampler2D uSampler;
+  uniform lowp vec4 uColor;
+
+  // Lighting Uniforms
+  uniform lowp vec3 uAmbientColor;
+  uniform int uActivePointLights;
+  uniform highp vec3 uLightPositions[16];
+  uniform lowp vec3 uLightColors[16];
+  uniform highp vec4 uLightParams[16];
+
+  uniform sampler2D uOcclusionSampler;
+  uniform highp vec2 uResolution;
+  uniform highp mat4 uViewMatrix;
+  uniform highp mat4 uProjectionMatrix;
+
+  uniform int uActiveParticleLights;
+  uniform highp vec4 uParticleLightPositions[64];
+  uniform lowp vec3 uParticleLightColors[64];
+
+  uniform highp float uTime;
+  
+  varying highp vec2 vMinUV;
+  varying highp vec2 vMaxUV;
+
+  float IGN(highp vec2 fragCoord) {
+      vec3 magic = vec3(0.06711056, 0.00583715, 52.9829189);
+      return fract(magic.z * fract(dot(fragCoord, magic.xy)));
+  }
+
+  float getFlicker(float time, vec3 pos) {
+      float localTimeOffset = pos.x * 137.0 + pos.y * 311.0;
+      float absoluteTime = time + localTimeOffset;
+      float decasecond = floor(absoluteTime * 0.1);
+      float dice = fract(sin(decasecond * 12.9898 + pos.x * 78.233) * 43758.5453);
+      if (dice < 0.015) {
+          float localProgress = fract(absoluteTime * 0.1) * 10.0;
+          if (localProgress < 1.0) {
+              float noise = fract(sin(time * 50.0 + pos.y) * 43758.5453);
+              float envelope = 1.0 - localProgress; 
+              return 1.0 - (noise * 0.7 * envelope);
+          }
+      }
+      return 1.0;
+  }
+
+  void main(void) {
+    vec4 texColor = texture2D(uSampler, vTextureCoord);
+    if (texColor.a < 0.05) discard;
+    
+    // Smooth boundary mask extracting pure water geometry from mixed grass-edge sprites
+    float isWaterMask = clamp((texColor.b - max(texColor.r, texColor.g)) * 10.0, 0.0, 1.0);
+
+    // Small, Soft Water Ripple Effect
+    // Reconstruct the physical texture distortion with higher frequencies
+    // to simulate gentle little ripples rather than large undulating swells.
+    float timeX = uTime * 2.0;
+    float timeY = uTime * 1.5;
+    
+    float wave1 = sin(vWorldPos.x * 12.0 + vWorldPos.y * 8.0 + timeX);
+    float wave2 = cos(vWorldPos.x * -9.0 + vWorldPos.y * 14.0 - timeY);
+    float wave3 = sin(vWorldPos.x * 15.0 + vWorldPos.y * -6.0 + timeX * 1.2);
+    
+    float uvWaveX = (wave1 + wave2 * 0.5) * 0.015;
+    float uvWaveY = (wave2 + wave3 * 0.5) * 0.015;
+    
+    // Safely constrain UV distortion to stay within the pure pixel boundaries of this specific sprite instance
+    // A 16x16 tile means 1 texel is 1/16th of the UV scale. 0.5 of that is a perfectly safe half-texel inset!
+    vec2 safeInset = (vMaxUV - vMinUV) / 16.0 * 0.5;
+    vec2 distortedUV = clamp(vTextureCoord + vec2(uvWaveX, uvWaveY), vMinUV + safeInset, vMaxUV - safeInset);
+    vec4 displacedColor = texture2D(uSampler, distortedUV);
+    
+    // A brilliant, dynamic solution:
+    // Blend smoothly from the rigidly perfect static edges (grass borders) into the fully undulating 
+    // water interior. This mathematically destroys edge-tearing gaps while preserving liquid physics.
+    vec4 baseColor = mix(texColor, displacedColor, isWaterMask) * uColor;
+    
+    vec3 lightAdded = vec3(0.0);
+    vec3 specularAdded = vec3(0.0);
+    vec2 fragUV = gl_FragCoord.xy / uResolution;
+    
+    float is2D = uProjectionMatrix[3][3] > 0.5 ? 1.0 : 0.0;
+    
+    vec3 norm = normalize(vNormal);
+    if (is2D > 0.5) {
+        norm = vec3(0.0, 0.0, 1.0);
+    }
+    
+    vec3 viewDir = normalize(vec3(0.0, 0.707, 0.707));
+
+    // A. CORE POINT LIGHTS
+    for (int i = 0; i < 16; i++) {
+        if (i >= uActivePointLights) break;
+        
+        vec3 lightPos = uLightPositions[i];
+        vec3 lightColor = uLightColors[i];
+        float intensity = uLightParams[i].x; 
+        float radius = uLightParams[i].y;
+        float height = uLightParams[i].z;
+        float flickerIntensity = uLightParams[i].w;
+        
+        vec3 physPos = vWorldPos;
+        
+        if (is2D > 0.5) {
+            if (vWorldPos.z > -4.0) {
+                float trueBaseY = -vWorldPos.z * 100.0;
+                float pixelElevation = max(0.0, vWorldPos.y - trueBaseY);
+                physPos = vec3(vWorldPos.x, trueBaseY, pixelElevation);
+            } else {
+                physPos = vec3(vWorldPos.x, vWorldPos.y, 0.0);
+            }
+        }
+        
+        vec3 diff3D = lightPos - physPos; 
+        float distSq = dot(diff3D, diff3D);
+        float radiusSq = radius * radius;
+        
+        if (distSq < radiusSq) {
+            float dist = max(0.001, sqrt(distSq));
+            vec3 lightDir = diff3D / dist;
+            float normDist = dist / radius;
+            
+            float diffuse = dot(norm, lightDir) * 0.5 + 0.5;
+            vec3 specular = vec3(0.0);
+            
+            if (is2D > 0.5) {
+                if (vWorldPos.z < -4.0) {
+                     // Extra specular glints for water surface interacting with geometry offsets!
+                     float bump = fract(sin(dot(floor(vWorldPos.xy * 16.0), vec2(12.9898, 78.233))) * 43758.5453);
+                     diffuse = mix(0.9, 0.7 + bump * 0.4, clamp(1.0 - normDist, 0.0, 1.0));
+                     
+                     // WATER SPECIFIC HIGHLIGHTS
+                     vec3 pHalfVector = normalize(lightDir + viewDir);
+                     float pSpec = pow(max(dot(norm, pHalfVector), 0.0), 12.0);
+                     specularAdded += pSpec * lightColor * intensity * 0.5 * (1.0 - normDist) * isWaterMask;
+                } else {
+                     diffuse = 0.6 + (dot(vec3(0,0,1), lightDir) * 0.4);
+                }
+            } else {
+                vec3 halfVector = normalize(lightDir + viewDir);
+                float spec = pow(max(dot(norm, halfVector), 0.0), 16.0); 
+                specularAdded += spec * lightColor * intensity * 0.8;
+            }
+            
+            float attenuation = max(0.0, (exp(-normDist * normDist * 4.0) - 0.0183) / 0.9817);
+
+            if (is2D > 0.5) {
+                float spotlightCone = smoothstep(0.55, 0.85, lightDir.z);
+                attenuation *= spotlightCone;
+            }
+
+            float flickerAmount = getFlicker(uTime, lightPos);
+            attenuation *= mix(1.0, flickerAmount, flickerIntensity);
+            
+            float shadowMultiplier = 1.0;
+            
+            if (is2D < 0.5) {
+                vec4 lClip = uProjectionMatrix * uViewMatrix * vec4(lightPos, 1.0);
+                vec2 lightScreenUV = (lClip.xy / lClip.w) * 0.5 + 0.5;
+                
+                vec2 rayVec = lightScreenUV - fragUV;
+                float stepsNum = 12.0;
+                vec2 stepUV = rayVec / stepsNum;
+                
+                vec2 sampleUV = fragUV;
+                sampleUV += stepUV * (IGN(gl_FragCoord.xy) - 0.5);
+                
+                for (int k = 0; k < 12; k++) {
+                    sampleUV += stepUV;
+                    if (sampleUV.x < 0.0 || sampleUV.x > 1.0 || sampleUV.y < 0.0 || sampleUV.y > 1.0) {
+                        break;
+                    }
+                    vec4 occData = texture2D(uOcclusionSampler, sampleUV);
+                    float isOccluder = 1.0 - occData.b; 
+                    
+                    if (isOccluder > 0.5) {
+                        float normZ = occData.r + occData.g * (1.0/255.0);
+                        float occluderZ = normZ * 20.0 - 10.0;
+                        if (occluderZ > vWorldPos.z + 0.005) {
+                            shadowMultiplier = 0.0;
+                            break;
+                        }
+                    }
+                }
+            }
+            
+            lightAdded += lightColor * intensity * attenuation * diffuse * shadowMultiplier;
+        }
+    }
+    
+    // B. SECONDARY PARTICLE LIGHTS
+    vec3 particleAdded = vec3(0.0);
+    
+    for (int j = 0; j < 64; j++) {
+        if (j >= uActiveParticleLights) break;
+        
+        vec3 pLightPos = uParticleLightPositions[j].xyz;
+        float pRadius = uParticleLightPositions[j].w;
+        vec3 pLightColor = uParticleLightColors[j]; 
+        
+        vec3 posToLight = vWorldPos;
+        if (is2D > 0.5) {
+            posToLight = floor(vWorldPos * 16.0) / 16.0;
+        }
+
+        vec3 pDiff3D = pLightPos - posToLight;
+        if (is2D > 0.5) pDiff3D.z = 0.5;
+        
+        float pDistSq = dot(pDiff3D, pDiff3D);
+        float pRadiusSq = pRadius * pRadius;
+        
+        if (pDistSq < pRadiusSq) {
+            float pDist = sqrt(pDistSq);
+            vec3 pLightDir = pDiff3D / pDist;
+            
+            float pDiffuse = dot(norm, pLightDir) * 0.5 + 0.5;
+            if (is2D > 0.5) pDiffuse = 1.0;
+            
+            float pNormDist = pDist / pRadius;
+            float pAtten = max(0.0, (exp(-pNormDist * pNormDist * 4.0) - 0.0183) / 0.9817);
+            
+            if (is2D > 0.5) pAtten = floor(pAtten * 6.0) / 6.0;
+            
+            particleAdded += pLightColor * pAtten * pDiffuse;
+            
+            vec3 pHalfVector = normalize(pLightDir + viewDir);
+            float pSpec = pow(max(dot(norm, pHalfVector), 0.0), 32.0);
+            specularAdded += pSpec * pLightColor * pAtten * 0.5;
+        }
+    }
+    
+    vec3 shadedBase = baseColor.rgb * uAmbientColor;
+    vec3 mappedLight = baseColor.rgb * lightAdded;
+    
+    vec3 ambientGlow = vec3(0.0);
+    if (is2D > 0.5 && vWorldPos.z < -4.0) {
+        vec3 safeGlowEnergy = min(lightAdded, vec3(1.1));
+        ambientGlow = safeGlowEnergy * (vec3(1.0) - baseColor.rgb) * 0.9; 
+    }
+    
+    vec3 litColor = shadedBase + mappedLight + (baseColor.rgb * particleAdded) + specularAdded + ambientGlow + (particleAdded * 0.1);
+    litColor = clamp(litColor, 0.0, 1.0);
+    
+    float dither = IGN(gl_FragCoord.xy) * (1.0 / 255.0);
+    litColor += dither - (0.5 / 255.0);
+    
+    gl_FragColor = vec4(litColor, baseColor.a);
+  }
+`;
+
+export class WaterMaterial extends Material {
+	constructor() {
+		super(WATER_SPRITE_VS, WATER_SPRITE_FS);
+	}
+}