framefields 2.0.2

package/dist/preview-engine/chunk-5XDHHOF2.mjs

@@ -0,0 +1,367 @@
+import{a as E}from"./chunk-CNSHAFEA.mjs";import{a as Y}from"./chunk-YSTLMWCG.mjs";import{d as H}from"./chunk-6YJP57MZ.mjs";import{e as w}from"./chunk-BVF64D6H.mjs";w();w();var he=`
+struct RefractionCausticsUniforms {
+    // vec4 0
+    _pad0                : f32,
+    ior                  : f32,
+    dispersion           : f32,
+    refractionScale      : f32,
+
+    // vec4 1
+    causticBrightness    : f32,
+    causticScale         : f32,
+    fluidRipples         : f32,
+    rippleSpeed          : f32,
+
+    // vec4 2
+    roughness            : f32,
+    specularIntensity    : f32,
+    lightPosX            : f32,
+    lightPosY            : f32,
+
+    // vec4 3
+    tintStrength         : f32,
+    depthInvert          : f32,
+    depthScale           : f32,
+    hasDepthMap          : f32,
+
+    // vec4 4
+    timeProgress         : f32,
+    aspect               : f32,
+    _pad1                : f32,
+    _pad2                : f32,
+
+    // vec4 5: signal flags
+    hasSigIOR            : f32,
+    hasSigDispersion     : f32,
+    hasSigRefractScale   : f32,
+    hasSigCaustic        : f32,
+
+    // vec4 6: signal flags
+    hasSigRipples        : f32,
+    hasSigRoughness      : f32,
+    hasSigLightPosX      : f32,
+    hasSigLightPosY      : f32,
+
+    // vec4 7: reserved
+    _pad3                : f32,
+    _pad4                : f32,
+    _pad5                : f32,
+    _pad6                : f32,
+
+    // vec4 8: color
+    tintColor            : vec4<f32>,
+};
+
+@group(0) @binding(0) var<uniform> u : RefractionCausticsUniforms;
+
+@group(1) @binding(0) var srcTex     : texture_2d<f32>;
+@group(1) @binding(1) var srcSamp    : sampler;
+
+@group(2) @binding(0) var depthTex   : texture_2d<f32>;
+@group(2) @binding(1) var depthSamp  : sampler;
+
+@group(3) @binding(0) var iorSigTex           : texture_2d<f32>;
+@group(3) @binding(1) var dispersionSigTex    : texture_2d<f32>;
+@group(3) @binding(2) var refractScaleSigTex  : texture_2d<f32>;
+@group(3) @binding(3) var causticSigTex       : texture_2d<f32>;
+@group(3) @binding(4) var ripplesSigTex       : texture_2d<f32>;
+@group(3) @binding(5) var roughnessSigTex     : texture_2d<f32>;
+@group(3) @binding(6) var lightPosXSigTex     : texture_2d<f32>;
+@group(3) @binding(7) var lightPosYSigTex     : texture_2d<f32>;
+@group(3) @binding(8) var sigSamp             : sampler;
+
+struct VSOut {
+    @builtin(position) pos : vec4<f32>,
+    @location(0) uv        : vec2<f32>,
+};
+
+@vertex fn vs(@builtin(vertex_index) vi: u32) -> VSOut {
+    var pos = array<vec2<f32>, 4>(
+        vec2<f32>(-1.0, 1.0),
+        vec2<f32>(1.0, 1.0),
+        vec2<f32>(-1.0, -1.0),
+        vec2<f32>(1.0, -1.0)
+    );
+    var uv = array<vec2<f32>, 4>(
+        vec2<f32>(0.0, 0.0),
+        vec2<f32>(1.0, 0.0),
+        vec2<f32>(0.0, 1.0),
+        vec2<f32>(1.0, 1.0)
+    );
+    return VSOut(vec4<f32>(pos[vi], 0.0, 1.0), uv[vi]);
+}
+
+fn sampleDepth(uv: vec2<f32>) -> f32 {
+    let clampedUV = clamp(uv, vec2<f32>(0.0), vec2<f32>(1.0));
+    var raw: f32 = 0.0;
+    if (u.hasDepthMap > 0.5) {
+        let dSample = textureSampleLevel(depthTex, depthSamp, clampedUV, 0.0);
+        raw = dot(dSample.rgb, vec3<f32>(0.299, 0.587, 0.114));
+    } else {
+        let c = textureSampleLevel(srcTex, srcSamp, clampedUV, 0.0);
+        raw = dot(c.rgb, vec3<f32>(0.299, 0.587, 0.114));
+    }
+    if (u.depthInvert > 0.5) {
+        raw = 1.0 - raw;
+    }
+    return clamp(raw, 0.0, 1.0);
+}
+
+fn sampleSmoothDepth(uv: vec2<f32>, texelSize: vec2<f32>) -> f32 {
+    let d0 = sampleDepth(uv);
+    let d1 = sampleDepth(uv + vec2<f32>(texelSize.x, 0.0));
+    let d2 = sampleDepth(uv - vec2<f32>(texelSize.x, 0.0));
+    let d3 = sampleDepth(uv + vec2<f32>(0.0, texelSize.y));
+    let d4 = sampleDepth(uv - vec2<f32>(0.0, texelSize.y));
+    return (d0 * 4.0 + d1 + d2 + d3 + d4) * 0.125;
+}
+
+// Analytical fluid ripple wave height and normal gradient
+fn getFluidWave(uv: vec2<f32>, time: f32, freqScale: f32) -> vec3<f32> {
+    let p = uv * freqScale * 18.0;
+    let t = time * 3.0;
+
+    let a1 = sin(p.x * 1.4 + p.y * 1.0 + t * 1.2);
+    let a2 = sin(p.x * -1.8 + p.y * 1.6 + t * 0.9);
+    let a3 = cos((p.x + p.y) * 2.2 - t * 1.4);
+
+    let height = (a1 + a2 + a3) * 0.333;
+
+    let dx = (1.4 * cos(p.x * 1.4 + p.y * 1.0 + t * 1.2)
+            - 1.8 * cos(p.x * -1.8 + p.y * 1.6 + t * 0.9)
+            - 2.2 * sin((p.x + p.y) * 2.2 - t * 1.4)) * freqScale * 18.0 * 0.333;
+
+    let dy = (1.0 * cos(p.x * 1.4 + p.y * 1.0 + t * 1.2)
+            + 1.6 * cos(p.x * -1.8 + p.y * 1.6 + t * 0.9)
+            - 2.2 * sin((p.x + p.y) * 2.2 - t * 1.4)) * freqScale * 18.0 * 0.333;
+
+    return vec3<f32>(dx, dy, height);
+}
+
+// Photometric cellular water caustic web (swimming pool / sunlight underwater filaments)
+fn getWaterCaustics(uv: vec2<f32>, time: f32, scale: f32) -> f32 {
+    let p = uv * scale * 32.0;
+    let t1 = time * 0.8;
+    let t2 = time * 1.1;
+
+    var p1 = p;
+    p1.x = p1.x + sin(p.y * 0.45 + t1) * 1.6;
+    p1.y = p1.y + cos(p.x * 0.45 + t1 * 0.8) * 1.6;
+
+    var p2 = p * 1.2 + vec2<f32>(4.7, 2.1);
+    p2.x = p2.x + cos(p2.y * 0.5 - t2 * 0.9) * 1.4;
+    p2.y = p2.y + sin(p2.x * 0.5 + t2) * 1.4;
+
+    let k1 = 1.0 - abs(sin(p1.x) * sin(p1.y));
+    let k2 = 1.0 - abs(cos(p2.x) * cos(p2.y));
+
+    // Sharp interconnected caustic web filaments
+    let web = pow(k1 * k2, 3.5);
+    return web;
+}
+
+fn computeSurfaceNormal(uv: vec2<f32>, texelSize: vec2<f32>, fluidRippleAmount: f32, rippleTime: f32, depthScaleVal: f32, causticScaleVal: f32) -> vec3<f32> {
+    let step = texelSize * 2.0;
+    let dL = sampleSmoothDepth(uv - vec2<f32>(step.x, 0.0), texelSize);
+    let dR = sampleSmoothDepth(uv + vec2<f32>(step.x, 0.0), texelSize);
+    let dD = sampleSmoothDepth(uv - vec2<f32>(0.0, step.y), texelSize);
+    let dU = sampleSmoothDepth(uv + vec2<f32>(0.0, step.y), texelSize);
+
+    var dx = (dR - dL) * depthScaleVal * 2.0;
+    var dy = (dU - dD) * depthScaleVal * 2.0;
+
+    if (fluidRippleAmount > 0.001) {
+        let wave = getFluidWave(uv, rippleTime, causticScaleVal);
+        dx = dx + wave.x * fluidRippleAmount * 0.08;
+        dy = dy + wave.y * fluidRippleAmount * 0.08;
+    }
+
+    return normalize(vec3<f32>(-dx, -dy, 1.0));
+}
+
+// Snell's Law ray refraction with Total Internal Reflection (TIR) fallback
+fn calcRefractOffset(I: vec3<f32>, N: vec3<f32>, eta: f32, thickness: f32) -> vec2<f32> {
+    let cosi = dot(-I, N);
+    let cost2 = 1.0 - eta * eta * (1.0 - cosi * cosi);
+    if (cost2 < 0.0) {
+        // Total internal reflection -> reflect
+        let R = reflect(I, N);
+        return R.xy * thickness * 0.5;
+    }
+    let R = eta * I + (eta * cosi - sqrt(cost2)) * N;
+    return R.xy * (thickness / max(0.2, abs(R.z)));
+}
+
+fn sampleAlbedoSafe(uv: vec2<f32>) -> vec4<f32> {
+    if (uv.x >= 0.0 && uv.x <= 1.0 && uv.y >= 0.0 && uv.y <= 1.0) {
+        return textureSampleLevel(srcTex, srcSamp, uv, 0.0);
+    }
+    // Mirror with subtle clamp for border inpainting / anti-tearing
+    let mirroredUV = abs(fract(uv * 0.5 + 0.5) * 2.0 - 1.0);
+    let clampedUV = clamp(mirroredUV, vec2<f32>(0.001), vec2<f32>(0.999));
+    return textureSampleLevel(srcTex, srcSamp, clampedUV, 0.0);
+}
+
+fn spectralWavelength(t: f32) -> vec3<f32> {
+    let x = clamp(t, 0.0, 1.0) * 6.0;
+    var r: f32 = 0.0;
+    var g: f32 = 0.0;
+    var b: f32 = 0.0;
+
+    if (x < 1.0) {
+        r = 1.0;
+        g = x;
+        b = 0.0;
+    } else if (x < 2.0) {
+        r = 2.0 - x;
+        g = 1.0;
+        b = 0.0;
+    } else if (x < 3.0) {
+        r = 0.0;
+        g = 1.0;
+        b = x - 2.0;
+    } else if (x < 4.0) {
+        r = 0.0;
+        g = 4.0 - x;
+        b = 1.0;
+    } else if (x < 5.0) {
+        r = x - 4.0;
+        g = 0.0;
+        b = 1.0;
+    } else {
+        r = 1.0;
+        g = 0.0;
+        b = max(0.4, 6.0 - x);
+    }
+    return vec3<f32>(r, g, b);
+}
+
+@fragment fn fs(in: VSOut) -> @location(0) vec4<f32> {
+    let dims = vec2<f32>(textureDimensions(srcTex));
+    let texelSize = vec2<f32>(1.0 / dims.x, 1.0 / dims.y);
+    let aspect = select(u.aspect, dims.x / max(1.0, dims.y), u.aspect <= 0.0);
+
+    // Resolve signals
+    var ior = u.ior;
+    if (u.hasSigIOR > 0.5) {
+        ior = clamp(textureSampleLevel(iorSigTex, sigSamp, in.uv, 0.0).r, 1.0, 2.5);
+    }
+
+    var dispersion = u.dispersion;
+    if (u.hasSigDispersion > 0.5) {
+        dispersion = clamp(textureSampleLevel(dispersionSigTex, sigSamp, in.uv, 0.0).r, 0.0, 0.2);
+    }
+
+    var refractionScale = u.refractionScale;
+    if (u.hasSigRefractScale > 0.5) {
+        refractionScale = clamp(textureSampleLevel(refractScaleSigTex, sigSamp, in.uv, 0.0).r, 0.0, 2.0);
+    }
+
+    var causticBrightness = u.causticBrightness;
+    if (u.hasSigCaustic > 0.5) {
+        causticBrightness = clamp(textureSampleLevel(causticSigTex, sigSamp, in.uv, 0.0).r, 0.0, 2.0);
+    }
+
+    var fluidRipples = u.fluidRipples;
+    if (u.hasSigRipples > 0.5) {
+        fluidRipples = clamp(textureSampleLevel(ripplesSigTex, sigSamp, in.uv, 0.0).r, 0.0, 1.0);
+    }
+
+    var roughness = u.roughness;
+    if (u.hasSigRoughness > 0.5) {
+        roughness = clamp(textureSampleLevel(roughnessSigTex, sigSamp, in.uv, 0.0).r, 0.0, 1.0);
+    }
+
+    var lightPosX = u.lightPosX;
+    if (u.hasSigLightPosX > 0.5) {
+        lightPosX = clamp(textureSampleLevel(lightPosXSigTex, sigSamp, in.uv, 0.0).r, 0.0, 1.0);
+    }
+
+    var lightPosY = u.lightPosY;
+    if (u.hasSigLightPosY > 0.5) {
+        lightPosY = clamp(textureSampleLevel(lightPosYSigTex, sigSamp, in.uv, 0.0).r, 0.0, 1.0);
+    }
+
+    let depthScaleVal = u.depthScale;
+    let causticScaleVal = max(0.1, u.causticScale);
+    let rippleSpeedVal = u.rippleSpeed;
+    let rippleTime = u.timeProgress * rippleSpeedVal * 6.2831853;
+
+    // Surface Normal & Incident Vectors
+    let N = computeSurfaceNormal(in.uv, texelSize, fluidRipples, rippleTime, depthScaleVal, causticScaleVal);
+    let I = vec3<f32>(0.0, 0.0, -1.0); // View vector towards surface
+    let V = vec3<f32>(0.0, 0.0, 1.0);  // View vector towards camera
+
+    // Base Snell's Law Refraction
+    let eta = 1.0 / max(1.001, ior);
+    let refractVec = calcRefractOffset(I, N, eta, refractionScale * 0.16);
+    let baseUV = in.uv + vec2<f32>(refractVec.x / aspect, refractVec.y);
+
+    // Multi-Spectral Chromatic Rainbow Dispersion
+    var accumColor = vec3<f32>(0.0);
+    var accumWeight = vec3<f32>(0.0);
+    var accumAlpha: f32 = 0.0;
+
+    let dispersionStrength = dispersion * refractionScale * 0.6;
+    let dispDirection = vec2<f32>(N.x / aspect, N.y);
+
+    // 7-tap spectral rainbow integration across wavelength spectrum (Red -> Yellow -> Green -> Cyan -> Blue -> Violet)
+    for (var s = 0; s < 7; s = s + 1) {
+        let t = f32(s) / 6.0; // 0.0 (Red) to 1.0 (Violet)
+        let specColor = spectralWavelength(t);
+        let lambdaOffset = dispDirection * ((t - 0.5) * dispersionStrength);
+        let sampleUV = baseUV + lambdaOffset;
+
+        var sampledTex = sampleAlbedoSafe(sampleUV);
+
+        // Microfacet frosted blur if roughness is enabled
+        if (roughness > 0.005) {
+            let blurRad = roughness * 0.018;
+            let j1 = sampleAlbedoSafe(sampleUV + vec2<f32>(blurRad / aspect, blurRad * 0.5));
+            let j2 = sampleAlbedoSafe(sampleUV - vec2<f32>(blurRad / aspect, blurRad * 0.5));
+            sampledTex = (sampledTex * 2.0 + j1 + j2) * 0.25;
+        }
+
+        accumColor = accumColor + sampledTex.rgb * specColor;
+        accumWeight = accumWeight + specColor;
+        accumAlpha = accumAlpha + sampledTex.a;
+    }
+
+    let finalRefractedRGB = accumColor / max(accumWeight, vec3<f32>(0.001));
+    let finalAlpha = accumAlpha / 7.0;
+
+    // Incident light vector
+    let lightPos3D = vec3<f32>((lightPosX - 0.5) * aspect, lightPosY - 0.5, 0.85);
+    let surfPos3D = vec3<f32>((in.uv.x - 0.5) * aspect, in.uv.y - 0.5, 0.0);
+    let L = normalize(lightPos3D - surfPos3D);
+
+    // 1. Dynamic Fluid Caustics (active when fluidRipples > 0.001)
+    var fluidCaustic = 0.0;
+    if (fluidRipples > 0.001) {
+        let web = getWaterCaustics(in.uv, rippleTime, causticScaleVal);
+        let pLight = vec2<f32>(lightPosX, lightPosY);
+        let distLight = length((in.uv - pLight) * vec2<f32>(aspect, 1.0));
+        let lightAtt = 1.0 / (1.0 + distLight * distLight * 1.2);
+        fluidCaustic = web * lightAtt * fluidRipples * causticBrightness * 0.45;
+    }
+
+    // 2. Specular Highlights & Fresnel Reflectance (Schlick's approximation)
+    let f0 = pow((ior - 1.0) / (ior + 1.0), 2.0);
+    let NdotV = max(dot(N, V), 0.0);
+    let fresnel = f0 + (1.0 - f0) * pow(1.0 - NdotV, 5.0);
+
+    let H = normalize(L + V);
+    let NdotH = max(dot(N, H), 0.0);
+    let specShininess = mix(256.0, 32.0, roughness);
+    let specular = pow(NdotH, specShininess) * u.specularIntensity * fresnel * 1.5;
+
+    // Glass Absorption & Tinting
+    let tintStrengthVal = u.tintStrength;
+    let tintedBase = mix(finalRefractedRGB, finalRefractedRGB * u.tintColor.rgb, tintStrengthVal);
+
+    // Final Composite (Refracted Rainbow Spectrum + Fluid Caustics + Crisp Specular)
+    let finalRGB = tintedBase + vec3<f32>(fluidCaustic) * u.tintColor.rgb + vec3<f32>(specular);
+
+    return vec4<f32>(clamp(finalRGB, vec3<f32>(0.0), vec3<f32>(1.0)), finalAlpha);
+}
+`,X=new WeakMap;function ve(r){let e=X.get(r);if(e)return e;let i=r.createBindGroupLayout({entries:[{binding:0,visibility:GPUShaderStage.FRAGMENT,buffer:{type:"uniform"}}]}),p=r.createBindGroupLayout({entries:[{binding:0,visibility:GPUShaderStage.FRAGMENT,texture:{sampleType:"float"}},{binding:1,visibility:GPUShaderStage.FRAGMENT,sampler:{type:"filtering"}}]}),o=r.createBindGroupLayout({entries:[{binding:0,visibility:GPUShaderStage.FRAGMENT,texture:{sampleType:"float"}},{binding:1,visibility:GPUShaderStage.FRAGMENT,sampler:{type:"filtering"}}]}),d=r.createBindGroupLayout({entries:[{binding:0,visibility:GPUShaderStage.FRAGMENT,texture:{sampleType:"float"}},{binding:1,visibility:GPUShaderStage.FRAGMENT,texture:{sampleType:"float"}},{binding:2,visibility:GPUShaderStage.FRAGMENT,texture:{sampleType:"float"}},{binding:3,visibility:GPUShaderStage.FRAGMENT,texture:{sampleType:"float"}},{binding:4,visibility:GPUShaderStage.FRAGMENT,texture:{sampleType:"float"}},{binding:5,visibility:GPUShaderStage.FRAGMENT,texture:{sampleType:"float"}},{binding:6,visibility:GPUShaderStage.FRAGMENT,texture:{sampleType:"float"}},{binding:7,visibility:GPUShaderStage.FRAGMENT,texture:{sampleType:"float"}},{binding:8,visibility:GPUShaderStage.FRAGMENT,sampler:{type:"filtering"}}]});return e={uniformLayout:i,srcTextureLayout:p,depthTextureLayout:o,signalTextureLayout:d,pipelineCache:new Map},X.set(r,e),e}function me(r,e){let i=ve(r),p=`refraction_caustics_${e}`,o=i.pipelineCache.get(p);if(!o){let d=r.createShaderModule({label:`refraction_caustics_${e}.wgsl`,code:he});o=r.createRenderPipeline({label:`RefractionCausticsPipeline_${e}`,layout:r.createPipelineLayout({bindGroupLayouts:[i.uniformLayout,i.srcTextureLayout,i.depthTextureLayout,i.signalTextureLayout]}),vertex:{module:d,entryPoint:"vs"},fragment:{module:d,entryPoint:"fs",targets:[{format:e}]},primitive:{topology:"triangle-strip"}}),i.pipelineCache.set(p,o)}return{pipeline:o,uniformLayout:i.uniformLayout,srcTextureLayout:i.srcTextureLayout,depthTextureLayout:i.depthTextureLayout,signalTextureLayout:i.signalTextureLayout}}function c(r,e,i,p,o){let d=`${e}HandleId`,m=r[d],u=m?r.inputs?.[m]:null,a=!!(u?.connectionValid&&(u.outputItem?.type==="Signal"||u.outputItem?.type==="Numeric")),S=a&&u?.outputItem?.data?u.outputItem.data:null,h=i;if(a){if(S){let f=Number(S.offset??i);h=Math.max(p,Math.min(o,f))}}else if(u?.connectionValid&&u.outputItem?.type==="Number"){let f=Number(u.outputItem.data??i);h=Math.max(p,Math.min(o,f))}else{let f=Number(r[e]??i);h=Math.max(p,Math.min(o,f))}return{hasSignal:a,sd:S,value:h}}var k=async r=>{let{ctx:e,encoder:i,pass:p,targetView:o,targetTexture:d,targetWidth:m,targetHeight:u,props:a,drawChild:S}=r,h=a.frame??0,f=a.fps||60,s=a.virtualMedia?.operation;if(s?.op!=="RefractionCaustics3D"||!s)return;let G=a.virtualMedia.children?.[0];if(!G)return;p.end();let n=m,l=u,x=e.renderer.getTemporaryTexture(n,l,[...a.excludeTextures||[],d]),L=x.createView();e.renderer.beginFrame(i,L,{r:0,g:0,b:0,a:0},n,l,"clear").end(),e.renderer.pushScissor({x:0,y:0,width:n,height:l}),e.renderer.pushIdentity(),await S(G,{...a,virtualMedia:G,containerWidth:n,containerHeight:l},L,x,n,l),e.renderer.popTransform(),e.renderer.popScissor(),r.pass.end();let I=s.depthMedia,y,R,V=!1;I?(y=e.renderer.getTemporaryTexture(n,l,[...a.excludeTextures||[],d,x]),R=y.createView(),e.renderer.beginFrame(i,R,{r:0,g:0,b:0,a:0},n,l,"clear").end(),e.renderer.pushScissor({x:0,y:0,width:n,height:l}),e.renderer.pushIdentity(),await S(I,{...a,virtualMedia:I,containerWidth:n,containerHeight:l},R,y,n,l),e.renderer.popTransform(),e.renderer.popScissor(),r.pass.end(),V=!0):(y=x,R=L,V=!1);let{pipeline:q,uniformLayout:j,srcTextureLayout:$,depthTextureLayout:K,signalTextureLayout:J}=me(e.device,e.renderer.format),C=e.renderer.samplerCache.getSampler(e.device),O=a.elapsedMs!==void 0?a.elapsedMs/1e3:h/f,T=a.virtualMedia?.metadata?.durationMs?a.virtualMedia.metadata.durationMs/1e3:a.durationMs!==void 0?a.durationMs/1e3:4,Q=T>0?O%T/T:0,D=c(s,"ior",1.52,1,2.5),M=c(s,"dispersion",.04,0,.2),U=c(s,"refractionScale",.5,0,2),_=c(s,"causticBrightness",.6,0,2),Z=c(s,"causticScale",1,.1,5),N=c(s,"fluidRipples",0,0,1),A=c(s,"roughness",0,0,1),B=c(s,"lightPosX",.5,0,1),F=c(s,"lightPosY",.2,0,1),ee=c(s,"specularIntensity",.8,0,2),te=c(s,"depthScale",1,.1,5),ie=c(s,"tintStrength",0,0,1),re=c(s,"rippleSpeed",1,0,5),g=(b,fe)=>b.hasSignal&&b.sd?H.getOrCreate2DTextureView(e.device,i,b.sd.nodeId??fe,O,T,b.sd,n,l,a.renderId,h,f):H.getDummy1x1TextureView(e.device),ae=g(D,"refr_ior_sig"),se=g(M,"refr_disp_sig"),ne=g(U,"refr_scale_sig"),le=g(_,"refr_caust_sig"),ce=g(N,"refr_rip_sig"),oe=g(A,"refr_rough_sig"),ue=g(B,"refr_lightx_sig"),pe=g(F,"refr_lighty_sig"),t=new Float32Array(36);t[0]=0,t[1]=D.value,t[2]=M.value,t[3]=U.value,t[4]=_.value,t[5]=Z.value,t[6]=N.value,t[7]=re.value,t[8]=A.value,t[9]=ee.value,t[10]=B.value,t[11]=F.value,t[12]=ie.value,t[13]=s.depthInvert?1:0,t[14]=te.value,t[15]=V?1:0,t[16]=Q,t[17]=n/Math.max(1,l),t[18]=0,t[19]=0,t[20]=D.hasSignal?1:0,t[21]=M.hasSignal?1:0,t[22]=U.hasSignal?1:0,t[23]=_.hasSignal?1:0,t[24]=N.hasSignal?1:0,t[25]=A.hasSignal?1:0,t[26]=B.hasSignal?1:0,t[27]=F.hasSignal?1:0,t[28]=0,t[29]=0,t[30]=0,t[31]=0;let P=E(s.tintColor??"#ffffff");t[32]=P.r,t[33]=P.g,t[34]=P.b,t[35]=P.a;let de=e.renderer.getTemporaryBuffer(t),W=e.renderer.getTemporaryTexture(n,l,[x,y,d,...a.excludeTextures||[]]),v=i.beginRenderPass({colorAttachments:[{view:W.createView(),loadOp:"clear",storeOp:"store",clearValue:{r:0,g:0,b:0,a:0}}]});v.setPipeline(q),v.setBindGroup(0,e.device.createBindGroup({layout:j,entries:[{binding:0,resource:{buffer:de}}]})),v.setBindGroup(1,e.renderer.bindGroupCache.getBindGroup(e.device,$,x,C)),v.setBindGroup(2,e.renderer.bindGroupCache.getBindGroup(e.device,K,y,C)),v.setBindGroup(3,e.device.createBindGroup({layout:J,entries:[{binding:0,resource:ae},{binding:1,resource:se},{binding:2,resource:ne},{binding:3,resource:le},{binding:4,resource:ce},{binding:5,resource:oe},{binding:6,resource:ue},{binding:7,resource:pe},{binding:8,resource:C}]})),v.draw(4),v.end();let z=e.renderer.beginFrame(i,o,{r:0,g:0,b:0,a:0},m,u,"load");e.renderer.drawTexture(z,W,{x:0,y:0,width:m,height:u},{opacity:s.opacity??1}),r.pass=z};var Pe=Y({WebGPURenderer:k});export{k as a,Pe as b};