@rings-webgpu/core 1.0.0 → 1.0.2

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

@@ -0,0 +1,169 @@
+/**
+ * 多重反射全局光照 result = 直接光照 + 二次反射 * 表面颜色 * 能量守恒系数
+ */
+export let MultiBouncePass_cs = `
+    #include "MathShader"
+    #include "IrradianceVolumeData_frag"
+
+    struct IrradianceField {
+        probeStartPosition: vec4<f32>,
+        probeCounts:vec4<f32>,
+        probeStep:f32,
+        irradianceTextureWidth:f32,
+        irradianceTextureHeight:f32,
+        irradianceProbeSideLength:f32,
+    };
+
+    @group(0) @binding(0) var outputBuffer : texture_storage_2d<rgba16float, write>;
+    @group(0) @binding(1) var<uniform> uniformData : IrradianceVolumeData ;
+    @group(1) @binding(0) var normalMapSampler : sampler;
+    @group(1) @binding(1) var normalMap : texture_2d<f32>;
+    @group(1) @binding(2) var colorMapSampler : sampler;
+    @group(1) @binding(3) var colorMap : texture_2d<f32>;
+    @group(1) @binding(4) var litMapSampler : sampler;
+    @group(1) @binding(5) var litMap : texture_2d<f32>;
+    @group(1) @binding(6) var irradianceMapSampler : sampler;
+    @group(1) @binding(7) var irradianceMap : texture_2d<f32>;
+
+    var<private> wsn:vec3<f32>;
+    var<private> ulitColor:vec4<f32>;
+    var<private> litColor:vec4<f32>;
+    var<private> irradianceFieldSurface : IrradianceField ;
+    var<private> probeID:u32;
+    var<private> quaternion:vec4<f32> = vec4<f32>(0.0, -0.7071067811865475, 0.7071067811865475, 0.0);
+
+    fn getIrradianceFieldSurface() -> IrradianceField{
+        let data = uniformData;
+        irradianceFieldSurface.probeStartPosition = vec4<f32>(data.startX, data.startY, data.startZ, 0.0);
+        irradianceFieldSurface.probeCounts = vec4<f32>(data.gridXCount, data.gridYCount, data.gridZCount, 0.0);
+        irradianceFieldSurface.probeStep = data.ProbeSpace;
+        irradianceFieldSurface.irradianceTextureWidth = data.OctRTMaxSize;
+        irradianceFieldSurface.irradianceTextureHeight = data.OctRTMaxSize;
+        irradianceFieldSurface.irradianceProbeSideLength = data.OctRTSideSize;
+        return irradianceFieldSurface;
+    }
+
+    fn rotateDir(n:vec3<f32>) -> vec3<f32>{
+        return normalize(applyQuaternion(-n, quaternion));
+    }
+
+    fn sampleLitColor(uv:vec2<i32>) -> vec4<f32>
+    {
+        var oc1:vec4<f32> = textureSampleLevel(litMap, litMapSampler, vec2<f32>(0.0), 0.0);
+        var oc:vec4<f32> = textureLoad(litMap, uv, 0);
+        return oc;
+    }
+
+    fn sampleNormal(uv:vec2<i32>) -> vec4<f32>
+    {
+        var oc1:vec4<f32> = textureSampleLevel(normalMap, normalMapSampler, vec2<f32>(0.0), 0.0);
+        var oc:vec4<f32> = textureLoad(normalMap, uv, 0);
+        return oc;
+    }
+
+    fn sampleColor(uv:vec2<i32>) -> vec4<f32>
+    {
+        var oc1:vec4<f32> = textureSampleLevel(colorMap, colorMapSampler, vec2<f32>(0.0), 0.0);
+        var oc:vec4<f32> = textureLoad(colorMap, uv, 0);
+        return oc;
+    }
+
+    fn sampleProbe(fragCoord:vec2<u32>){
+        var uv = vec2<i32>(i32(fragCoord.x), i32(fragCoord.y)) ;
+        litColor = sampleLitColor(uv);
+        var normalMap = sampleNormal(uv);
+        wsn = normalMap.xyz * 2.0 - 1.0;
+        ulitColor = sampleColor(uv);
+    }
+
+    @compute @workgroup_size(8,8,1)
+    fn CsMain(@builtin(global_invocation_id) globalInvocation_id : vec3<u32>){
+        getIrradianceFieldSurface();
+        var fragCoord = vec2<u32>( globalInvocation_id.x, globalInvocation_id.y);
+        probeID = globalInvocation_id.z;
+        fragCoord = fragCoord + getCoordOffset(probeID);
+        sampleProbe(fragCoord);
+        let irradiance = getIrradianceColor();
+        let result = blendIrradianceColor(irradiance);
+        textureStore(outputBuffer, vec2<i32>(fragCoord), result);
+    }
+
+    fn blendIrradianceColor(irradiance:vec4<f32>) -> vec4<f32>{
+        var bounceColor = irradiance * ulitColor;
+        let bounceIntensity = getBounceIntensity(uniformData.bounceIntensity);
+        let conservation1 = 1.0 / sqrt((1.0 + bounceIntensity * 0.55));
+        let conservation2 = 1.0 / sqrt((1.0 + bounceIntensity));
+        var result = litColor * conservation2 + bounceColor * sqrt(bounceIntensity) * conservation1;
+        return vec4<f32>(result.xyz, litColor.w);
+    }
+
+    fn getBounceIntensity(intensity:f32) -> f32 {
+        var value = clamp(intensity, 0.0, 1.0) * 10.0;
+        return value;
+    }
+
+    fn getCoordOffset(id:u32) -> vec2<u32>{
+        var fullCol = u32(uniformData.ProbeSourceTextureSize / uniformData.ProbeSize);
+        var offsetSampleUv = vec2<u32>( (id / fullCol) * 6u , id % fullCol) * u32(uniformData.ProbeSize);
+        return offsetSampleUv;
+    }
+
+    fn getIrradianceColor() -> vec4<f32>{
+        var probeIrradiance: vec4<f32> = vec4<f32>(0.0);
+        if(length(wsn) > 0.01){
+        probeIrradiance = getIrrdiaceIndex(i32(probeID), wsn);
+        }
+        return probeIrradiance;
+    }
+
+    fn getIrrdiaceIndex(index:i32, wsn:vec3<f32>) -> vec4<f32>{
+        var wsN = rotateDir(wsn.xyz);
+        var texCoord:vec2<f32> = textureCoordFromDirection(wsN,
+        index,
+        irradianceFieldSurface.irradianceTextureWidth,
+        irradianceFieldSurface.irradianceTextureHeight,
+        irradianceFieldSurface.irradianceProbeSideLength);
+
+        var probeIrradiance: vec3<f32> = textureSampleLevel(irradianceMap, irradianceMapSampler, texCoord, 0.0).xyz;
+        return vec4<f32>(probeIrradiance, 1.0);
+    }
+
+    fn textureCoordFromDirection(dir:vec3<f32>, probeIndex:i32, width:f32, height:f32, sideLength:f32) -> vec2<f32>
+    {
+        var uv = getWriteOctUVByID(dir, u32(probeIndex), sideLength) ;
+        uv.x = uv.x / irradianceFieldSurface.irradianceTextureWidth;
+        uv.y = uv.y / irradianceFieldSurface.irradianceTextureHeight;
+        return uv ;
+    }
+
+    fn getWriteOctUVByID(dir:vec3<f32> , probeID:u32, size: f32) -> vec2<f32>
+    {
+        var blockCount = u32(irradianceFieldSurface.probeCounts.x * irradianceFieldSurface.probeCounts.z) ;
+        var offsetX = (probeID % blockCount) % u32(irradianceFieldSurface.probeCounts.x) ;
+        var offsetY = u32(irradianceFieldSurface.probeCounts.z - 1.0) - (probeID % blockCount) / u32(irradianceFieldSurface.probeCounts.x) ;
+        var offsetZ = probeID / blockCount ;
+        var pixelCoord = (( octEncode(dir) + 1.0 ) * 0.5) * vec2<f32>(size,size) ;
+        var blockOffset = vec2<f32>(0.0);
+        blockOffset.x = f32(offsetX) * size;
+        blockOffset.y = f32(offsetY) * size + f32(offsetZ) * f32(irradianceFieldSurface.probeCounts.z) * size;
+        let mapHeight = u32(irradianceFieldSurface.irradianceTextureHeight);
+        var probeCounts:vec3<f32> = vec3<f32>(irradianceFieldSurface.probeCounts.xyz);
+        var gridOffsetFrom = vec2<i32>(blockOffset) + 1;
+        var gridOffsetTo = offsetByCol(gridOffsetFrom, size, mapHeight, probeCounts);
+        pixelCoord = pixelCoord + vec2<f32>(gridOffsetTo - 1) + vec2<f32>(vec2<i32>(vec2<f32>(gridOffsetTo) / size) * 2);
+        return pixelCoord + 1.0 ;
+    }
+
+    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;
+    }
+`;

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

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

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

@@ -0,0 +1,49 @@
+export let OutLineBlendColor_cs = /*wgsl*/ `
+    struct OutlineSettingData{
+        strength: f32,
+        useAddMode: f32,
+        outlinePixel: f32,
+        fadeOutlinePixel: f32,
+        lowTexWidth: f32,
+        lowTexHeight: f32,
+        slot0: f32,
+        slot1: f32,
+    }
+
+   @group(0) @binding(0) var<uniform> outlineSetting: OutlineSettingData;
+   @group(0) @binding(1) var inTex : texture_2d<f32>;
+   @group(0) @binding(2) var lowTexSampler : sampler;
+   @group(0) @binding(3) var lowTex : texture_2d<f32>;
+   @group(0) @binding(4) var outlineTex : texture_storage_2d<rgba16float, write>;
+
+   var<private> texSize: vec2<u32>;
+   var<private> fragCoord: vec2<i32>;
+
+   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);
+   }
+
+   @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(outlineTex).xy;
+        if(fragCoord.x >= i32(texSize.x) || fragCoord.y >= i32(texSize.y)){
+            return;
+        }
+        let uv01 = CalcUV_01(fragCoord, texSize);
+        var outLineColor = textureSampleLevel(lowTex, lowTexSampler, uv01, 0.0);
+        outLineColor.x *= outlineSetting.strength;
+        outLineColor.y *= outlineSetting.strength;
+        outLineColor.z *= outlineSetting.strength;
+        var inColor = textureLoad(inTex, fragCoord, 0);
+        var blendColor: vec3<f32> = vec3<f32>(0.0);
+        if(outlineSetting.useAddMode > 0.5){
+            blendColor = inColor.xyz + outLineColor.xyz * outLineColor.w;
+        }else{
+            blendColor = mix(inColor.xyz, outLineColor.xyz, outLineColor.w);
+        };
+        textureStore(outlineTex, fragCoord, vec4<f32>(blendColor, inColor.w));
+   }
+`;

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

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

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

@@ -0,0 +1,95 @@
+export let OutlineCalcOutline_cs = /*wgsl*/ `
+#include "GlobalUniform"
+#include "GBufferStand"
+
+struct OutlineSettingData{
+    strength: f32,
+    useAddMode: f32,
+    outlinePixel: f32,
+    fadeOutlinePixel: f32,
+    lowTexWidth: f32,
+    lowTexHeight: f32,
+    slot0: f32,
+    slot1: f32,
+}
+
+struct OutlineSlotData{
+    color: vec3<f32>,
+    count: f32,
+}
+
+struct OutlineWeightData{
+    slotIndex:f32,
+    outerSlotIndex:f32,
+    entityIndex:f32,
+    weight:f32
+}
+
+struct OutlineEntities{
+    list: array<f32, 16u>,
+}
+
+@group(0) @binding(2) var<uniform> outlineSetting: OutlineSettingData;
+@group(0) @binding(3) var<storage, read_write> slotsBuffer: array<OutlineSlotData>;
+@group(0) @binding(4) var<storage, read_write> weightBuffer: array<OutlineWeightData>;
+@group(0) @binding(5) var<storage, read_write> entitiesBuffer: array<OutlineEntities>;
+
+var<private> texSize: vec2<u32>;
+var<private> lowSize: vec2<i32>;
+var<private> fragCoord: vec2<i32>;
+var<private> fragUV: vec2<f32>;
+var<private> fragCoordLow: vec2<i32>;
+var<private> coordIndex: i32;
+
+var<private> fragOutline: OutlineWeightData;
+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>){
+    useNormalMatrixInv();
+    fragCoordLow = vec2<i32>(globalInvocation_id.xy);
+    texSize = textureDimensions(gBufferTexture).xy;
+    fragUV = vec2<f32>(fragCoordLow) / vec2<f32>(texSize);
+
+    lowSize = vec2<i32>(i32(outlineSetting.lowTexWidth), i32(outlineSetting,lowTexHeight));
+    let scaleValue = f32(texSize.x) / f32(lowSize.x);
+    fragCoord.x = i32(f32(fragCoordLow.x) * scaleValue);
+    fragCoord.y = i32(f32(fragCoordLow.y) * scaleValue);
+
+    if(fragCoord.x >= i32(texSize.x) || fragCoord.y >= i32(texSize.y)){
+        return;
+    }
+    if(fragCoordLow.x >= lowSize.x || fragCoordLow.y >= lowSize.y){
+        return;
+    }
+
+    coordIndex = fragCoordLow.x + fragCoordLow.y * lowSize.x;
+    fragOutline = weightBuffer[coordIndex];
+
+    var gBuffer = getGBuffer(fragCoord);
+    fragOutline.entityIndex = f32(getIDFromGBuffer_i32(gBuffer));
+    fragOutline.slotIndex = -1.0;
+    fragOutline.outerSlotIndex = -1.0;
+    fragOutline.weight = 0.0;
+
+    if(fragOutline.entityIndex >= 0.0){
+        fragOutline.slotIndex = f32(matchOutlineSlot());
+    }
+    weightBuffer[coordIndex] = fragOutline;
+}
+
+fn matchOutlineSlot() -> i32{
+    for(var i:i32 = 0; i<8; i += 1){
+        var slotData: OutlineSlotData = slotsBuffer[i];
+        var entities: array<f32, 16u> = entitiesBuffer[i].list;
+        let count:i32 = i32(slotData.count);
+        for(var j:i32 = 0;j<count; j+=1){
+            var outlineIndex = entities[j];
+            if(abs(fragOutline.entityIndex - outlineIndex) < 0.1){
+                return i;
+            }
+        }
+    }
+    return -1;
+}
+`;

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

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

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

@@ -0,0 +1,116 @@
+export let Outline_cs = /*wgsl */ `
+    struct OutlineSettingData{
+        strength: f32,
+        useAddMode: f32,
+        outlinePixel: f32,
+        fadeOutlinePixel: f32,
+        lowTexWidth: f32,
+        lowTexHeight: f32,
+        slot0: f32,
+        slot1: f32,
+    }
+
+    struct OutlineSlotData{
+        color: vec3<f32>,
+        count: f32,
+    }
+
+    struct OutlineWeightData{
+        slotIndex:f32,
+        outerSlotIndex:f32,
+        entityIndex:f32,
+        weight:f32
+    }
+
+    @group(0) @binding(0) var<uniform> outlineSetting: OutlineSettingData;
+    @group(0) @binding(1) var<storage, read_write> slotsBuffer : array<OutlineSlotData>;
+    @group(0) @binding(2) var<storage, read_write> weightBuffer : array<OutlineWeightData>;
+    @group(0) @binding(3) var<storage, read_write> oldOutlineColor : array<vec4<f32>>;
+    @group(0) @binding(4) var lowTex : texture_storage_2d<rgba16float, write>;
+
+    var<private> texSize: vec2<u32>;
+    var<private> fragCoord: vec2<i32>;
+    var<private> coordIndex: i32;
+    var<private> fragOutline:OutlineWeightData;
+
+    @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(lowTex).xy;
+        if(fragCoord.x >= i32(texSize.x) || fragCoord.y >= i32(texSize.y)){
+            return;
+        }
+
+        coordIndex = fragCoord.x + fragCoord.y * i32(texSize.x);
+        fragOutline = weightBuffer[coordIndex];
+
+        var newOC = vec4<f32>(0.0);
+
+        calcOutline();
+        let outerSlotIndex: i32 = i32(round(fragOutline.outerSlotIndex));
+        if(outerSlotIndex >= 0){
+            let outLineColor = slotsBuffer[outerSlotIndex].color;
+            newOC = vec4<f32>(outLineColor, fragOutline.weight);
+        }
+
+        let coordIndex0 = fragCoord.x + 1 + (fragCoord.y + 1) * i32(texSize.x);
+        let coordIndex1 = fragCoord.x - 1 + (fragCoord.y + 1) * i32(texSize.x);
+        let coordIndex2 = fragCoord.x + (fragCoord.y - 1) * i32(texSize.x);
+
+        let oldOC = oldOutlineColor[coordIndex];
+        let oldOC0 = oldOutlineColor[coordIndex0];
+        let oldOC1 = oldOutlineColor[coordIndex1];
+        let oldOC2 = oldOutlineColor[coordIndex2];
+
+        newOC = mix((oldOC + oldOC0 + oldOC1 + oldOC2) * 0.25, newOC, 0.5);
+        oldOutlineColor[coordIndex] = newOC;
+        textureStore(lowTex, fragCoord, newOC);
+    }
+
+    fn calcOutline(){
+        let outlinePixel = outlineSetting.outlinePixel;
+        let pixelRadius = outlinePixel + outlineSetting.fadeOutlinePixel;
+        let minX = max(0.0, f32(fragCoord.x) - pixelRadius);
+        let maxX = min(f32(texSize.x), f32(fragCoord.x) + pixelRadius);
+        let minY = max(0.0, f32(fragCoord.y) - pixelRadius);
+        let maxY = min(f32(texSize.y), f32(fragCoord.y) + pixelRadius);
+        var coordTemp_f32 = vec2<f32>(0.0);
+        var coordCurrent_f32 = vec2<f32>(fragCoord);
+        var tempCoordIndex = 0;
+        var tempWeightData: OutlineWeightData;
+        for(var x:f32 = minX; x<maxX; x += 1.0){
+            for(var y:f32 = minY; y<maxY; y += 1.0){
+                coordTemp_f32.x = x;
+                coordTemp_f32.y = y;
+                let distanceToOuter = length(coordTemp_f32-coordCurrent_f32);
+                if(distanceToOuter < pixelRadius){
+                    var coord_i32 = vec<i32>(coordTemp_f32);
+                    tempCoordIndex = coord_i32.x + coord_i32.y * i32(texSize.x);
+                    tempWeightData = weightBuffer[tempCoordIndex];
+                    let outlineGap = abs(tempWeightData.slotIndex - fragOutline.slotIndex);
+                    if(outlineGap > 0.1){
+                        if(tempWeightData.slotIndex > fragOutline.slotIndex){
+                            if(abs(tempWeightData.slotIndex - fragOutline.outerSlotIndex) < 0.1){
+                                fragOutline.weight = max(fragOutline.weight, calcWeight(pixelRadius, distanceToOuter, outlinePixel));
+                                fragOutline.outerSlotIndex = tempWeightData.slotIndex;
+                                weightBuffer[tempCoordIndex] = tempWeightData;
+                            }else if(tempWeightData.slotIndex > fragOutline.outerSlotIndex){
+                                fragOutline.weight = calcWeight(pixelRadius, distanceToOuter, outlinePixel);
+                                fragOutline.outerSlotIndex = tempWeightData.slotIndex;
+                                weightBuffer[tempCoordIndex] = tempWeightData;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    fn calcWeight(totalRadius:f32, distance:f32, innerRadius:f32) -> f32{
+        if(distance < innerRadius){
+            return 1.0;
+        }
+        var ret = 1.0 - (distance - innerRadius) / (totalRadius - innerRadius);
+        return ret;
+    }
+`;

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

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

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

@@ -0,0 +1,40 @@
+export let Picker_cs = `
+    #include "GlobalUniform"
+    #include "GBufferStand"
+
+    struct PickResult {
+        pick_meshID:f32,
+        pick_meshID2:f32,
+        pick_UV:vec2<f32>,
+        pick_Position:vec4<f32>,
+        pick_Normal:vec4<f32>,
+        pick_Tangent:vec4<f32>,
+        v4:vec4<f32>,
+        v5:vec4<f32>,
+        v6:vec4<f32>,
+        v7:vec4<f32>
+    }
+
+    @group(0) @binding(2) var<storage, read_write> outBuffer: PickResult;
+    const PI = 3.1415926;
+
+    @compute @workgroup_size(1)
+    fn CsMain(@builtin(workgroup_id) workgroup_id: vec3<u32>, @builtin(global_invocation_id) globalInvocation_id: vec3<u32>){
+        var result:PickResult;
+        let texSize = textureDimensions(gBufferTexture).xy;
+        let screenPoint = vec2<f32>(globalUniform.mouseX/globalUniform.windowWidth, globalUniform.mouseY/globalUniform.windowHieght);
+
+        let mouseUV = screenPoint * vec2<f32>(texSize.xy);
+        let fragCoord =  vec2<i32>(i32(mouseUV.x), i32(mouseUV.y));
+        var gBuffer = getGBuffer(fragCoord);
+        let pick_meshID = getIDFromGBuffer_i32(gBuffer);
+        outBuffer.pick_meshID = f32(pick_meshID);
+        outBuffer.pick_meshID2 = f32(pick_meshID);
+        outBuffer.pick_Tangent = vec4<f32>(2.0,2.0,2.0,2.0);
+        outBuffer.pick_UV = vec2<f32>(globalUniform.mouseX,globalUniform.mouseY);
+        let wPosition = getWorldPositionFromGBuffer(gBuffer,screenPoint);
+        let wNormal = getWorldNormalFromGBuffer(gBuffer);
+        outBuffer.pick_Position = vec4<f32>(wPosition, 1.0);
+        outBuffer.pick_Normal = vec4<f32>(wNormal, 1.0);
+    }
+`;

package/dist/src/assets/shader/compute/PreFilteredEnvironment_cs copy.d.ts

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

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

@@ -0,0 +1,162 @@
+export let PreFilteredEnvironment_cs2 = /*wgsl*/ `
+    #include "GenerayRandomDir"
+    #include "BitUtil"
+    #include "MathShader"
+    
+    struct UniformData{
+        roughness : f32 ,
+        roughness1 : f32 ,
+        roughness2 : f32 ,
+        roughness3 : f32 ,
+    }
+
+    @group(0) @binding(0) var inputTex : texture_2d<f32>;
+    @group(0) @binding(1) var outputTexture : texture_storage_2d<rgba32float, write>;
+    @group(1) @binding(0) var<uniform> uniformData:UniformData;
+
+    var<private> reflectionSize : vec2f ; 
+    var<private> PROBE_SOURCESIZE : vec2f ; 
+    var<private> PROBEMAP_SOURCESIZE : vec2f ; 
+    var<private> aspect : vec2f ; 
+    var<private> spaceV : f32 ; 
+    
+    var<private> i32InputFragCoord : vec2i;
+    var<private> PI_2 : f32 = 3.1415926 * 2.0 ;
+    var<private> PI : f32 = 3.1415926 ;
+    var<private> RAYS_PER_PROBE : f32 = 32.0 ;
+
+    var<private> screenSize : vec2f ; 
+
+    fn useSphereReflection(){
+        reflectionSize = vec2f(textureDimensions(inputTex).xy);
+        PROBE_SOURCESIZE = reflectionSize / vec2f(6.0,8.0);
+        PROBEMAP_SOURCESIZE = reflectionSize ;
+        aspect = PROBE_SOURCESIZE / PROBEMAP_SOURCESIZE;
+        spaceV = 1.0 / 8.0;
+    }
+
+    @compute @workgroup_size( 16 , 16 , 1 )
+    fn CsMain( @builtin(workgroup_id) workgroup_id : vec3<u32> , @builtin(global_invocation_id) globalInvocation_id : vec3<u32>)
+    {
+        var color : vec4f ;
+        useSphereReflection();
+        screenSize = vec2f(textureDimensions(outputTexture).xy);
+        i32InputFragCoord = vec2<i32>( globalInvocation_id.xy ) ;
+        let i = globalInvocation_id.z ;
+        let roughness = uniformData.roughness ;
+        let suv = vec2f(i32InputFragCoord) ;
+        let subUV = vec2f((suv.x+0.5) % (256.0*6.0),(suv.y+0.5) % 256.0) / vec2f( (256.0*6.0), 256.0 ) ;
+        let faceID = i32((suv.x / 256.0));
+        let probeID = i32(floor(suv.y / 256.0));
+        
+        var sphereUV = subUV;
+        var dir: vec3<f32> = UvToDir(sphereUV) ;
+        var preColor = PreFilterEnvMap(roughness,dir,0.0);
+        color.y = vec3fToFloat(preColor.xyz);
+        color.z = vec3fToFloat(dir);
+        
+        textureStore(outputTexture,i32InputFragCoord,color);
+    }
+
+    fn getReflectionsMap(n:vec3<f32>,gid:f32) -> vec3f {
+        var uv = getSampleProbeUV(n,gid);
+        let color = textureLoad(inputTex, vec2i(uv*screenSize) , 0);
+        return floatToVec3f(color.y) ;
+    }
+
+    fn getSampleProbeUV(dir:vec3<f32>,gid:f32) -> vec2<f32> {
+        let faceId = dir_to_faceId(dir);
+        var targetUV:vec2<f32> = convert_xyz_to_cube_uv(dir.x, dir.y, dir.z);
+        targetUV.x = 1.0 - targetUV.x;
+        let threshould = 0.5 / PROBE_SOURCESIZE;
+        targetUV = clamp(targetUV, vec2<f32>(threshould), vec2<f32>(1.0 - threshould));
+        targetUV.x = f32(faceId) + targetUV.x;
+        let aspect:vec2f = PROBE_SOURCESIZE / PROBEMAP_SOURCESIZE;
+        targetUV = targetUV * aspect ;
+        targetUV.y = targetUV.y + (spaceV*gid);
+     
+        return targetUV ;
+     }
+
+
+    
+fn radicalInverse_VdC( bits2:u32) -> f32
+{
+    var bits = bits2; 
+    bits = (bits << 16u) | (bits >> 16u);
+    bits = ((bits & 0x55555555u) << 1u) | ((bits & 0xAAAAAAAAu) >> 1u);
+    bits = ((bits & 0x33333333u) << 2u) | ((bits & 0xCCCCCCCCu) >> 2u);
+    bits = ((bits & 0x0F0F0F0Fu) << 4u) | ((bits & 0xF0F0F0F0u) >> 4u);
+    bits = ((bits & 0x00FF00FFu) << 8u) | ((bits & 0xFF00FF00u) >> 8u);
+    return f32(bits) * 2.3283064365386963e-10f; // / 0x100000000
+}
+
+
+fn hammersley( i:u32, N:u32) -> vec2f
+{
+    return vec2f(f32(i) / f32(N), radicalInverse_VdC(i));
+}
+
+fn ImportanceSampleGGX( xi:vec2f,  roughness:f32,  N:vec3f) -> vec3f
+{
+    var alpha2 = roughness * roughness * roughness * roughness;
+    var phi = 2.0f * 3.1415926 * xi.x  ;
+    var cosTheta = sqrt( (1.0f - xi.y) / (1.0f + (alpha2 - 1.0f) * xi.y ));
+    var sinTheta = sqrt( 1.0f - cosTheta*cosTheta );
+    var h : vec3f ;
+    h.x = sinTheta * cos( phi );
+    h.y = sinTheta * sin( phi );
+    h.z = cosTheta;
+    var up = vec3f(1,0,0) ;
+    if(abs(N.z) < 0.9999){
+        up = vec3f(0,0,1) ;
+    }
+    var tangentX = normalize( cross( up, N ) );
+    var tangentY = cross( N, tangentX );
+     
+    return (tangentX * h.x + tangentY * h.y + N * h.z);
+} 
+
+const NUM_SAMPLES = 512u;
+fn PreFilterEnvMap( roughness2:f32,  R:vec3f , gid:f32 ) -> vec3f
+{
+    var res = vec3f(0.0f);  
+    var totalWeight = 0.0f;   
+    var normal = normalize(R);
+    var toEye = normal;
+    var roughness = roughness2;
+     
+    for(var i=1u;i<=NUM_SAMPLES;i+=1u)
+    {
+        var xi:vec2f = hammersley(i, NUM_SAMPLES) ; 
+         
+        var halfway = ImportanceSampleGGX(xi,roughness,normal);
+        var lightVec = 2.0f * dot( toEye,halfway ) * halfway - toEye;
+         
+        var NdotL = dot( normal, lightVec )  ;
+        var NdotH = max(0.0,dot( normal, halfway ))  ;
+        var HdotV = max(0.0,dot( halfway, toEye ))  ;
+         
+        if( NdotL > 0.0 )
+        {
+            var D = specularD(roughness,NdotH);
+            var pdf = (D * NdotH / (4.0 * HdotV)) + 0.0001f  ;
+
+            var saSample = 1.0f / (f32(NUM_SAMPLES) * pdf + 0.00001f);
+            lightVec = normalize(lightVec);
+            res += vec3f(getReflectionsMap(lightVec,0.0)) * NdotL;;
+            totalWeight += NdotL;
+        }
+    }
+     
+    return res / max(totalWeight,0.001f);
+} 
+
+fn  specularD( roughness:f32,  NoH:f32) -> f32
+{
+    var NoH2 = NoH * NoH;
+    var r2 = roughness * roughness;
+    return r2 / pow(NoH2 * (r2 - 1.0) + 1.0, 2.0);
+}
+    
+`;

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

@@ -0,0 +1,4 @@
+/**
+ * @internal
+ */
+export declare let PreFilteredEnvironment_cs: string;