@rings-webgpu/core 1.0.2 → 1.0.4

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

@@ -1,169 +0,0 @@
-/**
- * 多重反射全局光照 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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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