{"version":3,"file":"WaveGradient.CD9OkZ_D.mjs","names":["useRef","prog","p"],"sources":["https:/framerusercontent.com/modules/qfjeaSvUvz5ZW9a00gTz/Df5bIFoKtASrPIoc8Ii1/WaveGradient.js"],"sourcesContent":["import{jsx as _jsx}from\"react/jsx-runtime\";import{addPropertyControls,ControlType}from\"framer\";import{useEffect,useRef}from\"react\";/**\n * Paper Shaders \"grain-gradient\" wave preset, ported with P3 wide-gamut output.\n *\n * Source: https://github.com/paper-design/shaders\n * Preset URL:\n *   https://shaders.paper.design/grain-gradient\n *     #colors=ffaa00,ff9100,ff4400&colorBack=ff6a00\n *     &softness=0.7&intensity=0.15&noise=0.5&shape=wave&speed=1&scale=1\n *\n * PERFORMANCE NOTES (output is visually identical to the original port):\n *  - The grain field (grainDist + noiseVal) depends only on pixel position,\n *    never on time. It is rendered ONCE into an offscreen texture (and again\n *    on resize), so the per-frame shader is just the cheap wave + colour mix\n *    + one texture fetch instead of 2 simplex + 12 value-noise evaluations\n *    per pixel per frame.\n *  - The render loop uploads only u_time; everything else is set on change.\n *  - No layout reads in the loop; the ResizeObserver owns sizing.\n *  - Rendering pauses entirely while the canvas is offscreen.\n *  - The GL context is created once and survives prop changes (uniforms are\n *    updated in place), so editor tweaks no longer rebuild everything.\n *\n * @framerSupportedLayoutWidth any\n * @framerSupportedLayoutHeight any\n * @framerIntrinsicWidth 1200\n * @framerIntrinsicHeight 600\n */export default function WaveGradient(props){const{color1,color2,color3,colorBack,softness,intensity,noise,speed,scale,style}=props;const canvasRef=useRef(null);const glStateRef=useRef(null);// One-time GL setup. Prop changes only update uniforms (effect below).\nuseEffect(()=>{const canvas=canvasRef.current;if(!canvas)return;const ctxAttribs={antialias:true,premultipliedAlpha:true,alpha:true,colorSpace:\"display-p3\"};const gl=canvas.getContext(\"webgl\",ctxAttribs);if(!gl)return;try{// @ts-ignore\ngl.drawingBufferColorSpace=\"display-p3\";// @ts-ignore\ngl.unpackColorSpace=\"display-p3\";}catch{}// Needed for fwidth(); guaranteed on all WebGL1 desktop + iOS Safari 14+.\ngl.getExtension(\"OES_standard_derivatives\");const vertSrc=`\n            attribute vec2 a_pos;\n            varying vec2 v_uv;\n            void main() {\n                v_uv = a_pos * 0.5 + 0.5;\n                gl_Position = vec4(a_pos, 0.0, 1.0);\n            }\n        `;// ---------------------------------------------------------------\n// PASS 1 — grain field, rendered once per resize into a texture.\n// Faithful copy of the noise stack from the original port. The two\n// outputs are time-independent:\n//   R: grainDist, encoded from its analytic range [-2, 1] into [0, 1]\n//   G: noiseVal, already in [0, 0.75]\n// 8-bit quantisation here is invisible: the values are noise and are\n// multiplied down by intensity/noise before entering the shape.\n// ---------------------------------------------------------------\nconst grainFragSrc=`\n            precision highp float;\n\n            vec2 rotate(vec2 v, float a) {\n                float c = cos(a), s = sin(a);\n                return mat2(c, -s, s, c) * v;\n            }\n\n            // --- Simplex 2D noise (Ashima Arts) ---\n            vec3 mod289_3(vec3 x) { return x - floor(x * (1.0 / 289.0)) * 289.0; }\n            vec2 mod289_2(vec2 x) { return x - floor(x * (1.0 / 289.0)) * 289.0; }\n            vec3 permute(vec3 x) { return mod289_3(((x * 34.0) + 1.0) * x); }\n            float snoise(vec2 v) {\n                const vec4 C = vec4(0.211324865405187, 0.366025403784439,\n                                    -0.577350269189626, 0.024390243902439);\n                vec2 i  = floor(v + dot(v, C.yy));\n                vec2 x0 = v - i + dot(i, C.xx);\n                vec2 i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);\n                vec4 x12 = x0.xyxy + C.xxzz; x12.xy -= i1;\n                i = mod289_2(i);\n                vec3 p = permute(permute(i.y + vec3(0.0, i1.y, 1.0))\n                                       + i.x + vec3(0.0, i1.x, 1.0));\n                vec3 m = max(0.5 - vec3(dot(x0, x0), dot(x12.xy, x12.xy),\n                                        dot(x12.zw, x12.zw)), 0.0);\n                m = m * m; m = m * m;\n                vec3 x = 2.0 * fract(p * C.www) - 1.0;\n                vec3 h = abs(x) - 0.5;\n                vec3 ox = floor(x + 0.5);\n                vec3 a0 = x - ox;\n                m *= 1.79284291400159 - 0.85373472095314 * (a0 * a0 + h * h);\n                vec3 g;\n                g.x  = a0.x  * x0.x  + h.x  * x0.y;\n                g.yz = a0.yz * x12.xz + h.yz * x12.yw;\n                return 130.0 * dot(m, g);\n            }\n\n            // --- Value noise + FBM matching paper shaders' implementation ---\n            float randomR(vec2 st) {\n                return fract(sin(dot(st, vec2(127.1, 311.7))) * 43758.5453);\n            }\n            float valueNoiseR(vec2 st) {\n                vec2 i = floor(st);\n                vec2 f = fract(st);\n                float a = randomR(i);\n                float b = randomR(i + vec2(1.0, 0.0));\n                float c = randomR(i + vec2(0.0, 1.0));\n                float d = randomR(i + vec2(1.0, 1.0));\n                vec2 u = f * f * (3.0 - 2.0 * f);\n                return mix(mix(a, b, u.x), mix(c, d, u.x), u.y);\n            }\n            vec4 fbmR(vec2 n0, vec2 n1, vec2 n2, vec2 n3) {\n                float amplitude = 0.2;\n                vec4 total = vec4(0.0);\n                for (int i = 0; i < 3; i++) {\n                    n0 = rotate(n0, 0.3);\n                    n1 = rotate(n1, 0.3);\n                    n2 = rotate(n2, 0.3);\n                    n3 = rotate(n3, 0.3);\n                    total.x += valueNoiseR(n0) * amplitude;\n                    total.y += valueNoiseR(n1) * amplitude;\n                    total.z += valueNoiseR(n2) * amplitude;\n                    total.z += valueNoiseR(n3) * amplitude;\n                    n0 *= 1.99; n1 *= 1.99; n2 *= 1.99; n3 *= 1.99;\n                    amplitude *= 0.6;\n                }\n                return total;\n            }\n\n            void main() {\n                // Grain is computed in pixel space so it stays a fine,\n                // fixed-size texture regardless of canvas size or scale —\n                // same approach as paper shaders.\n                vec2 grain_uv = gl_FragCoord.xy * 1.6;\n\n                float baseNoise = snoise(grain_uv * 0.5);\n                vec4 fbmVals = fbmR(\n                    0.002 * grain_uv + 10.0,\n                    0.003 * grain_uv,\n                    0.001 * grain_uv,\n                    rotate(0.4 * grain_uv, 2.0)\n                );\n                float grainDist = baseNoise * snoise(grain_uv * 0.2)\n                                  - fbmVals.x - fbmVals.y;\n                float rawNoise = 0.75 * baseNoise - fbmVals.w - fbmVals.z;\n                float noiseVal = clamp(rawNoise, 0.0, 1.0);\n\n                gl_FragColor = vec4((grainDist + 2.0) / 3.0, noiseVal, 0.0, 1.0);\n            }\n        `;// ---------------------------------------------------------------\n// PASS 2 — per-frame wave + colour mix. Grain comes from the texture.\n// ---------------------------------------------------------------\nconst fragSrc=`\n            #extension GL_OES_standard_derivatives : enable\n            precision highp float;\n\n            varying vec2 v_uv;\n            uniform vec2 u_res;\n            uniform float u_time;\n            uniform float u_scale;\n            uniform float u_softness;\n            uniform float u_intensity;\n            uniform float u_noise;\n            uniform float u_speed;\n            uniform vec4 u_c1;\n            uniform vec4 u_c2;\n            uniform vec4 u_c3;\n            uniform vec4 u_cBack;\n            uniform sampler2D u_grain;\n\n            void main() {\n                // Paper shaders' wave uses t = .1 * (time + 7.) — matched here.\n                float t = 0.1 * (u_time * u_speed + 7.0);\n\n                vec2 uv = (v_uv - 0.5);\n                uv.x *= u_res.x / max(u_res.y, 1.0);\n                vec2 patternUV = uv / max(u_scale, 0.01);\n                vec2 shape_uv = patternUV * 5.0;\n\n                // ----- Wave shape (paper shaders grain-gradient.ts) -----\n                float wave =\n                    cos(0.5 * shape_uv.x - 4.0 * t)\n                    * sin(1.5 * shape_uv.x + 2.0 * t)\n                    * (0.75 + 0.25 * cos(6.0 * t));\n                float shape = 1.0 - smoothstep(-1.0, 1.0, shape_uv.y + wave);\n\n                // ----- Grain / noise overlay (precomputed, 1:1 pixels) -----\n                vec2 g = texture2D(u_grain, v_uv).rg;\n                float grainDist = g.x * 3.0 - 2.0;\n                float noiseVal = g.y;\n\n                const float colorsCount = 3.0;\n                shape += u_intensity * 2.0 / colorsCount * (grainDist + 0.5);\n                shape += u_noise * 10.0 / colorsCount * noiseVal;\n\n                float aa = fwidth(shape);\n                shape = clamp(shape - 0.5 / colorsCount, 0.0, 1.0);\n                float totalShape = smoothstep(\n                    0.0,\n                    u_softness + 2.0 * aa,\n                    clamp(shape * colorsCount, 0.0, 1.0)\n                );\n                float mixer = shape * (colorsCount - 1.0);\n\n                // ----- 3-stop gradient with softness-controlled transitions -----\n                vec4 c0 = u_c1; c0.rgb *= c0.a;\n                vec4 c1 = u_c2; c1.rgb *= c1.a;\n                vec4 c2 = u_c3; c2.rgb *= c2.a;\n\n                vec4 gradient = c0;\n                float localT;\n                localT = clamp(mixer, 0.0, 1.0);\n                localT = smoothstep(0.5 - 0.5 * u_softness - aa,\n                                    0.5 + 0.5 * u_softness + aa, localT);\n                gradient = mix(gradient, c1, localT);\n\n                localT = clamp(mixer - 1.0, 0.0, 1.0);\n                localT = smoothstep(0.5 - 0.5 * u_softness - aa,\n                                    0.5 + 0.5 * u_softness + aa, localT);\n                gradient = mix(gradient, c2, localT);\n\n                vec3 color = gradient.rgb * totalShape;\n                float opacity = gradient.a * totalShape;\n\n                vec3 bgColor = u_cBack.rgb * u_cBack.a;\n                color = color + bgColor * (1.0 - opacity);\n                opacity = opacity + u_cBack.a * (1.0 - opacity);\n\n                gl_FragColor = vec4(color, opacity);\n            }\n        `;const compile=(type,src)=>{const sh=gl.createShader(type);gl.shaderSource(sh,src);gl.compileShader(sh);if(!gl.getShaderParameter(sh,gl.COMPILE_STATUS)){console.error(gl.getShaderInfoLog(sh));}return sh;};const link=fs=>{const prog=gl.createProgram();gl.attachShader(prog,compile(gl.VERTEX_SHADER,vertSrc));gl.attachShader(prog,compile(gl.FRAGMENT_SHADER,fs));gl.linkProgram(prog);return prog;};const prog=link(fragSrc);const grainProg=link(grainFragSrc);const buf=gl.createBuffer();gl.bindBuffer(gl.ARRAY_BUFFER,buf);gl.bufferData(gl.ARRAY_BUFFER,new Float32Array([-1,-1,1,-1,-1,1,-1,1,1,-1,1,1]),gl.STATIC_DRAW);for(const p of[prog,grainProg]){const loc=gl.getAttribLocation(p,\"a_pos\");gl.enableVertexAttribArray(loc);gl.vertexAttribPointer(loc,2,gl.FLOAT,false,0,0);}gl.useProgram(prog);const u=n=>gl.getUniformLocation(prog,n);const uRes=u(\"u_res\");const uTime=u(\"u_time\");// Grain texture + framebuffer (regenerated only on resize).\nconst grainTex=gl.createTexture();gl.bindTexture(gl.TEXTURE_2D,grainTex);gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_MIN_FILTER,gl.NEAREST);gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_MAG_FILTER,gl.NEAREST);gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_WRAP_S,gl.CLAMP_TO_EDGE);gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_WRAP_T,gl.CLAMP_TO_EDGE);const fbo=gl.createFramebuffer();gl.activeTexture(gl.TEXTURE0);gl.uniform1i(u(\"u_grain\"),0);const renderGrain=()=>{gl.bindFramebuffer(gl.FRAMEBUFFER,fbo);gl.bindTexture(gl.TEXTURE_2D,grainTex);gl.texImage2D(gl.TEXTURE_2D,0,gl.RGBA,canvas.width,canvas.height,0,gl.RGBA,gl.UNSIGNED_BYTE,null);gl.framebufferTexture2D(gl.FRAMEBUFFER,gl.COLOR_ATTACHMENT0,gl.TEXTURE_2D,grainTex,0);gl.disable(gl.BLEND);gl.useProgram(grainProg);gl.viewport(0,0,canvas.width,canvas.height);gl.drawArrays(gl.TRIANGLES,0,6);gl.bindFramebuffer(gl.FRAMEBUFFER,null);gl.useProgram(prog);gl.enable(gl.BLEND);gl.blendFunc(gl.ONE,gl.ONE_MINUS_SRC_ALPHA);};let needsFrame=true;const resize=()=>{const dpr=Math.min(window.devicePixelRatio||1,2);const w=Math.max(1,Math.round(canvas.clientWidth*dpr));const h=Math.max(1,Math.round(canvas.clientHeight*dpr));if(canvas.width!==w||canvas.height!==h){canvas.width=w;canvas.height=h;gl.viewport(0,0,w,h);gl.uniform2f(uRes,w,h);renderGrain();needsFrame=true;}};const ro=new ResizeObserver(resize);ro.observe(canvas);resize();// First sizing may be a no-op size change; ensure grain exists.\ngl.uniform2f(uRes,canvas.width,canvas.height);renderGrain();// Uniform setter exposed to the props effect — no GL rebuild on change.\nconst setParams=p=>{gl.useProgram(prog);gl.uniform1f(u(\"u_scale\"),p.scale);gl.uniform1f(u(\"u_softness\"),p.softness);gl.uniform1f(u(\"u_intensity\"),p.intensity);gl.uniform1f(u(\"u_noise\"),p.noise);gl.uniform1f(u(\"u_speed\"),p.speed);gl.uniform4f(u(\"u_c1\"),p.color1.r,p.color1.g,p.color1.b,p.color1.a);gl.uniform4f(u(\"u_c2\"),p.color2.r,p.color2.g,p.color2.b,p.color2.a);gl.uniform4f(u(\"u_c3\"),p.color3.r,p.color3.g,p.color3.b,p.color3.a);gl.uniform4f(u(\"u_cBack\"),p.colorBack.r,p.colorBack.g,p.colorBack.b,p.colorBack.a);needsFrame=true;};glStateRef.current={gl,setParams};// Render loop: only u_time per frame; paused while offscreen.\nconst start=performance.now();let raf=0;let running=false;const render=now=>{gl.uniform1f(uTime,(now-start)/1e3);gl.drawArrays(gl.TRIANGLES,0,6);raf=requestAnimationFrame(render);};const startLoop=()=>{if(running)return;running=true;raf=requestAnimationFrame(render);};const stopLoop=()=>{running=false;cancelAnimationFrame(raf);};const io=new IntersectionObserver(entries=>{if(entries[0].isIntersecting)startLoop();else stopLoop();});io.observe(canvas);return()=>{stopLoop();io.disconnect();ro.disconnect();glStateRef.current=null;gl.deleteTexture(grainTex);gl.deleteFramebuffer(fbo);gl.deleteBuffer(buf);gl.deleteProgram(prog);gl.deleteProgram(grainProg);const lose=gl.getExtension(\"WEBGL_lose_context\");if(lose)lose.loseContext();};},[]);// Prop changes only touch uniforms — the context and grain survive.\nuseEffect(()=>{glStateRef.current?.setParams({color1,color2,color3,colorBack,softness,intensity,noise,speed,scale});},[color1,color2,color3,colorBack,softness,intensity,noise,speed,scale]);return /*#__PURE__*/_jsx(\"canvas\",{ref:canvasRef,style:{width:\"100%\",height:\"100%\",display:\"block\",...style}});}// Defaults reproduce the exact URL preset:\n//   colors=ffaa00,ff9100,ff4400   colorBack=ff6a00\n//   softness=0.7  intensity=0.15  noise=0.5  speed=1  scale=1\n// Hex bytes are sent as raw P3 floats so they read slightly more saturated\n// than the sRGB preview — same hue family, wider gamut.\nWaveGradient.defaultProps={color1:{r:1,g:.667,b:0,a:1},color2:{r:1,g:.569,b:0,a:1},color3:{r:1,g:.267,b:0,a:1},colorBack:{r:1,g:.416,b:0,a:1},softness:.7,intensity:.15,noise:.5,speed:1,scale:1};const rgbaControl=(title,def)=>({type:ControlType.Object,title,controls:{r:{type:ControlType.Number,min:0,max:1,step:.001,defaultValue:def.r},g:{type:ControlType.Number,min:0,max:1,step:.001,defaultValue:def.g},b:{type:ControlType.Number,min:0,max:1,step:.001,defaultValue:def.b},a:{type:ControlType.Number,min:0,max:1,step:.01,defaultValue:def.a}}});addPropertyControls(WaveGradient,{color1:rgbaControl(\"Color 1 (P3)\",{r:1,g:.667,b:0,a:1}),color2:rgbaControl(\"Color 2 (P3)\",{r:1,g:.569,b:0,a:1}),color3:rgbaControl(\"Color 3 (P3)\",{r:1,g:.267,b:0,a:1}),colorBack:rgbaControl(\"Background (P3)\",{r:1,g:.416,b:0,a:1}),softness:{type:ControlType.Number,title:\"Softness\",min:0,max:1,step:.01,defaultValue:.7},intensity:{type:ControlType.Number,title:\"Intensity\",min:0,max:1,step:.01,defaultValue:.15},noise:{type:ControlType.Number,title:\"Noise\",min:0,max:1,step:.01,defaultValue:.5},speed:{type:ControlType.Number,title:\"Speed\",min:0,max:4,step:.05,defaultValue:1},scale:{type:ControlType.Number,title:\"Scale\",min:.1,max:4,step:.05,defaultValue:1}});\nexport const __FramerMetadata__ = {\"exports\":{\"default\":{\"type\":\"reactComponent\",\"name\":\"WaveGradient\",\"slots\":[],\"annotations\":{\"framerSupportedLayoutWidth\":\"any\",\"framerIntrinsicWidth\":\"1200\",\"framerContractVersion\":\"1\",\"framerIntrinsicHeight\":\"600\",\"framerSupportedLayoutHeight\":\"any\"}},\"__FramerMetadata__\":{\"type\":\"variable\"}}}\n//# sourceMappingURL=./WaveGradient.map"],"mappings":"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"}