@rings-webgpu/core 1.0.2 → 1.0.4

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

@@ -1,312 +0,0 @@
-/**
- * @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

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

@@ -1,122 +0,0 @@
-/**
- * @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

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

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

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

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

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

@@ -1,144 +0,0 @@
-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;
-    }
-`;