twinkling stars

src/net/torvald/terrarum/weather/WeatherMixer.kt

@@ -240,6 +240,12 @@ internal object WeatherMixer : RNGConsumer {
             shaderBlendMax.setUniform2fv("skyboxUV1", uvs, 0, 2)
             shaderBlendMax.setUniform2fv("skyboxUV2", uvs, 2, 2)
             shaderBlendMax.setUniformf("astrumScroll", astrumOffX, astrumOffY + astrumY)
+            shaderBlendMax.setUniformf("randomNumber",
+                (world.worldTime.TIME_T.plus(31L) xor 1453L + 31L).and(1023).toFloat(),
+                (world.worldTime.TIME_T.plus(37L) xor  862L + 31L).and(1023).toFloat(),
+                (world.worldTime.TIME_T.plus(37L) xor 1639L + 29L).and(1023).toFloat(),
+                (world.worldTime.TIME_T.plus(37L) xor 2971L + 41L).and(1023).toFloat(),
+            )
 
             batch.color = Color.WHITE
             batch.draw(tex, 0f, gradY, App.scr.wf, gH, 0f, 0f, 1f, 1f)

src/shaders/blendSkyboxStars.frag

@@ -17,21 +17,107 @@ uniform vec2 drawOffset; // value of the 'gradY'
 uniform vec2 drawOffsetSize; // value of the 'gradH'
 uniform vec2 skyboxUV1; // (u, v) for the skybox drawing
 uniform vec2 skyboxUV2; // (u2, v2) for the skybox drawing
-uniform vec2 tex1Size = vec2(4096.0, 4096.0);
+uniform vec2 tex1Size = vec2(4096.0);
-uniform vec2 astrumScroll = vec2(0.0, 0.0);
+uniform vec2 astrumScroll = vec2(0.0);
+uniform vec4 randomNumber = vec4(0.0);
 
+vec3 mod289(vec3 x) {
+    return x - floor(x * (1.0 / 289.0)) * 289.0;
+}
+
+vec2 mod289(vec2 x) {
+    return x - floor(x * (1.0 / 289.0)) * 289.0;
+}
+
+vec3 permute(vec3 x) {
+    return mod289(((x*34.0)+10.0)*x);
+}
+
+float snoise(vec2 v)
+{
+    const vec4 C = vec4(0.211324865405187,  // (3.0-sqrt(3.0))/6.0
+    0.366025403784439,  // 0.5*(sqrt(3.0)-1.0)
+    -0.577350269189626,  // -1.0 + 2.0 * C.x
+    0.024390243902439); // 1.0 / 41.0
+    // First corner
+    vec2 i  = floor(v + dot(v, C.yy) );
+    vec2 x0 = v -   i + dot(i, C.xx);
+
+    // Other corners
+    vec2 i1;
+    //i1.x = step( x0.y, x0.x ); // x0.x > x0.y ? 1.0 : 0.0
+    //i1.y = 1.0 - i1.x;
+    i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);
+    // x0 = x0 - 0.0 + 0.0 * C.xx ;
+    // x1 = x0 - i1 + 1.0 * C.xx ;
+    // x2 = x0 - 1.0 + 2.0 * C.xx ;
+    vec4 x12 = x0.xyxy + C.xxzz;
+    x12.xy -= i1;
+
+    // Permutations
+    i = mod289(i); // Avoid truncation effects in permutation
+    vec3 p = permute( permute( i.y + vec3(0.0, i1.y, 1.0 ))
+    + i.x + vec3(0.0, i1.x, 1.0 ));
+
+    vec3 m = max(0.5 - vec3(dot(x0,x0), dot(x12.xy,x12.xy), dot(x12.zw,x12.zw)), 0.0);
+    m = m*m ;
+    m = m*m ;
+
+    // Gradients: 41 points uniformly over a line, mapped onto a diamond.
+    // The ring size 17*17 = 289 is close to a multiple of 41 (41*7 = 287)
+
+    vec3 x = 2.0 * fract(p * C.www) - 1.0;
+    vec3 h = abs(x) - 0.5;
+    vec3 ox = floor(x + 0.5);
+    vec3 a0 = x - ox;
+
+    // Normalise gradients implicitly by scaling m
+    // Approximation of: m *= inversesqrt( a0*a0 + h*h );
+    m *= 1.79284291400159 - 0.85373472095314 * ( a0*a0 + h*h );
+
+    // Compute final noise value at P
+    vec3 g;
+    g.x  = a0.x  * x0.x  + h.x  * x0.y;
+    g.yz = a0.yz * x12.xz + h.yz * x12.yw;
+    return (65.0 * dot(m, g)) + 0.5;
+}
+
+vec4 snoise4(vec2 v) {
+    return vec4(
+        snoise(v + randomNumber.xy),
+        snoise(v + randomNumber.zw),
+        snoise(v + randomNumber.xz),
+        snoise(v + randomNumber.yw)
+    );
+}
+
+vec4 random(vec2 p) {
+    vec2 K1 = vec2(
+        23.14069263277926, // e^pi (Gelfond's constant)
+        2.665144142690225 // 2^sqrt(2) (Gelfond-Schneider constant)
+    );
+    return vec4(
+        fract(cos(dot(p + randomNumber.xy, K1)) * 12345.6789),
+        fract(cos(dot(p + randomNumber.zw, K1)) * 12345.6789),
+        fract(cos(dot(p + randomNumber.xz, K1)) * 12345.6789),
+        fract(cos(dot(p + randomNumber.yw, K1)) * 12345.6789)
+    );
+} // TODO the "grain" needs to be larger
 
 // draw call to this function must use UV coord of (0,0,1,1)!
 void main(void) {
     vec2 skyboxTexCoord = mix(skyboxUV1, skyboxUV2, v_texCoords);
     vec2 astrumTexCoord = (v_texCoords * drawOffsetSize + drawOffset + astrumScroll) / tex1Size;
 
+    vec4 randomness = snoise4(gl_FragCoord.xy * 0.16) * 2.0; // multiply by 2 so that the "density" of the stars would be same as the non-random version
+
 
     vec4 colorTex0 = texture(u_texture, skyboxTexCoord);
-    vec4 colorTex1 = texture(tex1, astrumTexCoord);
+    vec4 colorTex1 = texture(tex1, astrumTexCoord) * randomness;
 
 
 
     fragColor = (max(colorTex0, colorTex1) * boolean.yyyx) + boolean.xxxy;
 //    fragColor = colorTex1;
+//    fragColor = randomness * boolean.yyyx + boolean.xxxy;
 }