@rings-webgpu/core 1.0.0 → 1.0.2

package/dist/src/assets/shader/compute/PreFilteredEnvironment_cs.js

@@ -0,0 +1,201 @@
+/**
+ * @internal
+ */
+export let PreFilteredEnvironment_cs = /*wgsl*/ `
+    #include "GenerayRandomDir"
+    #include "BitUtil"
+    #include "MathShader"
+    #include "ColorUtil_frag"
+    
+    struct UniformData{
+        probeSize : f32 ,
+        probeCount : f32 ,
+        width : f32 ,
+        height : f32 ,
+    }
+
+    @group(0) @binding(0) var inputTex : texture_2d<f32>;
+    @group(0) @binding(1) var outputTexture : texture_storage_2d<rgba16float, write>;//rgba32float rgba16float
+    @group(1) @binding(0) var<uniform> uniformData:UniformData;//rgba32float
+
+    var<private> reflectionSize : vec2f ; 
+    var<private> PROBE_SOURCESIZE : vec2f ; 
+    var<private> PROBEMAP_SOURCESIZE : vec2f ; 
+    var<private> aspect : vec2f ; 
+    var<private> spaceV : f32 ; 
+    
+    var<private> i32InputFragCoord : vec2i;
+    var<private> PI_2 : f32 = 3.1415926 * 2.0 ;
+    var<private> PI : f32 = 3.1415926 ;
+
+    var<private> probeSize : f32 = 256.0 ;
+    var<private> probeCount : f32 = 8.0 ;
+    var<private> faceCount : f32 = 6.0 ;
+    var<private> mipCount : f32 = 8.0 ;
+
+    const NUM_SAMPLES = 256u;
+    var<private> inputSize : vec2f ; 
+    var<private> outSize : vec2f ; 
+
+    fn useSphereReflection(){
+        probeSize = uniformData.probeSize ;
+        probeCount = uniformData.probeCount;
+        reflectionSize = vec2f(textureDimensions(inputTex).xy);
+        PROBE_SOURCESIZE = reflectionSize / vec2f(faceCount,probeCount);
+        PROBEMAP_SOURCESIZE = reflectionSize ;
+        aspect = PROBE_SOURCESIZE / PROBEMAP_SOURCESIZE;
+        spaceV = 1.0 / probeCount ;
+    }
+
+    @compute @workgroup_size( 16 , 16 , 1 )
+    fn CsMain( @builtin(workgroup_id) workgroup_id : vec3<u32> , @builtin(global_invocation_id) globalInvocation_id : vec3<u32>)
+    {
+        var color : vec4f ;
+        useSphereReflection();
+        inputSize = vec2f(textureDimensions(inputTex).xy);
+        outSize = vec2f(textureDimensions(outputTexture).xy);
+        
+        i32InputFragCoord = vec2<i32>( globalInvocation_id.xy ) ;
+
+        let i = f32(globalInvocation_id.z) ;
+        let count = floor(i / mipCount) ;
+        preOneMip(count,floor(i % mipCount));
+    }
+
+    fn preOneMip( gid:f32,mip:f32 ){
+        let isuv = vec2f(i32InputFragCoord) ;
+        let suv = isuv * (inputSize/outSize);
+        let probeID = i32(floor(suv.y / probeSize));
+        let mipID = i32((isuv.x / probeSize));
+        if(probeID == i32(gid) && mipID == i32(mip)){
+
+            let sphereUV = vec2f((isuv.x+0.5) % (probeSize),(isuv.y+0.5) % probeSize) / vec2f( (probeSize), probeSize ) ;
+            var dir: vec3<f32> = octDecode(sphereUV * 2.0 - 1.0) ;
+            var preColor = PreFilterEnvMap(mip/mipCount + 0.05,dir,gid);
+            textureStore(outputTexture,vec2i(i32InputFragCoord),preColor);
+        }
+    }
+
+    fn PreFilterEnvMap( roughness2:f32,  R:vec3f , gid:f32 ) -> vec4f
+    {
+        var resColor = vec3f(0.0f);  
+        var resDepth = 0.0;  
+
+        var totalColorWeight = 0.0f;   
+        var totalDepthWeight = 0.0f;   
+        
+        var normal = normalize(R);
+        var toEye = normal;
+        
+        var roughness = roughness2;
+        
+        for(var i=1u;i<=NUM_SAMPLES;i+=1u)
+        {
+            var xi:vec2f = hammersley(i, NUM_SAMPLES) ; 
+            
+            var halfway = ImportanceSampleGGX(xi,roughness,normal);
+            var lightVec = 2.0f * dot( toEye,halfway ) * halfway - toEye;
+            
+            var NdotL = dot( normal, lightVec )  ;
+            var NdotH = max(0.0,dot( normal, halfway ))  ;
+            var HdotV = max(0.0,dot( halfway, toEye ))  ;
+            
+            if( NdotL > 0.0 )
+            {
+                var D = specularD(roughness,NdotH);
+                var pdf = (D * NdotH / (4.0 * HdotV)) + 0.0001f  ;
+
+                var saSample = 1.0f / (f32(NUM_SAMPLES) * pdf + 0.00001f);
+                lightVec = normalize(lightVec);
+
+                var buffer = getReflectionsMap(lightVec,gid); 
+                var rgb = unpack4x8unorm(u32(buffer.z)).rgb;
+                var m = unpack4x8unorm(u32(buffer.w)).z;
+                var rgbmColor = DecodeRGBM(vec4f(rgb,m));
+                resDepth += buffer.x ;
+                resColor += rgbmColor * NdotL;
+
+                totalColorWeight += NdotL;
+                totalDepthWeight += 1.0;
+            }
+        }
+
+        resDepth = resDepth / max(totalDepthWeight,0.001f);
+        resColor = resColor / max(totalColorWeight,0.001f);
+        
+        let rgbm = EncodeRGBM(resColor) ; 
+        let gBuffer = vec4f(
+            resDepth,
+            0.0,
+            f32(pack4x8unorm(vec4f(rgbm.rgb,0.0))),
+            f32(pack4x8unorm(vec4f(0.0,0.0,rgbm.w,0.0))),
+        ) ;
+        return vec4f(resColor,1.0) ;
+    } 
+
+    fn getReflectionsMap(n:vec3<f32>,gid:f32) -> vec4f {
+        var uv = getSampleProbeUV(n,gid);
+        let color = textureLoad(inputTex, vec2i(uv*inputSize) , 0);
+        return color ;
+    }
+
+    fn getSampleProbeUV(dir:vec3<f32>,gid:f32) -> vec2<f32> {
+        let faceId = dir_to_faceId(dir);
+        var targetUV:vec2<f32> = convert_xyz_to_cube_uv(dir.x, dir.y, dir.z);
+        targetUV.x = 1.0 - targetUV.x;
+        let threshould = 0.5 / PROBE_SOURCESIZE;
+        targetUV = clamp(targetUV, vec2<f32>(threshould), vec2<f32>(1.0 - threshould));
+        targetUV.x = f32(faceId) + targetUV.x;
+        let aspect:vec2f = PROBE_SOURCESIZE / PROBEMAP_SOURCESIZE;
+        targetUV = targetUV * aspect ;
+        targetUV.y = targetUV.y + (spaceV * gid);
+        return targetUV ;
+     }
+
+    fn radicalInverse_VdC( bits2:u32) -> f32
+    {
+        var bits = bits2; 
+        bits = (bits << 16u) | (bits >> 16u);
+        bits = ((bits & 0x55555555u) << 1u) | ((bits & 0xAAAAAAAAu) >> 1u);
+        bits = ((bits & 0x33333333u) << 2u) | ((bits & 0xCCCCCCCCu) >> 2u);
+        bits = ((bits & 0x0F0F0F0Fu) << 4u) | ((bits & 0xF0F0F0F0u) >> 4u);
+        bits = ((bits & 0x00FF00FFu) << 8u) | ((bits & 0xFF00FF00u) >> 8u);
+        return f32(bits) * 2.3283064365386963e-10f; // / 0x100000000
+    }
+
+    fn hammersley( i:u32, N:u32) -> vec2f
+    {
+        return vec2f(f32(i) / f32(N), radicalInverse_VdC(i));
+    }
+
+    fn ImportanceSampleGGX( xi:vec2f,  roughness:f32,  N:vec3f) -> vec3f
+    {
+        var alpha2 = roughness * roughness * roughness * roughness;
+        
+        var phi = 2.0f * 3.1415926 * xi.x  ;
+        var cosTheta = sqrt( (1.0f - xi.y) / (1.0f + (alpha2 - 1.0f) * xi.y ));
+        var sinTheta = sqrt( 1.0f - cosTheta*cosTheta );
+        
+        var h : vec3f ;
+        h.x = sinTheta * cos( phi );
+        h.y = sinTheta * sin( phi );
+        h.z = cosTheta;
+        
+        var up = vec3f(1,0,0) ;
+        if(abs(N.z) < 0.9999){
+            up = vec3f(0,0,1) ;
+        }
+
+        var tangentX = normalize( cross( up, N ) );
+        var tangentY = cross( N, tangentX );
+        return (tangentX * h.x + tangentY * h.y + N * h.z);
+    } 
+
+    fn  specularD( roughness:f32,  NoH:f32) -> f32
+    {
+        var NoH2 = NoH * NoH;
+        var r2 = roughness * roughness;
+        return r2 / pow(NoH2 * (r2 - 1.0) + 1.0, 2.0);
+    }
+    
+`;

package/dist/src/assets/shader/compute/PreIntegratedLut.d.ts

@@ -0,0 +1 @@
+export declare let PreIntegratedLut: string;

package/dist/src/assets/shader/compute/PreIntegratedLut.js

@@ -0,0 +1,46 @@
+export let PreIntegratedLut = /*wgsl*/ `
+var<private>PI: f32 = 3.141592653589793;
+fn Scatter(r:f32) -> vec3f{
+    return Gaussian(0.0064 * 1.414, r) * vec3f(0.233, 0.455, 0.649) + Gaussian(0.0484 * 1.414, r) * vec3f(0.100, 0.336, 0.344)
+           + Gaussian(0.1870 * 1.414, r) * vec3f(0.118, 0.198, 0.000) + Gaussian(0.5670 * 1.414, r) * vec3f(0.113, 0.007, 0.007) 
+           + Gaussian(1.9900 * 1.414, r) * vec3f(0.358, 0.004, 0.00001) + Gaussian(7.4100 * 1.414, r) * vec3f(0.078, 0.00001, 0.00001);
+}
+
+fn Gaussian(v:f32, r:f32) -> f32{
+    return 1.0 / sqrt(2.0 * PI * v) * exp(-(r * r) / (2.0 * v));
+}
+
+fn Integrate(cosTheta: f32, skinRadius: f32) -> vec3f{
+    var theta = acos(cosTheta);
+    var totalWeights = vec3f(0.0);
+    var totalLight = vec3f(0.0);
+    var a = -(PI/2.0);
+    let inc = 0.05;
+
+    while(a<=(PI/2.0)){
+        var sampleAngle = theta + a;
+        var diffuse = clamp(cos(sampleAngle), 0.0, 1.0);
+        var sampleDist = abs(2.0 * skinRadius * sin(a * 0.5));
+        var weights = Scatter(sampleDist);
+        totalWeights += weights;
+        totalLight += diffuse * weights;
+        a += inc;
+    }
+
+    var result = vec3f(totalLight.x / totalWeights.x, totalLight.y / totalWeights.y, totalLight.z / totalWeights.z);
+    return result;
+}
+
+@group(0) @binding(0) var sssMap: texture_storage_2d<rgba8unorm, write>;
+
+@compute @workgroup_size(8,8,1)
+fn CsMain(@builtin(global_invocation_id) global_invocation_id: vec3<u32>){
+    var fragCoord = vec2<u32>(global_invocation_id.x, global_invocation_id.y);
+    var fragColor = vec4<f32>(1.0,1.0,0.0,1.0);
+    var NDotL = mix(-1.0, 1.0, f32(fragCoord.x) / 256.0);
+    var oneOverR = 2.0 * 1.0 / (f32(fragCoord.y + 1u) / 256.0);
+    var diff = Integrate(NDotL, oneOverR);
+    fragColor = vec4f(vec3f(diff),1.0);
+    textureStore(sssMap, vec2<i32>(fragCoord.xy), fragColor);
+}
+`;

package/dist/src/assets/shader/compute/SSAO_cs.d.ts

@@ -0,0 +1 @@
+export declare let SSAO_cs: string;

package/dist/src/assets/shader/compute/SSAO_cs.js

@@ -0,0 +1,82 @@
+export let SSAO_cs = /*wgsl*/ `
+    #include "GlobalUniform"
+    struct UniformData {
+        radius: f32,
+        bias: f32,
+        aoPower: f32,
+        blurSize: f32,
+    }
+
+    @group(0) @binding(0) var<uniform> standUniform: GlobalUniform;
+    @group(0) @binding(1) var<uniform> uniformData: UniformData;
+    @group(0) @binding(2) var<storage,read> sampleData: array<vec4<f32>>;
+
+    @group(0) @binding(3) var positionMap: texture_2d<f32>;
+    @group(0) @binding(4) var normalMap: texture_2d<f32>;
+
+    @group(0) @binding(5) var noiseMapSampler: sampler;
+    @group(0) @binding(6) var noiseMap: texture_2d<f32>;
+
+    @group(0) @binding(7) var outTex: texture_storage_2d<rgba16float, write>;
+    var<private> kernelSize: i32 = 32;
+
+    @compute @workgroup_size(8,8)
+    fn CsMain(@builtin(workgroup_id) workgroup_id: vec3<u32>, builtin(global_invocation_id) globalInvocation_id: vec3<u32>){
+        var fragCoord = vec2<i32>(globalInvocation_id.xy);
+        var texSize = textureDimensions(positionMap).xy;
+        var texCoord = vec2<f32>(fragCoord) / vec2<f32>(texSize);
+        var fragColor = vec4<f32>(1.0);
+        var viewMat = standUniform.viewMat;
+        var wPos = textureLoad(positionMap, fragCoord, 0);
+        var fragPosition = viewMat * vec4<f32>(wPos.xyz,1.0);
+        fragPosition = vec4(fragPosition.xyz / fragPosition.w,1.0) ;
+        var texNormal = textureLoad(normalMap, fragCoord, 0);
+        var sampleNormal = texNormal.xyz;
+        sampleNormal = sampleNormal * 2.0 - 1.0;
+        var fragNormal = viewMat * vec4<f32>((sampleNormal.xyz),0.0);
+        var pes = vec2<f32>(texSize.xy) / 4.0;
+        var noiseTex: vec4<f32> = textureSampleLevel(noiseMap, noiseMapSampler, texCoord * pes, 0.0);
+        var randomVec = (viewMat * vec4<f32>(normalize(noiseTex.xyz),0.0)).xyz;
+
+        var tangent = normalize(randomVec - fragNormal.xyz * dot(randomVec, fragNormal.xyz));
+        var bTangent = cross(fragNormal.xyz, tangent) + 0.0001;
+        var tbn = mat3x3<f32>(tangent, bTangent, fragNormal.xyz);
+
+        var offset:vec4<f32>;
+        var samplePos :vec3<f32>;
+        var offsetPosition:f32;
+        var sample_depth_v:vec4<f32>;
+        var occlusion:f32 = 0.0;
+        var rangeCheck:f32 = 0.0;
+        var radius:f32 = uniformData.radius * 32.0 * fragPosition.z;
+
+        for(var i:i32 =0; i<32; i+=1){
+            samplePos = (tbn * sampleData[i].xyz);
+            samplePos = fragPosition.xyz + samplePos * radius;
+
+            offset = vec4(samplePos, 1.0);
+            offset = standUniform.projMat * offset;
+
+            var off = offset.xyz / offset.w;
+            off = (off.xyz * 0.5) + 0.5;
+            off.y = 1.0 - off.y;
+            var offsetUV = vec2<i32>(off.xyz * vec2<f32>(texSize.xy));
+
+            sample_depth_v = textureLoad(positionMap, offsetUV.xy, 0);
+            sample_depth_v = vec4<f32>((viewMat * vec4<f32>(sample_depth_v.xyz,1.0)).xyz,1.0);
+            offsetPosition = sample_depth_v.z / sample_depth_v.w;
+
+            rangeCheck = smoothstep(0.0, 1.0, radius / abs(offsetPosition - fragPosition.z));
+
+            var a = 1.0;
+            if(offsetPosition >= (samplePos.z + uniformData.bias)){
+                a = 0.0;
+            }
+            a = a * rangeCheck;
+            occlusion = occlusion + a;
+        }
+        occlusion = 1.0 - ( occlusion / f32(kernelSize) * texNormal.w );
+        occlusion = pow(occlusion, uniformData.aoPower);
+        textureStore(outTex, fragCoord, vec4(occlusion));
+    }
+`;

package/dist/src/assets/shader/compute/SSGI2_cs.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 屏幕空间全局光照
+ *  GBuffer数据读取：从GBuffer中获取位置、法线和颜色信息
+    屏幕空间光线追踪：在屏幕空间追踪光线来收集间接光照
+    结果混合：将间接光照结果与直接光照结合
+ */
+export declare let SSGI2_cs: string;

package/dist/src/assets/shader/compute/SSGI2_cs.js

@@ -0,0 +1,169 @@
+/**
+ * 屏幕空间全局光照
+ *  GBuffer数据读取：从GBuffer中获取位置、法线和颜色信息
+    屏幕空间光线追踪：在屏幕空间追踪光线来收集间接光照
+    结果混合：将间接光照结果与直接光照结合
+ */
+export let SSGI2_cs = /*wgsl */ `
+    #include "GlobalUniform"
+    #include "MathShader"
+    #include "FastMathShader"
+    #include "BitUtil"
+    #include "ColorUtil_frag"
+    #include "GBufferStand"
+
+    struct FrameBuffer{
+        rameCount : f32,
+        indirectIns : f32,
+        delay : f32,
+        frameCount4 : f32,
+        d1 : f32,
+        d2 : f32,
+        d3 : f32,
+        d4 : f32,
+    }
+
+    @group(0) @binding(3) var combineTexture : texture_2d<f32>;
+    @group(0) @binding(5) var newTexture : texture_storage_2d<rgba16float, write>;
+    @group(0) @binding(6) var<storage,read> updateBuffer: FrameBuffer;
+
+    var<private> i32InputSize: vec2<i32>;
+    var<private> i32GbufferSize: vec2<i32>;
+
+    var<private> f32InputSize: vec2<f32>;
+    var<private> f32GBufferSize: vec2<f32>;
+
+    var<private> i32InputFragCoord: vec2<i32>;
+    var<private> i32GbufferFragCoord: vec2<i32>;
+
+    var<private> f32InputFragCoord: vec2<f32>;
+    var<private> f32GbufferFragCoord: vec2<f32>;
+
+    var<private> f32InputUV: vec2<f32>;
+    var<private> f32GbufferUV: vec2<f32>;
+
+    var<private> inputToGBuffer: vec2<f32>;
+
+    var<private> gBuffer: GBuffer;
+    var<private> wColor: vec3<f32>;
+
+    var<private> halfPi: f32;
+
+    const PI: f32 = 3.141592653;
+    const I64: f32 = 1.0/64.0;
+    const offsetCount = 20u;
+
+    @compute @workgroup_size(16, 16, 1)
+    fn CsMain(@builtin(workgroup_id) workgroup_id: vec3<u32>, @builtin(global_invocation_id) globalInvocation_id: vec3<u32>){
+        i32InputFragCoord = vec2<i32>( globalInvocation_id.xy );
+        f32InputFragCoord = vec2<f32>( globalInvocation_id.xy );
+        i32InputSize = vec2i(textureDimensions(newTexture).xy);
+        i32GbufferSize = vec2i(textureDimensions(gBufferTexture).xy);
+        f32InputSize = vec2f(i32InputSize);
+        f32GBufferSize = vec2f(i32GbufferSize);
+        inputToGBuffer = 1.0/(f32InputSize / f32GBufferSize);
+        f32InputUV = f32InputFragCoord / f32InputSize;
+        f32GbufferUV = f32InputUV;
+        f32GbufferFragCoord = f32GbufferUV * f32GBufferSize;
+        i32GbufferFragCoord = vec2i(f32GbufferFragCoord);
+
+        gBuffer = getGBuffer(i32GbufferFragCoord);
+        wColor = getRGBMColorFromGBuffer(gBuffer);
+        var n = getViewNormalFromGBuffer(gBuffer);
+        var p = getWorldPositionFromGBuffer(gBuffer,f32GbufferUV);
+        let f = -globalUniform.far;
+        if(gBuffer.x <= f){
+            textureStore(newTexture, i32InputFragCoord, vec4f(0.0));
+            return;
+        }
+        halfPi = 1.0 / (PI*0.5) * f32(offsetCount);
+        var trackColor:vec4f = vec4f(0.0);
+        trackColor = ray(i32InputFragCoord, f32InputFragCoord);
+
+        textureStore(newTexture, i32InputFragCoord, trackColor);
+    }
+
+    fn ray(i32InputFragCoord:vec2<i32>,f32InputFragCoord:vec2<f32>) -> vec4f{
+        var Output = vec4f(0.0);
+        let i64pi = I64*PI ;
+        let iFrame = updateBuffer.frameCount;
+        var lastColor2 = textureLoad(combineTexture, i32InputFragCoord, 0);
+        if(iFrame > 1.0){
+            var CurrentFrame = f32(iFrame);
+            var SSOffset = vec2f(0.0);
+            gBuffer = getGBuffer(i32GbufferFragCoord);
+            var VColor = getRGBMColorFromGBuffer(gBuffer);
+            var VNormal = getViewNormalFromGBuffer(gBuffer) ;
+            var VPPos = getViewPositionFromGBuffer(gBuffer,f32GbufferUV);
+            var ModFC = f32InputFragCoord % 4.;
+            var RandPhiOffset = ARand21(vec2f(1.234)+ (CurrentFrame*3.26346) % 7.2634 );
+            var RandPhi2 = (((floor(ModFC.x)+floor(ModFC.y)*4.0+CurrentFrame*5.0) % 16.0)+RandPhiOffset)*2.0*PI*I64;
+            var stepScale = ceil( 128.0 / f32(offsetCount) ) ;
+            var skyColor = vec4f(0.0,0.0,0.0,1.0);
+            var ii = 0.0;
+            
+            for (var i=0u; i < 4u; i+=1u) {
+            let RandPhi = f32(i+1u) * (RandPhi2 + PI * 0.5);
+            let SSDir = (vec2f(cos(RandPhi),sin(RandPhi)));
+            var StepDist = stepScale ;
+            let StepCoeff = 0.15+0.15*ARand21(f32InputUV*(1.4+f32(iFrame)*3.26346%6.2634));
+
+            var BitMask = 0u;
+            var s = 1u ;
+            for (; s<= offsetCount ; s+=1u)
+            {
+                let SUV : vec2f = f32InputFragCoord + SSDir * StepDist;
+                let CurrentStep = max( 1.0 , (StepDist * StepCoeff) );
+                StepDist += CurrentStep;
+                let offsetUV = (SUV / f32InputSize) ;
+                let i32InputUV = vec2i( offsetUV * f32GBufferSize );
+                let stepGBuffer = getGBuffer(vec2i(i32InputUV));
+                var SSVC = getRGBMColorFromGBuffer(stepGBuffer);
+                
+                var uuv = (SUV * inputToGBuffer);
+                uuv = uuv / f32GBufferSize ;
+                var SVPPos = getViewPositionFromGBuffer(stepGBuffer,uuv) ;
+                var SWPos = getWorldPositionFromGBuffer(stepGBuffer,uuv) ;
+                var SNormal = getViewNormalFromGBuffer(stepGBuffer) ;
+
+                let f = (globalUniform.far - globalUniform.near) - 1000.0;
+                if(stepGBuffer.x <= f ){
+                  let svvd = SVPPos.xyz-VPPos ;
+                  var NorDot = dot(VNormal,(svvd))-0.001;
+  
+                  if(stepGBuffer.x < -1.1 || NorDot < 1.570796 )
+                  {
+                     continue ;
+                  }
+  
+                  var TanDist = (length(svvd-NorDot*VNormal));
+
+                  if(TanDist <= 0.00001 )
+                  {
+                      continue ;
+                  }
+  
+                  var Angle1f = atan2(NorDot,TanDist);
+                  var Angle2f = atan2((NorDot-0.03*max(1.0,StepDist*0.07)),TanDist);
+                  var Angle1 = max(0.0,ceil(Angle1f*halfPi));
+                  var Angle2 = max(0.0,floor(Angle2f*halfPi));
+                  var SBitMask = (u32(pow(2.0,Angle1-Angle2))-1u) << u32(Angle2);
+                  let b1 = f32(countOneBits(SBitMask & (~BitMask)))/max(1.0,Angle1-Angle2) ;
+                  let b2 = pow(cos(Angle2*i64pi),2.0)-pow(cos(Angle1*i64pi),2.0);
+                  let b3 = sqrt(max(0.0,dot(SNormal,-svvd))) ;
+                  let fb = b1 * b2 * b3 ;
+                  
+                  var lastColor2 = textureLoad(combineTexture, vec2i(SUV) , 0) ;
+                  Output = vec4f(Output.xyz + vec3f(fb * (SSVC.xyz + lastColor2.xyz * 0.15)  ) , 1.0);
+                  BitMask = BitMask | SBitMask;
+                }
+              }
+          }
+
+        }else{
+            Output = vec4f(wColor.xyz, 1.0);
+        };
+
+        return Output;
+    }
+`;

package/dist/src/assets/shader/compute/SSR_BlendColor_cs.d.ts

@@ -0,0 +1,4 @@
+/**
+ * 屏幕空间反射
+ */
+export declare let SSR_BlendColor_cs: string;

package/dist/src/assets/shader/compute/SSR_BlendColor_cs.js

@@ -0,0 +1,53 @@
+/**
+ * 屏幕空间反射
+ */
+export let SSR_BlendColor_cs = /*wgsl */ `
+#include "GlobalUniform"
+
+@group(0) @binding(2) var<storage, read_write> rayTraceBuffer: array<RayTraceRetData>;
+@group(0) @binding(3) var colorMap : texture_2d<f32>;
+@group(0) @binding(4) var ssrMapSampler : sampler;
+@group(0) @binding(5) var ssrMap : texture_2d<f32>;
+@group(0) @binding(6) var outTex : texture_storage_2d<rgba16float, write>;
+
+var<private> colorTexSize: vec2<u32>;
+var<private> ssrTexSize: vec2<u32>;
+var<private> fragCoord: vec2<i32>;
+var<private> ssrCoord: vec2<i32>;
+
+struct RayTraceRetData{
+    skyColor:vec3<f32>,
+    roughness:f32,
+    hitCoord:vec2<f32>,
+    alpha:f32,
+    fresnel:f32,
+}
+
+fn CalcUV_01(coord:vec2<i32>, texSize:vec2<u32>) -> vec2<f32>{
+    let u = (f32(coord.x) + 0.5) / f32(texSize.x);
+    let v = (f32(coord.y) + 0.5) / f32(texSize.y);
+    return vec2<f32>(u, v);
+}
+
+const PI = 3.1415926;
+@compute @workgroup_size(8,8,1)
+fn CsMain(@builtin(workgroup_id) workgroup_id: vec3<u32>, @builtin(global_invocation_id) globalInvocation_id: vec3<u32>){
+    fragCoord = vec2<i32>(globalInvocation_id.xy);
+    colorTexSize = textureDimensions(colorMap).xy;
+    ssrTexSize = textureDimensions(ssrMap).xy;
+    if(fragCoord.x >= i32(colorTexSize.x) || fragCoord.y >= i32(colorTexSize.y)){
+        return;
+    }
+    let scale: f32 = f32(ssrTexSize.x) / f32(colorTexSize.x);
+    ssrCoord = vec2<i32>(vec2<f32>(fragCoord.xy) * scale);
+    let index = ssrCoord.x + ssrCoord.y * i32(ssrTexSize.x);
+    let hitData = rayTraceBuffer[index];
+    var lastColor = textureLoad(colorMap, fragCoord, 0);
+    let time = globalUniform.time;
+    var uv01 = CalcUV_01(fragCoord, colorTexSize);
+    var ssrColor = textureSampleLevel(ssrMap, ssrMapSampler, uv01, 0.0);
+    var outColor = mix(lastColor, ssrColor, hitData.fresnel);
+    textureStore(outTex, fragCoord, outColor);
+}
+
+`;

package/dist/src/assets/shader/compute/SSR_IS_cs.d.ts

@@ -0,0 +1 @@
+export declare let SSR_IS_cs: string;

package/dist/src/assets/shader/compute/SSR_IS_cs.js

@@ -0,0 +1,76 @@
+export let SSR_IS_cs = /*wgsl */ `
+#include 'BitUtil'
+
+struct SSRUniformData {
+    ssrBufferSizeX: f32,
+    ssrBufferSizeY: f32,
+    colorMapSizeX: f32,
+    colorMapSizeY: f32,
+    fadeEdgeRatio: f32,
+    rayMarchRatio: f32,
+    fadeDistanceMin: f32,
+    fadeDistanceMax: f32,
+    mixThreshold: f32,
+    roughnessThreshold: f32,
+    reflectionRatio: f32,
+    powDotRN: f32,
+    randomSeedX: f32,
+    randomSeedY: f32,
+    slot1: f32,
+    slot2: f32,
+  };
+
+struct RayTraceRetData{
+    skyColor:vec3<f32>,
+    roughness:f32,
+    hitCoord:vec2<f32>,
+    alpha:f32,
+    fresnel:f32,
+  }
+
+  @group(0) @binding(0) var<uniform> ssrUniform: SSRUniformData;
+  @group(0) @binding(1) var<storage, read_write> rayTraceBuffer : array<RayTraceRetData>;
+  @group(0) @binding(2) var<storage, read_write> ssrColorData : array<vec4<f32>>;
+  @group(0) @binding(3) var<storage, read_write> historyPosition : array<vec4<f32>>;
+  @group(0) @binding(4) var colorMap: texture_2d<f32>;
+  @group(0) @binding(5) var outTex : texture_storage_2d<rgba16float, write>;
+
+  var<private> ssrBufferCoord: vec2<i32>;
+  var<private> colorTexSize: vec2<i32>;
+  var<private> bufferData: RayTraceRetData;
+  var<private> ssrBufferSize: vec2<i32>;
+  var<private> coordIndex: i32;
+
+  @compute @workgroup_size(8, 8, 1)
+  fn CsMain(@builtin(workgroup_id) workgroup_id: vec3<u32>, @builtin(global_invocation_id) globalInvocation_id: vec3<u32>){
+    ssrBufferCoord = vec2<i32>(globalInvocation_id.xy);
+    ssrBufferSize = vec2<i32>(i32(ssrUniform.ssrBufferSizeX), i32(ssrUniform.ssrBufferSizeY));
+    colorTexSize = vec2<i32>(i32(ssrUniform.colorMapSizeX), i32(ssrUniform.colorMapSizeY));
+
+    if(ssrBufferCoord.x >= ssrBufferSize.x || ssrBufferCoord.y >= ssrBufferSize.y){
+        return;
+    }
+
+    coordIndex = ssrBufferCoord.x + ssrBufferCoord.y * ssrBufferSize.x;
+    bufferData = rayTraceBuffer[coordIndex];
+    var oc = vec4<f32>(0.0,0.0,0.0,-1.0);
+    var mixFactor = historyPosition[coordIndex].w;
+
+    if(bufferData.alpha >= 0.0 && bufferData.roughness < ssrUniform.roughnessThreshold){
+        let prefilterColor = bufferData.skyColor;
+        var ssrColor = textureLoad(colorMap, vec2<i32>(bufferData.hitCoord), 0);
+        ssrColor.w = bufferData.alpha;
+        oc = ssrColor;
+    }
+    let skyColor = vec4<f32>(bufferData.skyColor, 1.0);
+    oc = mix(oc, skyColor, 1.0 - bufferData.alpha);
+
+    let lastColor = ssrColorData[coordIndex];
+    var newColor = mix(oc, lastColor, mixFactor);
+    newColor.w = oc.w;
+
+    ssrColorData[coordIndex] = newColor;
+    textureStore(outTex, ssrBufferCoord , newColor);
+  }
+
+`;

package/dist/src/assets/shader/compute/SSR_RayTrace_cs.d.ts

@@ -0,0 +1 @@
+export declare let SSR_RayTrace_cs: string;