Use texelFetch/textureLoad for WebGL2/WGSL

packages/dev/core/src/Lights/Shadows/shadowGenerator.ts

@@ -29,6 +29,7 @@ import type { Camera } from "../../Cameras/camera";
 import { AddClipPlaneUniforms, BindClipPlane, PrepareStringDefinesForClipPlanes } from "../../Materials/clipPlaneMaterialHelper";
 import type { BaseTexture } from "../../Materials/Textures/baseTexture";
 import {
+    BindBonesParameters,
     BindMorphTargetParameters,
     BindSceneUniformBuffer,
     PrepareDefinesAndAttributesForMorphTargets,
@@ -1362,22 +1363,7 @@ export class ShadowGenerator implements IShadowGenerator {
                 }
 
                 // Bones
-                if (renderingMesh.useBones && renderingMesh.computeBonesUsingShaders && renderingMesh.skeleton) {
-                    const skeleton = renderingMesh.skeleton;
-
-                    if (skeleton.isUsingTextureForMatrices) {
-                        const boneTexture = skeleton.getTransformMatrixTexture(renderingMesh);
-
-                        if (!boneTexture) {
-                            return;
-                        }
-
-                        effect.setTexture("boneSampler", boneTexture);
-                        effect.setFloat("boneTextureWidth", 4.0 * (skeleton.bones.length + 1));
-                    } else {
-                        effect.setMatrices("mBones", skeleton.getTransformMatrices(renderingMesh));
-                    }
-                }
+                BindBonesParameters(renderingMesh, effect);
 
                 // Morph targets
                 BindMorphTargetParameters(renderingMesh, effect);

packages/dev/core/src/Shaders/ShadersInclude/bakedVertexAnimationDeclaration.fx

@@ -1,6 +1,8 @@
 #ifdef BAKED_VERTEX_ANIMATION_TEXTURE
     uniform float bakedVertexAnimationTime;
-    uniform vec2 bakedVertexAnimationTextureSizeInverted;
+    #if !defined(WEBGL2) && !defined(WEBGPU)
+        uniform vec2 bakedVertexAnimationTextureSizeInverted;
+    #endif
     uniform vec4 bakedVertexAnimationSettings;
     uniform sampler2D bakedVertexAnimationTexture;
 
@@ -11,13 +13,23 @@
     #define inline
     mat4 readMatrixFromRawSamplerVAT(sampler2D smp, float index, float frame)
     {
-        float offset = index * 4.0;
-        float frameUV = (frame + 0.5) * bakedVertexAnimationTextureSizeInverted.y;
-        float dx = bakedVertexAnimationTextureSizeInverted.x;
-        vec4 m0 = texture2D(smp, vec2(dx * (offset + 0.5), frameUV));
-        vec4 m1 = texture2D(smp, vec2(dx * (offset + 1.5), frameUV));
-        vec4 m2 = texture2D(smp, vec2(dx * (offset + 2.5), frameUV));
-        vec4 m3 = texture2D(smp, vec2(dx * (offset + 3.5), frameUV));
-        return mat4(m0, m1, m2, m3);
+        #if defined(WEBGL2) || defined(WEBGPU)
+            int offset = int(index) * 4;
+            int frameUV = int(frame);
+            vec4 m0 = texelFetch(smp, ivec2(offset + 0, frameUV), 0);
+            vec4 m1 = texelFetch(smp, ivec2(offset + 1, frameUV), 0);
+            vec4 m2 = texelFetch(smp, ivec2(offset + 2, frameUV), 0);
+            vec4 m3 = texelFetch(smp, ivec2(offset + 3, frameUV), 0);
+            return mat4(m0, m1, m2, m3);
+        #else
+            float offset = index * 4.0;
+            float frameUV = (frame + 0.5) * bakedVertexAnimationTextureSizeInverted.y;
+            float dx = bakedVertexAnimationTextureSizeInverted.x;
+            vec4 m0 = texture2D(smp, vec2(dx * (offset + 0.5), frameUV));
+            vec4 m1 = texture2D(smp, vec2(dx * (offset + 1.5), frameUV));
+            vec4 m2 = texture2D(smp, vec2(dx * (offset + 2.5), frameUV));
+            vec4 m3 = texture2D(smp, vec2(dx * (offset + 3.5), frameUV));
+            return mat4(m0, m1, m2, m3);
+        #endif
     }
 #endif

packages/dev/core/src/Shaders/ShadersInclude/bonesDeclaration.fx

@@ -9,7 +9,9 @@
     #ifndef BAKED_VERTEX_ANIMATION_TEXTURE
         #ifdef BONETEXTURE
             uniform highp sampler2D boneSampler;
-            uniform float boneTextureWidth;
+            #if !defined(WEBGL2) && !defined(WEBGPU)
+                uniform float boneTextureWidth;
+            #endif
         #else
             uniform mat4 mBones[BonesPerMesh];
         #endif
@@ -22,15 +24,26 @@
             #define inline
             mat4 readMatrixFromRawSampler(sampler2D smp, float index)
             {
-                float offset = index  * 4.0;
-                float dx = 1.0 / boneTextureWidth;
+                #if defined(WEBGL2) || defined(WEBGPU)
+                    int offset = int(index)  * 4;	
 
-                vec4 m0 = texture2D(smp, vec2(dx * (offset + 0.5), 0.));
-                vec4 m1 = texture2D(smp, vec2(dx * (offset + 1.5), 0.));
-                vec4 m2 = texture2D(smp, vec2(dx * (offset + 2.5), 0.));
-                vec4 m3 = texture2D(smp, vec2(dx * (offset + 3.5), 0.));
+                    vec4 m0 = texelFetch(smp, ivec2(offset + 0, 0), 0);
+                    vec4 m1 = texelFetch(smp, ivec2(offset + 1, 0), 0);
+                    vec4 m2 = texelFetch(smp, ivec2(offset + 2, 0), 0);
+                    vec4 m3 = texelFetch(smp, ivec2(offset + 3, 0), 0);
 
-                return mat4(m0, m1, m2, m3);
+                    return mat4(m0, m1, m2, m3);
+                #else
+                    float offset = index  * 4.0;
+                    float dx = 1.0 / boneTextureWidth;
+
+                    vec4 m0 = texture2D(smp, vec2(dx * (offset + 0.5), 0.));
+                    vec4 m1 = texture2D(smp, vec2(dx * (offset + 1.5), 0.));
+                    vec4 m2 = texture2D(smp, vec2(dx * (offset + 2.5), 0.));
+                    vec4 m3 = texture2D(smp, vec2(dx * (offset + 3.5), 0.));
+
+                    return mat4(m0, m1, m2, m3);
+                #endif
             }
         #endif
     #endif

packages/dev/core/src/Shaders/ShadersInclude/morphTargetsVertexGlobalDeclaration.fx

@@ -8,18 +8,32 @@
 
 		vec3 readVector3FromRawSampler(int targetIndex, float vertexIndex)
 		{			
-			float y = floor(vertexIndex / morphTargetTextureInfo.y);
-			float x = vertexIndex - y * morphTargetTextureInfo.y;
-			vec3 textureUV = vec3((x + 0.5) / morphTargetTextureInfo.y, (y + 0.5) / morphTargetTextureInfo.z, morphTargetTextureIndices[targetIndex]);
-			return texture(morphTargets, textureUV).xyz;
+			#if defined(WEBGL2) || defined(WEBGPU)
+				int textureWidth = int(morphTargetTextureInfo.y);
+				int y = int(vertexIndex) / textureWidth;
+				int x = int(vertexIndex) % textureWidth;
+				return texelFetch(morphTargets, ivec3(x, y, int(morphTargetTextureIndices[targetIndex])), 0).xyz;
+			#else
+				float y = floor(vertexIndex / morphTargetTextureInfo.y);
+				float x = vertexIndex - y * morphTargetTextureInfo.y;
+				vec3 textureUV = vec3((x + 0.5) / morphTargetTextureInfo.y, (y + 0.5) / morphTargetTextureInfo.z, morphTargetTextureIndices[targetIndex]);
+				return texture(morphTargets, textureUV).xyz;
+			#endif
 		}
 
 		vec4 readVector4FromRawSampler(int targetIndex, float vertexIndex)
 		{			
-			float y = floor(vertexIndex / morphTargetTextureInfo.y);
-			float x = vertexIndex - y * morphTargetTextureInfo.y;
-			vec3 textureUV = vec3((x + 0.5) / morphTargetTextureInfo.y, (y + 0.5) / morphTargetTextureInfo.z, morphTargetTextureIndices[targetIndex]);
-			return texture(morphTargets, textureUV);
+			#if defined(WEBGL2) || defined(WEBGPU)
+				int textureWidth = int(morphTargetTextureInfo.y);
+				int y = int(vertexIndex) / textureWidth;
+				int x = int(vertexIndex) % textureWidth;
+				return texelFetch(morphTargets, ivec3(x, y, int(morphTargetTextureIndices[targetIndex])), 0);
+			#else
+				float y = floor(vertexIndex / morphTargetTextureInfo.y);
+				float x = vertexIndex - y * morphTargetTextureInfo.y;
+				vec3 textureUV = vec3((x + 0.5) / morphTargetTextureInfo.y, (y + 0.5) / morphTargetTextureInfo.z, morphTargetTextureIndices[targetIndex]);
+				return texture(morphTargets, textureUV);
+			#endif
 		}
 	#endif
 #endif

packages/dev/core/src/ShadersWGSL/ShadersInclude/bakedVertexAnimationDeclaration.fx

@@ -1,6 +1,5 @@
 #ifdef BAKED_VERTEX_ANIMATION_TEXTURE
     uniform bakedVertexAnimationTime: f32;
-    uniform bakedVertexAnimationTextureSizeInverted: vec2<f32>;
     uniform bakedVertexAnimationSettings: vec4<f32>;
     var bakedVertexAnimationTexture : texture_2d<f32>;
 

packages/dev/core/src/ShadersWGSL/ShadersInclude/bonesDeclaration.fx

@@ -9,7 +9,6 @@
     #ifndef BAKED_VERTEX_ANIMATION_TEXTURE
         #ifdef BONETEXTURE
             var boneSampler : texture_2d<f32>;
-            uniform boneTextureWidth : f32;
         #else
             uniform mBones : array<mat4x4f, BonesPerMesh>;
         #endif

packages/dev/core/src/ShadersWGSL/ShadersInclude/morphTargetsVertexGlobalDeclaration.fx

@@ -6,22 +6,21 @@
 		uniform morphTargetTextureInfo : vec3<f32>;
 
 		var morphTargets : texture_2d_array<f32>;
-        var morphTargetsSampler : sampler;
 
 		fn readVector3FromRawSampler(targetIndex : i32, vertexIndex : f32) -> vec3<f32>
 		{			
-			let y = floor(vertexIndex / uniforms.morphTargetTextureInfo.y);
-			let x = vertexIndex - y * uniforms.morphTargetTextureInfo.y;
-			let textureUV = vec2<f32>((x + 0.5) / uniforms.morphTargetTextureInfo.y, (y + 0.5) / uniforms.morphTargetTextureInfo.z);
-			return textureSampleLevel(morphTargets, morphTargetsSampler, textureUV, i32(uniforms.morphTargetTextureIndices[targetIndex]), 0.0).xyz;
+			let textureWidth: i32 = i32(uniforms.morphTargetTextureInfo.y);
+			let y: i32 = i32(vertexIndex) / textureWidth;
+			let x: i32 = i32(vertexIndex) % textureWidth;
+			return textureLoad(morphTargets, vec2i(x, y), i32(uniforms.morphTargetTextureIndices[targetIndex]), 0).xyz;
 		}
 
 		fn readVector4FromRawSampler(targetIndex : i32, vertexIndex : f32) -> vec4<f32>
-		{			
-			let y = floor(vertexIndex / uniforms.morphTargetTextureInfo.y);
-			let x = vertexIndex - y * uniforms.morphTargetTextureInfo.y;
-			let textureUV = vec2<f32>((x + 0.5) / uniforms.morphTargetTextureInfo.y, (y + 0.5) / uniforms.morphTargetTextureInfo.z);
-			return textureSampleLevel(morphTargets, morphTargetsSampler, textureUV, i32(uniforms.morphTargetTextureIndices[targetIndex]), 0.0);
+		{		
+			let textureWidth: i32 = i32(uniforms.morphTargetTextureInfo.y);	
+			let y: i32 = i32(vertexIndex) / textureWidth;
+			let x: i32 = i32(vertexIndex) % textureWidth;
+			return textureLoad(morphTargets, vec2i(x, y), i32(uniforms.morphTargetTextureIndices[targetIndex]), 0);
 		}
 	#endif
 #endif

packages/dev/core/src/ShadersWGSL/boundingInfo.compute.fx

@@ -98,20 +98,20 @@ struct Settings {
 #ifdef MORPHTARGETS
 fn readVector3FromRawSampler(targetIndex : i32, vertexIndex : u32) -> vec3f
 {			
-    let vertexID = f32(vertexIndex) * settings.morphTargetTextureInfo.x;
-    let y = floor(vertexID / settings.morphTargetTextureInfo.y);
-    let x = vertexID - y * settings.morphTargetTextureInfo.y;
-    let textureUV = vec2<i32>(i32(x), i32(y));
-    return textureLoad(morphTargets, textureUV, i32(morphTargetTextureIndices[targetIndex]), 0).xyz;
+    let vertexID: u32 = vertexIndex * u32(settings.morphTargetTextureInfo.x);
+    let textureWidth: u32 = u32(settings.morphTargetTextureInfo.y);
+    let y: u32 = vertexID / textureWidth;
+    let x: u32 = vertexID % textureWidth;
+    return textureLoad(morphTargets, vec2u(x, y), u32(morphTargetTextureIndices[targetIndex]), 0).xyz;
 }
 
 fn readVector4FromRawSampler(targetIndex : i32, vertexIndex : u32) -> vec4f
 {			
-    let vertexID = f32(vertexIndex) * settings.morphTargetTextureInfo.x;
-    let y = floor(vertexID / settings.morphTargetTextureInfo.y);
-    let x = vertexID - y * settings.morphTargetTextureInfo.y;
-    let textureUV = vec2<i32>(i32(x), i32(y));
-    return textureLoad(morphTargets, textureUV, i32(morphTargetTextureIndices[targetIndex]), 0);
+    let vertexID: u32 = vertexIndex * u32(settings.morphTargetTextureInfo.x);
+    let textureWidth: u32 = u32(settings.morphTargetTextureInfo.y);
+    let y: u32 = vertexID / textureWidth;
+    let x: u32 = vertexID % textureWidth;
+    return textureLoad(morphTargets, vec2u(x, y), u32(morphTargetTextureIndices[targetIndex]), 0);
 }
 #endif