@rings-webgpu/core 1.0.0 → 1.0.2

package/dist/src/assets/shader/sky/AtmosphericScatteringSky_shader.js

@@ -0,0 +1,312 @@
+/**
+ * @internal
+ */
+export class AtmosphericScatteringSky_shader {
+    static { this.cs = `
+    #include 'ColorUtil_frag'
+    struct UniformData {
+        width: f32,
+        height: f32,
+        sunU: f32,
+        sunV: f32,
+        eyePos: f32,
+        sunRadius: f32,         // = 500.0;
+        sunRadiance: f32,       // = 20.0;
+        mieG: f32,              // = 0.76;
+        mieHeight: f32,         // = 1200;
+        sunBrightness: f32,     // = 1.0;
+        displaySun: f32,        // > 0.5: true
+        skyColor: vec4<f32>,        // sky color
+      };
+
+      @group(0) @binding(0) var<uniform> uniformBuffer: UniformData;
+      @group(0) @binding(1) var outTexture : texture_storage_2d<rgba16float, write>;
+
+      var<private> uv01: vec2<f32>;
+      var<private> fragCoord: vec2<i32>;
+      var<private> texSizeF32: vec2<f32>;
+
+      var<private> PI:f32 = 3.1415926535;
+      var<private> PI_2:f32 = 0.0;
+      var<private> EPSILON:f32 = 0.0000001;
+      var<private> SAMPLES_NUMS:i32 = 16;
+
+      var<private> transmittance:vec3<f32>;
+      var<private> insctrMie:vec3<f32>;
+      var<private> insctrRayleigh:vec3<f32>;
+
+      @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);
+        texSizeF32 = vec2<f32>( uniformBuffer.width, uniformBuffer.height);
+        uv01 = vec2<f32>(globalInvocation_id.xy) / texSizeF32;
+        uv01.y = 1.0 - uv01.y - EPSILON;
+        PI_2 = PI * 2.0;
+        textureStore(outTexture, fragCoord , mainImage(uv01));//vec4(uv01, 0.0, 1.0));
+      }
+
+      struct ScatteringParams
+      {
+        sunRadius:f32,
+        sunRadiance:f32,
+
+        mieG:f32,
+        mieHeight:f32,
+
+        rayleighHeight:f32,
+
+        waveLambdaMie:vec3<f32>,
+        waveLambdaOzone:vec3<f32>,
+        waveLambdaRayleigh:vec3<f32>,
+
+        earthRadius:f32,
+        earthAtmTopRadius:f32,
+        earthCenter:vec3<f32>,
+      }
+
+      fn ComputeSphereNormal(coord:vec2<f32>, phiStart:f32, phiLength:f32, thetaStart:f32, thetaLength:f32) -> vec3<f32>
+      {
+        var normal:vec3<f32>;
+        normal.x = -sin(thetaStart + coord.y * thetaLength) * sin(phiStart + coord.x * phiLength);
+        normal.y = -cos(thetaStart + coord.y * thetaLength);
+        normal.z = -sin(thetaStart + coord.y * thetaLength) * cos(phiStart + coord.x * phiLength);
+        return normalize(normal);
+      }
+
+      fn ComputeRaySphereIntersection(position:vec3<f32>, dir:vec3<f32>, center:vec3<f32>, radius:f32) -> vec2<f32>
+      {
+        var origin:vec3<f32> = position - center;
+        var B = dot(origin, dir);
+        var C = dot(origin, origin) - radius * radius;
+        var D = B * B - C;
+
+        var minimaxIntersections:vec2<f32>;
+        if (D < 0.0)
+        {
+          minimaxIntersections = vec2<f32>(-1.0, -1.0);
+        }
+        else
+        {
+          D = sqrt(D);
+          minimaxIntersections = vec2<f32>(-B - D, -B + D);
+        }
+
+        return minimaxIntersections;
+      }
+
+      fn ComputeWaveLambdaRayleigh(lambda: vec3<f32>) -> vec3<f32>
+      {
+        var n:f32 = 1.0003;
+        var N:f32 = 2.545E25;
+        var pn:f32 = 0.035;
+        var n2:f32 = n * n;
+        var pi3:f32 = PI * PI * PI;
+        var rayleighConst:f32 = (8.0 * pi3 * pow(n2 - 1.0,2.0)) / (3.0 * N) * ((6.0 + 3.0 * pn) / (6.0 - 7.0 * pn));
+        return vec3<f32>(rayleighConst) / (lambda * lambda * lambda * lambda);
+      }
+
+      fn ComputePhaseMie(theta: f32, g:f32) -> f32
+      {
+        var g2 = g * g;
+        return (1.0 - g2) / pow(1.0 + g2 - 2.0 * g * saturate(theta), 1.5) / (4.0 * PI);
+      }
+
+      fn ComputePhaseRayleigh(theta: f32) -> f32
+      {
+        var theta2 = theta * theta;
+        return (theta2 * 0.75 + 0.75) / (4.0 * PI);
+      }
+
+      fn ChapmanApproximation(X: f32, h: f32, cosZenith: f32) -> f32
+      {
+        var c = sqrt(X + h);
+        var c_exp_h = c * exp(-h);
+
+        if (cosZenith >= 0.0)
+        {
+          return c_exp_h / (c * cosZenith + 1.0);
+        }
+        else
+        {
+          var x0 = sqrt(1.0 - cosZenith * cosZenith) * (X + h);
+          var c0 = sqrt(x0);
+
+          return 2.0 * c0 * exp(X - x0) - c_exp_h / (1.0 - c * cosZenith);
+        }
+      }
+
+      fn GetOpticalDepthSchueler(h: f32, H: f32, earthRadius: f32, cosZenith: f32) -> f32
+      {
+        return H * ChapmanApproximation(earthRadius / H, h / H, cosZenith);
+      }
+
+      fn GetTransmittance(setting: ScatteringParams, L:vec3<f32>, V: vec3<f32>) -> vec3<f32>
+      {
+        var ch = GetOpticalDepthSchueler(L.y, setting.rayleighHeight, setting.earthRadius, V.y);
+        return exp(-(setting.waveLambdaMie + setting.waveLambdaRayleigh) * ch);
+      }
+
+      fn ComputeOpticalDepth(setting: ScatteringParams, samplePoint: vec3<f32>, V: vec3<f32>, L: vec3<f32>, neg: f32) -> vec2<f32>
+      {
+        var rl = length(samplePoint);
+        var h = rl - setting.earthRadius;
+        var r: vec3<f32> = samplePoint / rl;
+
+        var cos_chi_sun = dot(r, L);
+        var cos_chi_ray = dot(r, V * neg);
+
+        var opticalDepthSun = GetOpticalDepthSchueler(h, setting.rayleighHeight, setting.earthRadius, cos_chi_sun);
+        var opticalDepthCamera = GetOpticalDepthSchueler(h, setting.rayleighHeight, setting.earthRadius, cos_chi_ray) * neg;
+
+        return vec2<f32>(opticalDepthSun, opticalDepthCamera);
+      }
+
+      fn AerialPerspective(setting:ScatteringParams, start: vec3<f32>, end: vec3<f32>, V: vec3<f32>, L: vec3<f32>, infinite:i32)
+      {
+        var inf_neg:f32 = 1.0;
+        if( infinite == 0){
+          inf_neg = -1.0;
+        }
+
+        var sampleStep: vec3<f32> = (end - start) / f32(SAMPLES_NUMS);
+        var samplePoint: vec3<f32> = end - sampleStep;
+        var sampleLambda: vec3<f32> = setting.waveLambdaMie + setting.waveLambdaRayleigh + setting.waveLambdaOzone;
+
+        var sampleLength:f32 = length(sampleStep);
+
+        var scattering:vec3<f32> = vec3<f32>(0.0);
+        var lastOpticalDepth:vec2<f32> = ComputeOpticalDepth(setting, end, V, L, inf_neg);
+
+        for (var i:i32 = 1; i < SAMPLES_NUMS; i = i + 1)
+        {
+          var opticalDepth: vec2<f32> = ComputeOpticalDepth(setting, samplePoint, V, L, inf_neg);
+
+          var segment_s: vec3<f32> = exp(-sampleLambda * (opticalDepth.x + lastOpticalDepth.x));
+          var segment_t: vec3<f32> = exp(-sampleLambda * (opticalDepth.y - lastOpticalDepth.y));
+
+          transmittance *= segment_t;
+
+          scattering = scattering * segment_t;
+          scattering += exp(-(length(samplePoint) - setting.earthRadius) / setting.rayleighHeight) * segment_s;
+
+          lastOpticalDepth = opticalDepth;
+          samplePoint = samplePoint - sampleStep;
+        }
+
+        insctrMie = scattering * setting.waveLambdaMie * sampleLength;
+        insctrRayleigh = scattering * setting.waveLambdaRayleigh * sampleLength;
+      }
+
+      fn ComputeSkyboxChapman(setting: ScatteringParams, eye:vec3<f32>, V:vec3<f32>, L:vec3<f32>) -> f32
+      {
+        var neg:i32 = 1;
+        var outerIntersections: vec2<f32> = ComputeRaySphereIntersection(eye, V, setting.earthCenter, setting.earthAtmTopRadius);
+        if (outerIntersections.y < 0.0){
+          return 0.0;
+        }
+        var innerIntersections: vec2<f32> = ComputeRaySphereIntersection(eye, V, setting.earthCenter, setting.earthRadius);
+        if (innerIntersections.x > 0.0)
+        {
+          neg = 0;
+          outerIntersections.y = innerIntersections.x;
+        }
+
+        let eye0 = eye - setting.earthCenter;
+
+        var start : vec3<f32> = eye0 + V * max(0.0, outerIntersections.x);
+        var end : vec3<f32>= eye0 + V * outerIntersections.y;
+
+        AerialPerspective(setting, start, end, V, L, neg);
+
+        //bool intersectionTest = innerIntersections.x < 0.0 && innerIntersections.y < 0.0;
+        //return intersectionTest ? 1.0 : 0.0;
+
+        if(innerIntersections.x < 0.0 && innerIntersections.y < 0.0){
+          return 1.0;
+        }
+        return 0.0;
+      }
+
+      fn ComputeSkyInscattering(setting: ScatteringParams, eye: vec3<f32>, V: vec3<f32>, L: vec3<f32>) -> vec4<f32>
+      {
+        transmittance = vec3<f32>(1.0);
+        insctrMie = vec3<f32>(0.0);
+        insctrRayleigh = vec3<f32>(0.0);
+        var intersectionTest:f32 = ComputeSkyboxChapman(setting, eye, V, L);
+
+        var phaseTheta = dot(V, L);
+        var phaseMie = ComputePhaseMie(phaseTheta, setting.mieG);
+        var phaseRayleigh = ComputePhaseRayleigh(phaseTheta);
+        var phaseNight = 1.0 - saturate(transmittance.x * EPSILON);
+
+        var insctrTotalMie: vec3<f32> = insctrMie * phaseMie;
+        var insctrTotalRayleigh: vec3<f32> = insctrRayleigh * phaseRayleigh;
+
+        var sky: vec3<f32> = (insctrTotalMie + insctrTotalRayleigh) * setting.sunRadiance;
+        if(uniformBuffer.displaySun > 0.5){
+          var angle:f32 = saturate((1.0 - phaseTheta) * setting.sunRadius);
+          var cosAngle:f32 = cos(angle * PI * 0.5);
+          var edge:f32 = 0.0;
+          if(angle >= 0.9){
+            edge = smoothstep(0.9, 1.0, angle);
+          }
+
+          var limbDarkening: vec3<f32> = GetTransmittance(setting, -L, V);
+          limbDarkening *= pow(vec3<f32>(cosAngle), vec3<f32>(0.420, 0.503, 0.652)) * mix(vec3<f32>(1.0), vec3<f32>(1.2,0.9,0.5), edge) * intersectionTest;
+          sky += limbDarkening * uniformBuffer.sunBrightness; 
+        }
+        return vec4<f32>(sky, phaseNight * intersectionTest);
+      }
+
+      fn TonemapACES(x: vec3<f32>) -> vec3<f32>
+      {
+        var A:f32 = 2.51f;
+        var B:f32 = 0.03f;
+        var C:f32 = 2.43f;
+        var D:f32 = 0.59f;
+        var E:f32 = 0.14f;
+        return (x * (A * x + B)) / (x * (C * x + D) + E);
+      }
+
+      fn noise(uv:vec2<f32>) -> f32
+      {
+        return fract(dot(sin(vec3<f32>(uv.xyx) * vec3<f32>(uv.xyy) * 1024.0), vec3<f32>(341896.483, 891618.637, 602649.7031)));
+      }
+
+      fn mainImage( uv:vec2<f32> ) -> vec4<f32>
+      {
+        let eyePosition = uniformBuffer.eyePos;
+        var sun = vec2<f32>(uniformBuffer.sunU, uniformBuffer.sunV);
+        var V: vec3<f32> = ComputeSphereNormal(uv, 0.0, PI_2, 0.0, PI);
+        var L: vec3<f32> = ComputeSphereNormal(vec2<f32>(sun.x, sun.y), 0.0, PI_2, 0.0, PI);
+
+        var setting: ScatteringParams;
+        setting.sunRadius = uniformBuffer.sunRadius;//500.0;
+        setting.sunRadiance = uniformBuffer.sunRadiance;//20.0;
+        setting.mieG = uniformBuffer.mieG;//0.76;
+        setting.mieHeight = uniformBuffer.mieHeight;// 1200.0;
+        setting.rayleighHeight = 8000.0;
+        setting.earthRadius = 6360000.0;
+        setting.earthAtmTopRadius = 6420000.0;
+        setting.earthCenter = vec3<f32>(0, -setting.earthRadius, 0);
+        setting.waveLambdaMie = vec3<f32>(0.0000002);
+
+        // wavelength with 680nm, 550nm, 450nm
+        setting.waveLambdaRayleigh = ComputeWaveLambdaRayleigh(vec3<f32>(0.000000680, 0.000000550, 0.000000450));
+
+        // see https://www.shadertoy.com/view/MllBR2
+        setting.waveLambdaOzone = vec3<f32>(1.36820899679147, 3.31405330400124, 0.13601728252538)* 0.0000006 * 2.504;
+
+        var eye:vec3<f32> = vec3<f32>(0,eyePosition,0);
+        var sky0:vec4<f32> = ComputeSkyInscattering(setting, eye, V, L);
+        var sky = vec3<f32>(sky0.rgb);
+
+        sky = TonemapACES(sky.rgb * 2.0);
+        sky = pow(sky.rgb, vec3<f32>(1.0/1.2)); // gamma
+
+        var fragColor:vec4<f32> = vec4<f32>((sky.rgb), 1.0);
+        return fragColor;
+      }
+    `; }
+}

package/dist/src/assets/shader/sky/CubeSky_Shader.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @internal
+ */
+export declare class CubeSky_Shader {
+    static sky_vs_frag_wgsl: string;
+    static sky_fs_frag_wgsl: string;
+}

package/dist/src/assets/shader/sky/CubeSky_Shader.js

@@ -0,0 +1,122 @@
+/**
+ * @internal
+ */
+export class CubeSky_Shader {
+    static { this.sky_vs_frag_wgsl = `
+    #include "WorldMatrixUniform"
+    #include "GlobalUniform"
+
+    struct VertexOutput {
+      @location(auto) fragUV: vec2<f32>,
+      @location(auto) vClipPos: vec4<f32>,
+      @location(auto) vWorldPos: vec4<f32>,
+      @location(auto) vWorldNormal: vec3<f32>,
+      @builtin(position) member: vec4<f32>
+    };
+
+    var<private> ORI_VertexOut: VertexOutput ;
+
+    @vertex
+    fn main( 
+      @builtin(instance_index) index : u32,
+      @location(auto) position: vec3<f32>,
+      @location(auto) normal: vec3<f32>,
+      @location(auto) uv: vec2<f32>
+    ) -> VertexOutput {
+      ORI_VertexOut.fragUV = uv;
+      let modelMat = models.matrix[u32(index)];
+      let vm = modelMat;
+      let normalMatrix = mat3x3<f32>(vm[0].xyz,vm[1].xyz,vm[2].xyz);
+	    ORI_VertexOut.vWorldNormal = normalize( normalMatrix * normal );
+      ORI_VertexOut.vWorldPos = modelMat * vec4<f32>(position.xyz,1.0) ;
+      
+      var fixProjMat = globalUniform.projMat ;
+      fixProjMat[2].z = 1.0 ;//99999.0 / (99999.0 - 1.0) ;
+      fixProjMat[3].z = -1.0 ;//(-1.0 * 99999.0) / (99999.0 - 1.0) ;
+
+      var fixViewMat = globalUniform.viewMat ;
+      fixViewMat[3].x = 0.0 ;
+      fixViewMat[3].y = 0.0 ;
+      fixViewMat[3].z = 0.0 ;
+
+      var clipPos = fixProjMat * fixViewMat * ORI_VertexOut.vWorldPos;
+      ORI_VertexOut.vClipPos = clipPos ;
+      ORI_VertexOut.member = clipPos;
+      return ORI_VertexOut;
+    }
+  `; }
+    static { this.sky_fs_frag_wgsl = `
+    #include "GlobalUniform"
+    #include "MathShader"
+    #include "BitUtil"
+    #include "ColorUtil_frag"
+    #include "FragmentOutput"
+
+    struct uniformData {
+        exposure: f32,
+        roughness: f32
+    };
+
+    @group(1) @binding(0)
+    var baseMapSampler: sampler;
+    @group(1) @binding(1)
+    var baseMap: texture_cube<f32>;
+
+    @group(2) @binding(0)
+    var<uniform> global: uniformData;
+
+    @fragment
+    fn main(@location(auto) fragUV: vec2<f32>,@location(auto) vClipPos: vec4<f32>, @location(auto) vWorldPos: vec4<f32>, @location(auto) vWorldNormal: vec3<f32> , @builtin(position) fragCoord : vec4<f32> ) -> FragmentOutput {
+        let maxLevel: u32 = textureNumLevels(baseMap);
+        let dir = normalize(vWorldPos.xyz);
+        var textureColor:vec3<f32> = textureSampleLevel(baseMap, baseMapSampler, normalize(dir.xyz), global.roughness * f32(maxLevel) ).xyz;
+        #if IS_HDR_SKY
+          textureColor = LinearToGammaSpace(textureColor);
+        #endif
+
+        // let o_Target: vec4<f32> = globalUniform.hdrExposure * vec4<f32>(textureColor, 1.0) * globalUniform.skyExposure ;
+        let o_Target: vec4<f32> = vec4<f32>(textureColor, 1.0) * globalUniform.skyExposure;
+        let finalMatrix = globalUniform.projMat * globalUniform.viewMat ;
+        let nMat = mat3x3<f32>(finalMatrix[0].xyz,finalMatrix[1].xyz,finalMatrix[2].xyz) ;
+        let ORI_NORMALMATRIX = transpose(inverse( nMat ));
+       
+        var vNormal = (ORI_NORMALMATRIX * -vWorldNormal );
+        var gBuffer = packGBuffer(
+          -globalUniform.far,
+          vec3f(0.0),
+          o_Target.rgb,
+          vec3f(0.0),
+          vNormal
+        ) ;
+      var fragmentOutput:FragmentOutput;
+      #if USE_CASTREFLECTION
+        fragmentOutput.gBuffer = gBuffer ;
+      #else
+        fragmentOutput.color = o_Target ;
+        fragmentOutput.gBuffer = gBuffer ;
+      #endif
+      return fragmentOutput;
+    }
+
+    fn packGBuffer(depth:f32, albedo:vec3f,hdrLighting:vec3f,rmao:vec3f,normal:vec3f) -> vec4f{
+        var gBuffer : vec4f ;
+        var octUVNormal = (octEncode(normalize(normal)) + 1.0) * 0.5 ;
+
+        var yc = f32(r11g11b9_to_float(vec3f(octUVNormal,0.0))) ;
+        #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,0.0)));
+          var wc = f32(r22g8_to_float(vec2f(f32(0.0),rmao.g)));
+        #endif
+    
+        gBuffer.x = depth  ;
+        gBuffer.y = yc ;
+        gBuffer.z = zc ;
+        gBuffer.w = wc ;
+        return gBuffer ;
+    }
+    `; }
+}

package/dist/src/assets/shader/utils/BitUtil.d.ts

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

package/dist/src/assets/shader/utils/BitUtil.js

@@ -0,0 +1,108 @@
+export let BitUtil = /* wgsl */ `
+
+    const inv256:f32 = 1.0/256.0;
+    const inv1024:f32 = 1.0/1024.0;
+
+    const bit7_inv128:f32 = 1.0 / 128.0;
+    const bit7_128:f32 = 128.0;
+    
+    const r10g10b10 = vec2i(0x3FFFFF,0xFF);
+    fn floatToVec3f( v:f32 ) -> vec3f {
+        var VPInt:i32 = bitcast<i32>(v);
+        var VPInt1024:i32 = VPInt%1024;
+        var VPInt10241024:i32 = ((VPInt-VPInt1024)/1024)%1024;
+        return vec3f(f32(VPInt1024),f32(VPInt10241024),f32(((VPInt-VPInt1024-VPInt10241024)/1048576)))*vec3f(inv1024);
+    }
+
+    fn vec3fToFloat( v:vec3f) -> f32{
+        let intv = min(vec3<i32>(floor(v*1024.)),vec3<i32>(1023));
+        return bitcast<f32>(i32(intv.x+intv.y*1024+intv.z*1048576));
+    }
+
+    fn vec4fToFloat_7bits( v:vec4f) -> f32{
+        //0~256
+        let intv = min(vec4<i32>(floor(v*bit7_128)),vec4<i32>(127));
+        return bitcast<f32>(i32(intv.x+intv.y*128+intv.z*16384+intv.w*2097152));
+    }
+
+    fn floatToVec4f_7bits( v:f32 ) -> vec4f {
+        var VPInt:i32 = bitcast<i32>(v);
+        var VPInt128:i32 = VPInt%128;
+        var VPInt128128:i32 = ((VPInt-VPInt128)/128)%128;
+        var VPInt128128128:i32 = ((VPInt-VPInt128-VPInt128128)/16384)%128;
+        var VPInt128128128128:i32 = ((VPInt-VPInt128-VPInt128128-VPInt128128128)/2097152)%128;
+        return vec4f(f32(VPInt128),f32(VPInt128128),f32(VPInt128128128),f32(VPInt128128128128))*vec4f(bit7_inv128);
+    }
+
+
+
+
+
+
+    const i_r11g11b11 = vec3i(0x7FF,0x7FF,0x7FF);
+    const f_r11g11b11 = vec3f(f32(0x7FF),f32(0x7FF),f32(0x7FF));
+    fn r11g11b11_to_float( v:vec3f) -> f32{
+        let iR: i32 = i32(v.r * f_r11g11b11.r);
+        let iG: i32 = i32(v.g * f_r11g11b11.g);
+        let iB: i32 = i32(v.b * f_r11g11b11.b);
+        return bitcast<f32>((iR << 22u) | (iG << 11u) | iB );
+    }
+
+    fn float_to_r11g11b11( v:f32 ) -> vec3f {
+        let iV: i32 = bitcast<i32>(v);
+        var r: f32 = f32((iV >> 22u) & i_r11g11b11.r) / f_r11g11b11.r;
+        var g: f32 = f32((iV >> 11u) & i_r11g11b11.g) / f_r11g11b11.g;
+        var b: f32 = f32(iV & i_r11g11b11.b) / f_r11g11b11.b ;
+        return vec3f(r,g,b);
+    }
+
+    const i_r22g8 = vec2i(0x3FFFFF,0xFF);
+    const f_r22g8 = vec2f(f32(0x3FFFFF),f32(0xFF));
+    fn r22g8_to_float( v:vec2f) -> f32{
+        let iR: i32 = i32(v.r * f_r22g8.r);
+        let iG: i32 = i32(v.g * f_r22g8.g);
+        return bitcast<f32>((iR << 8u) | iG);
+    }
+
+    fn float_to_r22g8( v:f32 ) -> vec2f {
+        let iV: i32 = bitcast<i32>(v);
+        var r: f32 = f32((iV >> 8u) & i_r22g8.r) / f_r22g8.r;
+        var g: f32 = f32(iV & i_r22g8.g) / f_r22g8.g ;
+        return vec2f(r,g);
+    }
+
+    const r11g11b9 = vec3i(0x7FF,0x7FF,0x1FF);
+    fn r11g11b9_to_float( v:vec3f) -> f32{
+        let iR: i32 = i32(v.r * f32(r11g11b9.r));
+        let iG: i32 = i32(v.g * f32(r11g11b9.g));
+        let iB: i32 = i32(v.b * f32(r11g11b9.b));
+        return bitcast<f32>((iR << 20u) | (iG << 9u) | iB );
+    }
+
+    fn float_to_r11g11b9( v:f32 ) -> vec3f {
+        let iV: i32 = bitcast<i32>(v);
+        var r: f32 = f32((iV >> 20u) & r11g11b9.r) / f32(r11g11b9.r);
+        var g: f32 = f32((iV >> 9u) & r11g11b9.g) / f32(r11g11b9.g);
+        var b: f32 = f32(iV & r11g11b9.b) / f32(r11g11b9.b) ;
+        return vec3f(r,g,b);
+    }
+
+
+
+
+    fn floatToRGBA(v:f32) -> vec4f{
+        var iv = bitcast<u32>(v);
+        var color = vec4f(0.0);
+        color.x = f32((iv&0x00FF0000u)>>16u)/255.0;
+        color.y = f32((iv&0x000FF00u)>>8u)/255.0;
+        color.z = f32(iv&0x000000FFu)/255.0;
+        return color;
+    }
+
+    const bitShift:vec4f = vec4f(1.0, 1.0/256.0, 1.0/(256.0*256.0), 1.0/(256.0*256.0*256.0));
+    fn RGBAToFloat(v:vec4f) -> f32 {
+        var f = dot(v, bitShift);
+        return f;
+    }
+
+`;

package/dist/src/assets/shader/utils/ColorUtil.d.ts

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

package/dist/src/assets/shader/utils/ColorUtil.js

@@ -0,0 +1,144 @@
+export let ColorUtil = `
+    fn getHDRColor(color: vec3<f32>, exposure: f32) -> vec3<f32> {
+        return color * pow(2.4, exposure);
+    }
+
+    const kRGBMRange = 8.0;
+    fn EncodeRGBM(icolor: vec3f) -> vec4f {
+        var color = icolor;
+        color *= 1.0 / kRGBMRange;
+        var m = max(max(color.x, color.y), max(color.z, 1e-5));
+        m = ceil(m * 255) / 255;
+        return vec4f(color / m, m);
+    }
+
+    fn DecodeRGBM(rgbm:vec4f) -> vec3f {
+        return rgbm.xyz * rgbm.w * kRGBMRange;
+    }
+
+    fn Luminance(LinearColor:vec3f, LuminanceFactors: vec3f) -> f32 {
+        return dot(LinearColor, LuminanceFactors);
+    }
+
+    fn lambda2rgb(lambda: f32) -> vec3<f32>{
+        let ultraviolet = 400.0;
+        let infrared = 700.0;
+
+        var a = (lambda - ultraviolet) / (infrared - ultraviolet);
+        let c = 10.0;
+        var b = vec3<f32>(a) - vec3<f32>(0.75,0.5,0.25);
+        return max((1.0 - c * b * b), vec3<f32>(0.0));
+    }
+
+    fn CEToneMapping(color: vec3<f32>, adapted_lum: f32) -> vec3<f32>{
+        return 1.0 - exp(-adapted_lum * color);
+    }
+
+    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));
+    }
+
+    fn ACESToneMapping(color: vec3<f32>, adapted_lum: f32) -> vec3<f32>
+    {
+        let A = 2.51;
+        let B = 0.03;
+        let C = 2.43;
+        let D = 0.59;
+        let E = 0.14;
+
+        var color2 = color * adapted_lum;
+        color2 = (color2 * (A * color2 + B)) / (color2 * (C * color2 + D) + E);
+        return color2;
+    }
+
+    fn gammaToLiner(color: vec3<f32>) -> vec3 < f32 > {
+        let gammaCorrect = 2.4;
+        var color2 = pow(color, vec3<f32>(gammaCorrect));
+        return color2 ;
+    }
+
+    fn linerToGamma4(color: vec4<f32>) -> vec4 < f32 > {
+        let gammaCorrect = 0.416666667;
+        var color2 = pow(color, vec4<f32>(gammaCorrect));
+        return color2 ;
+    }
+
+    fn linerToGamma3(color: vec3<f32>) -> vec3 < f32 > {
+        let gammaCorrect = 0.416666667;
+        var color2 = pow(color, vec3<f32>(gammaCorrect));
+        return color2 ;
+    }
+
+    fn LinearToGammaSpace(linRGB: vec3<f32>) -> vec3<f32> {
+        var linRGB1 = max(linRGB, vec3<f32>(0.0));
+        linRGB1 = pow(linRGB1, vec3<f32>(0.4166666567325592));
+        return max(((1.0549999475479126 * linRGB1) - vec3<f32>(0.054999999701976776)), vec3<f32>(0.0));
+    }
+
+    var<private>sRGB_2_LMS_MAT: mat3x3<f32> = mat3x3<f32>(
+        17.8824, 43.5161, 4.1193,
+        3.4557, 27.1554, 3.8671,
+        0.02996, 0.18431, 1.4670,
+    );
+
+    var<private>LMS_2_sRGB_MAT: mat3x3<f32> = mat3x3<f32>(
+        0.0809, -0.1305, 0.1167,
+        -0.0102, 0.0540, -0.1136,
+        -0.0003, -0.0041, 0.6935,
+    );
+
+    fn sRGB_2_LMS(RGB: vec3<f32>) -> vec3<f32>
+    {
+        return sRGB_2_LMS_MAT * RGB;
+    }
+
+    fn LMS_2_sRGB(LMS: vec3<f32>) -> vec3<f32>
+    {
+        return LMS_2_sRGB_MAT * LMS;
+    }
+
+    fn LinearToSrgbBranchless(lin: vec3<f32>) -> vec3<f32>
+    {
+        var lin2 = max(vec3<f32>(6.10352e-5), lin);
+        return min(lin2 * 12.92, pow(max(lin2, vec3<f32>(0.00313067)), vec3<f32>(0.416666667)) * vec3<f32>(1.055) - vec3<f32>(0.055));
+    }
+
+    fn sRGBToLinear(color : vec3<f32>) -> vec3<f32>
+    {
+        let color2 = max(vec3<f32>(6.10352e-5), color);
+        let c = 0.04045;
+        if (color2.r > c && color2.g > c && color2.b > c) {
+            return pow(color2 * (1.0 / 1.055) + 0.0521327, vec3<f32>(2.4));
+        } else {
+            return color2 * (1.0 / 12.92);
+        }
+    }
+
+    fn BlendNormalRNM( n1:vec3f,  n2:vec3f) -> vec3f
+	{
+		let t = n1.xyz + vec3f(0.0, 0.0, 1.0);
+		let u = n2.xyz * vec3f(-1.0, -1.0, 1.0);
+		let r = (t / t.z) * dot(t, u) - u;
+		return r;
+	}
+
+    fn packRGBA8( In : vec4f ) ->u32
+    {
+        let r = (u32(saturate(In.r) * 255.0) << 0u);
+        let g = (u32(saturate(In.g) * 255.0) << 8u);
+        let b = (u32(saturate(In.b) * 255.0) << 16u);
+        let a = (u32(saturate(In.a) * 255.0) << 24u);
+        return r | g | b | a;
+    }
+
+    const i256:f32 = 1.0 / 255.0 ;
+    fn unpackRGBA8( In : u32 ) -> vec4f 
+    {
+        var Out:vec4f ;
+        Out.r = f32((In >> 0u) & 0xFF) * i256;
+        Out.g = f32((In >> 8u) & 0xFF) * i256;
+        Out.b = f32((In >> 16u) & 0xFF) * i256;
+        Out.a = f32((In >> 24u) & 0xFF) * i256;
+        return Out;
+    }
+`;