@rings-webgpu/core 1.0.2 → 1.0.3

package/dist/src/assets/shader/compute/utils/TestComputeLoadBuffer.js

@@ -1,128 +0,0 @@
-export let TestComputeLoadBuffer = /* wgsl */ `
-    #include "GlobalUniform"
-    #include "MathShader"
-    #include "FastMathShader"
-    #include "BitUtil"
-    #include "ColorUtil_frag"
-    #include "GBufferStand"
-
-    struct Uniform{
-        state:i32,
-        state1:i32,
-        state2:i32,
-        state3:i32,
-    }
-
-    @group(0) @binding(auto) var outputTexture: texture_storage_2d<rgba16float, write>;
-    @group(0) @binding(auto) var reflectionsGBufferTexture: texture_2d<f32>;
-    @group(0) @binding(auto) var currentRenderTexture: texture_2d<f32>;
-    @group(0) @binding(auto) var envMap: texture_2d<f32>;
-    @group(0) @binding(auto) var<uniform> uniformData: Uniform;
-
-    var<private> fragCoord:vec2<u32>;
-    var<private> screenSize:vec2<u32>;
-    var<private> fragColor:vec4f;
-    const PI = 3.1415926;
-
-    var<private> colorSet: array<vec3<f32>, 9> = array<vec3<f32>, 9>(
-        vec3<f32>(1.0, 0.0, 0.0),
-        vec3<f32>(1.0, 0.5, 0.0),
-        vec3<f32>(0.5, 1.0, 0.0),
-        vec3<f32>(0.0, 1.0, 0.0),
-        vec3<f32>(0.0, 1.0, 0.5),
-        vec3<f32>(0.0, 0.5, 1.0),
-        vec3<f32>(0.0, 0.0, 1.0),
-        vec3<f32>(0.5, 0.0, 1.0),
-        vec3<f32>(1.0, 0.0, 0.5)
-    );
-
-    @compute @workgroup_size(16, 16, 1)
-    fn CsMain(@builtin(workgroup_id) workgroup_id: vec3<u32>, @builtin(global_invocation_id) globalInvocation_id : vec3<u32>){
-        fragCoord = globalInvocation_id.xy;
-        screenSize = vec2u(textureDimensions(outputTexture));
-        useNormalMatrixInv();
-        let color = textureLoad(currentRenderTexture, fragCoord , 0);
-        fragColor = color;
-        var outPixel:vec3f;
-        var a = globalUniform.time;
-        var state = uniformData.state;
-        let gBuffer: GBuffer = getGBuffer(vec2i(fragCoord));
-
-        switch (state) {
-            case 0:{
-                break;
-            }
-            case 1:{
-                fragColor = vec4f(getAbldeoFromGBuffer(gBuffer).rgb,1.0) ;
-                break;
-            }
-            case 2:{
-                fragColor = vec4f(getViewNormalFromGBuffer(gBuffer),1.0) ;
-                break;
-            }
-            case 3:{
-                fragColor = vec4f(getWorldNormalFromGBuffer(gBuffer),1.0) ;
-                break;
-            }
-            case 4:{
-                fragColor = vec4f(vec3f(getRoughnessFromGBuffer(gBuffer)),1.0) ;
-                break;
-            }
-            case 5:{
-                fragColor = vec4f(vec3f(getMetaillicFromGBuffer(gBuffer)),1.0) ;
-                break;
-            }    
-            case 6:{
-                fragColor = vec4f(vec3f(getAlphaFromGBuffer(gBuffer)),1.0) ;
-                break;
-            }
-            case 7:{
-                let id = (f32(getIDFromGBuffer_i32(gBuffer)) * f_r22g8.r) % 9.0;
-                fragColor = vec4f(colorSet[u32(id)],1.0) ;
-                break;
-            }
-            default:{
-                break;
-            }
-        }
-
-        let size = f32(uniformData.state1) ; 
-        let renderRec1 = vec4f(0.0,0.0,size,size);
-        renderBufferToViewPort(reflectionsGBufferTexture,renderRec1);
-        let size2 = f32(uniformData.state2) ; 
-        let renderRec2 = vec4f(0.0,size,size2,size2);
-        renderColorBufferToViewPort(envMap,renderRec2);
-        textureStore(outputTexture, fragCoord , fragColor);
-    }
-
-    fn renderBufferToViewPort(texture: texture_2d<f32>, viewRectangle: vec4f){
-        let size = vec2f(textureDimensions(texture));
-        let f32FragCoord = vec2f(fragCoord);
-        if(insideRectangle(f32FragCoord,viewRectangle)){
-            let uv = clipViewUV(viewRectangle,size,f32FragCoord);
-            let gBuffer = textureGBuffer(texture,uv);
-            let color = getRGBMColorFromGBuffer(gBuffer);
-            fragColor = vec4f(color,1.0); 
-        }
-    }
-
-    fn renderColorBufferToViewPort(texture:texture_2d<f32>, viewRectangle:vec4f) {
-        let size = vec2f(textureDimensions(texture));
-        let f32FragCoord = vec2f(fragCoord);
-        if(insideRectangle(f32FragCoord,viewRectangle)){
-            let uv = clipViewUV(viewRectangle,size,f32FragCoord);
-            let color = textureLoad(texture, uv , 0).rgb;
-            fragColor = vec4f(color,1.0); 
-        }
-    }
-
-    fn textureGBuffer(texture:texture_2d<f32>, fragCoord:vec2u) -> GBuffer {
-        let bufferTex = textureLoad(texture, fragCoord, 0) ;
-        var gBuffer:GBuffer;
-        gBuffer.x = bufferTex.x;
-        gBuffer.y = bufferTex.y;
-        gBuffer.z = bufferTex.z;
-        gBuffer.w = bufferTex.w;
-        return gBuffer ;
-    }
-`;

package/dist/src/assets/shader/compute/utils/TextureCompress.d.ts

@@ -1,2 +0,0 @@
-import { Texture } from "../../../../gfx/graphics/webGpu/core/texture/Texture";
-export declare let textureCompress: (colorMap: Texture, sourceTexture: Texture[], destTexture: Texture[], workX: number, workY: number, workZ?: number) => string;

package/dist/src/assets/shader/compute/utils/TextureCompress.js

@@ -1,131 +0,0 @@
-export let textureCompress = (colorMap, sourceTexture, destTexture, workX, workY, workZ = 1) => {
-    let begin = 0;
-    let bindInputTexture = "";
-    let preG = "";
-    preG += /* wgsl */ `
-        fn acesFilm( x:vec3f) -> vec3f {
-            return clamp((x*(2.51*x+vec3f(0.03)))/(x*(2.43*x+vec3f(0.59))+vec3f(0.14)),vec3f(0.0),vec3f(1.0));
-        }
-    `;
-    for (let i = 0; i < sourceTexture.length; i++) {
-        const inputTexture = sourceTexture[i];
-        let inTextureName = `source${i}Map`;
-        let inTextureSamplerName = `source${i}MapSampler`;
-        bindInputTexture += /* wgsl */ `
-            @group(0) @binding(${(begin + i) * 2 + 0}) var ${inTextureName} : texture_2d<f32>;\n
-            @group(0) @binding(${(begin + i) * 2 + 1}) var ${inTextureSamplerName} : sampler;
-        `;
-        preG += GaussBlur(`GaussBlur_${inTextureName}_1`, inTextureName, inTextureSamplerName);
-        preG += GaussBlur(`GaussBlur_${inTextureName}_0`, inTextureName, inTextureSamplerName);
-    }
-    begin += sourceTexture.length;
-    let bindOutputTexture = "";
-    for (let i = 0; i < destTexture.length; i++) {
-        bindOutputTexture += /* wgsl */ `@group(0) @binding(${(begin + i) * 2 + 0}) var dest${i}Map : texture_storage_2d<rgba16float, write>;\n`;
-    }
-    let loadMainColor = "";
-    if (colorMap) {
-        begin += destTexture.length;
-        bindInputTexture += /* wgsl */ `@group(0) @binding(${begin * 2 + 0}) var colorMap : texture_2d<f32>;\n
-       
-        `;
-        loadMainColor += /* wgsl */ `
-            mainColor = textureLoad( colorMap ,fragCoord, 0) ;
-        `;
-    }
-    let compute_workgroup_size = /* wgsl */ `@compute @workgroup_size(${workX}, ${workY},${workZ})`;
-    let copyTexture = copyToTexture(sourceTexture.length, colorMap ? true : false);
-    let compute_shader = /* wgsl */ `
-        ${GaussWeight2D}
-        ${CalcUV_01}
-        ${bindInputTexture}
-        ${bindOutputTexture}
-        ${preG}
-        
-        var<private> fragCoord: vec2<i32>;
-        var<private> texSize: vec2<u32>;
-        var<private> mainColor: vec4f;
-
-        ${compute_workgroup_size}
-        fn CsMain(@builtin(global_invocation_id) globalInvocation_id : vec3<u32>){
-            fragCoord = vec2<i32>( globalInvocation_id.xy );
-            texSize = textureDimensions(dest0Map).xy;
-            if(fragCoord.x >= i32(texSize.x) || fragCoord.y >= i32(texSize.y)){
-                return;
-            }
-            
-            ${loadMainColor}
-
-            ${copyTexture}
-        }
-    `;
-    return compute_shader;
-};
-let copyToTexture = (len, combineMainColor) => {
-    let code = ``;
-    for (let i = 0; i < len; i++) {
-        code += upSample(`GaussBlur_source${i}Map`, `dest${i}Map`, combineMainColor);
-    }
-    return code;
-};
-let upSample = (funName, outeTextureName, combineMainColor) => {
-    let code = /* wgsl */ `
-        var color = vec4<f32>(0.0, 0.0, 0.0, 1.0);
-        var uv = CalcUV_01(fragCoord, texSize);
-        
-        let prev_stride = vec2<f32>(0.5) / vec2<f32>(f32(texSize.x), f32(texSize.y));
-        let curr_stride = vec2<f32>(1.0) / vec2<f32>(f32(texSize.x), f32(texSize.y));
-
-        let rgb1 = ${funName}_1(uv, i32(1), prev_stride, 1.0);
-        let rgb2 = ${funName}_0(uv, i32(1), curr_stride, 1.0);
-        color = vec4<f32>((rgb1 + rgb2) * 0.5 , color.w) ;
-        color = vec4f(pow(acesFilm(max(vec3f(0.),color.xyz)),vec3f(0.45)),1.) * 0.5  ;   
-        ${combineMainColor ? "color = (color + mainColor) ;" : ""}
-        textureStore(${outeTextureName}, fragCoord, color );
-    `;
-    return code;
-};
-let CalcUV_01 = /*wgsl*/ `
-  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);
-  }
-`;
-let GaussWeight2D = /*wgsl*/ `
-fn GaussWeight2D(x:f32, y:f32, sigma:f32) -> f32
-  {
-      let PI = 3.14159265358;
-      let E  = 2.71828182846;
-      let sigma_2 = pow(sigma, 2);
-  
-      let a = -(x*x + y*y) / (2.0 * sigma_2);
-      return pow(E, a) / (2.0 * PI * sigma_2);
-  }
-`;
-let GaussBlur = function (GaussNxN, inTex, inTexSampler) {
-    var code = /*wgsl*/ `
-  
-  fn ${GaussNxN}(uv:vec2<f32>, n:i32, stride:vec2<f32>, sigma:f32) -> vec3<f32>
-  {
-      var color = vec3<f32>(0.0);
-      let r:i32 = n / 2;
-      var weight:f32 = 0.0;
-  
-      for(var i:i32=-r; i<=r; i+=1)
-      {
-          for(var j=-r; j<=r; j+=1)
-          {
-              let w = GaussWeight2D(f32(i), f32(j), sigma);
-              var coord:vec2<f32> = uv + vec2<f32>(f32(i), f32(j)) * stride;
-              color += textureSampleLevel(${inTex}, ${inTexSampler}, coord, 0.0).xyz * w;
-              weight += w;
-          }
-      }
-  
-      color /= weight;
-      return color;
-  }`;
-    return code;
-};

package/dist/src/assets/shader/compute/utils/tw.d.ts

@@ -1,4 +0,0 @@
-/**
- * 抗锯齿
- */
-export declare let tw: string;

package/dist/src/assets/shader/compute/utils/tw.js

@@ -1,43 +0,0 @@
-/**
- * 抗锯齿
- */
-export let tw = /*wgsl */ `
-    @group(0) @binding(1) var inputTexture : texture_2d<f32>;
-    @group(0) @binding(2) var outputTexture : texture_storage_2d<rgba16float, write>;
-    var<private> fragCoord:vec2<u32>;
-
-    @compute @workgroup_size(16, 16, 1)
-    fn CsMain(@builtin(workgroup_id) workgroup_id: vec3<u32>, @builtin(global_invocation_id) globalInvocation_id: vec3<u32>){
-        fragCoord = globalInvocation_id.xy;
-        wColor = textureLoad(colorTexture, fragCoord , 0);
-        finalMatrix = globalUniform.projMat * globalUniform.viewMat ;
-        let nMat = mat3x3<f32>(finalMatrix[0].xyz,finalMatrix[1].xyz,finalMatrix[2].xyz) ;
-        ORI_NORMALMATRIX = transpose(inverse( nMat ));
-        wPosition = textureLoad(posTexture, fragCoord, 0);
-        wNormal = textureLoad(normalTexture, fragCoord, 0);
-        var VPPos = (finalMatrix * vec4f(wPosition.xyz,1.0)).xyz ;
-        var VPNormal = normalize(ORI_NORMALMATRIX * wNormal.xyz) ;
-        var LastPixel = textureLoad(inputTexture,fragCoord,0);
-        var NewPixel:vec4f = wColor ;
-        var NewRadius = max(1.,ceil(1.99-LastPixel.w*0.25));
-        var RadiusCoeff = max(1.,2.25-LastPixel.w*0.25);
-        if (NewRadius>0.5) {
-            var NewWeight = 1.;
-            for (var x=-NewRadius; x<NewRadius+0.5; x+=1.0) {
-                for (var y=-NewRadius; y<NewRadius+0.5; y+=1.0) {
-                    var SUV:vec2f = vec2f(fragCoord)+vec2f(x,y)*RadiusCoeff;
-                    if (x*x+y*y<0.01) {
-                        continue;
-                    }
-                    var SVPos:vec3f = textureLoad(posTexture, vec2<u32>(SUV), 0);
-                    var SVNormal:vec3f = textureLoad(posTexture, vec2<u32>(SUV), 0).xyz * 2.0 - 1.0;
-                    var SWeight = max(0.0001,float(dot(Normal,SVPos-VPPos)<0.01))*
-                                    max(0.01,float(dot(Normal,normalize(SVNormal))>0.9));
-                    NewPixel += texture(iChannel1,SUV*IRES) * SWeight;
-                    NewWeight += SWeight;
-                }
-            }
-            NewPixel /= NewWeight;
-        }
-    }
-`;

package/dist/src/assets/shader/core/base/Common_frag.d.ts

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

package/dist/src/assets/shader/core/base/Common_frag.js

@@ -1,62 +0,0 @@
-export let Common_frag = `
-    #include "GlobalUniform"
-    #include "FragmentVarying"
-    #include "FragmentOutput"
-    #include "ShadingInput"
-    #include "ColorUtil_frag"
-    #include "BitUtil"
-
-    var<private> ORI_FragmentOutput: FragmentOutput;
-    var<private> ORI_VertexVarying: FragmentVarying;
-    var<private> ORI_ShadingInput: ShadingInput;
-    var<private> viewDir:vec3<f32>;
-    var<private> modelIndex:u32;
-
-    @fragment
-    fn FragMain( vertex_varying:FragmentVarying ) -> FragmentOutput {
-        modelIndex = u32(round(vertex_varying.index));
-        ORI_VertexVarying = vertex_varying;
-        ORI_VertexVarying.vWorldNormal = normalize(vertex_varying.vWorldNormal);
-        ORI_FragmentOutput.color = vec4<f32>(1.0, 0.0, 0.0, 1.0);
-        viewDir = normalize(globalUniform.CameraPos.xyz - ORI_VertexVarying.vWorldPos.xyz);
-        frag();
-
-        #if USE_DEBUG
-            debugFragmentOut();
-        #endif
-
-        #if USE_OUTDEPTH
-            #if USE_LOGDEPTH
-                ORI_FragmentOutput.out_depth = log2DepthFixPersp(ORI_VertexVarying.fragPosition.w, globalUniform.near, globalUniform.far);
-            #else
-                ORI_FragmentOutput.out_depth = ORI_ShadingInput.FragDepth;
-            #endif
-        #endif
-
-        return ORI_FragmentOutput;
-    }
-
-    fn packNHMDGBuffer(depth:f32, albedo:vec3f,hdrLighting:vec3f,rmao:vec3f,normal:vec3f,alpha:f32) -> vec4f {
-        var gBuffer : vec4f;
-        var octUVNormal = (octEncode(normalize( (normal) )) + 1.0) * 0.5;
-        var yc = f32(r11g11b9_to_float(vec3f(octUVNormal,rmao.r)));
-        #if USE_CASTREFLECTION
-            var rgbm = EncodeRGBM(hdrLighting);
-            var zc = f32(pack4x8unorm(vec4f(rgbm.rgb,0.0))) ;
-            var wc = f32(pack4x8unorm(vec4f(rmao.rg,rgbm.a,0.0)));
-        #else
-            var zc = f32(vec4fToFloat_7bits(vec4f(albedo.rgb,alpha)));
-            var wc = f32(r22g8_to_float(vec2f(f32(modelIndex)/f_r22g8.r,rmao.g)));
-        #endif
-
-        gBuffer.x = depth ;
-        gBuffer.y = yc;
-        gBuffer.z = zc;
-        gBuffer.w = wc;
-        return gBuffer;
-    }
-
-    fn transformUV( uv:vec2f , offsetScale:vec4f ) -> vec2f{
-        return uv * offsetScale.zw + offsetScale.xy;
-    }
-`;

package/dist/src/assets/shader/core/base/Common_vert.d.ts

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

package/dist/src/assets/shader/core/base/Common_vert.js

@@ -1,12 +0,0 @@
-export let Common_vert = /*wgsl*/ `
-    #include "WorldMatrixUniform"
-    #include "VertexAttributes_vert"
-    #include "GlobalUniform"
-    #include "Inline_vert"
-    @vertex
-    fn VertMain( vertex:VertexAttributes ) -> VertexOutput {
-        vertex_inline(vertex);
-        vert(vertex);
-        return ORI_VertexOut ;
-    }
-`;

package/dist/src/assets/shader/core/common/BrdfLut_frag.d.ts

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

package/dist/src/assets/shader/core/common/BrdfLut_frag.js

@@ -1,6 +0,0 @@
-export let BrdfLut_frag = /*wgsl*/ `
-    @group(1) @binding(auto)
-    var brdflutMapSampler: sampler;
-    @group(1) @binding(auto)
-    var brdflutMap: texture_2d<f32>;
-`;

package/dist/src/assets/shader/core/common/EnvMap_frag.d.ts

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

package/dist/src/assets/shader/core/common/EnvMap_frag.js

@@ -1,10 +0,0 @@
-export let EnvMap_frag = /*wgsl*/ `
-    @group(1) @binding(auto)
-    var prefilterMapSampler: sampler;
-    @group(1) @binding(auto)
-    var prefilterMap: texture_cube<f32>;
-    @group(1) @binding(auto)
-    var envMapSampler: sampler;
-    @group(1) @binding(auto)
-    var envMap: texture_cube<f32>;
-`;

package/dist/src/assets/shader/core/common/GBufferStand.d.ts

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

package/dist/src/assets/shader/core/common/GBufferStand.js

@@ -1,171 +0,0 @@
-export let GBufferStand = `
-    #include "MathShader"
-    #include "FastMathShader"
-    #include "BitUtil"
-    #include "ColorUtil_frag"
-
-    @group(0) @binding(1) var gBufferTexture : texture_2d<f32>;
-
-    struct GBuffer{
-        x : f32,
-        y : f32,
-        z : f32,
-        w : f32,
-    }
-    
-    struct ViewSpaceGBuffer{
-        depth:f32,
-        color:vec3f,
-        abldeoColor:vec3f,
-        viewPosition:vec3f,
-        viewNormal:vec3f,
-        roughness:f32,
-        metallic:f32,
-    }
-
-    struct WorldSpaceGBuffer{
-        depth:f32,
-        color:vec3f,
-        abldeoColor:vec3f ,
-        worldPosition:vec3f,
-        worldNormal:vec3f,
-        roughness:f32,
-        metallic:f32,
-    }
-
-    fn getViewSpaceGBuffer(fragCoord:vec2i,uv:vec2f) -> ViewSpaceGBuffer {
-        var sampleUV = uv;
-        sampleUV.y = 1.0 - sampleUV.y;
-        let gBufferTexture = textureLoad(gBufferTexture, fragCoord, 0);
-
-        var gBuffer:ViewSpaceGBuffer;
-        gBuffer.depth = gBufferTexture.x;
-        let viewPos = getViewPosition(gBufferTexture.x,sampleUV);
-        gBuffer.viewPosition = viewPos;
-
-        gBuffer.color = floatToVec3f(gBufferTexture.y);
-
-        let zChannel = floatToVec3f(gBufferTexture.z);
-        let octUV = zChannel.xy * 2.0 - 1.0;
-        gBuffer.viewNormal = octDecode(octUV.xy);
-
-        let wChannel = floatVec3f(gBufferTexture.w);
-        gBuffer.abldeoColor = wChannel.xyz;
-
-        gBuffer.roughness = zChannel.z;
-        gBuffer.metallic = 0.0;
-
-        return gBuffer;
-    }
-
-    fn getWorldSpaceGBuffer(fragCoord:vec2i, uv:vec2f) -> WorldSpaceGBuffer {
-        var sampleUV = uv;
-        sampleUV.y = 1.0 - sampleUV.y;
-        let gBufferTexture = textureLoad(gBufferTexture, fragCoord, 0);
-
-        var gBuffer:WorldSpaceGBuffer;
-
-        gBuffer.depth = gBufferTexture.x;
-        let worldPos = getWorldPosition(gBufferTexture.x, sampleUV);
-        gBuffer.worldPosition = worldPos;
-
-        gBuffer.color = floatToVec3f(gBufferTexture.y);
-
-        let zChannel = floatToVec3f(gBufferTexture.z);
-        let octUV = zChannel.xy * 2.0 - 1.0;
-        gBuffer.worldNormal = getWorldNormal(octDecode(octUV.xy));
-
-        let wChannel = floatToVec3f(gBufferTexture.w);
-        gBuffer.abldeoColor = wChannel.xyz;
-
-        gBuffer.roughness = zChannel.z;
-        gBuffer.metallic = 0.0;
-
-        return gBuffer;
-    }
-
-    fn getGBuffer(fragCoord:vec2i) -> GBuffer {
-        let gBufferTexture = textureLoad(gBufferTexture, fragCoord, 0);
-        var gBuffer:GBuffer;
-        gBuffer.x = gBufferTexture.x;
-        gBuffer.y = gBufferTexture.y;
-        gBuffer.z = gBufferTexture.z;
-        gBuffer.w = gBufferTexture.w;
-        return gBuffer;
-    }
-
-    fn getDepthFromGBuffer(gBuffer:GBuffer) -> f32 {
-        return gBuffer.x;
-    }
-
-    fn getViewPositionFromGBuffer(gBuffer:GBuffer,screenUV:vec2f) -> vec3f {
-        var sampleUV = screenUV;
-        sampleUV.x = 1.0 - sampleUV.x;
-        sampleUV.y = 1.0 - sampleUV.y;
-        let viewPos = getViewPosition(gBuffer.x,sampleUV);
-        return viewPos;
-    }
-
-    fn getViewNormalFromGBuffer(gBuffer:GBuffer) -> vec3f {
-        let worldNormal = getWorldNormalFromGBuffer(gBuffer);
-        return getViewNormal(worldNormal);
-    }
-
-    fn getWorldPositionFromGBuffer(gBuffer:GBuffer,uv:vec2f) -> vec3f {
-        var sampleUV = uv;
-        sampleUV.y = 1.0 - sampleUV.y;
-        let worldPos = getWorldPosition(gBuffer.x,sampleUV);
-        return worldPos;
-    }
-
-    fn getSkyPositionFromGBuffer(uv:vec2f) -> vec3f {
-        var sampleUV = uv;
-        sampleUV.y = 1.0 - sampleUV.y;
-        let worldPos = getWorldPosition(0.9999999,sampleUV);
-        return worldPos;
-    }
-
-    fn getRGBMColorFromGBuffer(gBuffer:GBuffer) -> vec3f {
-        let rbg = unpack4x8unorm(u32(gBuffer.z)).rgb;
-        let m = unpack4x8unorm(u32(gBuffer.w)).z;
-        return DecodeRGBM(vec4f(rgb,m));
-    }
-
-    fn getWorldNormalFromGBuffer(gBuffer:GBuffer) -> vec3f {
-        let zChannel = float_to_r11g11b9(gBuffer.y);
-        let octUV = zChannel.xy * 2.0 -1.0;
-        let viewNormal = octDecode(octUV.xy);
-        return viewNormal;
-    }
-
-    fn getAbldeoFromGBuffer(gBuffer:GBuffer) -> vec4f {
-        let rgba = floatToVec4f_7bits(gBuffer.z).rgba;
-        return rgba;
-    }
-
-    fn getAlphaFromGBuffer(gBuffer:GBuffer) -> f32 {
-        let rgba = floatToVec4f_7bits(gBuffer.z).rgba;
-        return rgba.a;
-    }
-
-    fn getMetaillicFromGBuffer(gBuffer:GBuffer) -> f32 {
-        let channel = float_to_r22g8(gBuffer.w);
-        return channel.y;
-    }
-
-    fn getRoughnessFromGBuffer(gBuffer:GBuffer) -> f32 {
-        let channel = float_to_r11g11b9(gBuffer.y);
-        return channel.z;
-    }
-
-    fn getIDFromGBuffer_f32_01(gBuffer:GBuffer) -> f32 {
-        let channel = float_to_r22g8(gBuffer.w);
-        return channel.x;
-    }
-
-    fn getIDFromGBuffer_i32(gBuffer:GBuffer) -> i32 {
-        let id_f32_01 = getIDFromGBuffer_f32_01(gBuffer);
-        let id = i32(round(id_f32_01 * f_r22g8.r));
-        return id;
-    }
-`;

package/dist/src/assets/shader/core/common/GlobalUniform.d.ts

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