Merge pull request #96 from jebbyk/0_12_2_bugfixes

0 12 2 bugfixes

README.md

@@ -1,4 +1,4 @@
-# OSBES v0.12.1
+# OSBES v0.12.2
 Open Source Bedrock Edition Shader  
 
 **------------Every contributor will be listed as a developer!-----------**
@@ -127,9 +127,9 @@ I recomend you to use rooted device with installed Termux <span style="color:gre
 |=|=|=|=|
 |reflections               |0.12.0       | Renderchunk refactoring            |<span style="color:green">Ready</span>
 |reflections               |0.12.1       | Metallness pipeline and reflections|<span style="color:green">Ready</span>
-|reflections               |0.12.2       | bugfixes                           |<span style="color:purple">**In progress**</span>|
+|reflections               |0.12.2       | bugfixes                           |<span style="color:green">Ready</span>
 |=|=|=|=|
-|presets                   |0.13.0       | shaders refactoring and comments   |<span style="color:orange">**Planned**</span>|
+|presets                   |0.13.0       | shaders refactoring and comments   |<span style="color:purple">**In progress**</span>|
 |presets                   |0.13.1       | Preset defines                     |<span style="color:orange">**Planned**</span>|
 |presets                   |0.13.2       | bugfixes                           |<span style="color:orange">**Planned**</span>|
 |=|=|=|=|

manifest.json

@@ -4,14 +4,14 @@
         "description": "Open Source Bedrock Edition Shader",
         "name": "OSBES",
         "uuid": "67010235-00f4-0484-8b1d-80b110011997",
-        "version": [0, 12, 1]
+        "version": [0, 12, 2]
     },
     "modules": [
         {
             "description": "Open Source Bedrock Edition Shader",
             "type": "resources",
             "uuid": "53644fac-a276-42e5-843f-a3c6f169a9cd",
-            "version": [0, 12, 1]
+            "version": [0, 12, 2]
         }
     ],
     "metadata": {

shaders/glsl/includes/helpers.glsl

@@ -1,7 +1,7 @@
 
-vec3 calculateRawNormalVector(vec3 position){
+highp vec3 calculateRawNormalVector(highp vec3 position){
     highp vec3 dp1 = dFdx(position);
-	vec3 dp2 = dFdy(position);
+	highp vec3 dp2 = dFdy(position);
 
 	return normalize(cross(dp1, dp2));
 }

shaders/glsl/includes/texture_mapping.glsl

@@ -88,30 +88,53 @@
 		return puddles * pow(uv1.y, 2.0);// No puddles in dark places like caves
     }
 
-    float mapCaustics(sampler2D texture0, vec3 position){
+    vec3 mapCaustics(sampler2D texture0, highp vec3 position, float isUnderWater){
         if(isUnderWater > 0.9){
-            float time = TIME;
-            float causticsSpeed = 0.05;
-            float causticsScale = 0.1;
+            highp float time = TIME;
+            highp float causticsSpeed = 0.05;
+            highp float causticsScale = 0.1;
 
-            vec2 cauLayerCoord_0 = (position.xz + vec2(position.y / 8.0)) * causticsScale + vec2(time * causticsSpeed);
-            vec2 cauLayerCoord_1 = (-position.xz - vec2(position.y / 8.0)) * causticsScale*0.876 + vec2(time * causticsSpeed);
+            highp vec2 cauLayerCoord_0 = (position.xz + vec2(position.y / 4.0)) * causticsScale + vec2(time * causticsSpeed);
+            highp vec2 cauLayerCoord_1 = (-position.xz - vec2(position.y / 4.0)) * causticsScale*0.876 + vec2(time * causticsSpeed);
 
-            vec2 noiseTexOffset = vec2(5.0/64.0, 1.0/64.0); 
-            float caustics = texture2D(texture0, fract(cauLayerCoord_0)*0.015625 + noiseTexOffset).r;
-            caustics += texture(texture0, fract(cauLayerCoord_1)*0.015625 + noiseTexOffset).r;
+            highp vec2 noiseTexOffset = vec2(1.0/32.0, 0.0); 
+            highp float caustics = texture2D(texture0, fract(cauLayerCoord_0)/32.0+ noiseTexOffset).r;
+            caustics += texture(texture0, fract(cauLayerCoord_1)/32.0 + noiseTexOffset).r;
 
+           /* highp float redCaustics = texture2D(texture0, fract(cauLayerCoord_0 + 0.001)/32.0+ noiseTexOffset).r;
+            redCaustics += texture(texture0, fract(cauLayerCoord_1 + 0.001)/32.0 + noiseTexOffset).r;
             
-            caustics = clamp(caustics, 0.0, 2.0);
+            highp float blueCaustics = texture2D(texture0, fract(cauLayerCoord_0 - 0.001)/32.0+ noiseTexOffset).r;
+            blueCaustics += texture(texture0, fract(cauLayerCoord_1 - 0.001)/32.0 + noiseTexOffset).r;
+            
+            */
+
+
+
+         //   caustics = clamp(caustics, 0.0, 2.0);
             if(caustics > 1.0){
                 caustics = 2.0 - caustics;
             }
-            float cauHardness = 2.0;
-            float cauStrength = 0.8;
-            caustics = pow(caustics * cauStrength * (0.2 + length(FOG_COLOR.rgb)) , cauHardness);
+
+          /*  if(redCaustics > 1.0){
+                redCaustics = 2.0 - redCaustics;
+            }
+            
+            if(blueCaustics > 1.0){
+                blueCaustics = 2.0 - blueCaustics;
+            }*/
+
+
+            highp float cauHardness = 8.0;
+            highp float cauStrength = 1.5;
+
+           // highp float blueCaustics = ;
+            caustics = pow(caustics, cauHardness);
+          /*  redCaustics = pow(redCaustics, cauHardness);
+            blueCaustics = pow(blueCaustics, cauHardness);*/
 
-            return caustics;
-        }else return 0.0;
+            return vec3(caustics) * cauStrength;
+        }else return vec3(0.0);
     }
 
 
@@ -123,23 +146,23 @@
 
         // Top left texture - default diffuse
         highp vec2 diffuseMapCoord = fract(uv0 * vec2(32.0)) * vec2(0.015625);// 1.0 / 64.0 = 0.015625
-        diffuseMap = texelFetch(texture0, ivec2((uv0 - diffuseMapCoord) * 1024.0), 0);
+        diffuseMap = texelFetch(texture0, ivec2((uv0 - diffuseMapCoord) * TEXTURE_DIMENSIONS.xy), 0);
 
         #if defined(BLEND)
             if(isWater >  0.9){
 		        reliefMap = mapWaterNormals(texture0);
             }else{
                 highp vec2 reliefMapCoord = diffuseMapCoord - vec2(0.0, 0.015625);
-                reliefMap = texelFetch(texture0, ivec2((uv0 - reliefMapCoord) * 1024.0), 0).rgb;
+                reliefMap = texelFetch(texture0, ivec2((uv0 - reliefMapCoord) * TEXTURE_DIMENSIONS.xy), 0).rgb;
             }
         #else
             highp vec2 reliefMapCoord = diffuseMapCoord - vec2(0.0, 0.015625);
-            reliefMap = texelFetch(texture0, ivec2((uv0 - reliefMapCoord) * 1024.0), 0).rgb;
+            reliefMap = texelFetch(texture0, ivec2((uv0 - reliefMapCoord) * TEXTURE_DIMENSIONS.xy), 0).rgb;
         #endif
 
         // Top right texture - specular map
         highp vec2 rmeMapCoord = diffuseMapCoord - vec2(0.015625, 0.0);// 1.0/64.0 = 0.015625
-        rmeMap = clamp(texelFetch(texture0, ivec2((uv0 - rmeMapCoord) * 1024.0), 0),0.01, 1.0);
+        rmeMap = clamp(texelFetch(texture0, ivec2((uv0 - rmeMapCoord) * TEXTURE_DIMENSIONS.xy), 0),0.01, 1.0);
     }
 
 

shaders/glsl/rain_snow.fragment

@@ -56,11 +56,11 @@ void main()
 
 	vec3 lighting = texture2D( TEXTURE_2, lightingUVs ).rgb;
 
-	float albedoR = albedo.r;
-	float albedoG = albedo.g;
-	float albedoB = albedo.b;
+	//if it is a rain drops then mke them gray
+	if(albedo.b > albedo.r + albedo.g){
+	    albedo.rgb = vec3((albedo.r + albedo.g + albedo.b) / 2.0);
+	}
 
-	albedo.rgb = vec3(albedoR + albedoG + albedoB)/3.0;
 	vec4 finalOutput = albedo;
 	finalOutput.rgb *= lighting.rgb;
 

shaders/glsl/renderchunk.fragment

@@ -27,7 +27,7 @@ varying float isRain;
 varying float isWater;
 varying float isUnderWater;
 varying vec4 color;
-varying vec4 position;// Get pixel position in world space (used for calculate fake normals)
+varying highp vec4 position;// Get pixel position in world space (used for calculate fake normals)
 varying vec4 relativePosition;// Calculates from vec4 position
 //#ifdef FOG
 	varying vec4 fogColor;
@@ -69,15 +69,28 @@ void main()
 
 	vec3 initialNormalVector = calculateRawNormalVector(position.xyz);
 	vec3 normalVector = rotateNormals(initialNormalVector, reliefMap);
-
-	vec4 diffuse = diffuseMap;
-	diffuse.rgb *= color.rgb;
+
+    vec4 diffuse = diffuseMap;
+    #ifndef SEASONS
+
+	    diffuse.rgb *= color.rgb;
+
+    #else
+    	vec2 uv = color.xy;
+	    diffuse.rgb *= mix(vec3(1.0,1.0,1.0), texture2D( TEXTURE_2, uv).rgb*2.0, color.b);
+	    diffuse.rgb *= color.aaa;
+	  //  diffuse.a = 1.0;
+    #endif
+
 
 	float pointLightsMap; float ambientOclusionMap; float fakeShadowMap;
 	readLightMaps(pointLightsMap, ambientOclusionMap, fakeShadowMap, uv1);
-
-	fakeShadowMap += mapCaustics(TEXTURE_0, position.xyz);
 
+    fakeShadowMap = clamp(fakeShadowMap, 0.0, 1.0);
+    if(isUnderWater  > 0.9){
+        fakeShadowMap = ambientOclusionMap; 
+    }
+
 	float  wetness = 0.0;
 	if(isRain > 0.1 && isWater < 0.1){
 		wetness = mapPuddles(TEXTURE_0, position.xz, isRain);	
@@ -124,12 +137,18 @@ void main()
 
 	// Mix lighting
 	vec3 resultLighting = skyLightDiffused.rgb * skyLightDiffused.a * ambientOclusionMap;	
+
+    //this two lines should be executed before building reflection
+	resultLighting += vec3((isHell - isUnderWater )* 0.175);// Ambient highlighting in hell gonna be refflected 
+	resultLighting += pointLightsDiffused * 0.25;//imagine this is a reflection of 25% of an evironment hihglighted by point light
 
 	vec4 skyLightReflected = clamp(buildRawSkyReflection(relativePosition.xyz, resultLighting), 0.0, 1.0);
 
-	resultLighting += pointLightsDiffused;
-	resultLighting += mainLightDiffused.rgb * mainLightDiffused.a * fakeShadowMap * (1.0 - isRain);
-	resultLighting += vec3(isHell * 0.175);// Ambient highlighting in hell
+	resultLighting += pointLightsDiffused * 0.75;// remaining point ligt isnt beign reflected
+
+	resultLighting += mainLightDiffused.rgb * mainLightDiffused.a * fakeShadowMap * (1.0 - isRain + isUnderWater);
+
+	resultLighting += resultLighting * mapCaustics(TEXTURE_0, position.xyz, isUnderWater);
 	diffuse.rgb *= resultLighting.rgb * 1.8 * (1.0 - metalness); 
 
 
@@ -146,8 +165,8 @@ void main()
 
 
 	if(isHell < 0.9){
-		diffuse.rgb = applyBasicFogs(diffuse.rgb, skyLightDiffused.rgb, fogColor.a, milkyFog, isDay, isHell);
-		diffuse.rgb = applyBlueFog(diffuse.rgb, blueFog, isDay, isRain, isWater); 
+	    diffuse.rgb = applyBlueFog(diffuse.rgb, blueFog, isDay, isRain, isWater); 
+		diffuse.rgb = applyBasicFogs(diffuse.rgb, skyLightDiffused.rgb * 2.0, fogColor.a, milkyFog, isDay, isHell);
 	}
 
 	diffuse.rgb = colorCorrection(diffuse.rgb);

shaders/glsl/renderchunk.vertex

@@ -84,59 +84,54 @@ void main()
 	color = COLOR;
 
 	isLeaves = 0.0; 
-	if(fract(position.y) <  0.01){
+	if(fract(position.y) <  0.01 && fract(position.x) < 0.01 && fract(position.z) < 0.01){
 		isLeaves = 1.0;
 	}
 
 
 	isPlantTop = 0.0;
-	if(isLeaves < 0.1 && fract(uv0.y * 16.0) > 0.5){
+	if(isLeaves < 0.1 && fract(uv0.y * 16.0) < 0.5){
 		isPlantTop = 1.0;
 	}
 
 
+#endif //BYPASS_PIXEL_SHADER
 
+#ifdef BLEND
     if(
-		color.b > color.g * 0.84 
-		&& color.b > color.r * 1.69
+
+		color.b > color.g * 0.8
+
+		&& color.b > color.r * 1.13
 	){
 		isWater = 1.0;
 	}
-	float spruce = 0.0;
-	if(color.b > 0.9 && color.r > 0.5 && color.g > 0.01 && color.g < 0.2 && color.r < 0.95){
-		isWater = 0.0;
-		spruce = 1.0;
-		color.rgb = vec3(1.0);
-	}
+
 
 	if(isWater > 0.9){
 		highp float t = TIME;
 		highp vec3 rawPosCorrected = position.xyz / 2.5463;//2.5463 - chunk scale (detaching prevention)
-		highp vec2 impulsesMovingSpeed = vec2(1.0);
-		highp vec2 impulsesFreq = vec2(1.0);
+//		highp vec2 impulsesMovingSpeed = vec2(1.0);
+//		highp vec2 impulsesFreq = vec2(1.0);
 
-		highp vec2 wavesMovingSpeed = vec2(1.0, 0.25);
-		highp vec2 wavesFreq = vec2(2.0, 1.0);
-		highp float wavesScale = 0.05;
+		highp vec2 wavesMovingSpeed = vec2(3.0, 3.0);
+		highp vec2 wavesFreq = vec2(3.0, 3.0);
+		highp float wavesScale = 0.035;
 
-		highp vec2 i = sin(t * impulsesMovingSpeed + rawPosCorrected.xz * impulsesFreq);
-		highp vec2 f = pow(sin(t * wavesMovingSpeed + rawPosCorrected.xz * wavesFreq), vec2(3.0)) * wavesScale;
+//		highp vec2 i = sin(t * impulsesMovingSpeed + rawPosCorrected.xz * impulsesFreq);
+		highp vec2 f = sin(t * wavesMovingSpeed + rawPosCorrected.xz * wavesFreq) * wavesScale;
 
-		position.y += (f.x + f.y) /* (f.x + f.y)*/;
+		position.y += (f.x + f.y)/* (f.x + f.y)*/;
 	}
-
-#endif //BYPASS_PIXEL_SHADER
-
-
-
+#endif
 
 
 
 // Leaves and grass
 #if defined ALPHA_TEST
 
 	//if((isWater < 0.1 && color.g > color.r) || spruce > 0.5 ){
-	if((isLeaves > 0.5 || isPlantTop > 0.5) && isWater < 0.1 && color.g > color.r){
+	if((isLeaves > 0.5 || isPlantTop > 0.5) && color.g > (color.r + color.b)/2.0 ){
 		// Wind waves
 		vec3 correctedRawPos = position.xyz / 2.5463;//2.55 - size of chunk (prevent leaves detaching)
 		highp float t = TIME;
@@ -225,12 +220,11 @@ if(isUnderWater > 0.9){
 	blueFog.a = clamp(ownFogAlpha, 0.0, 0.75);
 
 	milkyFog.rgb = mix(vec3(2.0), vec3(0.5), isRain);
-	float milkyFogHeightShift = -32.0 + isRain * 128.0;
-	float milkyFogHeightAtenuation = 1.0/64.0;
-	milkyFog.a = (relativePosition.y + milkyFogHeightShift * ownFogAlpha) * milkyFogHeightAtenuation;
-	milkyFog.a = pow(clamp(milkyFog.a, 0.0, 1.0), 1.5);
-	milkyFog.a *= 0.7 + isRain*0.3;
-	//milkyFog.a *= ownFogAlpha;
+	float milkyFogHeightShift = -RENDER_DISTANCE/8.0 + isRain * 128.0;
+	float milkyFogHeightAtenuation = 1.0 / (RENDER_DISTANCE / 4.0);
+	milkyFog.a = (relativePosition.y + milkyFogHeightShift) * milkyFogHeightAtenuation;
+	milkyFog.a = clamp(milkyFog.a, 0.0, 1.0);
+	milkyFog.a *= 0.3 + isRain*0.7;
 	milkyFog.a = clamp(milkyFog.a, 0.0, 1.0);
 
 

splashes.json

@@ -1,5 +1,5 @@
 {
   "splashes": [
-     "OSBES v0.12.1",
+     "OSBES v0.12.2"
   ]
 }