@rings-webgpu/core 1.0.2 → 1.0.3

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

@@ -1,307 +0,0 @@
-/**
- * 动态漫反射
- */
-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

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

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

@@ -1,285 +0,0 @@
-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

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

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

@@ -1,90 +0,0 @@
-/**
- * 深度感知模糊效果
- */
-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

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