@rings-webgpu/core 1.0.0 → 1.0.2

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

@@ -0,0 +1,289 @@
+export let SSR_RayTrace_cs = /*wgsl */ `
+#include "GlobalUniform"
+#include "MathShader"
+#include "BitUtil"
+#include "GBufferStand"
+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 HitData{
+    hitPos:vec3<f32>,
+    hitNormal:vec3<f32>,
+    fadeAlpha:vec4<f32>,
+    hitCoord:vec2<i32>,
+    hitResult:i32,
+    hitSky:i32,
+  };
+
+  struct RayTraceRetData{
+    skyColor:vec3<f32>,
+    roughness:f32,
+    hitCoord:vec2<f32>,
+    alpha:f32,
+    fresnel:f32,
+  }
+
+  @group(0) @binding(2) var<uniform> ssrUniform: SSRUniformData;
+  @group(0) @binding(3) var<storage, read_write> rayTraceBuffer: array<RayTraceRetData>;
+  @group(0) @binding(4) var<storage, read_write> historyPosition : array<vec4<f32>>;
+  @group(0) @binding(5) var prefilterMap: texture_cube<f32>;
+  @group(0) @binding(6) var prefilterMapSampler: sampler;
+
+  var<private> rayOrigin: vec3<f32>;
+  var<private> rayDirection: vec3<f32>;
+  var<private> cameraPosition: vec3<f32>;
+  var<private> reflectionDir: vec3<f32>;
+  var<private> colorTexSize: vec2<i32>;
+  var<private> fragCoordColor: vec2<i32>;
+  var<private> ssrBufferCoord: vec2<i32>;
+  var<private> ssrBufferSize: vec2<i32>;
+  var<private> hitData: HitData;
+  var<private> rayTraceRet: RayTraceRetData;
+  var<private> worldPosition: vec3<f32>;
+  var<private> worldNormal: vec3<f32>;
+  var<private> roughness: f32;
+  var<private> fresnel: f32;
+  var<private> historyPos: vec3<f32>;
+  var<private> coordIndex: i32;
+  var<private> sampleUV: vec2<f32>;
+  var <private> PI: f32 = 3.14159;
+
+  @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));
+    if(ssrBufferCoord.x >= ssrBufferSize.x || ssrBufferCoord.y >= ssrBufferSize.y){
+        return;
+    }
+    useNormalMatrixInv();
+    coordIndex = ssrBufferCoord.x + ssrBufferCoord.y * ssrBufferSize.x;
+    colorTexSize = vec2<i32>(i32(ssrUniform.colorMapSizeX), i32(ssrUniform.colorMapSizeY));
+    fragCoordColor = convertColorCoordFromSSRCoord(ssrBufferCoord);
+    hitData.fadeAlpha = vec4<f32>(0.0);
+    hitData.hitCoord = vec2<i32>(0);
+    hitData.hitResult = 0;
+    hitData.hitNormal = vec3<f32>(0.0, 1.0, 0.0);
+    hitData.hitSky = 1;
+    sampleUV = vec2f(fragCoordColor) / vec2f(colorTexSize);
+
+    let gBuffer: GBuffer = getGBuffer(vec2i(fragCoordColor));
+    worldPosition = getWorldPositionFromGBuffer(gBuffer, sampleUV);
+    historyPos = historyPosition[coordIndex].xyz;
+
+    var mixFactor = 0.2;
+    if(length(historyPos - worldPosition) < ssrUniform.mixThreshold){
+        mixFactor = 0.9;
+    }
+    historyPosition[coordIndex] = vec4<f32>(worldPosition, mixFactor);
+    worldNormal = getWorldNormalFromGBuffer(gBuffer);
+    let roughness = getRoughnessFromGBuffer(gBuffer);
+    fresnel = (1.0 - roughness) * ssrUniform.reflectionRatio;
+    fresnel *= fresnel;
+    cameraPosition = vec3<f32>(globalUniform.cameraWorldMatrix[3].xyz);
+    rayOrigin = vec3<f32>(worldPosition.xyz);
+    rayDirection = normalize(vec3<f32>(worldPosition.xyz - cameraPosition));
+    var randomSeed = fract(ssrUniform.randomSeedX + worldPosition.x);
+    rand_seed.x = randomSeed;
+    rand_seed.y = fract(ssrUniform.randomSeedY + worldPosition.y + worldPosition.z);
+    randomSeed = rand();
+
+    let normalRandom = makeRandomDirection(worldNormal, u32(randomSeed * 256.0), 256, roughness);
+    reflectionDir = normalize(reflect(rayDirection, normalRandom));
+
+    if(roughness > 0.0 && roughness < ssrUniform.roughnessThreshold){
+      let uvOrigin = vec2<f32>(f32(fragCoordColor.x), f32(fragCoordColor.y));
+      let rayMarchPosition = rayOrigin + reflectionDir * 100.0;
+      var uvRayMarch = globalUniform.projMat * (globalUniform.viewMat * vec4<f32>(rayMarchPosition, 1.0));
+      var uvOffset = (vec2<f32>(uvRayMarch.xy / uvRayMarch.w) + 1.0) * 0.5;
+      uvOffset.y = 1.0 - uvOffset.y;
+      uvOffset = uvOffset * vec2<f32>(colorTexSize) - uvOrigin;
+      uvOffset = normalize(uvOffset);
+
+      rayTrace(uvOffset);
+      if(hitData.hitResult == 1){
+          hidingArtifact();
+          rayTraceRet.alpha = hitData.fadeAlpha.x * hitData.fadeAlpha.y * hitData.fadeAlpha.z * hitData.fadeAlpha.w;
+          if(hitData.hitSky == 1){
+            rayTraceRet.alpha = 0.0;
+          }
+      }else{
+        rayTraceRet.alpha = 0.0;
+      };
+      rayTraceRet.skyColor = getSkyColor();
+    }else{
+      rayTraceRet.alpha = -1.0;
+      rayTraceRet.skyColor = vec3<f32>(0.0);
+    };
+
+    rayTraceRet.roughness = roughness;
+    rayTraceRet.fresnel = fresnel;
+    rayTraceRet.hitCoord = vec2<f32>(hitData.hitCoord);
+    let index:i32 = ssrBufferCoord.x + ssrBufferCoord.y * ssrBufferSize.x;
+    rayTraceBuffer[index] = rayTraceRet;
+  }
+
+  fn makeRandomDirection(srcDirection:vec3<f32>, i:u32, SAMPLE_COUNT:u32, roughness:f32) -> vec3<f32>{
+    var N: vec3<f32> = normalize(srcDirection);
+    var Xi:vec2<f32> = hammersley(i, SAMPLE_COUNT);
+    return ImportanceSampleGGX(Xi, N, roughness);
+  }
+
+  fn hammersley( i : u32 ,  N : u32 ) -> vec2<f32>
+  {
+    // Radical inverse based on http://holger.dammertz.org/stuff/notes_HammersleyOnHemisphere.html
+    var bits = (i << 16u) | (i >> 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);
+    var rdi = f32(bits) * 2.3283064365386963e-10;
+    return vec2<f32>(f32(i) /f32(N), rdi);
+  }
+
+  fn ImportanceSampleGGX( Xi:vec2<f32>, N:vec3<f32>, roughness:f32) ->vec3<f32>
+  {
+    var a = roughness*roughness;
+    var phi = 2.0 * PI * Xi.x;
+    var cosTheta = sqrt((1.0 - Xi.y) / (1.0 + (a*a - 1.0) * Xi.y));
+    var sinTheta = sqrt(1.0 - cosTheta*cosTheta);
+
+    var H:vec3<f32>;
+    H.x = cos(phi) * sinTheta;
+    H.y = sin(phi) * sinTheta;
+    H.z = cosTheta;
+
+    var up:vec3<f32>;
+    if(abs(N.z) < 0.999)
+    {
+        up = vec3<f32>(0.0, 0.0, 1.0);
+    }
+    else
+    {
+        up = vec3<f32>(1.0, 0.0, 0.0);
+    }
+    var tangent:vec3<f32>  = normalize(cross(up, N));
+    var bitangent:vec3<f32> = cross(N, tangent);
+    var sampleVec:vec3<f32> = tangent * H.x + bitangent * H.y + N * H.z;
+    return normalize(sampleVec);
+  }
+
+  var<private> rand_seed :vec2<f32> = vec2<f32>(0.0);
+  fn rand() -> f32 {
+    rand_seed.x = fract(cos(dot(rand_seed, vec2<f32>(23.14077926, 232.61690225))) * 136.8168);
+    rand_seed.y = fract(cos(dot(rand_seed, vec2<f32>(54.47856553, 345.84153136))) * 534.7645);
+    return rand_seed.y;
+  }
+
+  fn getSkyColor() -> vec3<f32>{
+    let calcRoughness = clamp(roughness, 0.0, 1.0);
+    let MAX_REFLECTION_LOD  = f32(textureNumLevels(prefilterMap)) ;
+    var prefilterColor = textureSampleLevel(prefilterMap, prefilterMapSampler, reflectionDir, calcRoughness * MAX_REFLECTION_LOD);
+    return LinearToGammaSpace(vec3<f32>(prefilterColor.xyz)) * globalUniform.skyExposure;
+  }
+
+  fn convertColorCoordFromSSRCoord(coord:vec2<i32>) -> vec2<i32>{
+    let color_ssr_ratio = ssrUniform.colorMapSizeX / ssrUniform.ssrBufferSizeX;
+    let targetCoord = vec2<f32>(coord) * color_ssr_ratio;
+    return vec2<i32>(targetCoord);
+  }
+
+  fn hidingArtifact(){
+    let texSizeF32 = vec2<f32>(f32(colorTexSize.x), f32(colorTexSize.y));
+    let halfTexSizeF32 = texSizeF32 * 0.5;
+
+    var distance2Center = abs(vec2<f32>(f32(hitData.hitCoord.x), f32(hitData.hitCoord.y)) - halfTexSizeF32);
+    let halfEdgeSize:f32 = min(texSizeF32.x, texSizeF32.y) * clamp(0.01, ssrUniform.fadeEdgeRatio, 1.0) * 0.5;
+    var distance2Edge = min(vec2<f32>(halfEdgeSize), halfTexSizeF32 - distance2Center);
+    var ratioXY = distance2Edge / halfEdgeSize;
+    hitData.fadeAlpha.x = sqrt(ratioXY.x * ratioXY.y);
+
+    var backFaceBias = max(0.0, dot(hitData.hitNormal, -reflectionDir));
+    hitData.fadeAlpha.y = pow(backFaceBias, max(0.0001, ssrUniform.powDotRN));
+
+    let maxLength = max(f32(colorTexSize.x), f32(colorTexSize.y)) * ssrUniform.rayMarchRatio;
+    let screenPointer = hitData.hitCoord - fragCoordColor;
+    var screenDistance = length(vec2<f32>(f32(screenPointer.x), f32(screenPointer.y)));
+    screenDistance = clamp(screenDistance / maxLength, 0.0, 1.0);
+    hitData.fadeAlpha.z = 1.0 - screenDistance;
+
+    var fadeDistance = length(vec3<f32>(hitData.hitPos - cameraPosition));
+    var dFar = ssrUniform.fadeDistanceMax;
+    var dNear = ssrUniform.fadeDistanceMin;
+    dFar = max(1.0, dFar);
+    dNear = clamp(dNear, 0.001, dFar - 0.001);
+    fadeDistance = clamp(fadeDistance, dNear, dFar);
+    fadeDistance = (fadeDistance - dNear) / (dFar - dNear);
+    hitData.fadeAlpha.w = 1.0 - fadeDistance;
+  }
+
+  fn rayTrace(rayMarchDir:vec2<f32>){
+    let stepLength = 4.0;
+    let maxLength = max(f32(colorTexSize.x), f32(colorTexSize.y)) * ssrUniform.rayMarchRatio;
+    for(var i:f32 = 1.0; i < maxLength; i+=stepLength){
+        let offsetFloat32 = i * rayMarchDir;
+        var uv = fragCoordColor + vec2<i32>(i32(offsetFloat32.x), i32(offsetFloat32.y));
+        let hitRet = rayInterestScene(uv);
+        if(hitRet > 0){
+            hitData.hitResult = hitRet;
+            break;
+        }
+    }
+    if(hitData.hitResult == 1){
+        let fromUV = hitData.hitCoord;
+        for(var i:f32 = -stepLength; i <= 0.0; i+=1.0 ){
+            let offsetFloat32 = i * rayMarchDir;
+            var uv = fromUV + vec2<i32>(i32(offsetFloat32.x), i32(offsetFloat32.y));
+            let hitRet = rayInterestScene(uv);
+            if(hitRet == 1){
+                let gBuffer = getGBuffer(hitData.hitCoord);
+                if(getRoughnessFromGBuffer(gBuffer) >= 0.0){
+                    hitData.hitSky = 0;
+                }
+
+                let WN = getWorldNormalFromGBuffer(gBuffer);
+                hitData.hitNormal = normalize(WN);
+                break;
+            }
+        }
+    }
+  }
+
+  fn rayInterestScene(uv: vec2<i32>) -> i32 {
+    if(uv.x < 0 || uv.y < 0 || uv.x >= colorTexSize.x || uv.y >= colorTexSize.y){
+      return 2;
+    }else{
+      let gBuffer = getGBuffer(uv);
+      let hitPos = getWorldPositionFromGBuffer(gBuffer , vec2f(uv) / vec2f(colorTexSize) );
+      let testDir = normalize(vec3<f32>(hitPos.xyz - rayOrigin));
+      let cosValue = dot(reflectionDir, testDir);
+
+      if(cosValue > 0.9996){
+        let cross1 = cross(reflectionDir, -rayDirection);
+        let cross2 = cross(reflectionDir, testDir);
+        if(dot(cross1, cross2) > 0.0){
+          hitData.hitPos = vec3<f32>(hitPos.xyz);
+          hitData.hitCoord = uv;
+          return 1;
+        }
+      };
+    }
+    return 0;
+  }
+
+`;

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

@@ -0,0 +1,4 @@
+/**
+ * 存储缓冲区中的数据复制到纹理中
+ */
+export declare let TAACopyTex_cs: string;

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

@@ -0,0 +1,22 @@
+/**
+ * 存储缓冲区中的数据复制到纹理中
+ */
+export let TAACopyTex_cs = /*wgsl */ `
+@group(0) @binding(0) var<storage, read_write> preColor: array<vec4<f32>>;
+@group(0) @binding(1) var preColorTex : texture_storage_2d<rgba16float, write>;
+
+var<private> texSize: vec2<u32>;
+var<private> fragCoord: 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>){
+    fragCoord = vec2<i32>(globalInvocation_id.xy);
+    texSize = textureDimensions(preColorTex).xy;
+    if(fragCoord.x >= i32(texSize.x) || fragCoord.y >= i32(texSize.y)){
+        return;
+    }
+    coordIndex = fragCoord.x + fragCoord.y * i32(texSize.x);
+    textureStore(preColorTex, fragCoord, preColor[coordIndex]);
+}
+`;

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

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

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

@@ -0,0 +1,42 @@
+export let TAASharpTex_cs = /*wgsl*/ `
+  struct TAAData{
+      preProjMatrix: mat4x4<f32>,
+      preViewMatrix: mat4x4<f32>,
+      jitterFrameIndex: f32,
+      blendFactor: f32,
+      sharpFactor: f32,
+      sharpPreBlurFactor: f32,
+      jitterX: f32,
+      jitterY: f32,
+      slot0: f32,
+      slot1: f32,
+  }
+  
+  @group(0) @binding(0) var<uniform> taaData: TAAData;
+  @group(0) @binding(1) var inTex : texture_2d<f32>;
+  @group(0) @binding(2) var outTex : texture_storage_2d<rgba16float, write>;
+
+  var<private> texSize: vec2<u32>;
+  var<private> fragCoord: vec2<i32>;
+
+  @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);
+    texSize = textureDimensions(outTex).xy;
+    if(fragCoord.x >= i32(texSize.x) || fragCoord.y >= i32(texSize.y)){
+        return;
+    }
+
+    let c0 = textureLoad(inTex, vec2<i32>(fragCoord.x, fragCoord.y - 1), 0);
+    let c1 = textureLoad(inTex, vec2<i32>(fragCoord.x, fragCoord.y + 1), 0);
+    let c2 = textureLoad(inTex, vec2<i32>(fragCoord.x - 1, fragCoord.y), 0);
+    let c3 = textureLoad(inTex, vec2<i32>(fragCoord.x + 1, fragCoord.y), 0);
+
+    var roundColor = (c0 + c1 + c2 + c3) * 0.25;
+    let originColor = textureLoad(inTex, fragCoord, 0);
+    let blurColor = mix(roundColor, originColor, taaData.sharpPreBlurFactor);
+    var oc = (originColor - blurColor * taaData.sharpFactor) / (1.0 - taaData.sharpFactor);
+    oc = clamp(oc, vec4<f32>(0.0), oc);
+    textureStore(outTex, fragCoord , oc);
+  }
+`;

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

@@ -0,0 +1,4 @@
+/**
+ * 时域抗锯齿
+ */
+export declare let TAA_cs: string;

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

@@ -0,0 +1,152 @@
+/**
+ * 时域抗锯齿
+ */
+export let TAA_cs = /*wgsl */ `
+#include "GlobalUniform"
+#include "GBufferStand"
+
+struct TAAData{
+  preProjMatrix: mat4x4<f32>,
+  preViewMatrix: mat4x4<f32>,
+  jitterFrameIndex: f32,
+  blendFactor: f32,
+  sharpFactor: f32,
+  sharpPreBlurFactor: f32,
+  jitterX: f32,
+  jitterY: f32,
+  slot0: f32,
+  slot1: f32,
+}
+
+@group(0) @binding(2) var<uniform> taaData: TAAData;
+@group(0) @binding(3) var<storage, read_write> preColorBuffer : array<vec4<f32>>;
+@group(0) @binding(4) var preColorTexSampler : sampler;
+@group(0) @binding(5) var preColorTex : texture_2d<f32>;
+@group(0) @binding(6) var inTexSampler : sampler;
+@group(0) @binding(7) var inTex : texture_2d<f32>;
+@group(0) @binding(8) var outTex : texture_storage_2d<rgba16float, write>;
+
+const PI = 3.1415926;
+const FLT_EPS = 5.960464478e-8;
+
+var<private> texSize: vec2<u32>;
+var<private> fragCoord: vec2<i32>;
+var<private> fragUV: vec2<f32>;
+var<private> coordIndex: i32;
+var<private> color_min: vec4<f32>;
+var<private> color_max: vec4<f32>;
+var<private> color_avg: vec4<f32>;
+var<private> re_proj_uv01: vec2<f32>;
+
+@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);
+    texSize = textureDimensions(inTex).xy;
+    if(fragCoord.x >= i32(texSize.x) || fragCoord.y >= i32(texSize.y)){
+        return;
+    }
+    useNormalMatrixInv();
+    fragUV = vec2<f32>(fragCoord) / vec2<f32>(texSize - 1);
+    let frame = globalUniform.frame;
+    coordIndex = fragCoord.x + fragCoord.y * i32(texSize.x);
+    let oc = blendColor();
+    preColorBuffer[coordIndex] = oc;
+    textureStore(outTex, fragCoord , oc);
+}
+
+fn blendColor() -> vec4<f32>{
+    var preCoord = fragCoord;
+    var mixWeight = 1.0;
+    re_proj_uv01 = vec2<f32>(0.0);
+    var reProjectionCoord:vec2<f32> = vec2<f32>(fragCoord);
+    if(taaData.jitterFrameIndex > 0.5){
+        let gBuffer: GBuffer = getGBuffer(fragCoord);
+        var wPos = getWorldPositionFromGBuffer(gBuffer,fragUV) ;
+        let roughness = getRoughnessFromGBuffer(gBuffer);
+        let ndc = taaData.preProjMatrix * (taaData.preViewMatrix * vec4<f32>(wPos.xyz, 1.0));
+        re_proj_uv01 = vec2<f32>(ndc.x, -ndc.y) / ndc.w;
+        re_proj_uv01 = (re_proj_uv01 + 1.0) * 0.5;
+
+        if(roughness > 0.0 && re_proj_uv01.x >= 0.0 && re_proj_uv01.x <= 1.0 && re_proj_uv01.y >= 0.0 && re_proj_uv01.y <= 1.0){
+            mixWeight = taaData.blendFactor;
+            reProjectionCoord.x = re_proj_uv01.x * f32(texSize.x - 1);
+            reProjectionCoord.y = re_proj_uv01.y * f32(texSize.y - 1);
+            preCoord = vec2<i32>(reProjectionCoord);
+        }else{ 
+            mixWeight = 1.0;
+        };
+    }
+
+    var curUV01 = fragUV;
+    let curColor = textureSampleLevel(inTex, inTexSampler, curUV01, 0.0);
+    let preIndex = preCoord.x + preCoord.y * i32(texSize.x);
+    var preColor = textureSampleLevel(preColorTex, preColorTexSampler, re_proj_uv01, 0.0);
+    minmax4(fragCoord);
+    
+    preColor = clip_aabb(color_min.xyz, color_max.xyz, color_avg, preColor);
+    var outColor = mix(preColor, curColor, mixWeight);
+    return outColor;
+}
+
+fn clampCoord(coord0:vec2<i32>) -> vec2<i32>{
+  return clamp(coord0, vec2<i32>(0), vec2<i32>(texSize - 1));
+}
+
+fn minmax4(coord:vec2<i32>) {
+      let uv0 = clampCoord(vec2<i32>(coord.x - 1, coord.y));
+      let uv1 = clampCoord(vec2<i32>(coord.x, coord.y - 1));
+      let uv2 = clampCoord(vec2<i32>(coord.x, coord.y + 1));
+      let uv3 = clampCoord(vec2<i32>(coord.x + 1, coord.y));
+      
+      let c0 = textureLoad(inTex, uv0, 0);
+      let c1 = textureLoad(inTex, uv1, 0);
+      let c2 = textureLoad(inTex, uv2, 0);
+      let c3 = textureLoad(inTex, uv3, 0);
+      
+      color_min = min(c0, min(c1, min(c2, c3)));
+      color_max = max(c0, max(c1, max(c2, c3)));
+      color_avg = (c0 + c1 + c2 + c3) * 0.25;
+  }
+
+ fn minmax9(coord:vec2<i32>) {
+      let uv0 = clampCoord(vec2<i32>(coord.x - 1, coord.y - 1));
+      let uv1 = clampCoord(vec2<i32>(coord.x - 1, coord.y));
+      let uv2 = clampCoord(vec2<i32>(coord.x - 1, coord.y + 1));
+      let uv3 = clampCoord(vec2<i32>(coord.x, coord.y - 1));
+      let uv4 = clampCoord(vec2<i32>(coord.x, coord.y));
+      let uv5 = clampCoord(vec2<i32>(coord.x, coord.y + 1));
+      let uv6 = clampCoord(vec2<i32>(coord.x + 1, coord.y - 1));
+      let uv7 = clampCoord(vec2<i32>(coord.x + 1, coord.y));
+      let uv8 = clampCoord(vec2<i32>(coord.x + 1, coord.y + 1));
+      
+      let ctl = textureLoad(inTex, uv0, 0);
+      let ctc = textureLoad(inTex, uv1, 0);
+      let ctr = textureLoad(inTex, uv2, 0);
+      let cml = textureLoad(inTex, uv3, 0);
+      let cmc = textureLoad(inTex, uv4, 0);
+      let cmr = textureLoad(inTex, uv5, 0);
+      let cbl = textureLoad(inTex, uv6, 0);
+      let cbc = textureLoad(inTex, uv7, 0);
+      let cbr = textureLoad(inTex, uv8, 0);
+      
+      color_min = min(ctl, min(ctc, min(ctr, min(cml, min(cmc, min(cmr, min(cbl, min(cbc, cbr))))))));
+      color_max = max(ctl, max(ctc, max(ctr, max(cml, max(cmc, max(cmr, max(cbl, max(cbc, cbr))))))));
+      color_avg = (ctl + ctc + ctr + cml + cmc + cmr + cbl + cbc + cbr) / 9.0;
+  }
+
+  fn clip_aabb(aabb_max:vec3<f32>, aabb_min:vec3<f32>, color_avg:vec4<f32>, input_texel:vec4<f32>) -> vec4<f32>
+  {
+      var p_clip:vec3<f32> = 0.5 * (aabb_max + aabb_min);
+      var e_clip:vec3<f32> = 0.5 * (aabb_max - aabb_min) + FLT_EPS;
+      var v_clip:vec4<f32> = input_texel - vec4<f32>(p_clip, color_avg.w);
+      var v_unit:vec3<f32> = v_clip.xyz / e_clip;
+      var a_unit:vec3<f32> = abs(v_unit);
+      var ma_unit:f32 = max(a_unit.x, max(a_unit.y, a_unit.z));
+
+      if (ma_unit > 1.0){
+          return vec4<f32>(p_clip, color_avg.w) + v_clip / ma_unit;
+      }else{
+          return input_texel;
+      };
+  }
+`;

package/dist/src/assets/shader/compute/utils/Combine_cs.d.ts

@@ -0,0 +1,4 @@
+/**
+ * 多通道渲染结合
+ */
+export declare let Combine_cs: string;

package/dist/src/assets/shader/compute/utils/Combine_cs.js

@@ -0,0 +1,47 @@
+/**
+ * 多通道渲染结合
+ */
+export let Combine_cs = /*wgsl */ `
+    #include "GlobalUniform"
+    #include "BitUtil"
+    #include "ColorUtil_frag"
+    #include "GBufferStand"
+
+    struct FrameBuffer{
+        frameCount : f32,
+        indirectIns : f32,
+        delay : f32,
+        colorIns : f32,
+        d1 : f32,
+        d2 : f32,
+        d3 : f32,
+        d4 : f32,
+    }
+
+    @group(0) @binding(2) var inputBTexture: texture_2d<f32>;
+    @group(0) @binding(3) var inputBTextureSampler: sampler;
+    @group(0) @binding(4) var outTexture: texture_storage_2d<rgba16float, write>;
+    @group(0) @binding(5) var<storage,read> updateBuffer: FrameBuffer;
+
+    var<private> fragCoord: vec2<u32>;
+
+    const PI = 3.1415926;
+
+    @compute @workgroup_size(16, 16, 1)
+    fn CsMain(@builtin(workgroup_id) workgroup_id: vec3<u32>, @builtin(global_invocation_id) globalInvocation_id: vec3<u32>){
+        fragCoord = globalInvocation_id.xy;
+        let textsize = vec2f(textureDimensions(inputBTexture).xy);
+        let size = vec2f(textureDimensions(outTexture).xy);
+        let inputUV = vec2f(fragCoord) / size;
+        let inputUV2 = vec2<i32>(inputUV * textsize);
+        let time = globalUniform.time;
+        let gBuffer = getGBuffer(vec2i(fragCoord));
+        let b = textureSampleLevel(inputBTexture, inputBTextureSampler, inputUV, 0.0);
+        let albedoColor = getAbldeoFromGBuffer(gBuffer) / PI;
+        let bufferColor = getRGBMColorFromGBuffer(gBuffer);
+        var colorA = bufferColor.xyz * updateBuffer.colorIns;
+        var color = b.xyz * updateBuffer.indirectIns * albedoColor;
+        var currentPixel: vec4f = vec4f(colorA.xyz + color, 1.0);
+        textureStore(outTexture, fragCoord, currentPixel);
+    }
+`;

package/dist/src/assets/shader/compute/utils/Denoising_cs.d.ts

@@ -0,0 +1,4 @@
+/**
+ * 时间降噪
+ */
+export declare let Denoising_cs: string;

package/dist/src/assets/shader/compute/utils/Denoising_cs.js

@@ -0,0 +1,28 @@
+/**
+ * 时间降噪
+ */
+export let Denoising_cs = /*wgsl*/ `
+    struct FrameBuffer{
+        frameCount: f32,
+        indirectIns: f32,
+        delay: f32,
+        frameCount4: i32,
+    }
+
+    @group(0) @binding(1) var<storage,read_write> updateBuffer: FrameBuffer;
+    @group(0) @binding(2) var newTexture: texture_2d<f32>;
+    @group(0) @binding(3) var oldTexture: texture_2d<f32>;
+    @group(0) @binding(4) var combineTexture: texture_storage_2d<rgba16float, write>;
+    var<private> fragCoord:vec2<u32>;
+
+    @compute @workgroup_size(16, 16, 1)
+    fn CsMain(@builtin(workgroup_id) workgroup_id: vec3<u32>, @builtin(global_invocation_id) globalInvocation_id: vec3<u32>){
+        fragCoord = globalInvocation_id.xy;
+        let newPixel = textureLoad( newTexture, fragCoord, 0 );
+        let oldPixel = textureLoad( oldTexture, fragCoord, 0 );
+        let weight = updateBuffer.delay ;
+        var currentPixel:vec4f;
+        currentPixel = vec4f(newPixel.xyz * weight + (1.0-weight) * oldPixel.xyz , 1.0 );
+        textureStore(combineTexture, fragCoord , currentPixel );
+    }
+`;

package/dist/src/assets/shader/compute/utils/TestComputeLoadBuffer.d.ts

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