@rings-webgpu/core 1.0.0 → 1.0.2

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

@@ -0,0 +1,307 @@
+/**
+ * 动态漫反射
+ */
+export let DDGIIrradiance_shader = `
+    #include "GenerayRandomDir"
+    #include "MathShader"
+    #include "IrradianceVolumeData_frag"
+    var<private> PI: f32 = 3.14159265359;
+
+    struct ProbeData{
+        offsetX:f32,
+        offsetY:f32,
+        offsetZ:f32,
+        frame:f32,
+    }
+
+    struct Uniforms {
+        matrix : array<mat4x4<f32>>
+    };
+
+    struct RayProbeBuffer{
+        WPosition: vec3<f32>,
+        WNormal:vec3<f32>,
+        WRadiance:vec4<f32>,
+    }
+
+    struct CacheHitData{
+        color:vec4<f32>,
+        depth:vec4<f32>,
+    }
+
+    @group(0) @binding(0) var<storage, read> probes : array<ProbeData>;
+    @group(0) @binding(1) var<storage, read_write> irradianceBuffer : array<vec4<f32>>;
+    @group(0) @binding(2) var<storage, read_write> depthBuffer : array<vec4<f32>>;
+    @group(0) @binding(3) var<uniform> uniformData : IrradianceVolumeData ;
+    @group(0) @binding(4) var probeIrradianceMap : texture_storage_2d<rgba16float, write>;
+    @group(0) @binding(5) var probeDepthMap : texture_storage_2d<rgba16float, write>;
+    @group(0) @binding(6) var<storage, read_write> depthRaysBuffer : array<vec4<f32>>;
+    @group(1) @binding(0) var positionMap : texture_2d<f32>;
+    @group(1) @binding(1) var normalMap : texture_2d<f32>;
+    @group(1) @binding(2) var colorMap : texture_2d<f32>;
+    @group(2) @binding(0) var<storage, read> models : Uniforms;
+    
+    var<private> probeID: u32 ;
+    var<private> workgroup_idx: u32 ;
+    var<private> workgroup_idy: u32 ;
+    var<private> hysteresis: f32 = 0.98 ;
+    var<private> epsilon: f32 = 1e-6 ;
+    var<private> probeLocation:vec3<f32> = vec3<f32>(0.0);
+    var<private> energyConservation: f32 = 0.85 ;
+    var<private> resultIrradiance: vec4<f32> ;
+    var<private> resultDepth: vec4<f32> ;
+    var<private> RAYS_PER_PROBE: f32 = 144.0 ;
+    var<private> OCT_RT_SIZE: u32;
+    var<private> PROBE_OCT_RT_SIZE: u32;
+    var<private> OCT_SIDE_SIZE_u32: u32;
+    var<private> OCT_SIDE_SIZE_f32: f32;
+    var<private> OCT_RT_SIZE_f32: f32;
+    var<private> PROBE_SOURCESIZE: f32;
+    var<private> PROBEMAP_SOURCESIZE: f32;
+    var<private> quaternion:vec4<f32> = vec4<f32>(0.0, -0.7071067811865475, 0.7071067811865475, 0.0);
+    var<private> randomMatrix:mat4x4<f32>;
+
+    @compute @workgroup_size(8,8,1)
+    fn CsMain(@builtin(global_invocation_id) globalInvocation_id : vec3<u32>){
+        RAYS_PER_PROBE = f32(i32(uniformData.rayNumber));
+        OCT_RT_SIZE = u32(uniformData.OctRTMaxSize);
+        OCT_RT_SIZE_f32 = f32(uniformData.OctRTMaxSize);
+        OCT_SIDE_SIZE_u32 = u32(uniformData.OctRTSideSize);
+        OCT_SIDE_SIZE_f32 = f32(uniformData.OctRTSideSize);
+        PROBE_SOURCESIZE = f32(uniformData.ProbeSize);
+        PROBEMAP_SOURCESIZE = f32(uniformData.ProbeSourceTextureSize);
+        hysteresis = uniformData.hysteresis;
+        probeID = globalInvocation_id.z ;
+        workgroup_idx = globalInvocation_id.x ;
+        workgroup_idy = globalInvocation_id.y;
+        probeLocation = calcProbePosition(probeID);
+        resultIrradiance = vec4<f32>(0.0);
+        resultDepth = vec4<f32>(0.0,0.0,0.0,0.0);
+        var tdr = normalize(getCurrentDir());
+        let orientationIndex = u32(uniformData.orientationIndex);
+        randomMatrix = models.matrix[orientationIndex];
+        var distancePprobeUV = getSampleProbeUV(tdr.xyz);
+        var rayUv:vec2<i32> = vec2<i32>(distancePprobeUV.xy * f32(PROBEMAP_SOURCESIZE - 1.0));
+        let rayHitPosition = textureLoad(positionMap, rayUv, 0).xyz;
+        for(var i:f32 = 0.0; i < RAYS_PER_PROBE ; i = i + 1.0 ){
+            radianceProbeOnce(i, tdr);
+        }
+        if (resultIrradiance.w > epsilon) {
+            var color = vec3<f32>(resultIrradiance.xyz/(2.0*resultIrradiance.w)) ;
+            color = pow(color.rgb, vec3<f32>(1.0 / uniformData.ddgiGamma));
+            resultIrradiance = vec4<f32>(color,1.0-hysteresis);
+        }
+
+        if (resultDepth.w > epsilon) {
+             resultDepth = vec4<f32>(resultDepth.xyz/(2.0*resultDepth.w),1.0-hysteresis) ;
+        }
+
+        let pixelCoord = getWriteOctUVByID();
+        var lerpDataResult:CacheHitData;
+        lerpDataResult.color = resultIrradiance;
+        lerpDataResult.depth = resultDepth;
+        lerpDataResult = lerpHitData(lerpDataResult, pixelCoord);
+        writeRayHitData(pixelCoord, lerpDataResult);
+        storePixelAtCoord(probeIrradianceMap, pixelCoord , vec4<f32>(lerpDataResult.color.xyz, 1.0), true);
+        storePixelAtCoord(probeDepthMap, pixelCoord , vec4<f32>(resultDepth.xy, 0.0, 1.0), false);
+    }
+
+    fn lerpHitData(data:CacheHitData, coord:vec2<i32>) -> CacheHitData{
+        let frameIndex = probes[probeID].frame;
+        var newData:CacheHitData = data;
+        var oldData = readRayHitData(coord);
+        newData.color = mix(oldData.color, newData.color, uniformData.lerpHysteresis);
+        newData.depth = mix(oldData.depth, newData.depth, uniformData.lerpHysteresis);
+        return newData;
+    }
+
+    fn square(v:vec3<f32>) -> vec3<f32>{
+        var v3 = v;
+        v3.x = v3.x * v3.x;
+        v3.y = v3.y * v3.y;
+        v3.z = v3.z * v3.z;
+        return v3;
+    }
+
+    fn testSample() ->vec4<f32>{
+        var ux = f32(workgroup_idx) / OCT_SIDE_SIZE_f32;
+        var uy = f32(workgroup_idy) / OCT_SIDE_SIZE_f32;
+        var uv = vec2<f32>(ux,uy) * 2.0 - 1.0 ;
+        var dir = octDecode(uv);
+        var probeUV = getSampleProbeUV(dir.xyz);
+        var rayProbeBuffer = getCurrentRayHitBuffer(probeUV);
+        return rayProbeBuffer.WRadiance;
+    }
+
+    fn gridCoordToProbeIndex(grid:vec3<i32>) -> i32
+    {
+        return grid.x + grid.z * i32(uniformData.gridXCount) + grid.y * i32(uniformData.gridXCount * uniformData.gridZCount);
+    }
+
+    fn storePixelAtCoord(texture:texture_storage_2d<rgba16float, write>, coord:vec2<i32>, color:vec4<f32>, isColor:bool){
+        let sideCnt = i32(OCT_SIDE_SIZE_u32);
+        let sideBorderCnt = sideCnt + 2;
+        let indexXY = coord / sideCnt;
+        let modeXY = coord % sideCnt;
+
+        var newCoord = indexXY * sideBorderCnt + modeXY;
+        textureStore(texture, newCoord + 1, color);
+
+        var borderCoord = vec2<i32>(-1);
+        //左右
+        if(modeXY.x % (sideCnt - 1) == 0){
+            borderCoord = modeXY;
+            borderCoord.y = sideCnt - borderCoord.y;
+            if(modeXY.x == sideCnt - 1){
+            borderCoord.x = sideBorderCnt - 1;
+            }
+            borderCoord = indexXY * sideBorderCnt + borderCoord;
+            textureStore(texture, borderCoord, color);
+        }
+        //上下
+        if(modeXY.y % (sideCnt - 1) == 0){
+            borderCoord = modeXY;
+            borderCoord.x = sideCnt - borderCoord.x;
+            if(modeXY.y == sideCnt - 1){
+                borderCoord.y = sideBorderCnt - 1;
+            }
+            borderCoord = indexXY * sideBorderCnt + borderCoord;
+            textureStore(texture, borderCoord, color);
+        }
+        //补角
+        if(modeXY.x % (sideCnt - 1) == 0 && modeXY.y % (sideCnt - 1) == 0){
+            var cornerCoord = modeXY;
+            if(modeXY.x == 0){
+                cornerCoord.x = sideBorderCnt - 1;
+            }else{
+                cornerCoord.x = 0;
+            };
+            if(modeXY.y == 0){
+                cornerCoord.y = sideBorderCnt - 1;
+            }else{
+                cornerCoord.y = 0;
+            };
+            cornerCoord = indexXY * sideBorderCnt + cornerCoord;
+            textureStore(texture, cornerCoord, color);
+        }
+    }
+
+    fn calcProbePosition(id:u32) -> vec3<f32>{
+        var probeLocation = vec3<f32>(0.0);
+        var blockCount = u32(uniformData.gridXCount * uniformData.gridZCount) ;
+        var grid = vec3<u32>(0u);
+        grid.x = (id % blockCount) % u32(uniformData.gridXCount);
+        grid.y = id / blockCount;
+        grid.z = (id % blockCount) / u32(uniformData.gridXCount);
+        probeLocation.x = f32(grid.x) * uniformData.ProbeSpace + uniformData.startX;
+        probeLocation.y = f32(grid.y) * uniformData.ProbeSpace + uniformData.startY;
+        probeLocation.z = f32(grid.z) * uniformData.ProbeSpace + uniformData.startZ;
+        return probeLocation;
+    }
+
+    fn getWriteOctUVByID() -> vec2<i32>
+    {
+        var blockCount = u32(uniformData.gridXCount * uniformData.gridZCount) ;
+        var offsetX = (probeID % blockCount) % u32(uniformData.gridXCount) ;
+        var offsetY = u32(uniformData.gridZCount - 1.0) - (probeID % blockCount) / u32(uniformData.gridXCount) ;
+        var offsetZ = probeID / blockCount ;
+        var pixelCoord = vec2<i32>(i32(workgroup_idx), i32(workgroup_idy));
+        pixelCoord.x = pixelCoord.x + i32(offsetX * OCT_SIDE_SIZE_u32);
+        pixelCoord.y = pixelCoord.y + i32(offsetY * OCT_SIDE_SIZE_u32 + offsetZ * u32(uniformData.gridZCount) * OCT_SIDE_SIZE_u32);
+
+        pixelCoord = offsetByCol(pixelCoord, OCT_SIDE_SIZE_f32, OCT_RT_SIZE, vec3<f32>(uniformData.gridXCount, uniformData.gridYCount, uniformData.gridZCount));
+        return pixelCoord;
+    }
+
+    fn offsetByCol(pixelCoord0:vec2<i32>, octSideSize:f32, mapHeight:u32, counts:vec3<f32>) -> vec2<i32>
+    {
+        var pixelCoord = pixelCoord0;
+        let blockSize:vec2<i32> = vec2<i32>(i32(octSideSize * counts.x),  i32(octSideSize * counts.z));
+        let blockSizeYBorder:i32 = i32((octSideSize + 2.0) * counts.z);
+        let blockMaxRowBorder:i32 = i32(mapHeight) / blockSizeYBorder;
+        let pixelCountYMax:i32 = blockMaxRowBorder * i32(octSideSize * counts.z);
+        let col:i32 = pixelCoord.y / pixelCountYMax;
+
+        pixelCoord.x = col * i32(octSideSize * counts.x) + pixelCoord.x;
+        pixelCoord.y = pixelCoord.y % pixelCountYMax;
+
+        return pixelCoord;
+    }
+
+    fn radianceProbeOnce(rayID:f32, tdr:vec3<f32>){
+        var texelDirection = sphericalFibonacci(rayID, RAYS_PER_PROBE ) ;
+        var rayDirection = normalize( vec3<f32>((randomMatrix * vec4<f32>(texelDirection, 1.0)).xyz));
+        var probeUV = getSampleProbeUV(rayDirection.xyz);
+        var rayWriteUV = getWriteRayInfoUV();
+        var rayProbeBuffer = getCurrentRayHitBuffer(probeUV);
+        var rayHitLocation = rayProbeBuffer.WPosition + normalize(rayProbeBuffer.WNormal) * 0.01;
+        var rayProbeDistance = length(probeLocation - rayHitLocation) ;
+        let rid = i32(probeID) * i32(RAYS_PER_PROBE) + i32(rayID) ;
+        depthRaysBuffer[rid] = vec4<f32>(rayDirection.xyz,rayProbeDistance) ;
+
+        // Detect misses and force depth
+        var i_weight = max(0.0, dot(tdr,rayDirection) );
+        var d_weight = pow(i_weight, uniformData.depthSharpness);
+        
+        if (i_weight >= epsilon) {
+            resultIrradiance += vec4(rayProbeBuffer.WRadiance.rgb, i_weight );
+        }
+        if(d_weight>= epsilon){
+            resultDepth += vec4(rayProbeDistance * d_weight, rayProbeDistance * rayProbeDistance * d_weight, 0.0 , i_weight);
+        }
+    }
+
+    fn getCurrentRayHitBuffer(probeUV:vec2<f32>) -> RayProbeBuffer {
+        var rayProbeBuffer : RayProbeBuffer;
+        var uv:vec2<i32> = vec2<i32>(probeUV.xy * f32(PROBEMAP_SOURCESIZE - 1.0));
+        rayProbeBuffer.WPosition = textureLoad(positionMap, uv, 0).xyz;
+        rayProbeBuffer.WNormal = normalize(textureLoad(normalMap, uv, 0).xyz * 2.0 - 1.0);
+        rayProbeBuffer.WRadiance = textureLoad(colorMap, uv, 0).xyzw * energyConservation;
+        return rayProbeBuffer;
+    }
+
+    fn getSampleProbeUV(dir0:vec3<f32>) -> vec2<f32> {
+        var dir = applyQuaternion(dir0, quaternion);
+        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:f32 = PROBE_SOURCESIZE / PROBEMAP_SOURCESIZE;
+        targetUV = targetUV * aspect;
+
+        var fullCol = u32(PROBEMAP_SOURCESIZE) / u32(PROBE_SOURCESIZE);
+        var offsetSampleUv = vec2<f32>( f32(probeID / fullCol) * 6.0 , f32(probeID % fullCol)) * aspect;
+        return targetUV + offsetSampleUv;
+    }
+
+    fn getWriteRayInfoUV() -> vec2<i32> {
+        var writeUV = vec2<i32>(i32(workgroup_idy),i32(probeID));
+        return writeUV;
+    }
+
+    fn writeRayHitData( uv:vec2<i32> , data:CacheHitData){
+        let index = uv.y * i32(OCT_RT_SIZE) + uv.x;
+        irradianceBuffer[index] = data.color;
+        depthBuffer[index] = data.depth;
+    }
+
+    fn readRayHitData( uv:vec2<i32> ) -> CacheHitData{
+        var data:CacheHitData;
+        let index = uv.y * i32(OCT_RT_SIZE) + uv.x;
+        data.color = irradianceBuffer[index];
+        data.depth = depthBuffer[index];
+        return data;
+    }
+
+    fn getCurrentDir() -> vec3<f32> {
+        var ux = f32(workgroup_idx) / OCT_SIDE_SIZE_f32;
+        var uy = f32(workgroup_idy) / OCT_SIDE_SIZE_f32;
+        var uv = vec2<f32>(ux,uy) * 2.0 - 1.0;
+        var dir = octDecode(uv);
+        return normalize(dir);
+    }
+`;

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

@@ -0,0 +1,4 @@
+/**
+ * 延迟光照渲染
+ */
+export declare let DDGILighting_shader: string;

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

@@ -0,0 +1,285 @@
+import { CSM } from "../../../core/csm/CSM";
+/**
+ * 延迟光照渲染
+ */
+export let DDGILighting_shader = `
+var<private> PI: f32 = 3.14159265359;
+#include "GlobalUniform"
+#include "MathShader"
+#include "FastMathShader"
+#include "ColorUtil_frag"
+
+struct ConstUniform{
+   screenWidth:f32,
+   screenHeight:f32
+}
+
+struct LightData {
+     index:f32,
+     lightType:i32,
+     radius:f32,
+     linear:f32,
+     position:vec3<f32>,
+     lightMatrixIndex:f32,
+     direction:vec3<f32>,
+     quadratic:f32,
+     lightColor:vec3<f32>,
+     intensity:f32,
+     innerCutOff :f32,
+     outerCutOff:f32,
+     range :f32,
+     castShadow:i32,
+     lightTangent:vec3<f32>,
+     ies:f32,
+};
+
+struct Uniforms {
+     matrix : array<mat4x4<f32>>
+ };
+
+const PointLightType = 1;
+const DirectLightType = 2;
+const SpotLightType = 3;
+
+@group(0) @binding(auto) var outputBuffer : texture_storage_2d<rgba16float, write>;
+@group(0) @binding(auto) var prefilterMapSampler: sampler;
+@group(0) @binding(auto) var prefilterMap: texture_cube<f32>;
+@group(1) @binding(auto) var positionMapSampler : sampler;
+@group(1) @binding(auto) var positionMap : texture_2d<f32>;
+@group(1) @binding(auto) var normalMapSampler : sampler;
+@group(1) @binding(auto) var normalMap : texture_2d<f32>;
+@group(1) @binding(auto) var colorMapSampler : sampler;
+@group(1) @binding(auto) var colorMap : texture_2d<f32>;
+@group(1) @binding(auto) var shadowMapSampler : sampler_comparison;
+@group(1) @binding(auto) var shadowMap : texture_depth_2d_array;
+@group(1) @binding(auto) var pointShadowMapSampler: sampler;
+@group(1) @binding(auto) var pointShadowMap: texture_depth_cube_array;
+@group(2) @binding(0) var<storage,read> lightBuffer: array<LightData>;
+@group(2) @binding(1) var<storage, read> models : Uniforms;
+
+struct ShadowStruct{
+ directShadowVisibility:f32,
+ pointShadows:array<f32,8>,
+}
+
+var<private> shadowStrut: ShadowStruct ;
+var<private> ulitColor:vec3<f32>;
+var<private> wPosition:vec3<f32>;
+var<private> wNormal:vec3<f32>;
+
+const LUMEN = 10.764;
+
+fn samplePosition(uv:vec2<f32>) -> vec4<f32>
+{
+   return textureSampleLevel(positionMap, positionMapSampler,uv, 0.0);
+}
+
+fn sampleNormal(uv:vec2<f32>) -> vec4<f32>
+{
+  return textureSampleLevel(normalMap, normalMapSampler, uv, 0.0);
+}
+
+fn sampleColor(uv:vec2<f32>) -> vec4<f32>
+{
+   var oc:vec4<f32> = textureSampleLevel(colorMap, colorMapSampler, uv, 0.0);
+   ulitColor = vec3(oc.xyz);
+   return oc;
+}
+
+const csmCount:i32 = ${CSM.Cascades};
+fn directShadowMaping(P:vec3<f32>, N:vec3<f32>, shadowBias: f32)  {
+  let enableCSM:bool = globalUniform.enableCSM > 0.5;
+  var light = lightBuffer[0];
+  var visibility = 1.0;
+    var shadowIndex = i32(light.castShadow);
+    if (shadowIndex >= 0 ) {
+      var shadowMatrix:mat4x4<f32>;
+      if(enableCSM && csmCount > 1){
+        for(var csm:i32 = 0; csm < csmCount; csm ++){
+          var csmShadowBias = globalUniform.csmShadowBias[csm];
+          shadowMatrix = globalUniform.csmMatrix[csm];
+          let csmShadowResult = directShadowMapingIndex(light, shadowMatrix, P, N, csm, csmShadowBias);
+          if(csmShadowResult.y < 0.5){
+            visibility = csmShadowResult.x;
+            break;
+          }
+        }
+      }else{
+        shadowMatrix = globalUniform.shadowMatrix[shadowIndex];
+        visibility = directShadowMapingIndex(light, shadowMatrix, P, N, shadowIndex, shadowBias).x;
+      };
+    }
+  shadowStrut.directShadowVisibility = visibility;
+}
+
+fn directShadowMapingIndex(light:LightData, matrix:mat4x4<f32>, P:vec3<f32>, N:vec3<f32>, depthTexIndex:i32, shadowBias:f32) -> vec2<f32>
+{
+  var visibility = 1.0;
+  var isOutSideArea:f32 = 1.0;
+  var shadowPosTmp = matrix * vec4<f32>(P.xyz, 1.0);
+  var shadowPos = shadowPosTmp.xyz / shadowPosTmp.w;
+  var varying_shadowUV = shadowPos.xy * vec2<f32>(0.5, -0.5) + vec2<f32>(0.5, 0.5);
+  if (varying_shadowUV.x <= 1.0
+    && varying_shadowUV.x >= 0.0
+    && varying_shadowUV.y <= 1.0
+    && varying_shadowUV.y >= 0.0
+    && shadowPosTmp.z <= 1.0
+    && shadowPosTmp.z >= 0.0)
+  {
+    isOutSideArea = 0.0;
+    var uvOnePixel = 1.0 / vec2<f32>(globalUniform.shadowMapSize);
+    var NoL = abs(dot(N, normalize(light.direction)));
+    var bias = shadowBias / max(NoL, 0.000001);
+    visibility = textureSampleCompareLevel(shadowMap, shadowMapSampler, varying_shadowUV, depthTexIndex, shadowPos.z - bias);
+    visibility += 0.001;
+  }
+  return vec2<f32>(visibility, isOutSideArea);
+}
+
+fn pointShadowMapCompare(shadowBias:f32){
+   for(var i:i32 = i32(0) ; i < i32(8); i = i + 1 )
+   {
+       var v = 1.0;
+       let light = lightBuffer[i];
+       if(light.castShadow < 0){
+         shadowStrut.pointShadows[i] = v;
+         continue;
+       }
+
+       let frgToLight = wPosition - light.position.xyz;
+       var dir:vec3<f32> = normalize(frgToLight);
+       var len = length(frgToLight);
+       var depth = textureSampleLevel(pointShadowMap,pointShadowMapSampler,dir.xyz,i,0); 
+       depth *= globalUniform.far;
+       if((len - shadowBias) > depth){
+          v = 0.0; 
+       }
+       shadowStrut.pointShadows[i] = v;
+   }
+}
+
+fn directLighting( albedo:vec3<f32> , WP :vec3<f32>, N:vec3<f32> , V:vec3<f32> , light:LightData , shadowBias:f32  ) -> vec3<f32> {
+    var L = -normalize(light.direction.xyz) ;
+    var NoL = max(dot(N,L),0.0);
+    let lightCC = pow( light.lightColor.rgb,vec3<f32>(2.2));
+    var lightColor = getHDRColor( lightCC , light.linear ) ;
+    var att = light.intensity / LUMEN ;
+    if(light.castShadow>=0){
+        lightColor *= shadowStrut.directShadowVisibility ;
+    }
+    let finalLight = (albedo / PI) * lightColor * NoL * att * 2.0 ;
+    return finalLight ;
+}
+
+fn pointLighting( albedo:vec3<f32>,WP:vec3<f32>, N:vec3<f32>, V:vec3<f32>, light:LightData ) -> vec3<f32> {
+    let lightPos = models.matrix[u32(light.lightMatrixIndex)][3].xyz;
+    var dir = lightPos.xyz - WP ;
+    let dist = length(dir);
+    var color = vec3<f32>(0.0) ;
+    if(dist != 0.0){
+    dir *= 1.0 / dist ;
+    }
+
+    if( abs(dist) < light.range ){
+        var L = dir ;
+        var atten = 1.0 ;
+        atten = 1.0 - smoothstep(0.0,light.range,dist) ;
+        atten *= 1.0 / max(light.radius,0.0001) ;
+
+        var lightColor = light.lightColor.rgb  ;
+        lightColor = getHDRColor(lightColor , light.linear ) * light.intensity / LUMEN * 2.0;
+        color = (albedo / PI) * lightColor.rgb * atten ;
+    }
+
+    return  color *0.0;
+}
+
+fn spotLight( albedo:vec3<f32>,WP:vec3<f32>, N:vec3<f32>, V:vec3<f32>, light:LightData ) -> vec3<f32> {
+ let lightPos = models.matrix[u32(light.lightMatrixIndex)][3].xyz;
+ var dir = lightPos.xyz - WP;
+ let dist = length(dir);
+ if(dist != 0.0){
+   dir *= 1.0 / dist ;
+ }
+
+ var color = vec3<f32>(0.0) ;
+ if( abs(dist) < light.range * 2.0 ){
+     var L = dir ;
+     let theta = dot(-L, normalize(light.direction));
+     let angle = acos(theta) ;
+     var atten = 1.0 ;
+     atten = 1.0 - smoothstep(0.0,light.range,dist) ;
+     atten *= 1.0 / max(light.radius,0.1) ;
+     if(angle < light.outerCutOff){
+       if(angle > light.innerCutOff){
+         atten *= 1.0 - smoothstep(light.innerCutOff, light.outerCutOff, angle) ;
+       }
+     }else{
+       atten = 0.0 ;
+     };
+     var lightColor = light.lightColor.rgb  ;
+     lightColor = getHDRColor(lightColor , light.linear ) * light.intensity / LUMEN * 2.0;
+     color = (albedo / PI) * lightColor.rgb * atten ;
+   }
+ return  color ;
+}
+
+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);
+}
+
+fn coordFun(fragCoord:vec2<i32>)-> vec4<f32>{
+    let uv_01 = CalcUV_01(fragCoord, texSize);
+    var pos = samplePosition(uv_01);
+    var normalMap = sampleNormal(uv_01);
+    var normal = normalize( normalMap.xyz * 2.0 - 1.0 );
+    var color = sampleColor(uv_01);
+    var emissive = vec4<f32>(pos.a,normalMap.a,color.a,0.0) * 1.0 ;
+    if(pos.w + 1.0 > 10000.0){
+    return vec4<f32>(color);
+    }
+    var V = normalize(pos.xyz - globalUniform.cameraWorldMatrix[3].xyz);
+    var N = normal.xyz ;
+    wPosition = pos.xyz;
+    wNormal = N;
+    directShadowMaping(wPosition, wNormal, globalUniform.shadowBias);
+    pointShadowMapCompare(globalUniform.shadowBias);
+    var lighting = vec3<f32>(0.0);
+    let lightCount = 32 ;
+    for(var i:i32 = 0 ; i < lightCount ; i = i + 1 )
+    {
+        let light = lightBuffer[i];
+        switch (light.lightType) {
+            case PointLightType: {
+                lighting += pointLighting(color.rgb,pos.xyz,N,V,light);
+            }
+            case DirectLightType: {
+                lighting += directLighting(color.rgb,pos.xyz,N,V,light,globalUniform.shadowBias);
+            }
+            case SpotLightType: {
+                lighting += spotLight(color.rgb,pos.xyz,N,V,light);
+            }
+            default: {
+            }
+        }
+    }
+
+    var skyLight: vec3<f32> = globalUniform.skyExposure * (textureSampleLevel(prefilterMap, prefilterMapSampler, N.xyz, 8.0 ).rgb);
+    lighting = lighting.rgb ;//+ skyLight.rgb ;
+    return vec4<f32>(lighting.rgb,color.w)+emissive;
+}
+
+var<private> texSize: vec2<u32>;
+
+@compute @workgroup_size( 8 , 8 , 1 )
+fn CsMain( @builtin(workgroup_id) workgroup_id : vec3<u32> , @builtin(global_invocation_id) globalInvocation_id : vec3<u32>)
+{
+   var fragCoord = vec2<i32>(globalInvocation_id.xy);
+   texSize = textureDimensions(colorMap).xy;
+   var color = coordFun(fragCoord);
+   textureStore(outputBuffer, fragCoord, color);
+}
+`;

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

@@ -0,0 +1,4 @@
+/**
+ * 深度感知模糊效果
+ */
+export declare let DepthOfView_cs: string;

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

@@ -0,0 +1,90 @@
+/**
+ * 深度感知模糊效果
+ */
+export let DepthOfView_cs = `
+    #include "GlobalUniform"
+    #include "GBufferStand"
+
+    struct BlurSetting{
+        near: f32,
+        far: f32,
+        pixelOffset: f32,
+    }
+
+    @group(0) @binding(2) var<uniform> blurSetting: BlurSetting;
+    @group(0) @binding(3) var inTexSampler: sampler;
+    @group(0) @binding(4) var inTex: texture_2d<f32>;
+    @group(0) @binding(5) var outTex: texture_storage_2d<rgba16float, write>;
+
+    var<private> cameraPosition: vec3<f32>;
+    var<private> texSize: vec2<u32>;
+    var<private> fragCoord: vec2<i32>;
+    var<private> fragUV: vec2<f32>;
+    var<private> texelSize: vec2<f32>;
+
+    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 );
+        texSize = textureDimensions(inTex).xy;
+
+        if(fragCoord.x >= i32(texSize.x) || fragCoord.y >= i32(texSize.y)){
+            return;
+        }
+
+        fragUV = vec2<f32>(fragCoord) / vec2<f32>(texSize);
+        texelSize = 1.0 / vec2<f32>(texSize - 1);
+        var gBuffer = getGBuffer(fragCoord);
+        useNormalMatrixInv();
+
+        cameraPosition = globalUniform.CameraPos.xyz;
+        var wPosition = getWorldPositionFromGBuffer(gBuffer,fragUV);
+        var distance = length(wPosition - cameraPosition);
+        var oc:vec4<f32> = textureLoad(inTex, fragCoord, 0);
+        if(distance > blurSetting.near){
+            var normal = getWorldNormalFromGBuffer(gBuffer);
+            var pixelScale = 0.5;
+            if(gBuffer.x > 9999.0){
+                distance = min(distance, blurSetting.far);
+                pixelScale = (distance - blurSetting.near) / (blurSetting.far - blurSetting.near);
+            }
+            oc = mixBlurColor(oc, fragCoord, blurSetting.pixelOffset, pixelScale);
+        }
+        textureStore(outTex, fragCoord, oc);
+    }
+
+    fn mixBlurColor(orginColor: vec4<f32>, coord: vec2<i32>, pixelOffset: f32, scale: f32) -> vec4<f32> {
+        let uv = vec2<f32>(coord);
+        var uv0 = (uv + scale * vec2<f32>( pixelOffset,  pixelOffset)) * texelSize;
+        var uv1 = (uv + scale * vec2<f32>(-pixelOffset,  pixelOffset)) * texelSize;
+        var uv2 = (uv + scale * vec2<f32>(-pixelOffset, -pixelOffset)) * texelSize;
+        var uv3 = (uv + scale * vec2<f32>( pixelOffset, -pixelOffset)) * texelSize;
+
+        uv0.x = processUVEdge(uv0.x);
+        uv0.y = processUVEdge(uv0.y);
+        uv1.x = processUVEdge(uv1.x);
+        uv1.y = processUVEdge(uv1.y);
+        uv2.x = processUVEdge(uv2.x);
+        uv2.y = processUVEdge(uv2.y);
+        uv3.x = processUVEdge(uv3.x);
+        uv3.y = processUVEdge(uv3.y);
+
+        var ob = vec4<f32>(0.0);
+        ob += textureSampleLevel(inTex, inTexSampler, uv0, 0.0);
+        ob += textureSampleLevel(inTex, inTexSampler, uv1, 0.0);
+        ob += textureSampleLevel(inTex, inTexSampler, uv2, 0.0);
+        ob += textureSampleLevel(inTex, inTexSampler, uv3, 0.0);
+        return mix(originColor, ob * 0.25, scale);
+    }
+
+    fn processUVEdge(v: f32) -> f32{
+        var value = v;
+        if(value < 0.0){
+            value = -value;
+        }else if(value > 1.0){
+            value = 2.0 - value;
+        }
+        return value;
+    }
+`;

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

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