2.0 - WebGPU Only

src/shaders/atmosphericScatteringFragment.glsl

@@ -15,7 +15,7 @@
 //  You should have received a copy of the GNU Affero General Public License
 //  along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
-precision lowp float;
+precision highp float;
 
 #define DISABLE_UNIFORMITY_ANALYSIS
 
@@ -39,8 +39,6 @@ uniform sampler2D atmosphereLUT;
 
 #include "./utils/atmosphere.glsl";
 
-#include "./utils/remap.glsl";
-
 #include "./utils/worldFromUV.glsl";
 
 #include "./utils/rayIntersectSphere.glsl";
@@ -162,12 +160,12 @@ void main() {
 
     float depth = texture2D(depthSampler, vUV).r;// the depth corresponding to the pixel in the depth map
 
-    vec3 pixelWorldPosition = worldFromUV(vUV, camera_inverseProjection, camera_inverseView);// the pixel position in world space (near plane)
-
-    vec3 rayDir = normalize(pixelWorldPosition - camera_position);// normalized direction of the ray
+    vec3 pixelWorldPosition = worldFromUV(vUV, depth, camera_inverseProjectionView);// the pixel position in world space (near plane)
 
     // actual depth of the scene
-    float maximumDistance = length(pixelWorldPosition - camera_position) * remap(depth, 0.0, 1.0, camera_near, camera_far);
+    float maximumDistance = length(pixelWorldPosition - camera_position);
+
+    vec3 rayDir = normalize(worldFromUV(vUV, 1.0, camera_inverseProjectionView) - camera_position);
 
     // Cohabitation avec le shader d'océan (un jour je merge)
     float waterImpact, waterEscape;

src/shaders/blackhole.glsl

@@ -32,8 +32,6 @@ uniform mat4 starfieldRotation;
 
 #include "./utils/camera.glsl";
 
-#include "./utils/remap.glsl";
-
 #include "./utils/worldFromUV.glsl";
 
 #include "./utils/uvFromWorld.glsl";
@@ -156,14 +154,13 @@ float customLength(vec3 v) {
 
 void main() {
     vec4 screenColor = texture2D(textureSampler, vUV);// the current screen color
-
-    vec3 pixelWorldPosition = worldFromUV(vUV, camera_inverseProjection, camera_inverseView);// the pixel position in world space (near plane)
-    vec3 rayDir = normalize(pixelWorldPosition - camera_position);// normalized direction of the ray
-
     float depth = texture2D(depthSampler, vUV).r;// the depth corresponding to the pixel in the depth map
 
+    vec3 pixelWorldPosition = worldFromUV(vUV, depth, camera_inverseProjectionView);// the pixel position in world space (near plane)
+    vec3 rayDir = normalize(worldFromUV(vUV, 1.0, camera_inverseProjectionView) - camera_position);// normalized direction of the ray
+
     // actual depth of the scene
-    float maximumDistance = length(pixelWorldPosition - camera_position) * remap(depth, 0.0, 1.0, camera_near, camera_far);
+    float maximumDistance = length(pixelWorldPosition - camera_position);
 
     float maxBendDistance = max(accretionDiskRadius * 3.0, schwarzschildRadius * 15.0);
 
@@ -255,17 +252,17 @@ void main() {
 
     // getting the screen coordinate of the end of the bended ray
     vec2 uv = uvFromWorld(rayPositionBlackHoleSpace + object_position, camera_projection, camera_view);
+    float depthEndRay = texture2D(depthSampler, uv).r;// the depth corresponding to the pixel in the depth map
     // check if there is an object occlusion
-    vec3 pixelWorldPositionEndRay = worldFromUV(uv, camera_inverseProjection, camera_inverseView);// the pixel position in world space (near plane)
+    vec3 pixelWorldPositionEndRay = worldFromUV(uv, depthEndRay, camera_inverseProjectionView);// the pixel position in world space (near plane)
     vec3 rayDirToEndRay = normalize(pixelWorldPositionEndRay - camera_position);// normalized direction of the ray
 
-    float depthEndRay = texture2D(depthSampler, uv).r;// the depth corresponding to the pixel in the depth map
     for(int i = 0; i < 10; i++) {
         vec2 offset = (vec2(hash(float(i)), hash(float(i + 1))) - 0.5) * 0.01;
         depthEndRay = min(depthEndRay, texture2D(depthSampler, uv + offset).r);
     }
     // closest physical point from the camera in the direction of the pixel (occlusion)
-    vec3 closestPointEndRay = (pixelWorldPositionEndRay - camera_position) * remap(depthEndRay, 0.0, 1.0, camera_near, camera_far);
+    vec3 closestPointEndRay = pixelWorldPositionEndRay - camera_position;
     float maximumDistanceEndRay = length(closestPointEndRay);// the maxium ray length due to occlusion
     float BHDistance = length(camera_position - object_position);
 

src/shaders/flatCloudsFragment.glsl

@@ -49,8 +49,6 @@ uniform float time;
 
 #include "./utils/saturate.glsl";
 
-#include "./utils/remap.glsl";
-
 #include "./utils/worldFromUV.glsl";
 
 #include "./utils/rayIntersectSphere.glsl";
@@ -164,12 +162,12 @@ void main() {
 
     float depth = texture2D(depthSampler, vUV).r;// the depth corresponding to the pixel in the depth map
 
-    vec3 pixelWorldPosition = worldFromUV(vUV, camera_inverseProjection, camera_inverseView);// the pixel position in world space (near plane)
+    vec3 pixelWorldPosition = worldFromUV(vUV, depth, camera_inverseProjectionView);// the pixel position in world space (near plane)
 
     // closest physical point from the camera in the direction of the pixel (occlusion)
-    float maximumDistance = length(pixelWorldPosition - camera_position) * remap(depth, 0.0, 1.0, camera_near, camera_far);
+    float maximumDistance = length(pixelWorldPosition - camera_position);
 
-    vec3 rayDir = normalize(pixelWorldPosition - camera_position);// normalized direction of the ray
+    vec3 rayDir = normalize(worldFromUV(vUV, 1.0, camera_inverseProjectionView) - camera_position);// normalized direction of the ray
 
     vec3 closestPoint = camera_position + rayDir * maximumDistance;
     float t0, t1;

src/shaders/grassMaterial/grassVertex.glsl

@@ -37,7 +37,6 @@ uniform sampler2D perlinNoise;
 varying vec3 vPosition;
 varying vec3 vPositionW;
 
-varying mat4 normalMatrix;
 varying vec3 vNormalW;
 
 varying float vPlanetNdl;

src/shaders/juliaSet.glsl

@@ -122,12 +122,14 @@ float contrast(float val, float contrast_offset, float contrast_mid_level)
 void main() {
     vec4 screenColor = texture2D(textureSampler, vUV);// the current screen color
 
-    vec3 pixelWorldPosition = worldFromUV(vUV, camera_inverseProjection, camera_inverseView);// the pixel position in world space (near plane)
-    vec3 rayDir = normalize(pixelWorldPosition - camera_position);// normalized direction of the ray
-
     float depth = texture2D(depthSampler, vUV).r;// the depth corresponding to the pixel in the depth map
+
+    vec3 pixelWorldPosition = worldFromUV(vUV, depth, camera_inverseProjectionView);// the pixel position in world space (near plane)
+
     // actual depth of the scene
-    float maximumDistance = length(pixelWorldPosition - camera_position) * remap(depth, 0.0, 1.0, camera_near, camera_far);
+    float maximumDistance = length(pixelWorldPosition - camera_position);
+
+    vec3 rayDir = normalize(worldFromUV(vUV, 1.0, camera_inverseProjectionView) - camera_position);
 
     float impactPoint, escapePoint;
     if (!(rayIntersectSphere(camera_position, rayDir, object_position, object_radius * object_scaling_determinant, impactPoint, escapePoint))) {

src/shaders/lensflare.glsl

@@ -112,8 +112,8 @@ void main() {
         return;
     }
 
-    vec3 pixelWorldPosition = worldFromUV(vUV, camera_inverseProjection, camera_inverseView);// the pixel position in world space (near plane)
-    vec3 rayDir = normalize(pixelWorldPosition - camera_position);
+    vec3 pixelWorldPosition = worldFromUV(vUV, 1.0, camera_inverseProjectionView);// the pixel position in world space (near plane)
+    vec3 rayDir = normalize(worldFromUV(vUV, 1.0, camera_inverseProjectionView) - camera_position);
 
     vec3 objectDirection = normalize(object_position - camera_position);
 

src/shaders/mandelbulb.glsl

@@ -34,8 +34,6 @@ uniform sampler2D depthSampler;
 
 #include "./utils/camera.glsl";
 
-#include "./utils/remap.glsl";
-
 #include "./utils/worldFromUV.glsl";
 
 #include "./utils/rayIntersectSphere.glsl";
@@ -120,12 +118,14 @@ float contrast(float val, float contrast_offset, float contrast_mid_level)
 void main() {
     vec4 screenColor = texture2D(textureSampler, vUV);// the current screen color
 
-    vec3 pixelWorldPosition = worldFromUV(vUV, camera_inverseProjection, camera_inverseView);// the pixel position in world space (near plane)
-    vec3 rayDir = normalize(pixelWorldPosition - camera_position);// normalized direction of the ray
-
     float depth = texture2D(depthSampler, vUV).r;// the depth corresponding to the pixel in the depth map
+
+    vec3 pixelWorldPosition = worldFromUV(vUV, depth, camera_inverseProjectionView);// the pixel position in world space (near plane)
+
     // actual depth of the scene
-    float maximumDistance = length(pixelWorldPosition - camera_position) * remap(depth, 0.0, 1.0, camera_near, camera_far);
+    float maximumDistance = length(pixelWorldPosition - camera_position);
+
+    vec3 rayDir = normalize(worldFromUV(vUV, 1.0, camera_inverseProjectionView) - camera_position);
 
     float impactPoint, escapePoint;
     if (!(rayIntersectSphere(camera_position, rayDir, object_position, object_radius * object_scaling_determinant, impactPoint, escapePoint))) {

src/shaders/matterjet.glsl

@@ -30,8 +30,6 @@ uniform float time;
 
 #include "./utils/rotateAround.glsl";
 
-#include "./utils/remap.glsl";
-
 #include "./utils/worldFromUV.glsl";
 
 #include "./utils/removeAxialTilt.glsl";
@@ -116,12 +114,12 @@ void main() {
 
     float depth = texture2D(depthSampler, vUV).r;// the depth corresponding to the pixel in the depth map
 
-    vec3 pixelWorldPosition = worldFromUV(vUV, camera_inverseProjection, camera_inverseView);// the pixel position in world space (near plane)
+    vec3 pixelWorldPosition = worldFromUV(vUV, depth, camera_inverseProjectionView);// the pixel position in world space (near plane)
 
     // actual depth of the scene
-    float maximumDistance = length(pixelWorldPosition - camera_position) * remap(depth, 0.0, 1.0, camera_near, camera_far);
+    float maximumDistance = length(pixelWorldPosition - camera_position);
 
-    vec3 rayDir = normalize(pixelWorldPosition - camera_position);// normalized direction of the ray
+    vec3 rayDir = normalize(worldFromUV(vUV, 1.0, camera_inverseProjectionView) - camera_position);// normalized direction of the ray
 
     vec4 finalColor = screenColor;
 

src/shaders/metalSectionMaterial/fragment.glsl

@@ -38,12 +38,14 @@ void main() {
 
     vec2 uv = vec2(fract(6.0 * vUV.x), fract(vPosition.y / 50.0));
 
+    float gamma = 2.2;
+
     vec3 normalFromMap = texture(normalMap, uv).rgb;
     normalFromMap.y = 1.0 - normalFromMap.y;
     normalFromMap = normalFromMap * 2.0 - 1.0;
     vec3 normalW = normalize(vTBN * normalFromMap);
 
-    vec3 albedo = pow(texture(albedoMap, uv).rgb, vec3(2.2));
+    vec3 albedo = pow(texture(albedoMap, uv).rgb, vec3(gamma));
     float roughness = texture(roughnessMap, uv).r;
     float metallic = texture(metallicMap, uv).r;
 
@@ -53,7 +55,7 @@ void main() {
         Lo += calculateLight(albedo, normalW, roughness, metallic, lightDirectionW, viewDirectionW, star_colors[i]);
     }
 
-    Lo = pow(Lo, vec3(1.0 / 2.2));
+    Lo = pow(Lo, vec3(1.0 / gamma));
 
     gl_FragColor = vec4(Lo, 1.0);
 }

src/shaders/metalSectionMaterial/vertex.glsl

@@ -22,7 +22,6 @@ attribute vec3 normal;
 attribute vec2 uv;
 
 uniform mat4 world;
-uniform mat4 view;
 uniform mat4 worldViewProjection;
 
 varying vec3 vPositionW;

src/shaders/oceanFragment.glsl

@@ -43,8 +43,6 @@ uniform float ocean_waveBlendingSharpness;
 
 uniform float time;
 
-#include "./utils/remap.glsl";
-
 #include "./utils/worldFromUV.glsl";
 
 #include "./utils/rayIntersectSphere.glsl";
@@ -68,12 +66,12 @@ void main() {
 
     float depth = texture2D(depthSampler, vUV).r;// the depth corresponding to the pixel in the depth map
 
-    vec3 pixelWorldPosition = worldFromUV(vUV, camera_inverseProjection, camera_inverseView);// the pixel position in world space (near plane)
+    vec3 pixelWorldPosition = worldFromUV(vUV, depth, camera_inverseProjectionView);// the pixel position in world space (near plane)
 
     // actual depth of the scene
-    float maximumDistance = length(pixelWorldPosition - camera_position) * remap(depth, 0.0, 1.0, camera_near, camera_far);
+    float maximumDistance = length(pixelWorldPosition - camera_position);
 
-    vec3 rayDir = normalize(pixelWorldPosition - camera_position);// normalized direction of the ray
+    vec3 rayDir = normalize(worldFromUV(vUV, 1.0, camera_inverseProjectionView) - camera_position);
 
     vec4 finalColor = screenColor;
 
@@ -109,7 +107,7 @@ void main() {
         vec3 ambiant = mix(oceanColor, screenColor.rgb, alpha);
 
         // if the camera is not inside the ocean
-        if(impactPoint > 0.0) {
+        if (impactPoint > 0.0) {
             // color of the sky
             vec3 reflectedSkyColor = vec3(0.6, 0.8, 0.95);
 

src/shaders/ringsFragment.glsl

@@ -45,12 +45,12 @@ void main() {
 
     float depth = texture2D(depthSampler, vUV).r;// the depth corresponding to the pixel in the depth map
 
-    vec3 pixelWorldPosition = worldFromUV(vUV, camera_inverseProjection, camera_inverseView);// the pixel position in world space (near plane)
+    vec3 pixelWorldPosition = worldFromUV(vUV, depth, camera_inverseProjectionView);// the pixel position in world space (near plane)
 
     // actual depth of the scene
-    float maximumDistance = length(pixelWorldPosition - camera_position) * remap(depth, 0.0, 1.0, camera_near, camera_far);
+    float maximumDistance = length(pixelWorldPosition - camera_position);
 
-    vec3 rayDir = normalize(pixelWorldPosition - camera_position);// normalized direction of the ray
+    vec3 rayDir = normalize(worldFromUV(vUV, 1.0, camera_inverseProjectionView) - camera_position);// normalized direction of the ray
 
     vec4 finalColor = screenColor;
 

src/shaders/shadowFragment.glsl

@@ -87,12 +87,12 @@ void main() {
 
     float depth = texture2D(depthSampler, vUV).r;// the depth corresponding to the pixel in the depth map
 
-    vec3 pixelWorldPosition = worldFromUV(vUV, camera_inverseProjection, camera_inverseView);// the pixel position in world space (near plane)
+    vec3 pixelWorldPosition = worldFromUV(vUV, depth, camera_inverseProjectionView);// the pixel position in world space (near plane)
 
     // closest physical point from the camera in the direction of the pixel (occlusion)
-    float maximumDistance = length(pixelWorldPosition - camera_position) * remap(depth, 0.0, 1.0, camera_near, camera_far);
+    float maximumDistance = length(pixelWorldPosition - camera_position);
 
-    vec3 rayDir = normalize(pixelWorldPosition - camera_position);// normalized direction of the ray
+    vec3 rayDir = normalize(worldFromUV(vUV, 1.0, camera_inverseProjectionView) - camera_position);// normalized direction of the ray
 
     vec4 finalColor = screenColor;
 

src/shaders/sierpinski.glsl

@@ -36,8 +36,6 @@ uniform sampler2D depthSampler;
 
 #include "./utils/camera.glsl";
 
-#include "./utils/remap.glsl";
-
 #include "./utils/worldFromUV.glsl";
 
 #include "./utils/rayIntersectSphere.glsl";
@@ -127,12 +125,13 @@ vec3 estimate_normal(const vec3 p, const float delta)
 void main() {
     vec4 screenColor = texture2D(textureSampler, vUV);// the current screen color
 
-    vec3 pixelWorldPosition = worldFromUV(vUV, camera_inverseProjection, camera_inverseView);// the pixel position in world space (near plane)
-    vec3 rayDir = normalize(pixelWorldPosition - camera_position);// normalized direction of the ray
-
     float depth = texture2D(depthSampler, vUV).r;// the depth corresponding to the pixel in the depth map
+
+    vec3 pixelWorldPosition = worldFromUV(vUV, depth, camera_inverseProjectionView);// the pixel position in world space (near plane)
+    vec3 rayDir = normalize(pixelWorldPosition - cameraPosition);// normalized direction of the ray
+
     // actual depth of the scene
-    float maximumDistance = length(pixelWorldPosition - camera_position) * remap(depth, 0.0, 1.0, camera_near, camera_far);
+    float maximumDistance = length(pixelWorldPosition - camera_position);
 
     float impactPoint, escapePoint;
     if (!(rayIntersectSphere(camera_position, rayDir, object_position, planetRadius, impactPoint, escapePoint))) {

src/shaders/solarPanelMaterial/fragment.glsl

@@ -28,12 +28,8 @@ uniform sampler2D roughnessMap;
 
 uniform vec3 cameraPosition;
 
-#include "../utils/pi.glsl";
-
 #include "../utils/stars.glsl";
 
-#include "../utils/remap.glsl";
-
 #include "../utils/textureNoTile.glsl";
 
 #include "../utils/pbr.glsl";

src/shaders/solarPanelMaterial/vertex.glsl

@@ -21,17 +21,16 @@ attribute vec3 position;
 attribute vec3 normal;
 
 uniform mat4 world;
-uniform mat4 view;
 uniform mat4 worldViewProjection;
 
 varying vec3 vPositionW;
 varying vec3 vNormalW;
 varying vec3 vPosition;
 
 void main() {
-    gl_Position = worldViewProjection * vec4(position, 1.0);
-
     vPositionW = vec3(world * vec4(position, 1.0));
     vNormalW = vec3(world * vec4(normal, 0.0));
     vPosition = position;
+
+    gl_Position = worldViewProjection * vec4(position, 1.0);
 }

src/shaders/utils/camera.glsl

@@ -18,8 +18,7 @@
 uniform vec3  camera_position;
 uniform mat4  camera_projection;
 uniform mat4  camera_view;
-uniform mat4  camera_inverseProjection;
-uniform mat4  camera_inverseView;
+uniform mat4  camera_inverseProjectionView;
 uniform float camera_near;
 uniform float camera_far;
 uniform float camera_fov;

src/shaders/utils/worldFromUV.glsl

@@ -19,10 +19,15 @@
 // This is an evolution from the code found here
 // https://forum.babylonjs.com/t/pixel-position-in-world-space-from-fragment-postprocess-shader-issue/30232
 // also see https://www.babylonjs-playground.com/#1PHYB0#318 for smaller scale testing
+// also see https://forum.babylonjs.com/t/clip-space-to-world-space-with-non-linear-reverse-depth-buffer-with-webgpu/48892/5 for the ultimate version
 // This is a revised version that works with the reverse depth buffer
-vec3 worldFromUV(vec2 pos, mat4 inverseProjection, mat4 inverseView) {
-    vec4 ndc = vec4(pos.xy * 2.0 - 1.0, 1.0, 1.0); // get ndc position (z = 1 because the depth buffer is reversed)
-    vec4 posVS = inverseProjection * ndc; // unproject the ndc coordinates : we are now in view space if i understand correctly
-    vec4 posWS = inverseView * posVS; // then we use inverse view to get to world space, division by w to get actual coordinates
-    return  posWS.xyz / posWS.w;
+vec3 worldFromUV(vec2 pos, float depth, mat4 inverseProjectionView) {
+    vec4 ndc = vec4(
+        pos.xy * 2.0 - 1.0,
+        depth,
+        1.0
+    );
+
+    vec4 positionWorldSpace = inverseProjectionView * ndc;
+    return positionWorldSpace.xyz / positionWorldSpace.w;
 }