@rings-webgpu/core 1.0.0 → 1.0.2

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

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

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

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

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

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

@@ -0,0 +1,43 @@
+/**
+ * 抗锯齿
+ */
+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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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