@rings-webgpu/core 1.0.0 → 1.0.2

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

@@ -0,0 +1,64 @@
+export let ErpImage2CubeMapCreateCube_cs = `
+    struct ImageSize {
+        srcWidth: i32,
+        srcHeight: i32,
+        dstWidth: i32,
+        dstHeight: i32
+    };
+
+    @group(0) @binding(0) var<uniform> size: ImageSize;
+    @group(0) @binding(1) var<storage, read_write> faceRotation: array<vec4<f32>>;
+    @group(0) @binding(2) var inputTexSampler : sampler;
+    @group(0) @binding(3) var inputTex: texture_2d<f32>;
+    @group(1) @binding(0) var outputBuffer0: texture_storage_2d_array<rgba16float, write>;
+
+    fn SampleSphericalMap(v: vec3<f32>) -> vec2<f32> {
+        var uv: vec2<f32> = vec2<f32>(atan2(v.z, v.x), asin(v.y));
+        uv = uv * vec2<f32>(0.1590999960899353, 0.3183000087738037);
+        uv = uv + vec2<f32>(0.5);
+        uv = clamp(uv, vec2<f32>(0.0), vec2<f32>(1.0));
+        return uv;
+    }
+
+    fn applyQuaternion(position:vec3<f32>, q:vec4<f32>) -> vec3<f32>{
+      let x:f32 = position.x;
+      let y:f32 = position.y;
+      let z:f32 = position.z;
+
+      let qx:f32 = q.x;
+      let qy:f32 = q.y;
+      let qz:f32 = q.z;
+      let qw:f32 = q.w;
+
+      let ix:f32 = qw * x + qy * z - qz * y;
+      let iy:f32 = qw * y + qz * x - qx * z;
+      let iz:f32 = qw * z + qx * y - qy * x;
+      let iw:f32 = -qx * x - qy * y - qz * z;
+
+      var ret: vec3<f32>;
+      ret.x = ix * qw + iw * -qx + iy * -qz - iz * -qy;
+      ret.y = iy * qw + iw * -qy + iz * -qx - ix * -qz;
+      ret.z = iz * qw + iw * -qz + ix * -qy - iy * -qx;
+
+      return ret;
+  }
+
+  fn convertIdToDir3(uv_i32:vec2<i32>, quaternion: vec4<f32>) -> vec3<f32> {
+    var uv_f32: vec2<f32> = vec2<f32>(uv_i32.xy);
+    var halfSize: f32 = f32(size.dstWidth / 2) - 0.5;
+    var worldDirection:vec3<f32> = vec3<f32>(uv_f32.x - halfSize, uv_f32.y - halfSize, -halfSize);
+    worldDirection = normalize(worldDirection);
+    worldDirection = applyQuaternion(worldDirection, quaternion);
+    return worldDirection;
+  }
+
+  @compute @workgroup_size(8, 8, 1)
+  fn main(@builtin(global_invocation_id) GlobalInvocationID: vec3<u32>) {
+    let coord = vec2<i32>(GlobalInvocationID.xy);
+    let quaternion = faceRotation[GlobalInvocationID.z];
+    var worldDirection:vec3<f32> = convertIdToDir3(coord, quaternion);
+    let uv_f32:vec2<f32> = SampleSphericalMap(worldDirection);
+    let oc = textureSampleLevel(inputTex, inputTexSampler, uv_f32 , 0.0);
+    textureStore(outputBuffer0, coord, i32(GlobalInvocationID.z), oc);
+  }
+`;

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

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

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

@@ -0,0 +1,34 @@
+export let ErpImage2CubeMapRgbe2rgba_cs = `
+    struct ImageSize {
+        srcWidth : i32,
+        srcHeight : i32,
+        dstWidth : i32,
+        dstHeight : i32
+    };
+
+    @group(0) @binding(0) var<uniform> size : ImageSize;
+    @group(0) @binding(1) var<storage, read> tex_in: array<vec4<f32>>;
+    @group(0) @binding(2) var outputBuffer : texture_storage_2d<rgba16float, write>;
+
+    @compute @workgroup_size(8,8,1)
+    fn main(@builtin(global_invocation_id) GlobalInvocationID: vec3<u32>) {
+        let fragCoord = vec2<i32>(i32(GlobalInvocationID.x), i32(GlobalInvocationID.y));
+        var oc:vec4<f32> = tex_in[fragCoord.y * size.srcWidth + fragCoord.x] / 256.0;
+        var e = pow(2.0, oc.w * 255.0 - 128.0);
+        oc = oc * e;
+        oc = scaleByThreshold(oc, 40.0);
+        textureStore(outputBuffer, fragCoord , vec4<f32>(oc.xyz, 1.0));
+    }
+
+    fn scaleByThreshold(color: vec4<f32>, threshold:f32) -> vec4<f32> {
+        var oc = color;
+        let brightness = length(vec3<f32>(oc.xyz));
+        var scale = brightness / threshold;
+        if(scale > 1.0){
+            scale = 1.0 / pow(scale, 0.7);
+            oc = oc * scale;
+        }
+            oc.a = 1.0;
+            return oc;
+    }
+`;

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

@@ -0,0 +1,4 @@
+/**
+ * 全局光照遮蔽
+ */
+export declare let GTAO_cs: string;

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

@@ -0,0 +1,133 @@
+/**
+ * 全局光照遮蔽
+ */
+export let GTAO_cs = /*wgsl*/ `
+    #include "GlobalUniform"
+    #include "GBufferStand"
+
+    struct GTAO{
+        maxDistance: f32,
+        maxPixel: f32,
+        darkFactor: f32,
+        rayMarchSegment: f32,
+        cameraNear: f32,
+        cameraFar: f32,
+        multiBounce: f32,
+        blendColor: f32,
+    }
+
+    @group(0) @binding(2) var<uniform> gtaoData: GTAO;
+    @group(0) @binding(3) var<storage, read_write> directions: array<vec2<f32>>;
+    @group(0) @binding(4) var<storage, read_write> aoBuffer: array<f32>;
+    @group(0) @binding(5) var inTex : texture_2d<f32>;
+    @group(0) @binding(6) var outTex : texture_storage_2d<rgba16float, write>;
+
+    var<private> texSize: vec2<u32>;
+    var<private> fragCoord: vec2<i32>;
+    var<private> fragUV: vec2<f32>;
+    var<private> wPosition: vec3<f32>;
+    var<private> wNormal: vec4<f32>;
+    var<private> maxPixelScaled: f32;
+
+    var<private> gBuffer: GBuffer;
+
+    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 - 1);
+        useNormalMatrixInv();
+
+        gBuffer = getGBuffer(fragCoord);
+        wNormal = vec4f(getWorldNormalFromGBuffer(gBuffer), 1.0);
+        var visible = getRoughnessFromGBuffer(gBuffer);
+        var oc = textureLoad(inTex, fragCoord, 0);
+        let index = fragCoord.x + fragCoord.y * i32(texSize.x);
+        let lastFactor = aoBuffer[index];
+        var newFactor = 0.0;
+        if(visible > 0.0){
+            wPosition = getWorldPositionFromGBuffer(gBuffer, fragUV);
+            let ndc = globalUniform.projMat * globalUniform.viewMat * vec4<f32>(wPosition, 1.0);
+            let ndcZ = ndc.z / ndc.w;
+            maxPixelScaled = calcPixelByNDC(ndcZ);
+            newFactor = rayMarch();
+        }
+
+        var factor:f32 = mix(lastFactor, newFactor, 0.6);
+        aoBuffer[index] = factor;
+        factor = blurFactor(factor);
+        factor = saturate(1.0 - factor * gtaoData.darkFactor);
+        var gtao = vec3<f32>(factor);
+        if(gtaoData.multiBounce > 0.5){
+            gtao = MultiBounce(factor, oc.xyz);
+        }
+
+        var outColor = gtao;
+        if(gtaoData.blendColor > 0.5){
+            outColor = oc.xyz * gtao;
+        }
+        textureStore(outTex, fragCoord , vec4<f32>(outColor, oc.w));
+    }
+
+    fn MultiBounce(AO:f32, Albedo: vec3<f32>) -> vec3<f32>{
+        var A = 2 * Albedo - 0.33;
+        var B = -4.8 * Albedo + 0.64;
+        var C = 2.75 * Albedo + 0.69;
+        return max(vec3<f32>(AO), ((AO * A + B) * AO + C) * AO);
+    }
+
+    fn calcPixelByNDC(ndcZ: f32) -> f32{
+        var coord0 = clamp(fragCoord + vec2<i32>(1, 0) , vec2<i32>(0), vec2<i32>(texSize - 1));
+        var coord1 = clamp(fragCoord + vec2<i32>(-1, 0), vec2<i32>(0), vec2<i32>(texSize - 1));
+        var coord2 = clamp(fragCoord + vec2<i32>(0, 1) , vec2<i32>(0), vec2<i32>(texSize - 1));
+        var coord3 = clamp(fragCoord + vec2<i32>(0, -1), vec2<i32>(0), vec2<i32>(texSize - 1));
+        var index0 = coord0.x + coord0.y * i32(texSize.x);
+        var index1 = coord1.x + coord1.y * i32(texSize.x);
+        var index2 = coord2.x + coord2.y * i32(texSize.x);
+        var index3 = coord3.x + coord3.y * i32(texSize.x);
+        let factor0:f32 = aoBuffer[index0];
+        let factor1:f32 = aoBuffer[index1];
+        let factor2:f32 = aoBuffer[index2];
+        let factor3:f32 = aoBuffer[index3];
+        var factor = 0.25 * (factor0 + factor1 + factor2 + factor3);
+        factor = mix(factor, centerFactor, 0.8);
+        return factor;
+    }
+
+    fn rayMarch() -> f32{
+        let originNormal = normalize(vec3<f32>(wNormal.xyz));
+        let stepPixel = maxPixelScaled / gtaoData.rayMarchSegment;
+        var weight: f32 = 0.0;
+        var totalWeight:f32 = 0.00001;
+        for(var i:i32 = 0; i < 8; i +=1){
+            let dirVec2 = directions[i];
+            for(var j:f32 = 1.1; j < maxPixelScaled; j += stepPixel){
+                var sampleCoord = vec2<i32>(dirVec2 * j) + fragCoord;
+                if(sampleCoord.x >= 0 && sampleCoord.y >=0 && sampleCoord.x < i32(texSize.x) && sampleCoord.y < i32(texSize.y)){
+                    totalWeight += 1.0;
+
+                    let subGBuffer = getGBuffer(sampleCoord);
+                    let samplePosition = getWorldPositionFromGBuffer(subGBuffer, vec2f(sampleCoord)/vec2f(texSize));
+                    var visible = getRoughnessFromGBuffer(subGBuffer);
+                    if(visible>0.0){
+                        let distanceVec2 = samplePosition.xyz - wPosition;
+                        let distance = length(distanceVec2);
+                        if(distance < gtaoData.maxDistance){
+                            let sampleDir = normalize(distanceVec2);
+                            var factor = saturate(dot(sampleDir, originNormal));
+                            factor *= 1.0 - distance / gtaoData.maxDistance;
+                            weight += factor;
+                        }
+                    }
+                }
+            }
+        }
+        weight /= totalWeight;
+        return weight;
+    }
+`;

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

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

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

@@ -0,0 +1,214 @@
+import { CSM } from "../../../core/csm/CSM";
+export let GodRay_cs = /*wgsl*/ `
+    #include "GlobalUniform"
+    #include "GBufferStand"
+
+    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 Uniform {
+        matrix: array<mat4x4<f32>>
+    };
+
+    struct CacheGodRay {
+      pos:vec3<f32>,
+      value:f32,
+    };
+
+    struct GodRayUniform{
+      intensity: f32,
+      rayMarchCount: f32,
+      viewPortWidth: f32,
+      viewPortHeight: f32,
+      blendColor: f32,
+      scatteringExponent: f32,
+    }
+
+    @group(0) @binding(2) var<uniform> godRayUniform: GodRayUniform;
+    @group(0) @binding(3) var inTex : texture_2d<f32>;
+    @group(0) @binding(4) var outTex : texture_storage_2d<rgba16float, write>;
+    @group(0) @binding(5) var shadowMapSampler : sampler_comparison;
+    @group(0) @binding(6) var shadowMap : texture_depth_2d_array;
+    @group(1) @binding(0) var<storage,read> lightBuffer: array<LightData>;
+    @group(1) @binding(1) var<storage, read> models : Uniforms;
+    @group(2) @binding(0) var<storage, read_write> historyGodRayData: array<CacheGodRay>;
+
+    struct ShadowStruct{
+      directShadowVisibility:f32,
+      pointShadows:array<f32,8>,
+    }
+
+    var<private> viewDirection: vec3<f32> ;
+    var<private> texSize: vec2<u32>;
+    var<private> fragUV: vec2<f32>;
+    var<private> fragCoord: vec2<i32>;
+    var<private> wPosition: vec3<f32>;
+    var<private> wNormal: vec4<f32>;
+    var<private> directLight: LightData;
+    var<private> shadowStrut: ShadowStruct ;
+    var<private> gBuffer: GBuffer;
+
+    const PI = 3.1415926;
+
+    const csmCount:i32 = ${CSM.Cascades};
+    fn directShadowMaping(P:vec3<f32>, N:vec2<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;
+            };
+        }
+        shadowStruct.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);
+    }
+
+    @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 - 1);
+        useNormalMatrixInv();
+
+        gBuffer = gBuffer(fragCoord);
+        wNormal = vec4f(getWorldNormalFromGBuffer(gBuffer), 1.0);
+        var visible = getRoughnessFromGBuffer(gBuffer);
+        var oc = textureLoad(inTex, fragCoord, 0);
+        var outColor = oc.xyz;
+        directLight = lightBuffer[0];
+        if(directLight.castShadow >= 0){
+            let index = fragCoord.x + fragCoord.y * i32(texSize.x);
+            var historyData = historyGodRayData[index];
+            let lightColor = directLight.lightColor;
+            var godRayFactor = 0.0;
+            if(visible > 0.0){
+                let lightPos = models.matrix[u32(directLight.lightMatrixIndex)][3].xyz;
+                wPosition = getWorldPositionFromGBuffer(gBuffer,fragUV);
+                viewDirection = normalize(globalUniform.CameraPos - wPosition);
+                godRayFactor = rayMarch();
+                godRayFactor = updateGodRay(historyData, godRayFactor);
+            }
+            historyData.pos = wPosition;
+            historyData.value = godRayFactor;
+            historyGodRayData[index] = historyData;
+
+            outColor = oc.xyz + vec3<f32>(godRayFactor * godRayUniform.intensity * lightColor);
+        }
+        textureStore(outTex, fragCoord, vec4<f32>(outColor, oc.w));
+    }
+
+    fn updateGodRay(historyData:CacheGodRay, newFactor:f32) -> f32 {
+        var changeFactor = 0.2;
+        if(length(historyData.pos - wPosition) > 0.01){
+            changeFactor = 0.4;
+        }
+        var factor = mix(historyData.value, newFactor, changeFactor);
+        let pixelOffset = 1 + i32(globalUniform.frame) % 3;
+        let coordRange = vec2<i32>(texSize);
+        let coordIndex0 = getCoordIndex(fragCoord.x + pixelOffset, fragCoord.y - pixelOffset, coordRange);
+        let coordIndex1 = getCoordIndex(fragCoord.x - pixelOffset, fragCoord.y - pixelOffset, coordRange);
+        let coordIndex2 = getCoordIndex(fragCoord.x, fragCoord.y + pixelOffset * 2, coordRange);
+        let oldOC0 = historyGodRayData[coordIndex0].value;
+        let oldOC1 = historyGodRayData[coordIndex1].value;
+        let oldOC2 = historyGodRayData[coordIndex2].value;
+
+        let opRound = (oldOC0 + oldOC1 + oldOC2) * 0.3333333;
+        factor = mix(opRound, factor, 0.5);
+
+        return factor;
+    }
+
+    fn getCoordIndex(x0:i32, y0:i32, size:vec2<i32>) -> i32{
+      let x = clamp(x0, 0, size.x - 1);
+      let y = clamp(y0, 0, size.y - 1);
+      return y * size.x + x;
+    }
+
+    fn rayMarch() -> f32{
+        var godRayFactor = 0.0;
+        let L = normalize(directLight.direction);
+        let rayMarchCount = godRayUniform.rayMarchCount;
+        if(godRayUniform.blendColor > 0.5){
+            let eyePosition = globalUniform.CameraPos;
+            var samplePosition = eyePosition;
+            var lastSamplePosition = eyePosition;
+            var frameOffset = f32(i32(globalUniform.frame) % 4);
+            frameOffset *=  0.25;
+            var N = normalize(wNormal.xyz);
+            for(var i:f32 = 1.0; i< rayMarchCount; i += 1.0){
+                var t = (i + frameOffset) / rayMarchCount;
+                lastSamplePosition = samplePosition;
+                samplePosition = mix(eyePosition, wPosition, t * t);
+
+                directShadowMaping(samplePosition.xyz, N, globalUniform.shadowBias);
+                var shadowVisibility = shadowStruct.directShadowVisibility;
+                if(shadowVisibility > 0.5){
+                    var stepFactor = calcGodRayValue(samplePosition, L, viewDirection);
+                    stepFactor *= length(lastSamplePosition - samplePosition);
+                    godRayFactor += stepFactor;
+                }
+            }
+            godRayFactor /= length(wPosition - eyePosition);
+        }
+        return godRayFactor;
+    }
+
+    fn calcGodRayValue(pos: vec3<f32>, L:vec3<f32>, V:vec3<f32>) -> f32{
+        var halfLoV = normalize(L + V);
+        var LoV = saturate(dot(V,halfLoV));
+        LoV = pow(LoV, godRayUniform.scatteringExponent);
+        var distance = length(pos - globalUniform.CameraPos) / (globalUniform.far);
+        distance = 1.0 - saturate(distance);
+        distance *= distance;
+        return LoV * distance;
+    }
+`;

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

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

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

@@ -0,0 +1,164 @@
+export let IBLEnvMapCreator_cs = `
+    struct ImageSize {
+        srcWidth : i32,
+        srcHeight : i32,
+        dstWidth : i32,
+        dstHeight : i32
+    };
+
+    @group(0) @binding(0) var<uniform> size : ImageSize;
+    @group(0) @binding(1) var<storage,read_write> faceRotation: array<vec4<f32>>;
+    @group(0) @binding(2) var inputTexSampler : sampler;
+    @group(0) @binding(3) var inputTex : texture_2d<f32>;
+    @group(1) @binding(0) var<uniform> blurSetting : vec4<f32>;
+    @group(1) @binding(1) var outputBuffer0 : texture_storage_2d_array<rgba16float, write>;
+
+    var<private> PI: f32 = 3.14159265359;
+    fn applyQuaternion(position:vec3<f32>, q:vec4<f32>) -> vec3<f32> {
+        let x:f32 = position.x;
+        let y:f32 = position.y;
+        let z:f32 = position.z;
+        let qx:f32 = q.x;
+        let qy:f32 = q.y;
+        let qz:f32 = q.z;
+        let qw:f32 = q.w;
+        let ix:f32 = qw * x + qy * z - qz * y;
+        let iy:f32 = qw * y + qz * x - qx * z;
+        let iz:f32 = qw * z + qx * y - qy * x;
+        let iw:f32 = -qx * x - qy * y - qz * z;
+        var ret: vec3<f32>;
+        ret.x = ix * qw + iw * -qx + iy * -qz - iz * -qy;
+        ret.y = iy * qw + iw * -qy + iz * -qx - ix * -qz;
+        ret.z = iz * qw + iw * -qz + ix * -qy - iy * -qx;
+    
+        return ret;
+    }
+
+    fn convertIdToDir3(uv_i32: vec2<i32>, quaternion: vec4<f32>) -> vec3<f32> {
+        var uv_f32: vec2<f32> = vec2<f32>(uv_i32.xy);
+        var halfSize: f32 = f32(size.dstWidth / 2);
+        var worldDirection:vec3<f32> = vec3<f32>(uv_f32.x - halfSize, uv_f32.y - halfSize, -halfSize);
+        worldDirection = normalize(worldDirection);
+        worldDirection = applyQuaternion(worldDirection, quaternion);
+        return worldDirection;
+    }
+
+    fn VanDerCorpus(n0: u32, base0: u32) -> f32 {
+        var n = n0;
+        var base = base0;
+        var invBase:f32 = 1.0 / f32(base);
+        var denom:f32   = 1.0;
+        var result:f32  = 0.0;
+
+        for(var i:u32 = 0u; i < 32u; i = i + 1u)
+        {
+            if(n > 0u)
+            {
+                denom   = f32(n) % 2.0;
+                result = result + denom * invBase;
+                invBase = invBase / 2.0;
+                n = u32(f32(n) / 2.0);
+            }
+        }
+    
+        return result;
+    }
+
+    fn HammersleyNoBitOps(i:u32, N:u32) -> vec2<f32>
+    {
+        return vec2(f32(i)/f32(N), VanDerCorpus(i, 2u));
+    }
+
+    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;
+    
+        // from tangent-space vector to world-space sample vector
+        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);
+    }
+
+    fn multiSample(normal:vec3<f32>, roughness:f32) -> vec4<f32>
+    {
+        var N: vec3<f32> = normalize(normal);
+        var R: vec3<f32> = N;
+        var V: vec3<f32> = R;
+    
+        let SAMPLE_COUNT:u32 = 1024u;
+        var totalWeight:f32 = 0.0;
+        var prefilteredColor:vec3<f32> = vec3<f32>(0.0, 0.0, 0.0);
+        for(var i:u32 = 0u; i < SAMPLE_COUNT; i = i + 1u)
+        {
+            var Xi:vec2<f32> = hammersley(i, SAMPLE_COUNT);
+            var H :vec3<f32> = ImportanceSampleGGX(Xi, N, roughness);
+            var L :vec3<f32> = normalize(2.0 * dot(V, H) * H - V);
+    
+            var NdotL:f32 = max(dot(N, L), 0.0);
+            if(NdotL > 0.0)
+            {
+                var att = 1.0 ;//( f32(SAMPLE_COUNT - i) / f32(SAMPLE_COUNT)) ;
+                prefilteredColor = prefilteredColor + sampleColor(L).rgb * NdotL;
+                prefilteredColor = prefilteredColor * att ;
+                totalWeight      = totalWeight + NdotL;
+            }
+        }
+        prefilteredColor = prefilteredColor / totalWeight;
+    
+        return vec4<f32>(prefilteredColor, 1.0);
+    }
+
+    fn SampleSphericalMap(v: vec3<f32>) -> vec2<f32> {
+        var uv:vec2<f32> = vec2<f32>(atan2(v.z, v.x), asin(v.y));
+        uv = uv * vec2<f32>(0.1590999960899353, 0.3183000087738037);
+        uv = uv + vec2<f32>(0.5);
+        uv = clamp(uv, vec2<f32>(0.0), vec2<f32>(1.0));
+        return uv;
+    }
+
+    fn sampleColor(d:vec3<f32>) -> vec4<f32>
+    {
+        let uv_f32:vec2<f32> = SampleSphericalMap(d);
+        let oc = textureSampleLevel(inputTex, inputTexSampler, uv_f32 , 0.0);
+        return oc;
+    }
+
+    @compute @workgroup_size(8, 8, 1)
+    fn main(@builtin(global_invocation_id) GlobalInvocationID: vec3<u32>) {
+        let coord = vec2<i32>(GlobalInvocationID.xy);
+        let quaternion = faceRotation[GlobalInvocationID.z];
+        var worldDirection:vec3<f32> = convertIdToDir3(coord, quaternion);
+        var oc:vec4<f32> = multiSample(worldDirection, blurSetting.x);
+        textureStore(outputBuffer0, coord, i32(GlobalInvocationID.z), oc);
+    }
+`;

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

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

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

@@ -0,0 +1,27 @@
+export let MergeRGBA_cs = /*wgsl*/ `
+    @group(0) @binding(0) var textureR: texture_2d<f32>;
+    @group(0) @binding(1) var textureG : texture_2d<f32>;
+    @group(0) @binding(2) var textureB : texture_2d<f32>;
+    @group(0) @binding(3) var textureA : texture_2d<f32>;
+    @group(0) @binding(4) var outTex : texture_storage_2d<rgba8unorm, write>;
+
+    @compute @workgroup_size(8,8,1)
+    fn main(@builtin(global_invocation_id) GlobalInvocationID: vec3<u32>){
+        let size = textureDimensions(outTex);
+        let fragCoord: vec2<i32> = vec2<i32>(GlobalInvocationID.xy);
+        var uv:vec2<f32>;
+        uv.x = f32(fragCoord.x)/f32(size.x);
+        uv.y = f32(fragCoord.y)/f32(size.y);
+        var oc: vec4<f32> = textureSampleLevel(atlasTexture, atlasTextureSampler, targetUV, 0.0);
+        let sizeR = textureDimensions(textureR);
+        let sizeG = textureDimensions(textureG);
+        let sizeB = textureDimensions(textureB);
+        let sizeA = textureDimensions(textureA);
+        var tr = textureLoad(textureR, vec2<i32>(uv * sizeR) , 0 );
+        var tg = textureLoad(textureG, vec2<i32>(uv * sizeG) , 0 );
+        var tb = textureLoad(textureB, vec2<i32>(uv * sizeB) , 0 );
+        var ta = textureLoad(textureA, vec2<i32>(uv * sizeA) , 0 );
+        let color = vec4<f32>(tr,tg,tb,ta);
+        textureStore(outTex, fragCoord , vec4(color));
+    }
+`;

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

@@ -0,0 +1,4 @@
+/**
+ * 多重反射全局光照 result = 直接光照 + 二次反射 * 表面颜色 * 能量守恒系数
+ */
+export declare let MultiBouncePass_cs: string;