diff --git a/packages/use-shader-fx/build/use-shader-fx.js b/packages/use-shader-fx/build/use-shader-fx.js new file mode 100644 index 00000000..8c34b162 --- /dev/null +++ b/packages/use-shader-fx/build/use-shader-fx.js @@ -0,0 +1,2112 @@ +import * as o from "three"; +import { useState as E, useEffect as K, useCallback as h, useRef as T } from "react"; +const R = (e) => typeof e == "number" ? { shader: e, fbo: e } : { + shader: e.shader ?? !1, + fbo: e.fbo ?? !1 +}, N = (e, t = !1) => { + const r = t ? e.width * t : e.width, a = t ? e.height * t : e.height, [n] = E(() => new o.Vector2(r, a)); + return n.set(r, a), n; +}, De = (e, t) => { + const r = t, a = e / t, [n, i] = [r * a / 2, r / 2]; + return { width: n, height: i, near: -1e3, far: 1e3 }; +}, be = (e, t = "OrthographicCamera") => { + const r = N(e), { width: a, height: n, near: i, far: s } = De( + r.x, + r.y + ), [c] = E(() => t === "OrthographicCamera" ? new o.OrthographicCamera( + -a, + a, + n, + -n, + i, + s + ) : new o.PerspectiveCamera(50, a / n)); + return c instanceof o.OrthographicCamera ? (c.left = -a, c.right = a, c.top = n, c.bottom = -n, c.near = i, c.far = s, c.updateProjectionMatrix()) : c instanceof o.PerspectiveCamera && (c.aspect = a / n, c.updateProjectionMatrix()), c; +}, te = { + depthBuffer: !1 +}, de = ({ + gl: e, + fbo: t, + scene: r, + camera: a, + clear: n = !0, + onBeforeRender: i, + onSwap: s +}) => { + if (!r || !a) + return; + const c = e.autoClear; + e.autoClear = n, e.setRenderTarget(t), i(), e.render(r, a), s && s(), e.setRenderTarget(null), e.autoClear = c; +}, b = (e) => { + const { + scene: t, + camera: r, + size: a, + dpr: n = !1, + fboAutoSetSize: i = !1, + depth: s = !1, + ...c + } = e, l = N(a, n), [u] = E(() => { + const _ = new o.WebGLRenderTarget(l.x, l.y, { + ...te, + ...c + }); + return s && (_.depthTexture = new o.DepthTexture( + l.x, + l.y, + o.FloatType + )), _; + }); + i && u.setSize(l.x, l.y), K(() => { + const _ = u; + return () => { + _ == null || _.dispose(); + }; + }, [u]); + const v = h( + (_, m) => { + const x = u; + return de({ + ..._, + scene: _.scene || t, + camera: _.camera || r, + fbo: x, + onBeforeRender: () => m == null ? void 0 : m({ read: x.texture }) + }), x.texture; + }, + [t, r, u] + ); + return [u, v]; +}, he = (e) => { + var _, m; + const { + scene: t, + camera: r, + size: a, + dpr: n = !1, + fboAutoSetSize: i = !1, + depth: s = !1, + ...c + } = e, l = N(a, n), [u] = E(() => { + const x = new o.WebGLRenderTarget(l.x, l.y, { + ...te, + ...c + }), p = new o.WebGLRenderTarget(l.x, l.y, { + ...te, + ...c + }); + return s && (x.depthTexture = new o.DepthTexture( + l.x, + l.y, + o.FloatType + ), p.depthTexture = new o.DepthTexture( + l.x, + l.y, + o.FloatType + )), { + read: x, + write: p, + swap: function() { + let f = this.read; + this.read = this.write, this.write = f; + } + }; + }); + i && ((_ = u.read) == null || _.setSize(l.x, l.y), (m = u.write) == null || m.setSize(l.x, l.y)), K(() => { + const x = u; + return () => { + var p, f; + (p = x.read) == null || p.dispose(), (f = x.write) == null || f.dispose(); + }; + }, [u]); + const v = h( + (x, p) => { + var g; + const f = u; + return de({ + ...x, + scene: x.scene || t, + camera: x.camera || r, + fbo: f.write, + onBeforeRender: () => p == null ? void 0 : p({ + read: f.read.texture, + write: f.write.texture + }), + onSwap: () => f.swap() + }), (g = f.read) == null ? void 0 : g.texture; + }, + [t, r, u] + ); + return [ + { read: u.read, write: u.write }, + v + ]; +}, we = (e, t, r, a) => { + const [n] = E(() => new a(t, r)); + return K(() => (e && e.add(n), () => { + e && e.remove(n), t.dispose(), r.dispose(); + }), [e, t, r, n]), n; +}, M = ({ + size: e, + dpr: t, + material: r, + geometry: a = o.PlaneGeometry, + geometrySize: n, + ...i +}) => { + const [s] = E(() => new o.Scene()), [c] = E( + () => new a((n == null ? void 0 : n.width) || 2, (n == null ? void 0 : n.height) || 2) + ), [l] = E(() => new r(i)), u = N(e, t); + l.updateResolution(u.x, u.y), we(s, c, l, o.Mesh); + const v = be(e); + return { + scene: s, + material: l, + camera: v + }; +}, Ce = (e) => { + const t = T(e), r = h((a) => { + t.current = typeof a == "function" ? a(t.current) : a; + }, []); + return [t, r]; +}, Te = (() => { + try { + return process.env.NODE_ENV === "development"; + } catch { + return !1; + } +})(), S = new o.DataTexture( + new Uint8Array([0, 0, 0, 0]), + 1, + 1, + o.RGBAFormat +), Ee = "use-shader-fx", Oe = [ + "isColor", + "isMatrix3", + "isMatrix4", + "isVector2", + "isVector3", + "isVector4", + "isTexture", + "isQuaternion", + "isWebGLRenderTarget", + "isEuler", + "isBufferGeometry", + "isMaterial", + "isCamera", + "isLight", + "isObject3D", + "isBone", + "isVideoTexture" +], j = (e) => { + Te && console.warn(`${Ee}: ${e}`); +}, re = { + /*=============================================== + mixSrc + ===============================================*/ + mixSrc: { value: !1 }, + mixSrc_src: { value: new o.Texture() }, + mixSrc_fit: { value: 0 }, + mixSrc_fitScale: { value: new o.Vector2(1, 1) }, + // uv + mixSrc_uv: { value: !1 }, + mixSrc_uv_ch: { value: 0 }, + mixSrc_uv_factor: { value: 0 }, + mixSrc_uv_offset: { value: new o.Vector2(0, 0) }, + mixSrc_uv_radius: { value: 0.5 }, + mixSrc_uv_position: { value: new o.Vector2(0.5, 0.5) }, + mixSrc_uv_range: { value: new o.Vector2(0, 1) }, + mixSrc_uv_mixMap: { value: !1 }, + mixSrc_uv_mixMap_src: { value: S }, + mixSrc_uv_mixMap_ch: { value: 0 }, + // color + mixSrc_color: { value: !1 }, + mixSrc_color_factor: { value: 0 }, + mixSrc_color_radius: { value: 0.5 }, + mixSrc_color_position: { value: new o.Vector2(0.5, 0.5) }, + mixSrc_color_range: { value: new o.Vector2(0, 1) }, + mixSrc_color_mixMap: { value: !1 }, + mixSrc_color_mixMap_src: { value: S }, + mixSrc_color_mixMap_ch: { value: 0 }, + // alpha + mixSrc_alpha: { value: !1 }, + mixSrc_alpha_factor: { value: 0 }, + mixSrc_alpha_radius: { value: 0.5 }, + mixSrc_alpha_position: { value: new o.Vector2(0.5, 0.5) }, + mixSrc_alpha_range: { value: new o.Vector2(0, 1) }, + mixSrc_alpha_mixMap: { value: !1 }, + mixSrc_alpha_mixMap_src: { value: S }, + mixSrc_alpha_mixMap_ch: { value: 0 }, + /*=============================================== + mixDst + ===============================================*/ + mixDst: { value: !1 }, + mixDst_src: { value: new o.Texture() }, + mixDst_fit: { value: 0 }, + mixDst_fitScale: { value: new o.Vector2(1, 1) }, + // uv + mixDst_uv: { value: !1 }, + mixDst_uv_ch: { value: 0 }, + mixDst_uv_factor: { value: 0 }, + mixDst_uv_offset: { value: new o.Vector2(0, 0) }, + mixDst_uv_radius: { value: 0.5 }, + mixDst_uv_position: { value: new o.Vector2(0.5, 0.5) }, + mixDst_uv_range: { value: new o.Vector2(0, 1) }, + mixDst_uv_mixMap: { value: !1 }, + mixDst_uv_mixMap_src: { value: S }, + mixDst_uv_mixMap_ch: { value: 0 }, + // color + mixDst_color: { value: !1 }, + mixDst_color_factor: { value: 0 }, + mixDst_color_radius: { value: 0.5 }, + mixDst_color_position: { value: new o.Vector2(0.5, 0.5) }, + mixDst_color_range: { value: new o.Vector2(0, 1) }, + mixDst_color_mixMap: { value: !1 }, + mixDst_color_mixMap_src: { value: S }, + mixDst_color_mixMap_ch: { value: 0 }, + // alpha + mixDst_alpha: { value: !1 }, + mixDst_alpha_factor: { value: 0 }, + mixDst_alpha_radius: { value: 0.5 }, + mixDst_alpha_position: { value: new o.Vector2(0.5, 0.5) }, + mixDst_alpha_range: { value: new o.Vector2(0, 1) }, + mixDst_alpha_mixMap: { value: !1 }, + mixDst_alpha_mixMap_src: { value: S }, + mixDst_alpha_mixMap_ch: { value: 0 }, + /*=============================================== + adjustments + ===============================================*/ + // levels + levels: { value: !1 }, + levels_shadows: { value: new o.Vector4(0, 0, 0, 0) }, + levels_midtones: { value: new o.Vector4(1, 1, 1, 1) }, + levels_highlights: { value: new o.Vector4(1, 1, 1, 1) }, + levels_outputMin: { value: new o.Vector4(0, 0, 0, 0) }, + levels_outputMax: { value: new o.Vector4(1, 1, 1, 1) }, + // contrast + contrast: { value: !1 }, + contrast_factor: { value: new o.Vector4(1, 1, 1, 1) }, + // colorBalance + colorBalance: { value: !1 }, + colorBalance_factor: { value: new o.Vector3(1, 1, 1) }, + // hsv + hsv: { value: !1 }, + hsv_hueShift: { value: 0 }, + hsv_saturation: { value: 1 }, + hsv_brightness: { value: 1 }, + // posterize + posterize: { value: !1 }, + posterize_levels: { value: new o.Vector4(0, 0, 0, 0) }, + // grayscale + grayscale: { value: !1 }, + grayscale_weight: { value: new o.Vector3(0, 0, 0) }, + grayscale_duotone: { value: !1 }, + grayscale_duotone_color0: { value: new o.Color(0) }, + grayscale_duotone_color1: { value: new o.Color(16777215) }, + grayscale_threshold: { value: -1 } +}; +function Pe(e) { + const { + mixSrc: t, + mixDst: r, + srcSystem: a, + levels: n, + contrast: i, + colorBalance: s, + hsv: c, + posterize: l, + grayscale: u + } = e; + return { + USF_USE_SRC_SYSTEM: a, + USF_USE_MIXSRC: t, + USF_USE_MIXDST: r, + USF_USE_LEVELS: n, + USF_USE_CONTRAST: i, + USF_USE_COLORBALANCE: s, + USF_USE_HSV: c, + USF_USE_POSTERIZE: l, + USF_USE_GRAYSCALE: u + }; +} +function ue(e) { + const t = !!e.mixSrc.value, r = !!e.mixDst.value; + return { + mixSrc: t, + mixDst: r, + srcSystem: t || r, + levels: !!e.levels.value, + contrast: !!e.contrast.value, + colorBalance: !!e.colorBalance.value, + hsv: !!e.hsv.value, + posterize: !!e.posterize.value, + grayscale: !!e.grayscale.value + }; +} +var Ve = "#usf ", Ie = "#usf ", Be = "#usf ", Re = "#usf ", Le = `#usf +#usf `, Ae = `#usf +#usf +#usf `, ke = `#usf +#usf +#usf +#usf `, $e = "#usf ", je = `#usf +#usf +#usf `, ze = "#usf ", Ke = "#usf ", Ne = "#usf "; +const d = Object.freeze({ + plane_vertex: Ve, + default_vertex: Ie, + default_pars_vertex: Be, + default_pars_fragment: Re, + basicFx_vertex: Le, + basicFx_pars_vertex: Ae, + basicFx_pars_fragment: ke, + basicFx_fragment_begin: $e, + basicFx_fragment_end: je, + samplingFx_vertex: ze, + samplingFx_pars_vertex: Ke, + samplingFx_pars_fragment: Ne +}), Xe = ` + void main() { + ${d.plane_vertex} + } +`, qe = ` + precision highp int; + + uniform float tick; + uniform float timeStrength; + uniform int noiseOctaves; + uniform int fbmOctaves; + uniform int warpOctaves; + uniform vec2 warpDirection; + uniform float warpStrength; + uniform float scale; + uniform float timeOffset; + + const float per = 0.5; + const float PI = 3.14159265359; + + float rnd(vec2 n) { + float a = 0.129898; + float b = 0.78233; + float c = 437.585453; + float dt= dot(n ,vec2(a, b)); + float sn= mod(dt, PI); + return fract(sin(sn) * c); + } + + float interpolate(float a, float b, float x){ + float f = (1.0 - cos(x * PI)) * 0.5; + return a * (1.0 - f) + b * f; + } + + float irnd(vec2 p){ + vec2 i = floor(p); + vec2 f = fract(p); + vec4 v = vec4(rnd(vec2(i.x,i.y)),rnd(vec2(i.x + 1.0,i.y)),rnd(vec2(i.x,i.y + 1.0)),rnd(vec2(i.x + 1.0, i.y + 1.0))); + return interpolate(interpolate(v.x, v.y, f.x), interpolate(v.z, v.w, f.x), f.y); + } + + // Based on The Book of Shaders + // https://thebookofshaders.com/13/ + float noise(vec2 p, float time){ + float _time = time + timeOffset; + float t = 0.0; + for(int i = 0; i < noiseOctaves; i++){ + float freq = pow(2.0, float(i)); + float amp = pow(per, float(noiseOctaves - i)); + t += irnd(vec2(p.y / freq + _time, p.x / freq + _time)) * amp; + } + return t; + } + + float fbm(vec2 x, float time) { + float v = 0.0; + float a = 0.5; + vec2 shift = vec2(100); + mat2 rot = mat2(cos(0.5), sin(0.5), -sin(0.5), cos(0.5)); + float sign = 1.0; + for (int i = 0; i < fbmOctaves; ++i) { + v += a * noise(x, time * sign); + x = rot * x * 2.0 + shift; + a *= 0.5; + sign *= -1.0; + } + return v; + } + + float warp(vec2 x, float g,float time){ + float val = 0.0; + for (int i = 0; i < warpOctaves; i++){ + val = fbm(x + g * vec2(cos(warpDirection.x * val), sin(warpDirection.y * val)), time); + } + return val; + } + + void main() { + + vec2 usf_Uv = gl_FragCoord.xy * scale; + + ${d.basicFx_fragment_begin} + + float noise = warp(usf_Uv ,warpStrength,tick * timeStrength); + + vec4 usf_FragColor = vec4(noise); + + ${d.basicFx_fragment_end} + + gl_FragColor = usf_FragColor; + + } +`; +var Ge = "gl_Position = vec4(position, 1.0);", He = `#ifdef USF_USE_SRC_SYSTEM + + #usf + +#endif`, Qe = `#ifdef USF_USE_SRC_SYSTEM + + #usf + + float calcMixCirclePower(vec2 center, float radius, vec2 range) + { + vec2 adjustedUV = (vUv - 0.5) * vec2(aspectRatio, 1.0) + 0.5; + vec2 adjustedCenter = (center - 0.5) * vec2(aspectRatio, 1.0) + 0.5; + + float dist = length(adjustedUV - adjustedCenter); + float power = radius > 0.0 ? 1.0 - dist / radius : 1.0; + return smoothstep(range.x,range.y,power); + } + + float calcMixMapPower(sampler2D map,vec2 range, int ch) + { + return smoothstep(range.x,range.y, texture2D(map, vUv)[ch]); + } + + vec4 fitTexture(sampler2D src , vec2 uv, int fitType) + { + + float a = fitType == 2 ? step(0.0, uv.x) * step(uv.x, 1.0) * step(0.0, uv.y) * step(uv.y, 1.0) : 1.; + return mix(vec4(0.), texture2D(src, uv), a); + } + +#endif`, Ye = "vUv = uv;", We = `precision highp float; + +varying vec2 vUv; +uniform vec2 resolution; +uniform vec2 texelSize; +uniform float aspectRatio; +uniform vec2 maxAspect;`, Ze = `precision highp float; + +varying vec2 vUv; +uniform vec2 resolution; +uniform vec2 texelSize; +uniform float aspectRatio; +uniform vec2 maxAspect; +uniform int renderCount;`, Je = `#ifdef USF_USE_MIXSRC + varying vec2 vMixSrcCoverUv; + uniform vec2 mixSrc_fitScale; +#endif`, et = `#ifdef USF_USE_MIXSRC + vMixSrcCoverUv = calcSrcUv(vUv, mixSrc_fitScale); +#endif`, tt = `#ifdef USF_USE_MIXSRC + varying vec2 vMixSrcCoverUv; + uniform sampler2D mixSrc_src; + uniform int mixSrc_fit; + + uniform bool mixSrc_uv; + uniform int mixSrc_uv_ch; + uniform float mixSrc_uv_factor; + uniform vec2 mixSrc_uv_offset; + uniform float mixSrc_uv_radius; + uniform vec2 mixSrc_uv_position; + uniform vec2 mixSrc_uv_range; + uniform bool mixSrc_uv_mixMap; + uniform sampler2D mixSrc_uv_mixMap_src; + uniform int mixSrc_uv_mixMap_ch; + + uniform bool mixSrc_color; + uniform float mixSrc_color_factor; + uniform float mixSrc_color_radius; + uniform vec2 mixSrc_color_position; + uniform vec2 mixSrc_color_range; + uniform bool mixSrc_color_mixMap; + uniform sampler2D mixSrc_color_mixMap_src; + uniform int mixSrc_color_mixMap_ch; + + uniform bool mixSrc_alpha; + uniform float mixSrc_alpha_factor; + uniform float mixSrc_alpha_radius; + uniform vec2 mixSrc_alpha_position; + uniform vec2 mixSrc_alpha_range; + uniform bool mixSrc_alpha_mixMap; + uniform sampler2D mixSrc_alpha_mixMap_src; + uniform int mixSrc_alpha_mixMap_ch; + +#endif`, rt = `#ifdef USF_USE_MIXSRC + + vec4 mixSrcColor = fitTexture(mixSrc_src, vMixSrcCoverUv, mixSrc_fit); + + usf_Uv += mixSrc_uv + ? (mixSrc_uv_offset + (vec2(mixSrcColor[mixSrc_uv_ch]) * 2. - 1.)) * + (mixSrc_uv_mixMap + ? calcMixMapPower(mixSrc_uv_mixMap_src,mixSrc_uv_range,mixSrc_uv_mixMap_ch) + : calcMixCirclePower(mixSrc_uv_position,mixSrc_uv_radius,mixSrc_uv_range)) * mixSrc_uv_factor + : vec2(0.); + +#endif`, at = `#ifdef USF_USE_MIXSRC + + usf_FragColor = mixSrc_color + ? mix(usf_FragColor, mixSrcColor, + (mixSrc_color_mixMap + ? calcMixMapPower(mixSrc_color_mixMap_src,mixSrc_color_range,mixSrc_color_mixMap_ch) + : calcMixCirclePower(mixSrc_color_position,mixSrc_color_radius,mixSrc_color_range)) * mixSrc_color_factor) + : usf_FragColor; + + + usf_FragColor = mixSrc_alpha + ? mix(usf_FragColor, mixSrcColor, + (mixSrc_alpha_mixMap + ? calcMixMapPower(mixSrc_alpha_mixMap_src,mixSrc_alpha_range,mixSrc_alpha_mixMap_ch) + : calcMixCirclePower(mixSrc_alpha_position,mixSrc_alpha_radius,mixSrc_alpha_range)) * mixSrc_alpha_factor * mixSrcColor.a) + : usf_FragColor; + +#endif`, nt = `#ifdef USF_USE_MIXDST + varying vec2 vMixDstCoverUv; + uniform vec2 mixDst_fitScale; +#endif`, st = `#ifdef USF_USE_MIXDST + vMixDstCoverUv = calcSrcUv(vUv, mixDst_fitScale); +#endif`, it = `#ifdef USF_USE_MIXDST + + varying vec2 vMixDstCoverUv; + uniform sampler2D mixDst_src; + uniform int mixDst_fit; + + uniform bool mixDst_uv; + uniform int mixDst_uv_ch; + uniform float mixDst_uv_factor; + uniform vec2 mixDst_uv_offset; + uniform float mixDst_uv_radius; + uniform vec2 mixDst_uv_position; + uniform vec2 mixDst_uv_range; + uniform bool mixDst_uv_mixMap; + uniform sampler2D mixDst_uv_mixMap_src; + uniform int mixDst_uv_mixMap_ch; + + uniform bool mixDst_color; + uniform float mixDst_color_factor; + uniform float mixDst_color_radius; + uniform vec2 mixDst_color_position; + uniform vec2 mixDst_color_range; + uniform bool mixDst_color_mixMap; + uniform sampler2D mixDst_color_mixMap_src; + uniform int mixDst_color_mixMap_ch; + + uniform bool mixDst_alpha; + uniform float mixDst_alpha_factor; + uniform float mixDst_alpha_radius; + uniform vec2 mixDst_alpha_position; + uniform vec2 mixDst_alpha_range; + uniform bool mixDst_alpha_mixMap; + uniform sampler2D mixDst_alpha_mixMap_src; + uniform int mixDst_alpha_mixMap_ch; + +#endif`, ot = `#ifdef USF_USE_MIXDST + + + vec2 mixedUv = vMixDstCoverUv; + mixedUv += mixDst_uv + ? (mixDst_uv_offset + (vec2(usf_FragColor[mixDst_uv_ch]) * 2. - 1.)) * + (mixDst_uv_mixMap + ? calcMixMapPower(mixDst_uv_mixMap_src,mixDst_uv_range,mixDst_uv_mixMap_ch) + : calcMixCirclePower(mixDst_uv_position,mixDst_uv_radius,mixDst_uv_range)) * mixDst_uv_factor + : vec2(0.); + vec4 mixDstColor = fitTexture(mixDst_src, mixedUv , mixDst_fit); + + + usf_FragColor = mixDst_color + ? mix(usf_FragColor, mixDstColor, + (mixDst_color_mixMap + ? calcMixMapPower(mixDst_color_mixMap_src,mixDst_color_range,mixDst_color_mixMap_ch) + : calcMixCirclePower(mixDst_color_position,mixDst_color_radius,mixDst_color_range)) * mixDst_color_factor) + : usf_FragColor; + + + usf_FragColor = mixDst_alpha + ? mix(usf_FragColor, mixDstColor, + (mixDst_alpha_mixMap + ? calcMixMapPower(mixDst_alpha_mixMap_src,mixDst_alpha_range,mixDst_alpha_mixMap_ch) + : calcMixCirclePower(mixDst_alpha_position,mixDst_alpha_radius,mixDst_alpha_range)) * mixDst_alpha_factor * mixDstColor.a) + : usf_FragColor; + +#endif`, ct = `#ifdef USF_USE_TEXTURE + vTextureCoverUv = calcSrcUv(vUv, texture_fitScale); +#endif`, lt = `#ifdef USF_USE_TEXTURE + varying vec2 vTextureCoverUv; + uniform vec2 texture_fitScale; +#endif`, ut = `#ifdef USF_USE_TEXTURE + varying vec2 vTextureCoverUv; + uniform sampler2D texture_src; + uniform int texture_fit; + uniform vec2 texture_fitScale; +#endif`, ft = `#ifdef USF_USE_LEVELS + usf_FragColor = (usf_FragColor - vec4(levels_shadows)) / (vec4(levels_highlights) - vec4(levels_shadows)); + usf_FragColor = pow(usf_FragColor, vec4(1.0 / levels_midtones)); + usf_FragColor = usf_FragColor * (vec4(levels_outputMax) - vec4(levels_outputMin)) + vec4(levels_outputMin); +#endif + +#ifdef USF_USE_CONTRAST + usf_FragColor = clamp(((usf_FragColor-.5)*contrast_factor)+.5, 0., 1.); +#endif + +#ifdef USF_USE_COLORBALANCE + usf_FragColor.rgb = clamp(usf_FragColor.rgb * colorBalance_factor, 0., 1.); +#endif + +#ifdef USF_USE_HSV + vec3 hsv = rgb2hsv(usf_FragColor.rgb); + hsv.x = fract(hsv.x + hsv_hueShift); + hsv.y = clamp(hsv.y * hsv_saturation, 0.0, 1.0); + hsv.z = clamp(hsv.z * hsv_brightness, 0.0, 1.0); + usf_FragColor.rgb = hsv2rgb(hsv); +#endif + +#ifdef USF_USE_POSTERIZE + usf_FragColor = posterize(usf_FragColor, posterize_levels); +#endif + +#ifdef USF_USE_GRAYSCALE + float grayscale = dot(usf_FragColor.rgb, vec3(0.299 + grayscale_weight.r, 0.587 + grayscale_weight.g, 0.114 + grayscale_weight.b)); + grayscale = grayscale_threshold > 0.0 ? step(grayscale_threshold, grayscale) : grayscale; + vec3 duotoneColor = mix(grayscale_duotone_color0, grayscale_duotone_color1, grayscale); + usf_FragColor.rgb = grayscale_duotone ? duotoneColor : vec3(grayscale); +#endif`, _t = `#ifdef USF_USE_LEVELS + uniform vec4 levels_shadows; + uniform vec4 levels_midtones; + uniform vec4 levels_highlights; + uniform vec4 levels_outputMin; + uniform vec4 levels_outputMax; +#endif + +#ifdef USF_USE_CONTRAST + uniform vec4 contrast_factor; +#endif + +#ifdef USF_USE_COLORBALANCE + uniform vec3 colorBalance_factor; +#endif + +#ifdef USF_USE_HSV + uniform float hsv_hueShift; + uniform float hsv_saturation; + uniform float hsv_brightness; + vec3 hsv2rgb(vec3 c) + { + vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0); + vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www); + return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y); + } + vec3 rgb2hsv(vec3 c) + { + vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0); + vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g)); + vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r)); + + float d = q.x - min(q.w, q.y); + float e = 1.0e-10; + return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x); + } +#endif + +#ifdef USF_USE_POSTERIZE + uniform vec4 posterize_levels; + vec4 posterize(vec4 color, vec4 levels) + { + return vec4( + levels.x > 1. ? floor(color.r * levels.x) / levels.x : color.r, + levels.y > 1. ? floor(color.g * levels.y) / levels.y : color.g, + levels.z > 1. ? floor(color.b * levels.z) / levels.z : color.b, + levels.w > 1. ? floor(color.a * levels.w) / levels.w : color.a + ); + } +#endif + +#ifdef USF_USE_GRAYSCALE + uniform vec3 grayscale_weight; + uniform bool grayscale_duotone; + uniform vec3 grayscale_duotone_color0; + uniform vec3 grayscale_duotone_color1; + uniform float grayscale_threshold; +#endif`, vt = `vec2 calcSrcUv(vec2 uv, vec2 fitScale) { + return uv * fitScale + (1.0 - fitScale) * .5; +}`; +const mt = Object.freeze({ + plane_vertex: Ge, + srcSystem_pars_vertex: He, + srcSystem_pars_fragment: Qe, + default_vertex: Ye, + default_pars_vertex: We, + default_pars_fragment: Ze, + mixSrc_vertex: et, + mixSrc_pars_vertex: Je, + mixSrc_pars_fragment: tt, + mixSrc_fragment_begin: rt, + mixSrc_fragment_end: at, + mixDst_pars_vertex: nt, + mixDst_vertex: st, + mixDst_pars_fragment: it, + mixDst_fragment: ot, + texture_vertex: ct, + texture_pars_vertex: lt, + texture_pars_fragment: ut, + adjustments_fragment: ft, + adjustments_pars_fragment: _t, + calcSrcUv: vt +}); +function V(e) { + return e.filter((t) => t !== "").join(` +`); +} +function ne(e, t, r) { + let a, n; + const i = { + default: { + vertexPars: d.default_pars_vertex, + vertexMain: d.default_vertex, + fragmentPars: d.default_pars_fragment + }, + basicFx: { + vertexPars: d.basicFx_pars_vertex, + vertexMain: d.basicFx_vertex, + fragmentPars: d.basicFx_pars_fragment + }, + samplingFx: { + vertexPars: V([ + d.basicFx_pars_vertex, + d.samplingFx_pars_vertex + ]), + vertexMain: V([ + d.basicFx_vertex, + d.samplingFx_vertex + ]), + fragmentPars: V([ + d.basicFx_pars_fragment, + d.samplingFx_pars_fragment + ]) + } + }, s = i[r].vertexPars, c = i[r].vertexMain, l = i[r].fragmentPars; + return e && (a = V([s, e]), a = a.replace( + /void\s+main\s*\(\)\s*\{/, + `void main() { +${c}` + )), t && (n = V([l, t])), [a, n]; +} +const pt = /^[ \t]*#usf +<([\w\d./]+)>/gm; +function xt(e, t) { + return ae(mt[t] || ""); +} +function ae(e) { + return e.replace(pt, xt); +} +function dt(e) { + return e && Oe.some((t) => e[t] === !0); +} +function ht(e) { + const t = {}, r = (a, n = "") => { + for (const [i, s] of Object.entries(a)) { + const c = n ? `${n}_${i}` : i; + s && typeof s == "object" && !Array.isArray(s) && !dt(s) ? (t[c] = !0, r(s, c)) : (t.hasOwnProperty(c) && j(`${c} already exists and will be overwritten.`), t[c] = s); + } + }; + return r(e), t; +} +class w extends o.ShaderMaterial { + constructor({ + uniformValues: t, + materialParameters: r = {}, + uniforms: a, + vertexShader: n, + fragmentShader: i + } = {}) { + super(r), this.uniforms = { + resolution: { value: new o.Vector2() }, + texelSize: { value: new o.Vector2() }, + aspectRatio: { value: 0 }, + maxAspect: { value: new o.Vector2() }, + // 一部のFXでiterationをカウントする必要があるため + renderCount: { value: 0 }, + ...a + }, this._setupShaders(n, i), this.setUniformValues(t), this._defineUniformAccessors(); + } + /** This is updated in useFxScene */ + updateResolution(t, r) { + const a = Math.max(t, r); + this.uniforms.resolution.value.set(t, r), this.uniforms.texelSize.value.set(1 / t, 1 / r), this.uniforms.aspectRatio.value = t / r, this.uniforms.maxAspect.value.set(a / t, a / r); + } + _setupShaders(t, r) { + if (!t && !r) + return; + const [a, n] = ne( + t, + r, + "default" + ); + this.vertexShader = a ? ae(a) : this.vertexShader, this.fragmentShader = n ? ae(n) : this.fragmentShader; + } + setUniformValues(t) { + if (t === void 0) + return; + const r = ht(t); + for (const [a, n] of Object.entries(r)) { + if (n === void 0) { + j(`parameter '${a}' has value of undefined.`); + continue; + } + const i = this.uniforms[a]; + if (i === void 0) { + j(`'${a}' is not a uniform property of ${this.type}.`); + continue; + } + i.value = typeof n == "function" ? n(i.value) : n; + } + return r; + } + /** define getter/setters　*/ + _defineUniformAccessors(t) { + for (const r of Object.keys(this.uniforms)) { + if (this.hasOwnProperty(r)) { + j(`'${r}' is already defined in ${this.type}.`); + continue; + } + Object.defineProperty(this, r, { + get: () => this.uniforms[r].value, + set: (a) => { + this.uniforms[r].value = a, t == null || t(); + } + }); + } + } +} +w.key = o.MathUtils.generateUUID(); +class se extends w { + constructor({ + uniforms: t, + vertexShader: r, + fragmentShader: a, + ...n + } = {}) { + var i; + super({ + ...n, + uniforms: { + ...o.UniformsUtils.clone(re), + ...t + } + }), this.defines = { + ...(i = n == null ? void 0 : n.materialParameters) == null ? void 0 : i.defines + }, this.programCache = 0, this.fxKey = this._setupFxKey(this.uniforms), this._setupFxShaders(r, a); + } + _setupFxShaders(t, r) { + if (!t && !r) + return; + this._updateFxDefines(); + const [a, n] = this._handleMergeShaderLib( + t, + r + ); + super._setupShaders(a, n); + } + /** SamplingFxMaterialで継承するため、handlerとして独立させる */ + _handleMergeShaderLib(t, r) { + return ne(t, r, "basicFx"); + } + _updateFxShaders() { + if (!this.fxKey) + return; + const t = this.programCache, { diffCount: r, newFxKey: a } = this._handleUpdateFxShaders(); + this.programCache += r, this.fxKey = a, t !== this.programCache && (this._updateFxDefines(), this.needsUpdate = !0); + } + /** SamplingFxMaterialで継承するため、handlerとして独立させる */ + _handleUpdateFxShaders() { + const t = ue(this.uniforms); + return { + diffCount: Object.keys(t).filter((a) => this.fxKey[a] !== t[a]).length, + newFxKey: t + }; + } + _updateFxDefines() { + Object.assign(this.defines, this._handleUpdateFxDefines()); + } + /** SamplingFxMaterialで継承するため、handlerとして独立させる */ + _handleUpdateFxDefines() { + return Pe(this.fxKey); + } + _isContainsBasicFxValues(t, r) { + return t ? Object.keys(t).some( + (a) => Object.keys(r ?? re).includes(a) + ) : !1; + } + _setupFxKey(t) { + return ue(t); + } + /*=============================================== + Fit Scale + ===============================================*/ + _calcFitScale(t, r) { + var c; + let a = 1; + const n = new o.Vector2(1, 1), i = this.uniforms.aspectRatio.value, s = (c = t == null ? void 0 : t.source) == null ? void 0 : c.data; + return s != null && s.width && (s != null && s.height) ? a = s.width / s.height : a = i, r === 1 ? n.set( + Math.min(i / a, 1), + Math.min(a / i, 1) + ) : r === 2 && n.set( + Math.max(i / a, 1), + Math.max(a / i, 1) + ), n; + } + _setFitScale(t) { + const r = this.uniforms; + r[`${t}_fitScale`].value = this._calcFitScale( + r[`${t}_src`].value, + r[`${t}_fit`].value + ); + } + _updateFitScale() { + var t, r; + (t = this.fxKey) != null && t.mixSrc && this._setFitScale("mixSrc"), (r = this.fxKey) != null && r.mixDst && this._setFitScale("mixDst"); + } + /*=============================================== + super FxMaterial + ===============================================*/ + /** + * @param needsUpdate default : `true` + */ + setUniformValues(t, r = !0) { + const a = super.setUniformValues(t); + return r && this._isContainsBasicFxValues(a) && (this._updateFxShaders(), this._updateFitScale()), a; + } + _defineUniformAccessors(t) { + super._defineUniformAccessors(() => { + this._updateFxShaders(), this._updateFitScale(), t == null || t(); + }); + } + updateResolution(t, r) { + super.updateResolution(t, r), this._updateFitScale(); + } +} +const ge = class Se extends se { + constructor(t = {}) { + super({ + ...t, + vertexShader: Xe, + fragmentShader: qe, + uniforms: { + tick: { value: 0 }, + scale: { value: 0.03 }, + timeStrength: { value: 0.3 }, + noiseOctaves: { value: 2 }, + fbmOctaves: { value: 2 }, + warpOctaves: { value: 2 }, + warpDirection: { value: new o.Vector2(2, 2) }, + warpStrength: { value: 8 }, + timeOffset: { value: 0 } + } + }), this.type = Se.type; + } + static get type() { + return "NoiseMaterial"; + } +}; +ge.key = o.MathUtils.generateUUID(); +let gt = ge; +const fe = ` + uniform bool bounce; + varying vec2 vL; + varying vec2 vR; + varying vec2 vT; + varying vec2 vB; +`, ee = (e = !0) => ` + vec3 pos = position; + vec2 scale = ${e ? "bounce ? vec2(1.,1.) : 1.-texelSize*2." : "1.-texelSize*2."}; + pos.xy = pos.xy * scale; + vUv = vec2(.5)+(pos.xy)*.5; + `, _e = (e) => ` + vL = vUv - vec2(texelSize.x * ${e}, 0.0); + vR = vUv + vec2(texelSize.x * ${e}, 0.0); + vT = vUv + vec2(0.0, texelSize.y * ${e}); + vB = vUv - vec2(0.0, texelSize.y * ${e}); + `, St = { + main: ` + ${fe} + + void main(){ + + ${ee()} + ${_e("1.")} + + gl_Position = vec4(pos, 1.0); + } + `, + poisson: ` + ${fe} + + void main(){ + + ${ee()} + ${_e("2.")} + + gl_Position = vec4(pos, 1.0); + } + `, + advection: ` + void main(){ + ${ee(!1)} + gl_Position = vec4(pos, 1.0); + } + `, + splat: ` + uniform vec2 center; + uniform vec2 radius; + void main(){ + vec2 pos = position.xy * radius * 2.0 * texelSize + center; + gl_Position = vec4(pos, 0.0, 1.0); + } + ` +}, A = St; +var yt = `uniform float deltaTime; +uniform sampler2D velocity; +uniform float dissipation; + +void main(){ + vec2 vel = texture2D(velocity, vUv).xy; + vec2 uv2 = vUv - vel * deltaTime * maxAspect; + vec2 newVel = texture2D(velocity, uv2).xy; + gl_FragColor = vec4(dissipation * newVel, 0.0, 0.0); +}`; +class X extends w { + constructor(t) { + super({ + ...t, + vertexShader: A.advection, + fragmentShader: yt, + uniforms: { + dissipation: { value: 0.99 }, + velocity: { value: S }, + deltaTime: { value: W } + } + }), this.type = X.type; + } + static get type() { + return "AdvectionMaterial"; + } +} +var Ft = `uniform float deltaTime; +uniform sampler2D velocity; + +varying vec2 vL; +varying vec2 vR; +varying vec2 vT; +varying vec2 vB; + +void main(){ + float L = texture2D(velocity, vL).r; + float R = texture2D(velocity, vR).r; + float B = texture2D(velocity, vB).g; + float T = texture2D(velocity, vT).g; + + float divergence = (R-L + T-B) / 2.0; + gl_FragColor = vec4(divergence / deltaTime); +}`; +class q extends w { + constructor(t) { + super({ + ...t, + vertexShader: A.main, + fragmentShader: Ft, + uniforms: { + bounce: { value: !0 }, + velocity: { value: S }, + deltaTime: { value: W } + } + }), this.type = q.type; + } + static get type() { + return "DivergenceMaterial"; + } +} +var Mt = `uniform float deltaTime; +uniform sampler2D pressure; +uniform sampler2D velocity; + +varying vec2 vL; +varying vec2 vR; +varying vec2 vT; +varying vec2 vB; + +void main(){ + + float L = texture2D(pressure, vL).r; + float R = texture2D(pressure, vR).r; + float B = texture2D(pressure, vB).r; + float T = texture2D(pressure, vT).r; + + vec2 v = texture2D(velocity, vUv).xy; + vec2 gradP = vec2(R - L, T - B) * 0.5; + v = v - gradP * deltaTime; + + gl_FragColor = vec4(v, 0.0, 1.0); + +}`; +class G extends w { + constructor(t) { + super({ + ...t, + vertexShader: A.main, + fragmentShader: Mt, + uniforms: { + bounce: { value: !0 }, + deltaTime: { value: W }, + pressure: { value: S }, + velocity: { value: S } + } + }), this.type = G.type; + } + static get type() { + return "PressureMaterial"; + } +} +var Ut = `uniform sampler2D pressure; +uniform sampler2D divergence; + +varying vec2 vL; +varying vec2 vR; +varying vec2 vT; +varying vec2 vB; + +void main(){ + + float L = texture2D(pressure, vL).r; + float R = texture2D(pressure, vR).r; + float B = texture2D(pressure, vB).r; + float T = texture2D(pressure, vT).r; + + float div = texture2D(divergence, vUv).r; + + float newP = (L + R + B + T) / 4.0 - div; + + gl_FragColor = vec4(newP); +}`; +class H extends w { + constructor({ customParameters: t, ...r }) { + super({ + ...r, + vertexShader: A.poisson, + fragmentShader: Ut, + uniforms: { + bounce: { value: !0 }, + pressure: { value: S }, + divergence: { value: S } + } + }), this.iterations = (t == null ? void 0 : t.iterations) ?? 32, this.type = H.type; + } + static get type() { + return "PoissonMaterial"; + } +} +var Dt = `uniform vec2 force; +uniform float forceBias; + +void main(){ + gl_FragColor = vec4(force * forceBias * pow(1.0 - clamp(2.0 * distance(vUv, vec2(0.5)), 0.0, 1.0), 2.0), 0.0, 1.0); +}`; +class Q extends w { + constructor(t) { + super({ + ...t, + vertexShader: A.splat, + fragmentShader: Dt, + uniforms: { + forceBias: { value: 20 }, + radius: { value: new o.Vector2(50, 50) }, + force: { value: new o.Vector2(0, 0) }, + center: { value: new o.Vector2(0, 0) } + } + }), this.type = Q.type, this.blending = o.AdditiveBlending; + } + static get type() { + return "SplatMaterial"; + } +} +class Y extends se { + constructor(t = {}) { + super({ + ...t, + vertexShader: ` + void main() { + ${d.plane_vertex} + } + `, + fragmentShader: ` + uniform sampler2D src; + void main() { + vec2 usf_Uv = vUv; + + ${d.basicFx_fragment_begin} + + vec4 usf_FragColor = vec4(length(texture2D(src,usf_Uv).rg)); + + ${d.basicFx_fragment_end} + + gl_FragColor = usf_FragColor; + } + `, + uniforms: { + src: { value: S } + } + }), this.type = Y.type; + } + static get type() { + return "OutputMaterial"; + } +} +const W = 8e-3, kt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ + __proto__: null, + AdvectionMaterial: X, + DELTA_TIME: W, + DivergenceMaterial: q, + OutputMaterial: Y, + PoissonMaterial: H, + PressureMaterial: G, + SplatMaterial: Q +}, Symbol.toStringTag, { value: "Module" })), ve = { + texture: { value: !0 }, + texture_src: { value: S }, + texture_fit: { value: 0 }, + texture_fitScale: { value: new o.Vector2(1, 1) } +}; +class ye extends se { + constructor({ uniforms: t, ...r }) { + super({ + ...r, + uniforms: { + ...o.UniformsUtils.clone(ve), + ...t + } + }); + } + _handleMergeShaderLib(t, r) { + return ne(t, r, "samplingFx"); + } + _isContainsBasicFxValues(t) { + return super._isContainsBasicFxValues(t, { + ...re, + ...ve + }); + } + _updateFitScale() { + super._updateFitScale(), this._setFitScale("texture"); + } + _setupFxKey(t) { + const r = super._setupFxKey(t); + return r.srcSystem = !0, r; + } + _handleUpdateFxShaders() { + const { diffCount: t, newFxKey: r } = super._handleUpdateFxShaders(); + return r.srcSystem = !0, { + diffCount: t, + newFxKey: r + }; + } + _handleUpdateFxDefines() { + return Object.assign(super._handleUpdateFxDefines(), { + USF_USE_TEXTURE: !0 + }); + } +} +const Fe = class Me extends ye { + constructor(t = {}) { + super({ + ...t, + vertexShader: ` + void main() { + ${d.plane_vertex} + } + `, + fragmentShader: ` + void main() { + vec2 usf_Uv = vTextureCoverUv; + + ${d.basicFx_fragment_begin} + + vec4 usf_FragColor = fitTexture(texture_src,usf_Uv,texture_fit); + + ${d.basicFx_fragment_end} + + gl_FragColor = usf_FragColor; + } + ` + }), this.type = Me.type; + } + static get type() { + return "BufferMaterial"; + } +}; +Fe.key = o.MathUtils.generateUUID(); +let bt = Fe; +class ie extends w { + static get type() { + return "RawBlankMaterial"; + } + constructor(t) { + super(t), this.type = ie.type; + } +} +const me = ` + uniform float time; + uniform vec2 pointer; + uniform sampler2D backbuffer; +`; +class oe extends w { + constructor({ + vertexShader: t, + fragmentShader: r, + uniforms: a, + ...n + }) { + super({ + ...n, + vertexShader: t && V([me, t]), + fragmentShader: r && V([me, r]), + uniforms: { + time: { value: 0 }, + pointer: { value: new o.Vector2() }, + backbuffer: { value: new o.Texture() }, + ...a + } + }), this.type = oe.type; + } + static get type() { + return "BlankMaterial"; + } +} +const wt = ` + void main() { + ${d.plane_vertex} + } +`, Ct = ` + uniform vec2 count; + uniform bool autoScale; + uniform float tick; + uniform bool shuffle; + uniform float shuffle_frequency; + uniform float shuffle_range; + + uniform bool sprite; + uniform sampler2D sprite_src; + uniform float sprite_length; + uniform float sprite_shuffleSpeed; + + float hash(vec2 p) { + return fract(sin(dot(p, vec2(12.9898, 78.233))) * 43758.5453); + } + + vec2 shuffleIndex(vec2 cellIndex , vec2 count) { + + float discreteTime = floor(tick * shuffle_frequency); + + float r1 = hash(cellIndex + vec2(0.123, discreteTime)); + float r2 = hash(cellIndex + vec2(0.789, discreteTime)); + + // -range ~ +range + float offsetX = floor(r1 * (shuffle_range * 2.0 + 1.0)) - shuffle_range; + float offsetY = floor(r2 * (shuffle_range * 2.0 + 1.0)) - shuffle_range; + vec2 offset = vec2(offsetX, offsetY); + + return mod(cellIndex + offset, count); + } + + void main() { + vec2 usf_Uv = vUv; + ${d.basicFx_fragment_begin} + + vec2 n_count = count; + n_count.x *= autoScale ? aspectRatio : 1.; + + vec2 cellIndex = ceil(usf_Uv * n_count); + + vec2 shuffledIndex = shuffle ? shuffleIndex(cellIndex, n_count) : cellIndex; + + vec2 cellCenter = calcSrcUv((shuffledIndex - .5) / n_count, texture_fitScale); + + vec4 gridTextureColor = fitTexture(texture_src, cellCenter, texture_fit); + + if(sprite){ + vec2 cellUv = fract(usf_Uv * n_count); + float cellHash = hash(cellIndex); + float spritePos = fract(cellHash + tick * sprite_shuffleSpeed); + float spriteIndex = floor(spritePos * sprite_length); + float spriteSize = 1.0 / sprite_length; + float spriteOffset = spriteIndex * spriteSize; + float spriteU = spriteOffset + cellUv.x * spriteSize; + vec2 spriteUv = vec2(spriteU, cellUv.y); + vec4 spriteColor = texture2D(sprite_src, spriteUv); + gridTextureColor *= spriteColor; + } + + vec4 usf_FragColor = gridTextureColor; + ${d.basicFx_fragment_end} + + gl_FragColor = usf_FragColor; + + } +`; +class ce extends ye { + constructor(t) { + super({ + ...t, + vertexShader: wt, + fragmentShader: Ct, + uniforms: { + count: { value: new o.Vector2(20, 20) }, + autoScale: { value: !0 }, + tick: { value: 0 }, + shuffle: { value: !1 }, + shuffle_frequency: { value: 5 }, + shuffle_range: { value: 2 }, + sprite: { value: !1 }, + sprite_src: { value: new o.Texture() }, + sprite_length: { value: 10 }, + sprite_shuffleSpeed: { value: 0 } + } + }), this.setNearestFilter(), this.type = ce.type; + } + static get type() { + return "GridMaterial"; + } + /** When gridding with floor, you must use NearestFilter. */ + setNearestFilter() { + this.uniforms.texture_src.value.magFilter = o.NearestFilter, this.uniforms.texture_src.value.minFilter = o.NearestFilter, this.uniforms.sprite_src.value.magFilter = o.NearestFilter, this.uniforms.sprite_src.value.minFilter = o.NearestFilter; + } +} +const $t = ({ + size: e, + dpr: t, + fboAutoSetSize: r, + renderTargetOptions: a, + materialParameters: n, + ...i +}) => { + const s = R(t), { scene: c, material: l, camera: u } = M({ + size: e, + dpr: s.shader, + material: gt, + uniformValues: i, + materialParameters: n + }), [v, _] = b({ + scene: c, + camera: u, + size: e, + dpr: s.fbo, + fboAutoSetSize: r, + ...a + }), m = h( + (p, f = !0) => { + l.setUniformValues(p, f); + }, + [l] + ); + return { + render: h( + (p, f) => { + const { gl: g, clock: C } = p; + return f && m(f, !1), l.uniforms.tick.value = typeof (f == null ? void 0 : f.tick) == "function" ? f.tick(l.uniforms.tick.value) : (f == null ? void 0 : f.tick) || C.getElapsedTime(), _({ gl: g }); + }, + [m, _, l] + ), + setValues: m, + texture: v.texture, + material: l, + scene: c, + camera: u, + renderTarget: v + }; +}, Tt = ({ + size: e, + dpr: t, + ...r +}, a) => { + const { scene: n, material: i, camera: s } = M({ + size: e, + dpr: t, + material: X, + uniformValues: r + }); + return { render: h( + (l) => { + const { gl: u } = l; + a({ gl: u, scene: n, camera: s }); + }, + [a, n, s] + ), material: i }; +}, Et = (e = 0) => { + const t = T(new o.Vector2(0, 0)), r = T(new o.Vector2(0, 0)), a = T(new o.Vector2(0, 0)), n = T(0), i = T(new o.Vector2(0, 0)), s = T(!1); + return h( + (l) => { + const u = performance.now(); + let v; + s.current && e ? (a.current = a.current.lerp( + l, + 1 - e + ), v = a.current.clone()) : (v = l.clone(), a.current = v), n.current === 0 && (n.current = u, t.current = v); + const _ = Math.max(1, u - n.current); + n.current = u, i.current.copy(v).sub(t.current).divideScalar(_); + const m = i.current.length() > 0, x = s.current ? t.current.clone() : v; + return !s.current && m && (s.current = !0), t.current = v, { + currentPointer: v, + prevPointer: x, + diffPointer: r.current.subVectors(v, x), + velocity: i.current, + isVelocityUpdate: m + }; + }, + [e] + ); +}, Ot = ({ + size: e, + dpr: t, + ...r +}, a) => { + const { scene: n, material: i, camera: s } = M({ + size: e, + dpr: t, + material: Q, + geometrySize: { + width: 1, + height: 1 + }, + uniformValues: r + }), c = Et(); + return { render: h( + (u) => { + const { gl: v, pointer: _ } = u, { currentPointer: m, diffPointer: x } = c(_); + i.uniforms.center.value.copy(m), i.uniforms.force.value.copy(x), a({ gl: v, scene: n, camera: s, clear: !1 }); + }, + [a, i, c, n, s] + ), material: i }; +}, Pt = ({ + size: e, + dpr: t, + ...r +}, a) => { + const { scene: n, material: i, camera: s } = M({ + size: e, + dpr: t, + material: q, + uniformValues: r + }); + return { render: h( + (l) => { + const { gl: u } = l; + a({ gl: u, scene: n, camera: s }); + }, + [a, n, s] + ), material: i }; +}, Vt = ({ + size: e, + dpr: t, + pressureIterations: r, + ...a +}, n) => { + const { scene: i, material: s, camera: c } = M({ + size: e, + dpr: t, + material: H, + uniformValues: a, + customParameters: { + iterations: r + } + }); + return { render: h( + (u) => { + const { gl: v } = u; + for (let _ = 0; _ < s.iterations; _++) + n({ gl: v, scene: i, camera: c }, ({ read: m }) => { + s.uniforms.pressure.value = m; + }); + }, + [n, s, i, c] + ), material: s }; +}, It = ({ + size: e, + dpr: t, + ...r +}, a) => { + const { scene: n, material: i, camera: s } = M({ + size: e, + dpr: t, + material: G, + uniformValues: r + }); + return { render: h( + (l) => { + const { gl: u } = l; + a({ gl: u, scene: n, camera: s }); + }, + [a, n, s] + ), material: i }; +}, Bt = ({ + size: e, + dpr: t, + ...r +}, a) => { + const { scene: n, material: i, camera: s } = M({ + size: e, + dpr: t, + material: Y, + uniformValues: r + }); + return { render: h( + (l) => { + const { gl: u } = l; + a({ gl: u, scene: n, camera: s }); + }, + [a, n, s] + ), material: i }; +}, L = (e) => Object.fromEntries( + Object.entries(e).filter(([, t]) => t !== void 0) +), pe = (e) => { + const { + dissipation: t, + deltaTime: r, + bounce: a, + pressureIterations: n, + radius: i, + forceBias: s, + ...c + } = e; + return [ + { + advection: L({ dissipation: t, deltaTime: r }), + divergence: L({ bounce: a, deltaTime: r }), + poisson: L({ bounce: a }), + pressure: L({ bounce: a, deltaTime: r }), + splat: L({ radius: i, forceBias: s }), + pressureIterations: n + }, + c + ]; +}, jt = ({ + size: e, + dpr: t, + fboAutoSetSize: r, + renderTargetOptions: a, + materialParameters: n, + ...i +}) => { + const s = R(t), c = { + dpr: s.fbo, + size: e, + fboAutoSetSize: r, + type: o.HalfFloatType, + ...a + }, [l, u] = b(c), [v, _] = b(c), [m, x] = b(c), [p, f] = he(c), [g, C] = b(c), [U, le] = pe(i), y = { size: e, dpr: s.shader }, D = Tt( + { + ...y, + ...U.advection, + velocity: l.texture + }, + _ + ), O = Ot( + { + ...y, + ...U.splat + }, + _ + ), I = Pt( + { + ...y, + ...U.divergence, + velocity: v.texture + }, + x + ), P = Vt( + { + ...y, + ...U.poisson, + divergence: m.texture, + pressureIterations: U.pressureIterations + }, + f + ), B = It( + { + ...y, + ...U.pressure, + velocity: v.texture, + pressure: p.read.texture + }, + u + ), k = Bt( + { + ...y, + ...le, + src: l.texture + }, + C + ), Z = h( + (J, $ = !0) => { + const [F, Ue] = pe(J); + k.material.setUniformValues(Ue, $), D.material.setUniformValues(F.advection), I.material.setUniformValues(F.divergence), P.material.setUniformValues(F.poisson), B.material.setUniformValues(F.pressure), O.material.setUniformValues(F.splat), F.pressureIterations && (P.material.iterations = F.pressureIterations); + }, + [k, D, I, P, B, O] + ); + return { + render: h( + (J, $) => ($ && Z($, !1), [D, O, I, P, B, k].forEach( + (F) => F == null ? void 0 : F.render(J) + ), g.texture), + [ + Z, + g.texture, + D, + O, + I, + P, + B, + k + ] + ), + setValues: Z, + texture: g.texture, + velocity: l.texture + }; +}, zt = ({ + size: e, + dpr: t, + fboAutoSetSize: r, + renderTargetOptions: a, + materialParameters: n, + ...i +}) => { + const s = R(t), { scene: c, material: l, camera: u } = M({ + size: e, + dpr: s.shader, + material: bt, + uniformValues: i, + materialParameters: n + }), [v, _] = b({ + scene: c, + camera: u, + size: e, + dpr: s.fbo, + fboAutoSetSize: r, + ...a + }), m = h( + (p, f = !0) => { + l.setUniformValues(p, f); + }, + [l] + ); + return { + render: h( + (p, f) => { + const { gl: g } = p; + return f && m(f, !1), _({ gl: g }); + }, + [m, _] + ), + setValues: m, + texture: v.texture, + material: l, + scene: c, + camera: u, + renderTarget: v + }; +}, Kt = ({ + size: e, + dpr: t, + fboAutoSetSize: r, + renderTargetOptions: a, + materialParameters: n, + ...i +}) => { + const s = R(t), { scene: c, material: l, camera: u } = M({ + size: e, + dpr: s.shader, + material: ie, + materialParameters: n, + ...i + }), [v, _] = b({ + scene: c, + camera: u, + size: e, + dpr: s.fbo, + fboAutoSetSize: r, + ...a + }), m = h( + (p) => { + l.setUniformValues(p); + }, + [l] + ); + return { + render: h( + (p, f) => { + const { gl: g } = p; + return f && m(f), _({ gl: g }); + }, + [m, _] + ), + setValues: m, + texture: v.texture, + material: l, + scene: c, + camera: u, + renderTarget: v + }; +}, Nt = ({ + size: e, + dpr: t, + fboAutoSetSize: r, + renderTargetOptions: a, + materialParameters: n, + pointerLerp: i = 1, + ...s +}) => { + const c = R(t), { scene: l, material: u, camera: v } = M({ + size: e, + dpr: c.shader, + material: oe, + materialParameters: n, + ...s + }), _ = { + scene: l, + camera: v, + size: e, + dpr: c.fbo, + fboAutoSetSize: r, + ...a + }, [m, x] = b(_), [p, f] = he(_), [g, C] = Ce({ pointerLerp: i }), U = h( + ({ pointerLerp: y, ...D }) => { + u.setUniformValues(D), y && C({ pointerLerp: y }); + }, + [u, C] + ); + return { + render: h( + (y, D) => { + const { gl: O, clock: I, pointer: P } = y; + return D && U(D), u.uniforms.time.value = I.getElapsedTime(), u.uniforms.pointer.value.lerp( + P, + g.current.pointerLerp + ), f( + { gl: O }, + ({ read: B }) => u.uniforms.backbuffer.value = B + ), x({ gl: O }); + }, + [U, x, u, f, g] + ), + setValues: U, + texture: m.texture, + material: u, + scene: l, + camera: v, + renderTarget: m + }; +}, Xt = ({ + size: e, + dpr: t, + fboAutoSetSize: r, + renderTargetOptions: a, + materialParameters: n, + ...i +}) => { + const s = R(t), { scene: c, material: l, camera: u } = M({ + size: e, + dpr: s.shader, + material: ce, + uniformValues: i, + materialParameters: n + }), [v, _] = b({ + scene: c, + camera: u, + size: e, + dpr: s.fbo, + fboAutoSetSize: r, + ...a + }), m = h( + (p, f = !0) => { + l.setUniformValues(p, f), l.setNearestFilter(); + }, + [l] + ); + return { + render: h( + (p, f) => { + const { gl: g, clock: C } = p; + return f && m(f, !1), l.uniforms.tick.value = typeof (f == null ? void 0 : f.tick) == "function" ? f.tick(l.uniforms.tick.value) : (f == null ? void 0 : f.tick) || C.getElapsedTime(), _({ gl: g }); + }, + [m, _, l] + ), + setValues: m, + texture: v.texture, + material: l, + scene: c, + camera: u, + renderTarget: v + }; +}, z = Object.freeze({ + easeInSine(e) { + return 1 - Math.cos(e * Math.PI / 2); + }, + easeOutSine(e) { + return Math.sin(e * Math.PI / 2); + }, + easeInOutSine(e) { + return -(Math.cos(Math.PI * e) - 1) / 2; + }, + easeInQuad(e) { + return e * e; + }, + easeOutQuad(e) { + return 1 - (1 - e) * (1 - e); + }, + easeInOutQuad(e) { + return e < 0.5 ? 2 * e * e : 1 - Math.pow(-2 * e + 2, 2) / 2; + }, + easeInCubic(e) { + return e * e * e; + }, + easeOutCubic(e) { + return 1 - Math.pow(1 - e, 3); + }, + easeInOutCubic(e) { + return e < 0.5 ? 4 * e * e * e : 1 - Math.pow(-2 * e + 2, 3) / 2; + }, + easeInQuart(e) { + return e * e * e * e; + }, + easeOutQuart(e) { + return 1 - Math.pow(1 - e, 4); + }, + easeInOutQuart(e) { + return e < 0.5 ? 8 * e * e * e * e : 1 - Math.pow(-2 * e + 2, 4) / 2; + }, + easeInQuint(e) { + return e * e * e * e * e; + }, + easeOutQuint(e) { + return 1 - Math.pow(1 - e, 5); + }, + easeInOutQuint(e) { + return e < 0.5 ? 16 * e * e * e * e * e : 1 - Math.pow(-2 * e + 2, 5) / 2; + }, + easeInExpo(e) { + return e === 0 ? 0 : Math.pow(2, 10 * e - 10); + }, + easeOutExpo(e) { + return e === 1 ? 1 : 1 - Math.pow(2, -10 * e); + }, + easeInOutExpo(e) { + return e === 0 ? 0 : e === 1 ? 1 : e < 0.5 ? Math.pow(2, 20 * e - 10) / 2 : (2 - Math.pow(2, -20 * e + 10)) / 2; + }, + easeInCirc(e) { + return 1 - Math.sqrt(1 - Math.pow(e, 2)); + }, + easeOutCirc(e) { + return Math.sqrt(1 - Math.pow(e - 1, 2)); + }, + easeInOutCirc(e) { + return e < 0.5 ? (1 - Math.sqrt(1 - Math.pow(2 * e, 2))) / 2 : (Math.sqrt(1 - Math.pow(-2 * e + 2, 2)) + 1) / 2; + }, + easeInBack(e) { + return 2.70158 * e * e * e - 1.70158 * e * e; + }, + easeOutBack(e) { + return 1 + 2.70158 * Math.pow(e - 1, 3) + 1.70158 * Math.pow(e - 1, 2); + }, + easeInOutBack(e) { + const r = 2.5949095; + return e < 0.5 ? Math.pow(2 * e, 2) * ((r + 1) * 2 * e - r) / 2 : (Math.pow(2 * e - 2, 2) * ((r + 1) * (e * 2 - 2) + r) + 2) / 2; + }, + easeInElastic(e) { + const t = 2 * Math.PI / 3; + return e === 0 ? 0 : e === 1 ? 1 : -Math.pow(2, 10 * e - 10) * Math.sin((e * 10 - 10.75) * t); + }, + easeOutElastic(e) { + const t = 2 * Math.PI / 3; + return e === 0 ? 0 : e === 1 ? 1 : Math.pow(2, -10 * e) * Math.sin((e * 10 - 0.75) * t) + 1; + }, + easeInOutElastic(e) { + const t = 2 * Math.PI / 4.5; + return e === 0 ? 0 : e === 1 ? 1 : e < 0.5 ? -(Math.pow(2, 20 * e - 10) * Math.sin((20 * e - 11.125) * t)) / 2 : Math.pow(2, -20 * e + 10) * Math.sin((20 * e - 11.125) * t) / 2 + 1; + }, + easeInBounce(e) { + return 1 - z.easeOutBounce(1 - e); + }, + easeOutBounce(e) { + return e < 1 / 2.75 ? 7.5625 * e * e : e < 2 / 2.75 ? 7.5625 * (e -= 1.5 / 2.75) * e + 0.75 : e < 2.5 / 2.75 ? 7.5625 * (e -= 2.25 / 2.75) * e + 0.9375 : 7.5625 * (e -= 2.625 / 2.75) * e + 0.984375; + }, + easeInOutBounce(e) { + return e < 0.5 ? (1 - z.easeOutBounce(1 - 2 * e)) / 2 : (1 + z.easeOutBounce(2 * e - 1)) / 2; + } +}); +function Rt(e) { + let t = Math.sin(e * 12.9898) * 43758.5453; + return t - Math.floor(t); +} +const qt = (e, t = "easeOutQuart") => { + const r = e / 60, a = z[t]; + return h( + (i) => { + let s = i.getElapsedTime() * r; + const c = Math.floor(s), l = a(s - c); + s = l + c; + const u = Rt(c); + return { + beat: s, + floor: c, + fract: l, + hash: u + }; + }, + [r, a] + ); +}, xe = { passive: !0 }, Gt = (e) => { + const t = T(new o.Vector2(0)); + return K(() => { + const r = (i, s) => { + t.current.set( + (i - e.left) / e.width * 2 - 1, + -((s - e.top) / e.height) * 2 + 1 + ); + }, a = (i) => { + const s = i.touches[0]; + r(s.clientX, s.clientY); + }, n = (i) => { + r(i.clientX, i.clientY); + }; + return window.addEventListener("touchmove", a, xe), window.addEventListener("pointermove", n, xe), () => { + window.removeEventListener("touchmove", a), window.removeEventListener("pointermove", n); + }; + }, [e]), t.current; +}; +export { + re as BASICFX_VALUES, + oe as BlankMaterial, + bt as BufferMaterial, + kt as FluidMaterials, + ce as GridMaterial, + gt as NoiseMaterial, + ie as RawBlankMaterial, + ue as getFxKeyFromUniforms, + Pe as handleUpdateFxDefines, + qt as useBeat, + Nt as useBlank, + zt as useBuffer, + he as useDoubleFBO, + jt as useFluid, + Xt as useGrid, + $t as useNoise, + Et as usePointerTracker, + Kt as useRawBlank, + b as useSingleFBO, + Gt as useWindowPointer +}; +//# sourceMappingURL=use-shader-fx.js.map diff --git a/packages/use-shader-fx/build/use-shader-fx.js.map b/packages/use-shader-fx/build/use-shader-fx.js.map new file mode 100644 index 00000000..06e78f64 --- /dev/null +++ b/packages/use-shader-fx/build/use-shader-fx.js.map @@ -0,0 +1 @@ +{"version":3,"file":"use-shader-fx.js","sources":["../src/utils/getDpr.ts","../src/utils/useResolution.ts","../src/utils/useCamera.ts","../src/utils/useSingleFBO.ts","../src/utils/useDoubleFBO.ts","../src/utils/useSetup.ts","../src/utils/useMutableState.ts","../src/libs/constants.ts","../src/utils/warn.ts","../src/materials/core/BasicFxLib.ts","../src/shaders/ShaderLib/plane_vertex.glsl","../src/shaders/ShaderLib/default_vertex.glsl","../src/shaders/ShaderLib/default_pars_vertex.glsl","../src/shaders/ShaderLib/default_pars_fragment.glsl","../src/shaders/ShaderLib/basicFx_vertex.glsl","../src/shaders/ShaderLib/basicFx_pars_vertex.glsl","../src/shaders/ShaderLib/basicFx_pars_fragment.glsl","../src/shaders/ShaderLib/basicFx_fragment_begin.glsl","../src/shaders/ShaderLib/basicFx_fragment_end.glsl","../src/shaders/ShaderLib/samplingFx_vertex.glsl","../src/shaders/ShaderLib/samplingFx_pars_vertex.glsl","../src/shaders/ShaderLib/samplingFx_pars_fragment.glsl","../src/shaders/ShaderLib.ts","../src/materials/impl/noise/noise.glsl.ts","../src/shaders/ShaderChunk/plane_vertex.glsl","../src/shaders/ShaderChunk/srcSystem_pars_vertex.glsl","../src/shaders/ShaderChunk/srcSystem_pars_fragment.glsl","../src/shaders/ShaderChunk/default_vertex.glsl","../src/shaders/ShaderChunk/default_pars_vertex.glsl","../src/shaders/ShaderChunk/default_pars_fragment.glsl","../src/shaders/ShaderChunk/mixSrc_pars_vertex.glsl","../src/shaders/ShaderChunk/mixSrc_vertex.glsl","../src/shaders/ShaderChunk/mixSrc_pars_fragment.glsl","../src/shaders/ShaderChunk/mixSrc_fragment_begin.glsl","../src/shaders/ShaderChunk/mixSrc_fragment_end.glsl","../src/shaders/ShaderChunk/mixDst_pars_vertex.glsl","../src/shaders/ShaderChunk/mixDst_vertex.glsl","../src/shaders/ShaderChunk/mixDst_pars_fragment.glsl","../src/shaders/ShaderChunk/mixDst_fragment.glsl","../src/shaders/ShaderChunk/texture_vertex.glsl","../src/shaders/ShaderChunk/texture_pars_vertex.glsl","../src/shaders/ShaderChunk/texture_pars_fragment.glsl","../src/shaders/ShaderChunk/adjustments_fragment.glsl","../src/shaders/ShaderChunk/adjustments_pars_fragment.glsl","../src/shaders/ShaderChunk/calcSrcUv.glsl","../src/shaders/ShaderChunk.ts","../src/shaders/shaderUtils.ts","../src/shaders/uniformsUtils.ts","../src/materials/core/FxMaterial.ts","../src/materials/core/BasicFxMaterial.ts","../src/materials/impl/noise/NoiseMaterial.ts","../src/materials/impl/fluid/shaders/vertex.ts","../src/materials/impl/fluid/shaders/advection.frag","../src/materials/impl/fluid/AdvectionMaterial.ts","../src/materials/impl/fluid/shaders/divergence.frag","../src/materials/impl/fluid/DivergenceMaterial.ts","../src/materials/impl/fluid/shaders/pressure.frag","../src/materials/impl/fluid/PressureMaterial.ts","../src/materials/impl/fluid/shaders/poisson.frag","../src/materials/impl/fluid/PoissonMaterial.ts","../src/materials/impl/fluid/shaders/splat.frag","../src/materials/impl/fluid/SplatMaterial.ts","../src/materials/impl/fluid/OutputMaterial.ts","../src/materials/impl/fluid/index.js","../src/materials/core/SamplingFxMaterial.ts","../src/materials/impl/buffer/BufferMaterial.ts","../src/materials/impl/rawBlank/RawBlankMaterial.ts","../src/materials/impl/blank/BlankMaterial.ts","../src/materials/impl/grid/grid.glsl.ts","../src/materials/impl/grid/GridMaterial.ts","../src/hooks/useNoise/index.ts","../src/hooks/useFluid/scenes/useAdvection.ts","../src/misc/usePointerTracker.ts","../src/hooks/useFluid/scenes/useSplat.ts","../src/hooks/useFluid/scenes/useDivergence.ts","../src/hooks/useFluid/scenes/usePoisson.ts","../src/hooks/useFluid/scenes/usePressure.ts","../src/hooks/useFluid/scenes/useOutput.ts","../src/hooks/useFluid/index.ts","../src/hooks/useBuffer/index.tsx","../src/hooks/useRawBlank/index.tsx","../src/hooks/useBlank/index.tsx","../src/hooks/useGrid/index.ts","../src/libs/Easings.ts","../src/misc/useBeat.ts","../src/misc/useWindowPointer.ts"],"sourcesContent":["import { Dpr } from \"../hooks/types\";\n\nexport const getDpr = (\n dpr: Dpr\n): { shader: number | false; fbo: number | false } => {\n if (typeof dpr === \"number\") {\n return { shader: dpr, fbo: dpr };\n }\n return {\n shader: dpr.shader ?? false,\n fbo: dpr.fbo ?? false,\n };\n};\n","import * as THREE from \"three\";\nimport { useState } from \"react\";\nimport { Size } from \"../hooks/types\";\n\n/**\n * @params dpr if dpr is set, it returns the resolution which is size multiplied by dpr.\n */\nexport const useResolution = (size: Size, dpr: number | false = false) => {\n const _width = dpr ? size.width * dpr : size.width;\n const _height = dpr ? size.height * dpr : size.height;\n\n const [resolution] = useState(() => new THREE.Vector2(_width, _height));\n resolution.set(_width, _height);\n\n return resolution;\n};\n","import * as THREE from \"three\";\nimport { useResolution } from \"./useResolution\";\nimport { useState } from \"react\";\nimport { Size } from \"../hooks/types\";\n\nconst getCameraProps = (width: number, height: number) => {\n const frustumSize = height;\n const aspect = width / height;\n const [w, h] = [(frustumSize * aspect) / 2, frustumSize / 2];\n return { width: w, height: h, near: -1000, far: 1000 };\n};\n\nexport const useCamera = (\n size: Size,\n cameraType: \"OrthographicCamera\" | \"PerspectiveCamera\" = \"OrthographicCamera\"\n) => {\n const resolution = useResolution(size);\n const { width, height, near, far } = getCameraProps(\n resolution.x,\n resolution.y\n );\n\n const [camera] = useState(() => {\n return cameraType === \"OrthographicCamera\"\n ? new THREE.OrthographicCamera(\n -width,\n width,\n height,\n -height,\n near,\n far\n )\n : new THREE.PerspectiveCamera(50, width / height);\n });\n\n if (camera instanceof THREE.OrthographicCamera) {\n camera.left = -width;\n camera.right = width;\n camera.top = height;\n camera.bottom = -height;\n camera.near = near;\n camera.far = far;\n camera.updateProjectionMatrix();\n } else if (camera instanceof THREE.PerspectiveCamera) {\n camera.aspect = width / height;\n camera.updateProjectionMatrix();\n }\n\n return camera;\n};\n","import * as THREE from \"three\";\nimport { useCallback, useEffect, useState } from \"react\";\nimport { useResolution } from \"./useResolution\";\nimport { Size } from \"../hooks/types\";\n\nexport const FBO_DEFAULT_OPTION: THREE.RenderTargetOptions = {\n depthBuffer: false,\n};\n\nexport type UseFboProps = {\n scene?: THREE.Scene;\n camera?: THREE.Camera;\n size: Size;\n /** If dpr is set, dpr will be multiplied, default : `false` */\n dpr?: number | false;\n /** Whether to resize when resizing occurs. If isDpr is true, set FBO to setSize even if dpr is changed, default : `false` */\n fboAutoSetSize?: boolean;\n /** If set, the scene depth will be rendered into buffer.depthTexture. default : `false` */\n depth?: boolean;\n} & THREE.RenderTargetOptions;\n\nexport type RenderProps = {\n gl: THREE.WebGLRenderer;\n scene?: THREE.Scene;\n camera?: THREE.Camera;\n clear?: boolean;\n};\n\nexport const renderFBO = ({\n gl,\n fbo,\n scene,\n camera,\n clear = true,\n onBeforeRender,\n onSwap,\n}: {\n fbo: THREE.WebGLRenderTarget;\n onBeforeRender: () => void;\n onSwap?: () => void;\n} & RenderProps) => {\n if (!scene || !camera) return;\n const clearCache = gl.autoClear;\n gl.autoClear = clear;\n gl.setRenderTarget(fbo);\n onBeforeRender();\n gl.render(scene, camera);\n onSwap && onSwap();\n gl.setRenderTarget(null);\n gl.autoClear = clearCache;\n};\n\nexport type SingleFBOUpdateFunction = (\n renderProps: RenderProps,\n /** call before FBO is rendered */\n onBeforeRender?: ({ read }: { read: THREE.Texture }) => void\n) => THREE.Texture;\n\ntype UseSingleFBOReturn = [THREE.WebGLRenderTarget, SingleFBOUpdateFunction];\n\n/**\n * @param dpr If dpr is set, dpr will be multiplied, default:false\n * @param fboAutoSetSize Whether to resize when resizing occurs. If isDpr is true, set FBO to setSize even if dpr is changed, default:false\n * @param depthBuffer Unlike the default in three.js, the default is `false`.\n * @returns [THREE.WebGLRenderTarget , updateFBO] -Receives the RenderTarget as the first argument and the update function as the second argument.\n */\nexport const useSingleFBO = (props: UseFboProps): UseSingleFBOReturn => {\n const {\n scene,\n camera,\n size,\n dpr = false,\n fboAutoSetSize = false,\n depth = false,\n ...renderTargetOptions\n } = props;\n\n const resolution = useResolution(size, dpr);\n\n const [renderTarget] = useState(() => {\n const target = new THREE.WebGLRenderTarget(resolution.x, resolution.y, {\n ...FBO_DEFAULT_OPTION,\n ...renderTargetOptions,\n });\n if (depth) {\n target.depthTexture = new THREE.DepthTexture(\n resolution.x,\n resolution.y,\n THREE.FloatType\n );\n }\n return target;\n });\n\n if (fboAutoSetSize) {\n renderTarget.setSize(resolution.x, resolution.y);\n }\n\n useEffect(() => {\n const temp = renderTarget;\n return () => {\n temp?.dispose();\n };\n }, [renderTarget]);\n\n const updateRenderTarget: SingleFBOUpdateFunction = useCallback(\n (renderProps, onBeforeRender) => {\n const fbo = renderTarget!;\n renderFBO({\n ...renderProps,\n scene: renderProps.scene || scene,\n camera: renderProps.camera || camera,\n fbo,\n onBeforeRender: () => onBeforeRender?.({ read: fbo.texture }),\n });\n return fbo.texture;\n },\n [scene, camera, renderTarget]\n );\n\n return [renderTarget, updateRenderTarget];\n};\n","import * as THREE from \"three\";\nimport { useCallback, useEffect, useState } from \"react\";\nimport {\n FBO_DEFAULT_OPTION,\n UseFboProps,\n renderFBO,\n RenderProps,\n} from \"./useSingleFBO\";\nimport { useResolution } from \"./useResolution\";\n\nexport type DoubleRenderTarget = {\n read: THREE.WebGLRenderTarget;\n write: THREE.WebGLRenderTarget;\n};\n\ninterface WebGLDoubleRenderTarget extends DoubleRenderTarget {\n swap: () => void;\n}\n\nexport type DoubleFBOUpdateFunction = (\n renderProps: RenderProps,\n /** call before FBO is rendered */\n onBeforeRender?: ({\n read,\n write,\n }: {\n read: THREE.Texture;\n write: THREE.Texture;\n }) => void\n) => THREE.Texture;\n\ntype UseDoubleFBOReturn = [\n { read: THREE.WebGLRenderTarget; write: THREE.WebGLRenderTarget },\n DoubleFBOUpdateFunction\n];\n\n/**\n * @description Custom hook for setting up double buffering with WebGL render targets.\n * @param UseFboProps same as `useSingleFBO`\n */\nexport const useDoubleFBO = (props: UseFboProps): UseDoubleFBOReturn => {\n const {\n scene,\n camera,\n size,\n dpr = false,\n fboAutoSetSize = false,\n depth = false,\n ...renderTargetOptions\n } = props;\n\n const resolution = useResolution(size, dpr);\n\n const [renderTarget] = useState(() => {\n const read = new THREE.WebGLRenderTarget(resolution.x, resolution.y, {\n ...FBO_DEFAULT_OPTION,\n ...renderTargetOptions,\n });\n const write = new THREE.WebGLRenderTarget(resolution.x, resolution.y, {\n ...FBO_DEFAULT_OPTION,\n ...renderTargetOptions,\n });\n\n if (depth) {\n read.depthTexture = new THREE.DepthTexture(\n resolution.x,\n resolution.y,\n THREE.FloatType\n );\n write.depthTexture = new THREE.DepthTexture(\n resolution.x,\n resolution.y,\n THREE.FloatType\n );\n }\n\n return {\n read: read,\n write: write,\n swap: function () {\n let temp = this.read;\n this.read = this.write;\n this.write = temp;\n },\n };\n });\n\n if (fboAutoSetSize) {\n renderTarget.read?.setSize(resolution.x, resolution.y);\n renderTarget.write?.setSize(resolution.x, resolution.y);\n }\n\n useEffect(() => {\n const temp = renderTarget;\n return () => {\n temp.read?.dispose();\n temp.write?.dispose();\n };\n }, [renderTarget]);\n\n const updateRenderTarget: DoubleFBOUpdateFunction = useCallback(\n (renderProps, onBeforeRender) => {\n const fbo = renderTarget;\n renderFBO({\n ...renderProps,\n scene: renderProps.scene || scene,\n camera: renderProps.camera || camera,\n fbo: fbo.write!,\n onBeforeRender: () =>\n onBeforeRender?.({\n read: fbo.read!.texture,\n write: fbo.write!.texture,\n }),\n onSwap: () => fbo.swap(),\n });\n return fbo.read?.texture as THREE.Texture;\n },\n [scene, camera, renderTarget]\n );\n\n return [\n { read: renderTarget.read, write: renderTarget.write },\n updateRenderTarget,\n ];\n};\n","import * as THREE from \"three\";\nimport { useEffect, useState } from \"react\";\nimport { Size } from \"../hooks/types\";\nimport { useResolution } from \"./useResolution\";\nimport { FxMaterial, FxMaterialProps } from \"../materials/core/FxMaterial\";\nimport { useCamera } from \"./useCamera\";\n\ntype Object3DConstructor = new (\n geometry: THREE.BufferGeometry,\n material: M\n) => T;\n\ntype MaterialConstructor = new (props: FxMaterialProps) => M;\n\ntype GeometryConstructor = new (\n width: number,\n height: number\n) => THREE.BufferGeometry;\n\n/**\n * Add geometry and material to Object3D and add them to scene.\n */\nconst useObject3D = (\n scene: THREE.Scene | false,\n geometry: THREE.BufferGeometry,\n material: M,\n Proto: Object3DConstructor\n) => {\n const [object3D] = useState(() => new Proto(geometry, material));\n\n useEffect(() => {\n scene && scene.add(object3D);\n return () => {\n scene && scene.remove(object3D);\n geometry.dispose();\n material.dispose();\n };\n }, [scene, geometry, material, object3D]);\n\n return object3D;\n};\n\nexport const useSetup = ({\n size,\n dpr,\n material,\n geometry = THREE.PlaneGeometry,\n geometrySize,\n ...materialProps\n}: {\n size: Size;\n dpr: number | false;\n material: MaterialConstructor;\n geometry?: GeometryConstructor;\n geometrySize?: {\n width: number;\n height: number;\n };\n} & FxMaterialProps) => {\n // Mutable THREE objects should retain their values in useState\n // https://github.com/FunTechInc/use-shader-fx/issues/145\n const [scene] = useState(() => new THREE.Scene());\n const [_geometry] = useState(\n () => new geometry(geometrySize?.width || 2, geometrySize?.height || 2)\n );\n const [_material] = useState(() => new material(materialProps));\n\n // materialのresolutionはreactiveに更新する\n const resolution = useResolution(size, dpr);\n _material.updateResolution(resolution.x, resolution.y);\n\n useObject3D(scene, _geometry, _material, THREE.Mesh);\n\n const camera = useCamera(size);\n\n return {\n scene,\n material: _material,\n camera,\n };\n};\n","import { useCallback, useRef } from \"react\";\n\nexport const useMutableState = (state: S) => {\n const ref = useRef(state);\n const setRef = useCallback((value: S | ((prevState: S) => S)) => {\n ref.current =\n typeof value === \"function\"\n ? (value as (prevState: S) => S)(ref.current)\n : value;\n }, []);\n\n return [ref, setRef] as const;\n};\n","import * as THREE from \"three\";\n\n// CDNとして使う場合、processがundefinedになるので、その場合はfalseを返す\nexport const ISDEV = (() => {\n try {\n return process.env.NODE_ENV === \"development\";\n } catch (error) {\n return false;\n }\n})();\n\nexport const MATERIAL_BASIC_PARAMS = {\n transparent: false,\n depthTest: false,\n depthWrite: false,\n};\n\nexport const DEFAULT_TEXTURE = new THREE.DataTexture(\n new Uint8Array([0, 0, 0, 0]),\n 1,\n 1,\n THREE.RGBAFormat\n);\n\nexport const APP_NAME = \"use-shader-fx\";\n\nexport const THREE_FLAG_PROPS = [\n \"isColor\",\n \"isMatrix3\",\n \"isMatrix4\",\n \"isVector2\",\n \"isVector3\",\n \"isVector4\",\n \"isTexture\",\n \"isQuaternion\",\n \"isWebGLRenderTarget\",\n \"isEuler\",\n \"isBufferGeometry\",\n \"isMaterial\",\n \"isCamera\",\n \"isLight\",\n \"isObject3D\",\n \"isBone\",\n \"isVideoTexture\",\n];\n","import { APP_NAME, ISDEV } from \"../libs/constants\";\n\nexport const warn = (text: string) => {\n if (ISDEV) {\n console.warn(`${APP_NAME}: ${text}`);\n }\n};\n","import * as THREE from \"three\";\nimport { DefaultUniforms } from \"./FxMaterial\";\nimport {\n NestUniformValues,\n UniformParentKey,\n} from \"../../shaders/uniformsUtils\";\nimport { DEFAULT_TEXTURE } from \"../../libs/constants\";\nimport type { Vec4Channel } from \"../../libs/types\";\n\n/*===============================================\ntypes\n===============================================*/\n/** 0:`fill` 1:`cover` 2:`contain` */\nexport type FitType = 0 | 1 | 2;\n\nexport type BasicFxUniformsUnique = {\n /*===============================================\n\tmixSrc\n\t===============================================*/\n mixSrc: { value: UniformParentKey };\n mixSrc_src: { value: THREE.Texture };\n mixSrc_fit: { value: FitType };\n // uv\n mixSrc_uv: { value: UniformParentKey };\n mixSrc_uv_ch: { value: Vec4Channel }; // mixSrcのどのchを使って、このfxのuvをノイズさせるか\n mixSrc_uv_factor: { value: number };\n mixSrc_uv_offset: { value: THREE.Vector2 };\n mixSrc_uv_radius: { value: number }; // 負の値は画面全体\n mixSrc_uv_position: { value: THREE.Vector2 };\n mixSrc_uv_range: { value: THREE.Vector2 };\n mixSrc_uv_mixMap: { value: UniformParentKey };\n mixSrc_uv_mixMap_src: { value: THREE.Texture };\n mixSrc_uv_mixMap_ch: { value: Vec4Channel }; // どのチャンネルでmixするか\n\n // color\n mixSrc_color: { value: UniformParentKey };\n mixSrc_color_factor: { value: number };\n mixSrc_color_radius: { value: number }; // 負の値は画面全体\n mixSrc_color_position: { value: THREE.Vector2 };\n mixSrc_color_range: { value: THREE.Vector2 };\n mixSrc_color_mixMap: { value: UniformParentKey };\n mixSrc_color_mixMap_src: { value: THREE.Texture };\n mixSrc_color_mixMap_ch: { value: Vec4Channel }; // どのチャンネルでmixするか\n\n // alpha\n mixSrc_alpha: { value: UniformParentKey };\n mixSrc_alpha_factor: { value: number };\n mixSrc_alpha_radius: { value: number }; // 負の値は画面全体\n mixSrc_alpha_position: { value: THREE.Vector2 };\n mixSrc_alpha_range: { value: THREE.Vector2 };\n mixSrc_alpha_mixMap: { value: UniformParentKey };\n mixSrc_alpha_mixMap_src: { value: THREE.Texture };\n mixSrc_alpha_mixMap_ch: { value: Vec4Channel }; // どのチャンネルでmixするか\n\n /*===============================================\n\tmixDst\n\t===============================================*/\n mixDst: { value: UniformParentKey };\n mixDst_src: { value: THREE.Texture };\n mixDst_fit: { value: FitType };\n // uv\n mixDst_uv: { value: UniformParentKey };\n mixDst_uv_ch: { value: Vec4Channel }; // このfxのどのchを使ってmixDstのuvをノイズさせるか\n mixDst_uv_factor: { value: number };\n mixDst_uv_offset: { value: THREE.Vector2 };\n mixDst_uv_radius: { value: number }; // 負の値は画面全体\n mixDst_uv_position: { value: THREE.Vector2 };\n mixDst_uv_range: { value: THREE.Vector2 };\n mixDst_uv_mixMap: { value: UniformParentKey };\n mixDst_uv_mixMap_src: { value: THREE.Texture };\n mixDst_uv_mixMap_ch: { value: Vec4Channel }; // どのチャンネルでmixするか\n // color\n mixDst_color: { value: UniformParentKey };\n mixDst_color_factor: { value: number };\n mixDst_color_radius: { value: number }; // 負の値は画面全体\n mixDst_color_position: { value: THREE.Vector2 };\n mixDst_color_range: { value: THREE.Vector2 };\n mixDst_color_mixMap: { value: UniformParentKey };\n mixDst_color_mixMap_src: { value: THREE.Texture };\n mixDst_color_mixMap_ch: { value: Vec4Channel }; // どのチャンネルでmixするか\n // alpha\n mixDst_alpha: { value: UniformParentKey };\n mixDst_alpha_factor: { value: number };\n mixDst_alpha_radius: { value: number }; // 負の値は画面全体\n mixDst_alpha_position: { value: THREE.Vector2 };\n mixDst_alpha_range: { value: THREE.Vector2 };\n mixDst_alpha_mixMap: { value: UniformParentKey };\n mixDst_alpha_mixMap_src: { value: THREE.Texture };\n mixDst_alpha_mixMap_ch: { value: Vec4Channel }; // どのチャンネルでmixするか\n\n /*===============================================\n\tadjustments\n\t===============================================*/\n // levels\n levels: { value: UniformParentKey };\n levels_shadows: { value: THREE.Vector4 };\n levels_midtones: { value: THREE.Vector4 };\n levels_highlights: { value: THREE.Vector4 };\n levels_outputMin: { value: THREE.Vector4 };\n levels_outputMax: { value: THREE.Vector4 };\n // contrast\n contrast: { value: UniformParentKey };\n contrast_factor: { value: THREE.Vector4 };\n // colorBalance\n colorBalance: { value: UniformParentKey };\n colorBalance_factor: { value: THREE.Vector3 };\n // hsv\n hsv: { value: UniformParentKey };\n hsv_hueShift: { value: number }; // 色相を +X 度分回転 (0.0~1.0 で0~360度)\n hsv_saturation: { value: number }; // 彩度乗算 (1.0で変化なし)\n hsv_brightness: { value: number }; // 明度乗算 (1.0で変化なし)\n // posterize\n posterize: { value: UniformParentKey };\n posterize_levels: { value: THREE.Vector4 };\n // grayscale\n grayscale: { value: UniformParentKey };\n grayscale_weight: { value: THREE.Vector3 };\n grayscale_duotone: { value: UniformParentKey };\n grayscale_duotone_color0: { value: THREE.Color };\n grayscale_duotone_color1: { value: THREE.Color };\n grayscale_threshold: { value: number }; // 0~1 負の値は処理をスキップする\n};\n\n// BasicFxValuesの型からfitScaleを排除する\ntype BasicFxUniformsFitScale = {\n mixSrc_fitScale: { value: THREE.Vector2 };\n mixDst_fitScale: { value: THREE.Vector2 };\n};\n\nexport type BasicFxUniforms = BasicFxUniformsUnique & DefaultUniforms;\n\nexport type BasicFxValues = NestUniformValues;\n\nexport type FxKey = {\n srcSystem: boolean;\n mixSrc: boolean;\n mixDst: boolean;\n levels: boolean;\n contrast: boolean;\n colorBalance: boolean;\n hsv: boolean;\n posterize: boolean;\n grayscale: boolean;\n};\n\nexport type SrcSystemKey = \"mixSrc\" | \"mixDst\" | \"texture\";\n\n/*===============================================\nconstants\n===============================================*/\nexport const BASICFX_VALUES: BasicFxUniformsUnique & BasicFxUniformsFitScale = {\n /*===============================================\n\tmixSrc\n\t===============================================*/\n mixSrc: { value: false },\n mixSrc_src: { value: new THREE.Texture() },\n mixSrc_fit: { value: 0 },\n mixSrc_fitScale: { value: new THREE.Vector2(1, 1) },\n // uv\n mixSrc_uv: { value: false },\n mixSrc_uv_ch: { value: 0 },\n mixSrc_uv_factor: { value: 0 },\n mixSrc_uv_offset: { value: new THREE.Vector2(0, 0) },\n mixSrc_uv_radius: { value: 0.5 },\n mixSrc_uv_position: { value: new THREE.Vector2(0.5, 0.5) },\n mixSrc_uv_range: { value: new THREE.Vector2(0.0, 1.0) },\n mixSrc_uv_mixMap: { value: false },\n mixSrc_uv_mixMap_src: { value: DEFAULT_TEXTURE },\n mixSrc_uv_mixMap_ch: { value: 0 },\n\n // color\n mixSrc_color: { value: false },\n mixSrc_color_factor: { value: 0 },\n mixSrc_color_radius: { value: 0.5 },\n mixSrc_color_position: { value: new THREE.Vector2(0.5, 0.5) },\n mixSrc_color_range: { value: new THREE.Vector2(0.0, 1.0) },\n mixSrc_color_mixMap: { value: false },\n mixSrc_color_mixMap_src: { value: DEFAULT_TEXTURE },\n mixSrc_color_mixMap_ch: { value: 0 },\n\n // alpha\n mixSrc_alpha: { value: false },\n mixSrc_alpha_factor: { value: 0 },\n mixSrc_alpha_radius: { value: 0.5 },\n mixSrc_alpha_position: { value: new THREE.Vector2(0.5, 0.5) },\n mixSrc_alpha_range: { value: new THREE.Vector2(0.0, 1.0) },\n mixSrc_alpha_mixMap: { value: false },\n mixSrc_alpha_mixMap_src: { value: DEFAULT_TEXTURE },\n mixSrc_alpha_mixMap_ch: { value: 0 },\n\n /*===============================================\n\tmixDst\n\t===============================================*/\n mixDst: { value: false },\n mixDst_src: { value: new THREE.Texture() },\n mixDst_fit: { value: 0 },\n mixDst_fitScale: { value: new THREE.Vector2(1, 1) },\n\n // uv\n mixDst_uv: { value: false },\n mixDst_uv_ch: { value: 0 },\n mixDst_uv_factor: { value: 0 },\n mixDst_uv_offset: { value: new THREE.Vector2(0, 0) },\n mixDst_uv_radius: { value: 0.5 },\n mixDst_uv_position: { value: new THREE.Vector2(0.5, 0.5) },\n mixDst_uv_range: { value: new THREE.Vector2(0.0, 1.0) },\n mixDst_uv_mixMap: { value: false },\n mixDst_uv_mixMap_src: { value: DEFAULT_TEXTURE },\n mixDst_uv_mixMap_ch: { value: 0 },\n\n // color\n mixDst_color: { value: false },\n mixDst_color_factor: { value: 0 },\n mixDst_color_radius: { value: 0.5 },\n mixDst_color_position: { value: new THREE.Vector2(0.5, 0.5) },\n mixDst_color_range: { value: new THREE.Vector2(0.0, 1.0) },\n mixDst_color_mixMap: { value: false },\n mixDst_color_mixMap_src: { value: DEFAULT_TEXTURE },\n mixDst_color_mixMap_ch: { value: 0 },\n\n // alpha\n mixDst_alpha: { value: false },\n mixDst_alpha_factor: { value: 0 },\n mixDst_alpha_radius: { value: 0.5 },\n mixDst_alpha_position: { value: new THREE.Vector2(0.5, 0.5) },\n mixDst_alpha_range: { value: new THREE.Vector2(0.0, 1.0) },\n mixDst_alpha_mixMap: { value: false },\n mixDst_alpha_mixMap_src: { value: DEFAULT_TEXTURE },\n mixDst_alpha_mixMap_ch: { value: 0 },\n\n /*===============================================\n\tadjustments\n\t===============================================*/\n // levels\n levels: { value: false },\n levels_shadows: { value: new THREE.Vector4(0, 0, 0, 0) },\n levels_midtones: { value: new THREE.Vector4(1, 1, 1, 1) },\n levels_highlights: { value: new THREE.Vector4(1, 1, 1, 1) },\n levels_outputMin: { value: new THREE.Vector4(0, 0, 0, 0) },\n levels_outputMax: { value: new THREE.Vector4(1, 1, 1, 1) },\n // contrast\n contrast: { value: false },\n contrast_factor: { value: new THREE.Vector4(1, 1, 1, 1) },\n // colorBalance\n colorBalance: { value: false },\n colorBalance_factor: { value: new THREE.Vector3(1, 1, 1) },\n // hsv\n hsv: { value: false },\n hsv_hueShift: { value: 0 },\n hsv_saturation: { value: 1 },\n hsv_brightness: { value: 1 },\n // posterize\n posterize: { value: false },\n posterize_levels: { value: new THREE.Vector4(0, 0, 0, 0) },\n // grayscale\n grayscale: { value: false },\n grayscale_weight: { value: new THREE.Vector3(0, 0, 0) },\n grayscale_duotone: { value: false },\n grayscale_duotone_color0: { value: new THREE.Color(0x000000) },\n grayscale_duotone_color1: { value: new THREE.Color(0xffffff) },\n grayscale_threshold: { value: -1 },\n};\n\n/*===============================================\nfunctions\n===============================================*/\nexport function handleUpdateFxDefines(fxKey: FxKey): {\n [key: string]: any;\n} {\n const {\n mixSrc,\n mixDst,\n srcSystem,\n levels,\n contrast,\n colorBalance,\n hsv,\n posterize,\n grayscale,\n } = fxKey;\n return {\n USF_USE_SRC_SYSTEM: srcSystem,\n USF_USE_MIXSRC: mixSrc,\n USF_USE_MIXDST: mixDst,\n USF_USE_LEVELS: levels,\n USF_USE_CONTRAST: contrast,\n USF_USE_COLORBALANCE: colorBalance,\n USF_USE_HSV: hsv,\n USF_USE_POSTERIZE: posterize,\n USF_USE_GRAYSCALE: grayscale,\n };\n}\n\n/** setterで定義される場合もあるため、valuesではなくuniformsから判定する */\nexport function getFxKeyFromUniforms(uniforms: BasicFxUniformsUnique): FxKey {\n const isMixSrc = uniforms.mixSrc.value ? true : false;\n const isMixDst = uniforms.mixDst.value ? true : false;\n const isSrcSystem = isMixSrc || isMixDst;\n return {\n mixSrc: isMixSrc,\n mixDst: isMixDst,\n srcSystem: isSrcSystem,\n levels: uniforms.levels.value ? true : false,\n contrast: uniforms.contrast.value ? true : false,\n colorBalance: uniforms.colorBalance.value ? true : false,\n hsv: uniforms.hsv.value ? true : false,\n posterize: uniforms.posterize.value ? true : false,\n grayscale: uniforms.grayscale.value ? true : false,\n };\n}\n","#usf ","#usf ","#usf ","#usf ","#usf \n#usf ","#usf \n#usf \n#usf ","#usf \n#usf \n#usf \n#usf ","#usf ","#usf \n#usf \n#usf ","#usf ","#usf ","#usf ","import plane_vertex from \"./ShaderLib/plane_vertex.glsl\";\nimport default_vertex from \"./ShaderLib/default_vertex.glsl\";\nimport default_pars_vertex from \"./ShaderLib/default_pars_vertex.glsl\";\nimport default_pars_fragment from \"./ShaderLib/default_pars_fragment.glsl\";\nimport basicFx_vertex from \"./ShaderLib/basicFx_vertex.glsl\";\nimport basicFx_pars_vertex from \"./ShaderLib/basicFx_pars_vertex.glsl\";\nimport basicFx_pars_fragment from \"./ShaderLib/basicFx_pars_fragment.glsl\";\nimport basicFx_fragment_begin from \"./ShaderLib/basicFx_fragment_begin.glsl\";\nimport basicFx_fragment_end from \"./ShaderLib/basicFx_fragment_end.glsl\";\nimport samplingFx_vertex from \"./ShaderLib/samplingFx_vertex.glsl\";\nimport samplingFx_pars_vertex from \"./ShaderLib/samplingFx_pars_vertex.glsl\";\nimport samplingFx_pars_fragment from \"./ShaderLib/samplingFx_pars_fragment.glsl\";\n\nexport type ShaderLibTypes =\n | \"plane_vertex\"\n | \"default_vertex\"\n | \"default_pars_vertex\"\n | \"default_pars_fragment\"\n | \"basicFx_vertex\"\n | \"basicFx_pars_vertex\"\n | \"basicFx_pars_fragment\"\n | \"basicFx_fragment_begin\"\n | \"basicFx_fragment_end\"\n | \"samplingFx_vertex\"\n | \"samplingFx_pars_vertex\"\n | \"samplingFx_pars_fragment\";\n\nexport const ShaderLib: { [K in ShaderLibTypes]: string } = Object.freeze({\n plane_vertex,\n default_vertex,\n default_pars_vertex,\n default_pars_fragment,\n basicFx_vertex,\n basicFx_pars_vertex,\n basicFx_pars_fragment,\n basicFx_fragment_begin,\n basicFx_fragment_end,\n samplingFx_vertex,\n samplingFx_pars_vertex,\n samplingFx_pars_fragment,\n});\n","import { ShaderLib } from \"../../../shaders/ShaderLib\";\n\nexport const noiseVertex = `\n\tvoid main() {\n\t\t${ShaderLib.plane_vertex}\n\t}\n`;\n\nexport const noiseFragment = `\n\tprecision highp int;\n\n\tuniform float tick;\n\tuniform float timeStrength;\n\tuniform int noiseOctaves;\n\tuniform int fbmOctaves;\n\tuniform int warpOctaves;\n\tuniform vec2 warpDirection;\n\tuniform float warpStrength;\n\tuniform float scale;\n\tuniform float timeOffset;\n\n\tconst float per = 0.5;\n\tconst float PI = 3.14159265359;\n\n\tfloat rnd(vec2 n) {\n\t\tfloat a = 0.129898;\n\t\tfloat b = 0.78233;\n\t\tfloat c = 437.585453;\n\t\tfloat dt= dot(n ,vec2(a, b));\n\t\tfloat sn= mod(dt, PI);\n\t\treturn fract(sin(sn) * c);\n\t}\n\n\tfloat interpolate(float a, float b, float x){\n\t\tfloat f = (1.0 - cos(x * PI)) * 0.5;\n\t\treturn a * (1.0 - f) + b * f;\n\t}\n\n\tfloat irnd(vec2 p){\n\t\tvec2 i = floor(p);\n\t\tvec2 f = fract(p);\n\t\tvec4 v = vec4(rnd(vec2(i.x,i.y)),rnd(vec2(i.x + 1.0,i.y)),rnd(vec2(i.x,i.y + 1.0)),rnd(vec2(i.x + 1.0, i.y + 1.0)));\n\t\treturn interpolate(interpolate(v.x, v.y, f.x), interpolate(v.z, v.w, f.x), f.y);\n\t}\n\n\t// Based on The Book of Shaders\n\t// https://thebookofshaders.com/13/\n\tfloat noise(vec2 p, float time){\n\t\tfloat _time = time + timeOffset;\n\t\tfloat t = 0.0;\n\t\tfor(int i = 0; i < noiseOctaves; i++){\n\t\t\tfloat freq = pow(2.0, float(i));\n\t\t\tfloat amp = pow(per, float(noiseOctaves - i));\n\t\t\tt += irnd(vec2(p.y / freq + _time, p.x / freq + _time)) * amp;\n\t\t}\n\t\treturn t;\n\t}\n\n\tfloat fbm(vec2 x, float time) {\n\t\tfloat v = 0.0;\n\t\tfloat a = 0.5;\n\t\tvec2 shift = vec2(100);\n\t\tmat2 rot = mat2(cos(0.5), sin(0.5), -sin(0.5), cos(0.5));\n\t\tfloat sign = 1.0;\n\t\tfor (int i = 0; i < fbmOctaves; ++i) {\n\t\t\tv += a * noise(x, time * sign);\n\t\t\tx = rot * x * 2.0 + shift;\n\t\t\ta *= 0.5;\n\t\t\tsign *= -1.0;\n\t\t}\n\t\treturn v;\n\t}\n\n\tfloat warp(vec2 x, float g,float time){\n\t\tfloat val = 0.0;\n\t\tfor (int i = 0; i < warpOctaves; i++){\n\t\t\tval = fbm(x + g * vec2(cos(warpDirection.x * val), sin(warpDirection.y * val)), time);\n\t\t}\n\t\treturn val;\n\t}\n\n\tvoid main() {\n\n\t\tvec2 usf_Uv = gl_FragCoord.xy * scale;\n\n\t\t${ShaderLib.basicFx_fragment_begin}\n\n\t\tfloat noise = warp(usf_Uv ,warpStrength,tick * timeStrength);\n\n\t\tvec4 usf_FragColor = vec4(noise);\n\n\t\t${ShaderLib.basicFx_fragment_end}\n\n\t\tgl_FragColor = usf_FragColor;\n\n\t}\n`;\n","gl_Position = vec4(position, 1.0);","#ifdef USF_USE_SRC_SYSTEM\n\n\t#usf \n\n#endif\n","#ifdef USF_USE_SRC_SYSTEM\n\n\t#usf \n\n\tfloat calcMixCirclePower(vec2 center, float radius, vec2 range)\n\t{\n\t\tvec2 adjustedUV = (vUv - 0.5) * vec2(aspectRatio, 1.0) + 0.5;\n\t\tvec2 adjustedCenter = (center - 0.5) * vec2(aspectRatio, 1.0) + 0.5;\n\t\t\n\t\tfloat dist = length(adjustedUV - adjustedCenter);\n\t\tfloat power = radius > 0.0 ? 1.0 - dist / radius : 1.0;\n\t\treturn smoothstep(range.x,range.y,power);\n\t}\n\n\tfloat calcMixMapPower(sampler2D map,vec2 range, int ch)\n\t{\n\t\treturn smoothstep(range.x,range.y, texture2D(map, vUv)[ch]);\n\t}\n\n\tvec4 fitTexture(sampler2D src , vec2 uv, int fitType)\n\t{\n\t\t// fitTypeがcontainの場合だけ範囲外を透過する\n\t\tfloat a = fitType == 2 ? step(0.0, uv.x) * step(uv.x, 1.0) * step(0.0, uv.y) * step(uv.y, 1.0) : 1.;\n\t\treturn mix(vec4(0.), texture2D(src, uv), a);\n\t}\n\n#endif\n","vUv = uv;","precision highp float;\n\nvarying vec2 vUv;\nuniform vec2 resolution;\nuniform vec2 texelSize;\nuniform float aspectRatio;\nuniform vec2 maxAspect;","precision highp float;\n\nvarying vec2 vUv;\nuniform vec2 resolution;\nuniform vec2 texelSize;\nuniform float aspectRatio;\nuniform vec2 maxAspect;\nuniform int renderCount;","#ifdef USF_USE_MIXSRC\n\tvarying vec2 vMixSrcCoverUv;\n\tuniform vec2 mixSrc_fitScale;\n#endif","#ifdef USF_USE_MIXSRC\t\t\t\n\tvMixSrcCoverUv = calcSrcUv(vUv, mixSrc_fitScale);\t\n#endif","#ifdef USF_USE_MIXSRC\n\tvarying vec2 vMixSrcCoverUv;\n\tuniform sampler2D mixSrc_src;\n\tuniform int mixSrc_fit;\n\n\tuniform bool mixSrc_uv;\n\tuniform int mixSrc_uv_ch;\n\tuniform float mixSrc_uv_factor;\n\tuniform vec2 mixSrc_uv_offset;\n\tuniform float mixSrc_uv_radius;\n\tuniform vec2 mixSrc_uv_position;\n\tuniform vec2 mixSrc_uv_range;\n\tuniform bool mixSrc_uv_mixMap;\n\tuniform sampler2D mixSrc_uv_mixMap_src;\n\tuniform int mixSrc_uv_mixMap_ch;\n\n\tuniform bool mixSrc_color;\n\tuniform float mixSrc_color_factor;\n\tuniform float mixSrc_color_radius;\n\tuniform vec2 mixSrc_color_position;\n\tuniform vec2 mixSrc_color_range;\n\tuniform bool mixSrc_color_mixMap;\n\tuniform sampler2D mixSrc_color_mixMap_src;\n\tuniform int mixSrc_color_mixMap_ch;\n\n\tuniform bool mixSrc_alpha;\n\tuniform float mixSrc_alpha_factor;\n\tuniform float mixSrc_alpha_radius;\n\tuniform vec2 mixSrc_alpha_position;\n\tuniform vec2 mixSrc_alpha_range;\n\tuniform bool mixSrc_alpha_mixMap;\n\tuniform sampler2D mixSrc_alpha_mixMap_src;\n\tuniform int mixSrc_alpha_mixMap_ch;\n\n#endif","#ifdef USF_USE_MIXSRC\n\n\tvec4 mixSrcColor = fitTexture(mixSrc_src, vMixSrcCoverUv, mixSrc_fit);\n\n\tusf_Uv += mixSrc_uv \n\t\t? (mixSrc_uv_offset + (vec2(mixSrcColor[mixSrc_uv_ch]) * 2. - 1.)) * \n\t\t\t(mixSrc_uv_mixMap \n\t\t\t\t? calcMixMapPower(mixSrc_uv_mixMap_src,mixSrc_uv_range,mixSrc_uv_mixMap_ch)\n\t\t\t\t: calcMixCirclePower(mixSrc_uv_position,mixSrc_uv_radius,mixSrc_uv_range)) * mixSrc_uv_factor\n\t\t: vec2(0.);\n\n#endif","#ifdef USF_USE_MIXSRC\n\t// color\n\tusf_FragColor = mixSrc_color \n\t\t? mix(usf_FragColor, mixSrcColor,\n\t\t\t(mixSrc_color_mixMap\n\t\t\t\t? calcMixMapPower(mixSrc_color_mixMap_src,mixSrc_color_range,mixSrc_color_mixMap_ch)\n\t\t\t\t: calcMixCirclePower(mixSrc_color_position,mixSrc_color_radius,mixSrc_color_range)) * mixSrc_color_factor) \n\t\t: usf_FragColor;\n\t\n\t// alpha\n\tusf_FragColor = mixSrc_alpha \n\t\t? mix(usf_FragColor, mixSrcColor, \n\t\t\t(mixSrc_alpha_mixMap\n\t\t\t\t? calcMixMapPower(mixSrc_alpha_mixMap_src,mixSrc_alpha_range,mixSrc_alpha_mixMap_ch)\n\t\t\t\t: calcMixCirclePower(mixSrc_alpha_position,mixSrc_alpha_radius,mixSrc_alpha_range)) * mixSrc_alpha_factor * mixSrcColor.a)\n\t\t: usf_FragColor;\n\n#endif","#ifdef USF_USE_MIXDST\n\tvarying vec2 vMixDstCoverUv;\n\tuniform vec2 mixDst_fitScale;\n#endif","#ifdef USF_USE_MIXDST\t\t\n\tvMixDstCoverUv = calcSrcUv(vUv, mixDst_fitScale);\t\n#endif","#ifdef USF_USE_MIXDST\n\n\tvarying vec2 vMixDstCoverUv;\n\tuniform sampler2D mixDst_src;\n\tuniform int mixDst_fit;\n\t\n\tuniform bool mixDst_uv;\n\tuniform int mixDst_uv_ch;\n\tuniform float mixDst_uv_factor;\n\tuniform vec2 mixDst_uv_offset;\n\tuniform float mixDst_uv_radius;\n\tuniform vec2 mixDst_uv_position;\n\tuniform vec2 mixDst_uv_range;\n\tuniform bool mixDst_uv_mixMap;\n\tuniform sampler2D mixDst_uv_mixMap_src;\n\tuniform int mixDst_uv_mixMap_ch;\n\n\tuniform bool mixDst_color;\n\tuniform float mixDst_color_factor;\n\tuniform float mixDst_color_radius;\n\tuniform vec2 mixDst_color_position;\n\tuniform vec2 mixDst_color_range;\n\tuniform bool mixDst_color_mixMap;\n\tuniform sampler2D mixDst_color_mixMap_src;\n\tuniform int mixDst_color_mixMap_ch;\n\n\tuniform bool mixDst_alpha;\n\tuniform float mixDst_alpha_factor;\n\tuniform float mixDst_alpha_radius;\n\tuniform vec2 mixDst_alpha_position;\n\tuniform vec2 mixDst_alpha_range;\n\tuniform bool mixDst_alpha_mixMap;\n\tuniform sampler2D mixDst_alpha_mixMap_src;\n\tuniform int mixDst_alpha_mixMap_ch;\n\n#endif","#ifdef USF_USE_MIXDST\n\n\t// uv\n\tvec2 mixedUv = vMixDstCoverUv;\n\tmixedUv += mixDst_uv \n\t\t? (mixDst_uv_offset + (vec2(usf_FragColor[mixDst_uv_ch]) * 2. - 1.)) * \n\t\t\t(mixDst_uv_mixMap \n\t\t\t\t? calcMixMapPower(mixDst_uv_mixMap_src,mixDst_uv_range,mixDst_uv_mixMap_ch)\n\t\t\t\t: calcMixCirclePower(mixDst_uv_position,mixDst_uv_radius,mixDst_uv_range)) * mixDst_uv_factor\n\t\t: vec2(0.);\n\tvec4 mixDstColor = fitTexture(mixDst_src, mixedUv , mixDst_fit);\n\n\t// color\n\tusf_FragColor = mixDst_color \n\t\t? mix(usf_FragColor, mixDstColor,\n\t\t\t(mixDst_color_mixMap\n\t\t\t\t? calcMixMapPower(mixDst_color_mixMap_src,mixDst_color_range,mixDst_color_mixMap_ch)\n\t\t\t\t: calcMixCirclePower(mixDst_color_position,mixDst_color_radius,mixDst_color_range)) * mixDst_color_factor) \n\t\t: usf_FragColor;\n\n\t// alpha\n\tusf_FragColor = mixDst_alpha \n\t\t? mix(usf_FragColor, mixDstColor, \n\t\t\t(mixDst_alpha_mixMap\n\t\t\t\t? calcMixMapPower(mixDst_alpha_mixMap_src,mixDst_alpha_range,mixDst_alpha_mixMap_ch)\n\t\t\t\t: calcMixCirclePower(mixDst_alpha_position,mixDst_alpha_radius,mixDst_alpha_range)) * mixDst_alpha_factor * mixDstColor.a)\n\t\t: usf_FragColor;\n\n#endif\n\n","#ifdef USF_USE_TEXTURE\t\t\n\tvTextureCoverUv = calcSrcUv(vUv, texture_fitScale);\n#endif","#ifdef USF_USE_TEXTURE\n\tvarying vec2 vTextureCoverUv;\n\tuniform vec2 texture_fitScale;\n#endif","#ifdef USF_USE_TEXTURE\t\n\tvarying vec2 vTextureCoverUv;\n\tuniform sampler2D texture_src;\n\tuniform int texture_fit;\n\tuniform vec2 texture_fitScale;\n#endif","#ifdef USF_USE_LEVELS\n\tusf_FragColor = (usf_FragColor - vec4(levels_shadows)) / (vec4(levels_highlights) - vec4(levels_shadows));\n\tusf_FragColor = pow(usf_FragColor, vec4(1.0 / levels_midtones));\n\tusf_FragColor = usf_FragColor * (vec4(levels_outputMax) - vec4(levels_outputMin)) + vec4(levels_outputMin);\n#endif\n\n#ifdef USF_USE_CONTRAST\n\tusf_FragColor = clamp(((usf_FragColor-.5)*contrast_factor)+.5, 0., 1.);\n#endif\n\n#ifdef USF_USE_COLORBALANCE\n\tusf_FragColor.rgb = clamp(usf_FragColor.rgb * colorBalance_factor, 0., 1.);\n#endif\n\n#ifdef USF_USE_HSV\n\tvec3 hsv = rgb2hsv(usf_FragColor.rgb);\n\thsv.x = fract(hsv.x + hsv_hueShift);\n\thsv.y = clamp(hsv.y * hsv_saturation, 0.0, 1.0);\n\thsv.z = clamp(hsv.z * hsv_brightness, 0.0, 1.0);\n\tusf_FragColor.rgb = hsv2rgb(hsv);\n#endif\n\n#ifdef USF_USE_POSTERIZE\n\tusf_FragColor = posterize(usf_FragColor, posterize_levels);\n#endif\n\n#ifdef USF_USE_GRAYSCALE\n\tfloat grayscale = dot(usf_FragColor.rgb, vec3(0.299 + grayscale_weight.r, 0.587 + grayscale_weight.g, 0.114 + grayscale_weight.b));\n\tgrayscale = grayscale_threshold > 0.0 ? step(grayscale_threshold, grayscale) : grayscale;\n\tvec3 duotoneColor = mix(grayscale_duotone_color0, grayscale_duotone_color1, grayscale);\n\tusf_FragColor.rgb = grayscale_duotone ? duotoneColor : vec3(grayscale);\n#endif\n","#ifdef USF_USE_LEVELS\n\tuniform vec4 levels_shadows;\n\tuniform vec4 levels_midtones;\n\tuniform vec4 levels_highlights;\n\tuniform vec4 levels_outputMin;\n\tuniform vec4 levels_outputMax;\n#endif\n\n#ifdef USF_USE_CONTRAST\n\tuniform vec4 contrast_factor;\n#endif\n\n#ifdef USF_USE_COLORBALANCE\n\tuniform vec3 colorBalance_factor;\n#endif\n\n#ifdef USF_USE_HSV\n\tuniform float hsv_hueShift;\n\tuniform float hsv_saturation;\n\tuniform float hsv_brightness;\n\tvec3 hsv2rgb(vec3 c)\n\t{\n\t\tvec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);\n\t\tvec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);\n\t\treturn c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);\n\t}\n\tvec3 rgb2hsv(vec3 c)\n\t{\n\t\tvec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);\n\t\tvec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g));\n\t\tvec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r));\n\n\t\tfloat d = q.x - min(q.w, q.y);\n\t\tfloat e = 1.0e-10;\n\t\treturn vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);\n\t}\n#endif\n\n#ifdef USF_USE_POSTERIZE\n\tuniform vec4 posterize_levels;\n\tvec4 posterize(vec4 color, vec4 levels) \n\t{\n\t\treturn vec4(\n\t\t\tlevels.x > 1. ? floor(color.r * levels.x) / levels.x : color.r,\n\t\t\tlevels.y > 1. ? floor(color.g * levels.y) / levels.y : color.g,\n\t\t\tlevels.z > 1. ? floor(color.b * levels.z) / levels.z : color.b,\n\t\t\tlevels.w > 1. ? floor(color.a * levels.w) / levels.w : color.a\n\t\t);\n\t}\n#endif\n\n#ifdef USF_USE_GRAYSCALE\n\tuniform vec3 grayscale_weight;\n\tuniform bool grayscale_duotone;\n\tuniform vec3 grayscale_duotone_color0;\n\tuniform vec3 grayscale_duotone_color1;\n\tuniform float grayscale_threshold;\n#endif","vec2 calcSrcUv(vec2 uv, vec2 fitScale) {\n\treturn uv * fitScale + (1.0 - fitScale) * .5;\n}","import plane_vertex from \"./ShaderChunk/plane_vertex.glsl\";\nimport srcSystem_pars_vertex from \"./ShaderChunk/srcSystem_pars_vertex.glsl\";\nimport srcSystem_pars_fragment from \"./ShaderChunk/srcSystem_pars_fragment.glsl\";\nimport default_vertex from \"./ShaderChunk/default_vertex.glsl\";\nimport default_pars_vertex from \"./ShaderChunk/default_pars_vertex.glsl\";\nimport default_pars_fragment from \"./ShaderChunk/default_pars_fragment.glsl\";\nimport mixSrc_pars_vertex from \"./ShaderChunk/mixSrc_pars_vertex.glsl\";\nimport mixSrc_vertex from \"./ShaderChunk/mixSrc_vertex.glsl\";\nimport mixSrc_pars_fragment from \"./ShaderChunk/mixSrc_pars_fragment.glsl\";\nimport mixSrc_fragment_begin from \"./ShaderChunk/mixSrc_fragment_begin.glsl\";\nimport mixSrc_fragment_end from \"./ShaderChunk/mixSrc_fragment_end.glsl\";\nimport mixDst_pars_vertex from \"./ShaderChunk/mixDst_pars_vertex.glsl\";\nimport mixDst_vertex from \"./ShaderChunk/mixDst_vertex.glsl\";\nimport mixDst_pars_fragment from \"./ShaderChunk/mixDst_pars_fragment.glsl\";\nimport mixDst_fragment from \"./ShaderChunk/mixDst_fragment.glsl\";\nimport texture_vertex from \"./ShaderChunk/texture_vertex.glsl\";\nimport texture_pars_vertex from \"./ShaderChunk/texture_pars_vertex.glsl\";\nimport texture_pars_fragment from \"./ShaderChunk/texture_pars_fragment.glsl\";\nimport adjustments_fragment from \"./ShaderChunk/adjustments_fragment.glsl\";\nimport adjustments_pars_fragment from \"./ShaderChunk/adjustments_pars_fragment.glsl\";\nimport calcSrcUv from \"./ShaderChunk/calcSrcUv.glsl\";\n\nexport type ShaderChunkTypes =\n | \"default_pars_fragment\"\n | \"srcSystem_pars_vertex\"\n | \"srcSystem_pars_fragment\"\n | \"default_pars_vertex\"\n | \"default_vertex\"\n | \"plane_vertex\"\n | \"mixSrc_fragment_begin\"\n | \"mixSrc_fragment_end\"\n | \"mixSrc_pars_fragment\"\n | \"mixSrc_pars_vertex\"\n | \"mixSrc_vertex\"\n | \"mixDst_fragment\"\n | \"mixDst_pars_fragment\"\n | \"mixDst_pars_vertex\"\n | \"mixDst_vertex\"\n | \"texture_pars_fragment\"\n | \"texture_pars_vertex\"\n | \"texture_vertex\"\n | \"adjustments_fragment\"\n | \"adjustments_pars_fragment\"\n | \"calcSrcUv\";\n\nexport const ShaderChunk: { [K in ShaderChunkTypes]: string } = Object.freeze({\n plane_vertex,\n srcSystem_pars_vertex,\n srcSystem_pars_fragment,\n default_vertex,\n default_pars_vertex,\n default_pars_fragment,\n mixSrc_vertex,\n mixSrc_pars_vertex,\n mixSrc_pars_fragment,\n mixSrc_fragment_begin,\n mixSrc_fragment_end,\n mixDst_pars_vertex,\n mixDst_vertex,\n mixDst_pars_fragment,\n mixDst_fragment,\n texture_vertex,\n texture_pars_vertex,\n texture_pars_fragment,\n adjustments_fragment,\n adjustments_pars_fragment,\n calcSrcUv,\n});\n","import { ShaderLib } from \"./ShaderLib\";\nimport { ShaderChunk, ShaderChunkTypes } from \"./ShaderChunk\";\n\n/** merge shader codes */\nexport function mergeShaderCode(prefix: string[]): string {\n return prefix.filter((string) => string !== \"\").join(\"\\n\");\n}\n\n/*===============================================\nMEMO\n- SamplingFxMaterialをさらに拡張する場合（例えばuseTextureTransitionとかで、複数のtextureのfitScaleが必要な場合）、ここでShaderLibTypeを追加する。\n===============================================*/\n\nexport type ShaderLibType = \"default\" | \"basicFx\" | \"samplingFx\";\n/**\n * merge ShaderLib to shader\n * basicFx_fragment_begin, basicFx_fragment_endは含まない。これらは各FXでカスタマイズする必要があるため。\n */\nexport function mergeShaderLib(\n vertexShader: string | undefined,\n fragmentShader: string | undefined,\n type: ShaderLibType\n): [string | undefined, string | undefined] {\n let vertex,\n fragment = undefined;\n\n const ShaderLibs = {\n default: {\n vertexPars: ShaderLib.default_pars_vertex,\n vertexMain: ShaderLib.default_vertex,\n fragmentPars: ShaderLib.default_pars_fragment,\n },\n basicFx: {\n vertexPars: ShaderLib.basicFx_pars_vertex,\n vertexMain: ShaderLib.basicFx_vertex,\n fragmentPars: ShaderLib.basicFx_pars_fragment,\n },\n samplingFx: {\n vertexPars: mergeShaderCode([\n ShaderLib.basicFx_pars_vertex,\n ShaderLib.samplingFx_pars_vertex,\n ]),\n vertexMain: mergeShaderCode([\n ShaderLib.basicFx_vertex,\n ShaderLib.samplingFx_vertex,\n ]),\n fragmentPars: mergeShaderCode([\n ShaderLib.basicFx_pars_fragment,\n ShaderLib.samplingFx_pars_fragment,\n ]),\n },\n };\n\n const vertexPars = ShaderLibs[type].vertexPars;\n const vertexMain = ShaderLibs[type].vertexMain;\n const fragmentPars = ShaderLibs[type].fragmentPars;\n\n if (vertexShader) {\n vertex = mergeShaderCode([vertexPars, vertexShader]);\n vertex = vertex.replace(\n /void\\s+main\\s*\\(\\)\\s*\\{/,\n `void main() {\\n${vertexMain}`\n );\n }\n\n if (fragmentShader) {\n fragment = mergeShaderCode([fragmentPars, fragmentShader]);\n }\n\n return [vertex, fragment];\n}\n\nconst includePattern = /^[ \\t]*#usf +<([\\w\\d./]+)>/gm;\nfunction includeReplacer(match: string, include: ShaderChunkTypes): string {\n return resolveIncludes(ShaderChunk[include] || \"\");\n}\n/** Resolve Includes */\nexport function resolveIncludes(string: string): string {\n return string.replace(includePattern, includeReplacer);\n}\n","import * as THREE from \"three\";\nimport { warn } from \"../utils\";\nimport { THREE_FLAG_PROPS } from \"../libs/constants\";\n\nexport type Uniforms = { [uniform: string]: THREE.IUniform };\n\n/** typescriptトリックで{}を許容しているが、実際にuniformに渡る際にはbooleanのみ */\nexport type UniformParentKey = boolean | {};\n\nexport type ShaderWithUniforms = {\n uniforms?: Uniforms;\n vertexShader?: string;\n fragmentShader?: string;\n};\n\n/**\n * test:{value:number} => test:number\n * materialのprops型を定義する\n * materialにはuniformsのsetter/getterが定義されている.その型推論のため.\n */\nexport type ExtractUniformValues = {\n [K in keyof T]?: T[K] extends { value: infer U } ? U : never;\n};\n\n/**\n * test_test:{value:number} => { test: { test: number | (value:number)=>number } }\n */\ntype Nest = K extends `${infer First}_${infer Rest}`\n ? { [P in First]?: Nest }\n : { [P in K]?: V | ((value: V) => V) };\n\ntype UnionToIntersection = (U extends any ? (k: U) => void : never) extends (\n k: infer I\n) => void\n ? I\n : never;\nexport type NestUniformValues = UnionToIntersection<\n { [K in keyof U]: Nest, U[K][\"value\"]> }[keyof U]\n>;\n\n/**\n * Determines whether the given property is a three.js object by checking for the presence\n * of known boolean flag properties (e.g., `isTexture`, `isVector2`, etc.) that are typically\n * set to true on three.js instances.\n */\nfunction isTHREE(property: any) {\n return property && THREE_FLAG_PROPS.some((prop) => property[prop] === true);\n}\n\n/**\n * {test:{test:1}} => {test_test:1} に変換する\n * この時、条件分岐用uniform値として親のkey{test:true}を追加する\n */\nexport function flattenUniformValues(\n obj: Record\n): Record {\n const flatObject: Record = {};\n\n const flatten = (currentObj: any, parentKey = \"\"): void => {\n for (const [key, val] of Object.entries(currentObj)) {\n const newKey = parentKey ? `${parentKey}_${key}` : key;\n if (\n val &&\n typeof val === \"object\" &&\n !Array.isArray(val) &&\n !isTHREE(val)\n ) {\n (flatObject[newKey] as UniformParentKey) = true; // 親のkey{test:true}を追加する\n flatten(val, newKey);\n } else {\n if (flatObject.hasOwnProperty(newKey)) {\n warn(`${newKey} already exists and will be overwritten.`);\n }\n flatObject[newKey] = val;\n }\n }\n };\n\n flatten(obj);\n return flatObject;\n}\n","import * as THREE from \"three\";\nimport { resolveIncludes, mergeShaderLib } from \"../../shaders/shaderUtils\";\nimport {\n flattenUniformValues,\n ShaderWithUniforms,\n} from \"../../shaders/uniformsUtils\";\nimport { warn } from \"../../utils\";\n\nexport type DefaultUniforms = {\n resolution: { value: THREE.Vector2 };\n texelSize: { value: THREE.Vector2 };\n aspectRatio: { value: number };\n maxAspect: { value: THREE.Vector2 };\n renderCount: { value: number };\n};\n\nexport type FxMaterialProps = {\n uniformValues?: T;\n materialParameters?: THREE.ShaderMaterialParameters;\n customParameters?: { [key: string]: any };\n} & ShaderWithUniforms;\n\nexport class FxMaterial extends THREE.ShaderMaterial {\n public static readonly key: string = THREE.MathUtils.generateUUID();\n\n constructor({\n uniformValues,\n materialParameters = {},\n uniforms,\n vertexShader,\n fragmentShader,\n }: FxMaterialProps = {}) {\n super(materialParameters);\n\n this.uniforms = {\n resolution: { value: new THREE.Vector2() },\n texelSize: { value: new THREE.Vector2() },\n aspectRatio: { value: 0 },\n maxAspect: { value: new THREE.Vector2() },\n // 一部のFXでiterationをカウントする必要があるため\n renderCount: { value: 0 },\n ...uniforms,\n } as DefaultUniforms;\n\n this._setupShaders(vertexShader, fragmentShader);\n\n this.setUniformValues(uniformValues);\n\n this._defineUniformAccessors();\n }\n\n /** This is updated in useFxScene */\n public updateResolution(width: number, height: number) {\n const maxAspect = Math.max(width, height);\n this.uniforms.resolution.value.set(width, height);\n this.uniforms.texelSize.value.set(1 / width, 1 / height);\n this.uniforms.aspectRatio.value = width / height;\n this.uniforms.maxAspect.value.set(maxAspect / width, maxAspect / height);\n }\n\n protected _setupShaders(vertexShader?: string, fragmentShader?: string) {\n if (!vertexShader && !fragmentShader) return;\n\n const [vertex, fragment] = mergeShaderLib(\n vertexShader,\n fragmentShader,\n \"default\"\n );\n this.vertexShader = vertex ? resolveIncludes(vertex) : this.vertexShader;\n this.fragmentShader = fragment\n ? resolveIncludes(fragment)\n : this.fragmentShader;\n }\n\n public setUniformValues(values?: { [key: string]: any }) {\n if (values === undefined) return;\n const flattenedValues = flattenUniformValues(values);\n\n for (const [key, value] of Object.entries(flattenedValues)) {\n if (value === undefined) {\n warn(`parameter '${key}' has value of undefined.`);\n continue;\n }\n\n const curretUniform = this.uniforms[key];\n\n if (curretUniform === undefined) {\n warn(`'${key}' is not a uniform property of ${this.type}.`);\n continue;\n }\n\n curretUniform.value =\n typeof value === \"function\" ? value(curretUniform.value) : value;\n }\n\n return flattenedValues;\n }\n\n /** define getter/setters　*/\n protected _defineUniformAccessors(onSet?: () => void) {\n for (const key of Object.keys(this.uniforms)) {\n if (this.hasOwnProperty(key)) {\n warn(`'${key}' is already defined in ${this.type}.`);\n continue;\n }\n Object.defineProperty(this, key, {\n get: () => this.uniforms[key].value,\n set: (v) => {\n this.uniforms[key].value = v;\n onSet?.();\n },\n });\n }\n }\n}\n","import * as THREE from \"three\";\nimport { FxMaterial, FxMaterialProps } from \"./FxMaterial\";\nimport { mergeShaderLib } from \"../../shaders/shaderUtils\";\nimport * as BasicFxLib from \"./BasicFxLib\";\n\nexport class BasicFxMaterial extends FxMaterial {\n fxKey: BasicFxLib.FxKey;\n\n uniforms!: BasicFxLib.BasicFxUniforms;\n programCache: number;\n\n constructor({\n uniforms,\n vertexShader,\n fragmentShader,\n ...rest\n }: FxMaterialProps = {}) {\n super({\n ...rest,\n uniforms: {\n ...THREE.UniformsUtils.clone(BasicFxLib.BASICFX_VALUES),\n ...uniforms,\n },\n });\n\n this.defines = {\n ...rest?.materialParameters?.defines,\n };\n\n this.programCache = 0;\n\n this.fxKey = this._setupFxKey(this.uniforms);\n\n this._setupFxShaders(vertexShader, fragmentShader);\n }\n\n private _setupFxShaders(vertexShader?: string, fragmentShader?: string) {\n if (!vertexShader && !fragmentShader) return;\n\n this._updateFxDefines();\n\n const [vertex, fragment] = this._handleMergeShaderLib(\n vertexShader,\n fragmentShader\n );\n\n super._setupShaders(vertex, fragment);\n }\n\n /** SamplingFxMaterialで継承するため、handlerとして独立させる */\n protected _handleMergeShaderLib(\n vertexShader?: string,\n fragmentShader?: string\n ) {\n return mergeShaderLib(vertexShader, fragmentShader, \"basicFx\");\n }\n\n private _updateFxShaders() {\n // FxMaterialの初期化時にsetUniformValuesが呼ばれるが、isContainsBasicFxValuesがtrueを返すと、このメソッドが実行されてしまう。BasicFxMaterialの初期化前にはこの処理をスキップする。\n if (!this.fxKey) return;\n\n const _cache = this.programCache;\n\n const { diffCount, newFxKey } = this._handleUpdateFxShaders();\n\n this.programCache += diffCount;\n this.fxKey = newFxKey;\n\n if (_cache !== this.programCache) {\n this._updateFxDefines();\n this.needsUpdate = true;\n }\n }\n\n /** SamplingFxMaterialで継承するため、handlerとして独立させる */\n protected _handleUpdateFxShaders(): {\n diffCount: number;\n newFxKey: BasicFxLib.FxKey;\n } {\n const newFxKey = BasicFxLib.getFxKeyFromUniforms(this.uniforms);\n const diffCount = (\n Object.keys(newFxKey) as (keyof BasicFxLib.FxKey)[]\n ).filter((key) => this.fxKey[key] !== newFxKey[key]).length;\n return {\n diffCount,\n newFxKey,\n };\n }\n\n private _updateFxDefines() {\n Object.assign(this.defines, this._handleUpdateFxDefines());\n }\n\n /** SamplingFxMaterialで継承するため、handlerとして独立させる */\n protected _handleUpdateFxDefines(): {\n [key: string]: any;\n } {\n return BasicFxLib.handleUpdateFxDefines(this.fxKey);\n }\n\n protected _isContainsBasicFxValues(\n target?: { [key: string]: any },\n source?: { [key: string]: any }\n ): boolean {\n if (!target) return false;\n return Object.keys(target).some((key) =>\n Object.keys(source ?? BasicFxLib.BASICFX_VALUES).includes(key)\n );\n }\n\n protected _setupFxKey(\n uniforms: BasicFxLib.BasicFxUniforms\n ): BasicFxLib.FxKey {\n return BasicFxLib.getFxKeyFromUniforms(uniforms);\n }\n\n /*===============================================\n\tFit Scale\n\t===============================================*/\n private _calcFitScale(\n src: THREE.Texture,\n fitType: BasicFxLib.FitType\n ): THREE.Vector2 {\n let srcAspectRatio = 1;\n const fitScale = new THREE.Vector2(1, 1);\n const baseAspectRatio = this.uniforms.aspectRatio.value;\n\n const sourceData = src?.source?.data;\n\n if (sourceData?.width && sourceData?.height) {\n srcAspectRatio = sourceData.width / sourceData.height;\n } else {\n srcAspectRatio = baseAspectRatio;\n }\n\n if (fitType === 1) {\n fitScale.set(\n Math.min(baseAspectRatio / srcAspectRatio, 1),\n Math.min(srcAspectRatio / baseAspectRatio, 1)\n );\n } else if (fitType === 2) {\n fitScale.set(\n Math.max(baseAspectRatio / srcAspectRatio, 1),\n Math.max(srcAspectRatio / baseAspectRatio, 1)\n );\n }\n\n return fitScale;\n }\n\n protected _setFitScale(key: BasicFxLib.SrcSystemKey) {\n const uniforms = this.uniforms as any;\n uniforms[`${key}_fitScale`].value = this._calcFitScale(\n uniforms[`${key}_src`].value,\n uniforms[`${key}_fit`].value\n );\n }\n\n protected _updateFitScale() {\n if (this.fxKey?.mixSrc) this._setFitScale(\"mixSrc\");\n if (this.fxKey?.mixDst) this._setFitScale(\"mixDst\");\n }\n\n /*===============================================\n\tsuper FxMaterial\n\t===============================================*/\n /**\n * @param needsUpdate default : `true`\n */\n public setUniformValues(\n values?: { [key: string]: any },\n needsUpdate: boolean = true\n ) {\n const flattenedValues = super.setUniformValues(values);\n if (needsUpdate && this._isContainsBasicFxValues(flattenedValues)) {\n this._updateFxShaders();\n this._updateFitScale();\n }\n return flattenedValues;\n }\n\n protected _defineUniformAccessors(onSet?: () => void) {\n super._defineUniformAccessors(() => {\n this._updateFxShaders();\n this._updateFitScale();\n onSet?.();\n });\n }\n\n public updateResolution(width: number, height: number): void {\n super.updateResolution(width, height);\n this._updateFitScale();\n }\n}\n","import * as THREE from \"three\";\nimport { noiseFragment, noiseVertex } from \"./noise.glsl\";\nimport { BasicFxMaterial } from \"../../core/BasicFxMaterial\";\nimport { FxMaterialProps } from \"../../core/FxMaterial\";\nimport { BasicFxUniforms, BasicFxValues } from \"../../core/BasicFxLib\";\nimport {\n ExtractUniformValues,\n NestUniformValues,\n} from \"../../../shaders/uniformsUtils\";\n\ntype NoiseUniforms = {\n /** useBeatを渡せば、リズムを変えられる。 */\n tick: { value: number };\n /** noise scale , default : `0.004` */\n scale: { value: number };\n /** time factor default : `0.3` */\n timeStrength: { value: number };\n /** noiseOctaves, affects performance default : `2` */\n noiseOctaves: { value: number };\n /** fbmOctaves, affects performance default : `2` */\n fbmOctaves: { value: number };\n /** domain warping octaves , affects performance default : `2` */\n warpOctaves: { value: number };\n /** direction of domain warping , default : `(2.0,2,0)` */\n warpDirection: { value: THREE.Vector2 };\n /** strength of domain warping , default : `8.0` */\n warpStrength: { value: number };\n /** offset of the time */\n timeOffset: { value: number };\n} & BasicFxUniforms;\n\nexport type NoiseValues = NestUniformValues & BasicFxValues;\n\nexport type NoiseMaterialProps = ExtractUniformValues;\n\nexport class NoiseMaterial extends BasicFxMaterial {\n public static readonly key: string = THREE.MathUtils.generateUUID();\n\n static get type() {\n return \"NoiseMaterial\";\n }\n\n uniforms!: NoiseUniforms;\n\n constructor(props: FxMaterialProps = {}) {\n super({\n ...props,\n vertexShader: noiseVertex,\n fragmentShader: noiseFragment,\n uniforms: {\n tick: { value: 0.0 },\n scale: { value: 0.03 },\n timeStrength: { value: 0.3 },\n noiseOctaves: { value: 2 },\n fbmOctaves: { value: 2 },\n warpOctaves: { value: 2 },\n warpDirection: { value: new THREE.Vector2(2.0, 2.0) },\n warpStrength: { value: 8 },\n timeOffset: { value: 0 },\n } as NoiseUniforms,\n });\n this.type = NoiseMaterial.type;\n }\n}\n","const boxVarying = `\n\tuniform bool bounce;\n\tvarying vec2 vL;\n\tvarying vec2 vR;\n\tvarying vec2 vT;\n\tvarying vec2 vB;\n`;\n\nconst getPosition = (bounce: boolean = true) => {\n return `\n\t\tvec3 pos = position;\n\t\tvec2 scale = ${\n bounce ? \"bounce ? vec2(1.,1.) : 1.-texelSize*2.\" : \"1.-texelSize*2.\"\n };\n\t\tpos.xy = pos.xy * scale;\n\t\tvUv = vec2(.5)+(pos.xy)*.5;\n\t`;\n};\n\nconst getBoxCompute = (diff: string) => {\n return `\n\t\tvL = vUv - vec2(texelSize.x * ${diff}, 0.0);\n\t\tvR = vUv + vec2(texelSize.x * ${diff}, 0.0);\n\t\tvT = vUv + vec2(0.0, texelSize.y * ${diff});\n\t\tvB = vUv - vec2(0.0, texelSize.y * ${diff});\n\t`;\n};\n\nconst vertex = {\n main: `\n\t\t${boxVarying}\n\n\t\tvoid main(){\n\t\t\n\t\t\t${getPosition()}\n\t\t\t${getBoxCompute(\"1.\")}\n\n\t\t\tgl_Position = vec4(pos, 1.0);\n\t\t}\n\t`,\n poisson: `\n\t\t${boxVarying}\n\t\t\n\t\tvoid main(){\n\n\t\t\t${getPosition()}\n\t\t\t${getBoxCompute(\"2.\")}\n\n\t\t\tgl_Position = vec4(pos, 1.0);\n\t\t}\n\t`,\n advection: `\n\t\tvoid main(){\n\t\t\t${getPosition(false)}\n\t\t\tgl_Position = vec4(pos, 1.0);\n\t\t}\n\t`,\n splat: `\n\t\tuniform vec2 center;\n\t\tuniform vec2 radius;\n\t\tvoid main(){\t\t\n\t\t\tvec2 pos = position.xy * radius * 2.0 * texelSize + center;\n\t\t\tgl_Position = vec4(pos, 0.0, 1.0);\n\t\t}\n\t`,\n};\n\nexport default vertex;\n","uniform float deltaTime;\nuniform sampler2D velocity;\nuniform float dissipation;\n\nvoid main(){\n\tvec2 vel = texture2D(velocity, vUv).xy;\n\tvec2 uv2 = vUv - vel * deltaTime * maxAspect;\n\tvec2 newVel = texture2D(velocity, uv2).xy;\n\tgl_FragColor = vec4(dissipation * newVel, 0.0, 0.0);\n}","import * as THREE from \"three\";\nimport vertex from \"./shaders/vertex\";\nimport fragment from \"./shaders/advection.frag\";\nimport {\n FxMaterial,\n FxMaterialProps,\n} from \"../../../materials/core/FxMaterial\";\nimport { DEFAULT_TEXTURE } from \"../../../libs/constants\";\nimport { DELTA_TIME } from \".\";\nimport { NestUniformValues } from \"../../../shaders/uniformsUtils\";\n\ntype AdvectionUniforms = {\n dissipation: { value: number };\n deltaTime: { value: number };\n velocity: { value: THREE.Texture };\n};\n\nexport type AdvectionValues = NestUniformValues;\nexport type AdvectionValuesClient = Omit;\n\nexport class AdvectionMaterial extends FxMaterial {\n static get type() {\n return \"AdvectionMaterial\";\n }\n\n uniforms!: AdvectionUniforms;\n\n constructor(props: FxMaterialProps) {\n super({\n ...props,\n vertexShader: vertex.advection,\n fragmentShader: fragment,\n uniforms: {\n dissipation: { value: 0.99 },\n velocity: { value: DEFAULT_TEXTURE },\n deltaTime: { value: DELTA_TIME },\n } as AdvectionUniforms,\n });\n this.type = AdvectionMaterial.type;\n }\n}\n","uniform float deltaTime;\nuniform sampler2D velocity;\n\nvarying vec2 vL;\nvarying vec2 vR;\nvarying vec2 vT;\nvarying vec2 vB;\n\nvoid main(){\n float L = texture2D(velocity, vL).r;\n float R = texture2D(velocity, vR).r;\n float B = texture2D(velocity, vB).g;\n float T = texture2D(velocity, vT).g;\n\t \n float divergence = (R-L + T-B) / 2.0;\n gl_FragColor = vec4(divergence / deltaTime);\n}\n","import * as THREE from \"three\";\nimport vertex from \"./shaders/vertex\";\nimport fragment from \"./shaders/divergence.frag\";\nimport {\n FxMaterial,\n FxMaterialProps,\n} from \"../../../materials/core/FxMaterial\";\nimport { DEFAULT_TEXTURE } from \"../../../libs/constants\";\nimport { DELTA_TIME } from \".\";\nimport { NestUniformValues } from \"../../../shaders/uniformsUtils\";\n\ntype DivergenceUniforms = {\n bounce: { value: boolean };\n deltaTime: { value: number };\n velocity: { value: THREE.Texture };\n};\n\nexport type DivergenceValues = NestUniformValues;\nexport type DivergenceValuesClient = Omit;\n\nexport class DivergenceMaterial extends FxMaterial {\n static get type() {\n return \"DivergenceMaterial\";\n }\n\n uniforms!: DivergenceUniforms;\n\n constructor(props: FxMaterialProps) {\n super({\n ...props,\n vertexShader: vertex.main,\n fragmentShader: fragment,\n uniforms: {\n bounce: { value: true },\n velocity: { value: DEFAULT_TEXTURE },\n deltaTime: { value: DELTA_TIME },\n } as DivergenceUniforms,\n });\n\n this.type = DivergenceMaterial.type;\n }\n}\n","uniform float deltaTime;\nuniform sampler2D pressure;\nuniform sampler2D velocity;\n\nvarying vec2 vL;\nvarying vec2 vR;\nvarying vec2 vT;\nvarying vec2 vB;\n\nvoid main(){\n\n\tfloat L = texture2D(pressure, vL).r;\n\tfloat R = texture2D(pressure, vR).r;\n\tfloat B = texture2D(pressure, vB).r;\n\tfloat T = texture2D(pressure, vT).r;\n\n\tvec2 v = texture2D(velocity, vUv).xy;\n\tvec2 gradP = vec2(R - L, T - B) * 0.5;\n\tv = v - gradP * deltaTime;\n\n\tgl_FragColor = vec4(v, 0.0, 1.0);\n\n}","import * as THREE from \"three\";\nimport vertex from \"./shaders/vertex\";\nimport fragment from \"./shaders/pressure.frag\";\nimport {\n FxMaterial,\n FxMaterialProps,\n} from \"../../../materials/core/FxMaterial\";\nimport { DEFAULT_TEXTURE } from \"../../../libs/constants\";\nimport { DELTA_TIME } from \".\";\nimport { NestUniformValues } from \"../../../shaders/uniformsUtils\";\n\ntype PressureUniforms = {\n bounce: { value: boolean };\n deltaTime: { value: number };\n pressure: { value: THREE.Texture };\n velocity: { value: THREE.Texture };\n};\n\nexport type PressureValues = NestUniformValues;\nexport type PressureValuesClient = Omit<\n PressureValues,\n \"velocity\" | \"pressure\"\n>;\n\nexport class PressureMaterial extends FxMaterial {\n static get type() {\n return \"PressureMaterial\";\n }\n\n uniforms!: PressureUniforms;\n\n constructor(props: FxMaterialProps) {\n super({\n ...props,\n vertexShader: vertex.main,\n fragmentShader: fragment,\n uniforms: {\n bounce: { value: true },\n deltaTime: { value: DELTA_TIME },\n pressure: { value: DEFAULT_TEXTURE },\n velocity: { value: DEFAULT_TEXTURE },\n } as PressureUniforms,\n });\n\n this.type = PressureMaterial.type;\n }\n}\n","uniform sampler2D pressure;\nuniform sampler2D divergence;\n\nvarying vec2 vL;\nvarying vec2 vR;\nvarying vec2 vT;\nvarying vec2 vB;\n\nvoid main(){ \n\n\tfloat L = texture2D(pressure, vL).r;\n\tfloat R = texture2D(pressure, vR).r;\n\tfloat B = texture2D(pressure, vB).r;\n\tfloat T = texture2D(pressure, vT).r;\n\n\tfloat div = texture2D(divergence, vUv).r;\n\t\n\tfloat newP = (L + R + B + T) / 4.0 - div;\n\n\tgl_FragColor = vec4(newP);\n}\n","import * as THREE from \"three\";\nimport vertex from \"./shaders/vertex\";\nimport fragment from \"./shaders/poisson.frag\";\nimport {\n FxMaterial,\n FxMaterialProps,\n} from \"../../../materials/core/FxMaterial\";\nimport { DEFAULT_TEXTURE } from \"../../../libs/constants\";\nimport { NestUniformValues } from \"../../../shaders/uniformsUtils\";\n\ntype PoissonUniforms = {\n bounce: { value: boolean };\n pressure: { value: THREE.Texture };\n divergence: { value: THREE.Texture };\n};\n\nexport type PoissonValues = NestUniformValues;\nexport type PoissonValuesClient = Omit<\n PoissonValues,\n \"pressure\" | \"divergence\"\n>;\n\nexport class PoissonMaterial extends FxMaterial {\n static get type() {\n return \"PoissonMaterial\";\n }\n\n uniforms!: PoissonUniforms;\n\n iterations: number;\n\n constructor({ customParameters, ...rest }: FxMaterialProps) {\n super({\n ...rest,\n vertexShader: vertex.poisson,\n fragmentShader: fragment,\n uniforms: {\n bounce: { value: true },\n pressure: { value: DEFAULT_TEXTURE },\n divergence: { value: DEFAULT_TEXTURE },\n } as PoissonUniforms,\n });\n this.iterations = customParameters?.iterations ?? 32;\n this.type = PoissonMaterial.type;\n }\n}\n","uniform vec2 force;\nuniform float forceBias;\n\nvoid main(){\n\tgl_FragColor = vec4(force * forceBias * pow(1.0 - clamp(2.0 * distance(vUv, vec2(0.5)), 0.0, 1.0), 2.0), 0.0, 1.0);\n}","import * as THREE from \"three\";\nimport vertex from \"./shaders/vertex\";\nimport fragment from \"./shaders/splat.frag\";\nimport {\n FxMaterial,\n FxMaterialProps,\n} from \"../../../materials/core/FxMaterial\";\nimport { NestUniformValues } from \"../../../shaders/uniformsUtils\";\n\ntype SplatUniforms = {\n forceBias: { value: number };\n radius: { value: THREE.Vector2 };\n force: { value: THREE.Vector2 };\n center: { value: THREE.Vector2 };\n};\n\nexport type SplatValues = NestUniformValues;\nexport type SplatValuesClient = Omit;\n\nexport class SplatMaterial extends FxMaterial {\n static get type() {\n return \"SplatMaterial\";\n }\n\n uniforms!: SplatUniforms;\n\n constructor(props: FxMaterialProps) {\n super({\n ...props,\n vertexShader: vertex.splat,\n fragmentShader: fragment,\n uniforms: {\n forceBias: { value: 20 },\n radius: { value: new THREE.Vector2(50, 50) },\n force: { value: new THREE.Vector2(0, 0) },\n center: { value: new THREE.Vector2(0, 0) },\n } as SplatUniforms,\n });\n\n this.type = SplatMaterial.type;\n\n this.blending = THREE.AdditiveBlending;\n }\n}\n","import * as THREE from \"three\";\nimport { FxMaterialProps } from \"../../core/FxMaterial\";\nimport { BasicFxUniforms, BasicFxValues } from \"../../core/BasicFxLib\";\nimport { BasicFxMaterial } from \"../../core/BasicFxMaterial\";\nimport { NestUniformValues } from \"../../../shaders/uniformsUtils\";\nimport { DEFAULT_TEXTURE } from \"../../../libs/constants\";\nimport { ShaderLib } from \"../../../shaders/ShaderLib\";\n\ntype OutputUniforms = {\n src: { value: THREE.Texture };\n} & BasicFxUniforms;\n\nexport type OutputValues = NestUniformValues & BasicFxValues;\n\nexport class OutputMaterial extends BasicFxMaterial {\n static get type() {\n return \"OutputMaterial\";\n }\n\n uniforms!: OutputUniforms;\n\n constructor(props: FxMaterialProps = {}) {\n super({\n ...props,\n vertexShader: `\n\t\t\t\tvoid main() {\n\t\t\t\t\t${ShaderLib.plane_vertex}\n\t\t\t\t}\n\t\t\t`,\n fragmentShader: `\n\t\t\t\tuniform sampler2D src;\n\t\t\t\tvoid main() {\n\t\t\t\t\tvec2 usf_Uv = vUv;\n\t\t\t\t\t\n\t\t\t\t\t${ShaderLib.basicFx_fragment_begin}\n\n\t\t\t\t\tvec4 usf_FragColor = vec4(length(texture2D(src,usf_Uv).rg));\n\n\t\t\t\t\t${ShaderLib.basicFx_fragment_end}\n\n\t\t\t\t\tgl_FragColor = usf_FragColor;\n\t\t\t\t}\n\t\t\t`,\n uniforms: {\n src: { value: DEFAULT_TEXTURE },\n },\n });\n this.type = OutputMaterial.type;\n }\n}\n","export * from \"./AdvectionMaterial\";\nexport * from \"./DivergenceMaterial\";\nexport * from \"./PressureMaterial\";\nexport * from \"./PoissonMaterial\";\nexport * from \"./SplatMaterial\";\nexport * from \"./OutputMaterial\";\n\nexport const DELTA_TIME = 0.008;\n","import * as THREE from \"three\";\nimport { FxMaterialProps } from \"./FxMaterial\";\nimport {\n NestUniformValues,\n UniformParentKey,\n} from \"../../shaders/uniformsUtils\";\nimport { mergeShaderLib } from \"../../shaders/shaderUtils\";\nimport { BasicFxMaterial } from \"./BasicFxMaterial\";\nimport * as BasicFxLib from \"./BasicFxLib\";\nimport { DEFAULT_TEXTURE } from \"../../libs/constants\";\n\n/*===============================================\ntypes\n===============================================*/\ntype SamplingFxUniformsUnique = {\n texture: { value: UniformParentKey };\n texture_src: { value: THREE.Texture };\n texture_fit: { value: BasicFxLib.FitType };\n};\ntype SamplingFxUniformsFitScale = {\n texture_fitScale: { value: THREE.Vector2 };\n};\nexport type SamplingFxUniforms = SamplingFxUniformsUnique &\n BasicFxLib.BasicFxUniforms;\nexport type SamplingFxValues = NestUniformValues;\n\n/*===============================================\nconstants\n===============================================*/\nconst SAMPLINGFX_VALUES: SamplingFxUniformsUnique & SamplingFxUniformsFitScale =\n {\n texture: { value: true },\n texture_src: { value: DEFAULT_TEXTURE },\n texture_fit: { value: 0 },\n texture_fitScale: { value: new THREE.Vector2(1, 1) },\n };\n\n/**\n * SamplingFxMaterialでは常にtextureはtrueであるはずなので、BasicFxMaterialを継承して、srcSystemは常にtrueになるように、継承する\n */\nexport class SamplingFxMaterial extends BasicFxMaterial {\n uniforms!: SamplingFxUniforms;\n\n constructor({ uniforms, ...rest }: FxMaterialProps) {\n super({\n ...rest,\n uniforms: {\n ...THREE.UniformsUtils.clone(SAMPLINGFX_VALUES),\n ...uniforms,\n },\n });\n }\n\n protected _handleMergeShaderLib(\n vertexShader?: string,\n fragmentShader?: string\n ) {\n return mergeShaderLib(vertexShader, fragmentShader, \"samplingFx\");\n }\n\n protected _isContainsBasicFxValues(values?: {\n [key: string]: any;\n }): boolean {\n return super._isContainsBasicFxValues(values, {\n ...BasicFxLib.BASICFX_VALUES,\n ...SAMPLINGFX_VALUES,\n });\n }\n\n protected _updateFitScale() {\n super._updateFitScale();\n this._setFitScale(\"texture\");\n }\n\n protected _setupFxKey(\n uniforms: BasicFxLib.BasicFxUniforms\n ): BasicFxLib.FxKey {\n const key = super._setupFxKey(uniforms);\n key.srcSystem = true;\n return key;\n }\n\n protected _handleUpdateFxShaders(): {\n diffCount: number;\n newFxKey: BasicFxLib.FxKey;\n } {\n const { diffCount, newFxKey } = super._handleUpdateFxShaders();\n newFxKey.srcSystem = true;\n return {\n diffCount,\n newFxKey,\n };\n }\n\n protected _handleUpdateFxDefines(): {\n [key: string]: any;\n } {\n return Object.assign(super._handleUpdateFxDefines(), {\n USF_USE_TEXTURE: true,\n });\n }\n}\n","import * as THREE from \"three\";\nimport {\n SamplingFxUniforms,\n SamplingFxValues,\n SamplingFxMaterial,\n} from \"../../core/SamplingFxMaterial\";\nimport { FxMaterialProps } from \"../../core/FxMaterial\";\nimport {\n ExtractUniformValues,\n NestUniformValues,\n} from \"../../../shaders/uniformsUtils\";\nimport { ShaderLib } from \"../../../shaders/ShaderLib\";\n\n/*===============================================\nmemo\n\n- BufferMaterialはMaterialをそのまま、r3fでextendしてコンポーネントとして使うケースが考えられる\nので、keyを持たせる\n- また、globalで型定義する\n===============================================*/\n\ntype BufferUniforms = SamplingFxUniforms;\n\nexport type BufferValues = NestUniformValues & SamplingFxValues;\n\nexport type BufferMaterialProps = ExtractUniformValues;\n\nexport class BufferMaterial extends SamplingFxMaterial {\n public static readonly key: string = THREE.MathUtils.generateUUID();\n\n static get type() {\n return \"BufferMaterial\";\n }\n\n uniforms!: BufferUniforms;\n\n constructor(props: FxMaterialProps = {}) {\n super({\n ...props,\n vertexShader: `\n\t\t\t\tvoid main() {\n\t\t\t\t\t${ShaderLib.plane_vertex}\n\t\t\t\t}\n\t\t\t`,\n fragmentShader: `\n\t\t\t\tvoid main() {\n\t\t\t\t\tvec2 usf_Uv = vTextureCoverUv;\n\n\t\t\t\t\t${ShaderLib.basicFx_fragment_begin}\n\n\t\t\t\t\tvec4 usf_FragColor = fitTexture(texture_src,usf_Uv,texture_fit);\n\n\t\t\t\t\t${ShaderLib.basicFx_fragment_end}\n\n\t\t\t\t\tgl_FragColor = usf_FragColor;\n\t\t\t\t}\n\t\t\t`,\n });\n\n this.type = BufferMaterial.type;\n }\n}\n\ndeclare global {\n namespace JSX {\n interface IntrinsicElements {\n bufferMaterial: BufferMaterialProps & {\n ref?: React.RefObject;\n key?: React.Key;\n };\n }\n }\n}\n","import { FxMaterial, FxMaterialProps } from \"../../core/FxMaterial\";\n\nexport class RawBlankMaterial extends FxMaterial {\n static get type() {\n return \"RawBlankMaterial\";\n }\n constructor(props: FxMaterialProps) {\n super(props);\n this.type = RawBlankMaterial.type;\n }\n}\n","import * as THREE from \"three\";\nimport {\n DefaultUniforms,\n FxMaterial,\n FxMaterialProps,\n} from \"../../core/FxMaterial\";\nimport { mergeShaderCode } from \"../../../shaders/shaderUtils\";\n\ntype BlankUniforms = {\n time: { value: number };\n pointer: { value: THREE.Vector2 };\n backbuffer: { value: THREE.Texture };\n} & DefaultUniforms;\n\nconst SHADER_PARS = `\n\tuniform float time;\n\tuniform vec2 pointer;\n\tuniform sampler2D backbuffer;\n`;\n\nexport class BlankMaterial extends FxMaterial {\n static get type() {\n return \"BlankMaterial\";\n }\n\n uniforms!: BlankUniforms;\n\n constructor({\n vertexShader,\n fragmentShader,\n uniforms,\n ...rest\n }: FxMaterialProps) {\n super({\n ...rest,\n vertexShader:\n vertexShader && mergeShaderCode([SHADER_PARS, vertexShader]),\n fragmentShader:\n fragmentShader && mergeShaderCode([SHADER_PARS, fragmentShader]),\n uniforms: {\n time: { value: 0.0 },\n pointer: { value: new THREE.Vector2() },\n backbuffer: { value: new THREE.Texture() },\n ...uniforms,\n } as BlankUniforms,\n });\n this.type = BlankMaterial.type;\n }\n}\n","import { ShaderLib } from \"../../../shaders/ShaderLib\";\n\nexport const gridVertex = `\n\tvoid main() {\n\t\t${ShaderLib.plane_vertex}\n\t}\n`;\n\nexport const gridFragment = `\n\tuniform vec2 count;\n\tuniform bool autoScale;\n\tuniform float tick;\n\tuniform bool shuffle;\n\tuniform float shuffle_frequency;\n\tuniform float shuffle_range;\n\n\tuniform bool sprite;\n\tuniform sampler2D sprite_src;\n\tuniform float sprite_length;\n\tuniform float sprite_shuffleSpeed;\n\n\tfloat hash(vec2 p) {\n\t\treturn fract(sin(dot(p, vec2(12.9898, 78.233))) * 43758.5453);\n\t}\n\n\tvec2 shuffleIndex(vec2 cellIndex , vec2 count) {\n\n\t\tfloat discreteTime = floor(tick * shuffle_frequency);\n\n\t\tfloat r1 = hash(cellIndex + vec2(0.123, discreteTime));\n\t\tfloat r2 = hash(cellIndex + vec2(0.789, discreteTime));\n\n\t\t// -range ~ +range\n\t\tfloat offsetX = floor(r1 * (shuffle_range * 2.0 + 1.0)) - shuffle_range;\n\t\tfloat offsetY = floor(r2 * (shuffle_range * 2.0 + 1.0)) - shuffle_range;\n\t\tvec2 offset = vec2(offsetX, offsetY);\n\n\t\treturn mod(cellIndex + offset, count);\n\t}\n\n\tvoid main() {\n\t\tvec2 usf_Uv = vUv;\n\t\t${ShaderLib.basicFx_fragment_begin}\n\n\t\tvec2 n_count = count;\n\t\tn_count.x *= autoScale ? aspectRatio : 1.;\n\n\t\tvec2 cellIndex = ceil(usf_Uv * n_count);\n\n\t\tvec2 shuffledIndex = shuffle ? shuffleIndex(cellIndex, n_count) : cellIndex;\n\n\t\tvec2 cellCenter = calcSrcUv((shuffledIndex - .5) / n_count, texture_fitScale);\n\n\t\tvec4 gridTextureColor = fitTexture(texture_src, cellCenter, texture_fit);\n\n\t\tif(sprite){\n\t\t\tvec2 cellUv = fract(usf_Uv * n_count);\n\t\t\tfloat cellHash = hash(cellIndex);\n\t\t\tfloat spritePos = fract(cellHash + tick * sprite_shuffleSpeed);\n\t\t\tfloat spriteIndex = floor(spritePos * sprite_length);\n\t\t\tfloat spriteSize = 1.0 / sprite_length;\n\t\t\tfloat spriteOffset = spriteIndex * spriteSize;\n\t\t\tfloat spriteU = spriteOffset + cellUv.x * spriteSize;\n\t\t\tvec2 spriteUv = vec2(spriteU, cellUv.y);\n\t\t\tvec4 spriteColor = texture2D(sprite_src, spriteUv);\n\t\t\tgridTextureColor *= spriteColor;\n\t\t}\n\n\t\tvec4 usf_FragColor = gridTextureColor;\n\t\t${ShaderLib.basicFx_fragment_end}\n\n\t\tgl_FragColor = usf_FragColor;\n\n\t}\n`;\n","import * as THREE from \"three\";\nimport {\n SamplingFxUniforms,\n SamplingFxValues,\n SamplingFxMaterial,\n} from \"../../core/SamplingFxMaterial\";\nimport { FxMaterialProps } from \"../../core/FxMaterial\";\nimport {\n ExtractUniformValues,\n NestUniformValues,\n UniformParentKey,\n} from \"../../../shaders/uniformsUtils\";\nimport { gridVertex, gridFragment } from \"./grid.glsl\";\n\ntype GridUniforms = {\n /** グリッドのマス数 */\n count: { value: THREE.Vector2 };\n /** 自動で画面のアスペクト比に合わせて正方形にscaleする */\n autoScale: { value: boolean };\n /** tick */\n tick: { value: number };\n shuffle: { value: UniformParentKey };\n shuffle_frequency: { value: number };\n shuffle_range: { value: number };\n /** スプライトテクスチャ */\n sprite: { value: UniformParentKey };\n sprite_src: { value: THREE.Texture };\n sprite_length: { value: number };\n sprite_shuffleSpeed: { value: number };\n} & SamplingFxUniforms;\n\nexport type GridValues = NestUniformValues & SamplingFxValues;\n\nexport type GridMaterialProps = ExtractUniformValues;\n\nexport class GridMaterial extends SamplingFxMaterial {\n static get type() {\n return \"GridMaterial\";\n }\n\n uniforms!: GridUniforms;\n\n constructor(props: FxMaterialProps) {\n super({\n ...props,\n vertexShader: gridVertex,\n fragmentShader: gridFragment,\n uniforms: {\n count: { value: new THREE.Vector2(20, 20) },\n autoScale: { value: true },\n tick: { value: 0 },\n shuffle: { value: false },\n shuffle_frequency: { value: 5 },\n shuffle_range: { value: 2 },\n sprite: { value: false },\n sprite_src: { value: new THREE.Texture() },\n sprite_length: { value: 10 },\n sprite_shuffleSpeed: { value: 0 },\n } as GridUniforms,\n });\n\n this.setNearestFilter();\n\n this.type = GridMaterial.type;\n }\n\n /** When gridding with floor, you must use NearestFilter. */\n public setNearestFilter() {\n this.uniforms.texture_src.value.magFilter = THREE.NearestFilter;\n this.uniforms.texture_src.value.minFilter = THREE.NearestFilter;\n this.uniforms.sprite_src.value.magFilter = THREE.NearestFilter;\n this.uniforms.sprite_src.value.minFilter = THREE.NearestFilter;\n }\n}\n","import { useCallback } from \"react\";\nimport { useSingleFBO, getDpr, useSetup } from \"../../utils\";\nimport { HooksProps, HooksReturn, RootState } from \"../types\";\nimport {\n NoiseMaterial,\n NoiseMaterialProps,\n NoiseValues,\n} from \"../../materials\";\n\nexport type NoiseProps = HooksProps & NoiseValues;\n\n/**\n * @link https://github.com/FunTechInc/use-shader-fx?tab=readme-ov-file#usage\n */\nexport const useNoise = ({\n size,\n dpr,\n fboAutoSetSize,\n renderTargetOptions,\n materialParameters,\n ...uniformValues\n}: NoiseProps): HooksReturn<\n NoiseValues,\n NoiseMaterial & NoiseMaterialProps\n> => {\n const _dpr = getDpr(dpr);\n\n const { scene, material, camera } = useSetup({\n size,\n dpr: _dpr.shader,\n material: NoiseMaterial,\n uniformValues,\n materialParameters,\n });\n\n const [renderTarget, updateRenderTarget] = useSingleFBO({\n scene,\n camera,\n size,\n dpr: _dpr.fbo,\n fboAutoSetSize,\n ...renderTargetOptions,\n });\n\n const setValues = useCallback(\n (newValues: NoiseValues, needsUpdate: boolean = true) => {\n material.setUniformValues(newValues, needsUpdate);\n },\n [material]\n );\n\n const render = useCallback(\n (rootState: RootState, newValues?: NoiseValues) => {\n const { gl, clock } = rootState;\n newValues && setValues(newValues, false);\n material.uniforms.tick.value =\n typeof newValues?.tick === \"function\"\n ? newValues.tick(material.uniforms.tick.value)\n : newValues?.tick || clock.getElapsedTime();\n return updateRenderTarget({ gl });\n },\n [setValues, updateRenderTarget, material]\n );\n\n return {\n render,\n setValues,\n texture: renderTarget.texture,\n material,\n scene,\n camera,\n renderTarget,\n };\n};\n","import { useCallback } from \"react\";\nimport { RootState, Size } from \"../../types\";\nimport { FluidMaterials } from \"../../../materials\";\nimport { SingleFBOUpdateFunction, useSetup } from \"../../../utils\";\n\nexport const useAdvection = (\n {\n size,\n dpr,\n ...uniformValues\n }: {\n size: Size;\n dpr: number | false;\n } & FluidMaterials.AdvectionValues,\n updateRenderTarget: SingleFBOUpdateFunction\n) => {\n const { scene, material, camera } = useSetup({\n size,\n dpr,\n material: FluidMaterials.AdvectionMaterial,\n uniformValues,\n });\n\n const render = useCallback(\n (rootState: RootState) => {\n const { gl } = rootState;\n updateRenderTarget({ gl, scene, camera });\n },\n [updateRenderTarget, scene, camera]\n );\n\n return { render, material };\n};\n","import * as THREE from \"three\";\nimport { useCallback, useRef } from \"react\";\n\nexport type PointerValues = {\n currentPointer: THREE.Vector2;\n prevPointer: THREE.Vector2;\n diffPointer: THREE.Vector2;\n velocity: THREE.Vector2;\n isVelocityUpdate: boolean;\n};\n\ntype PointerTracker = (currentPointer: THREE.Vector2) => PointerValues;\n\n/**\n * @description When given the pointer vector2 from r3f's RootState, it generates an update function that returns {`currentPointer`, `prevPointer`, `diffPointer`, `isVelocityUpdate`, `velocity`}.\n * @description When calling custom in a `useFrame` loop, you can avoid duplication of execution by passing `pointerValues` to the update function of a Pointer-activated fxHook, such as `useBrush`.\n * @param lerp 0~1, lerp intensity (0 to less than 1) , default : `0`\n */\nexport const usePointerTracker = (lerp: number = 0): PointerTracker => {\n const prevPointer = useRef(new THREE.Vector2(0, 0));\n const diffPointer = useRef(new THREE.Vector2(0, 0));\n const lerpPointer = useRef(new THREE.Vector2(0, 0));\n const lastUpdateTime = useRef(0);\n const velocity = useRef(new THREE.Vector2(0, 0));\n const isMoved = useRef(false);\n\n const pointerTracker = useCallback(\n (currentPointer: THREE.Vector2) => {\n const now = performance.now();\n\n // lerp\n let current: THREE.Vector2;\n if (isMoved.current && lerp) {\n lerpPointer.current = lerpPointer.current.lerp(\n currentPointer,\n 1 - lerp\n );\n current = lerpPointer.current.clone();\n } else {\n current = currentPointer.clone();\n lerpPointer.current = current;\n }\n\n // first frame\n if (lastUpdateTime.current === 0) {\n lastUpdateTime.current = now;\n prevPointer.current = current;\n }\n const deltaTime = Math.max(1, now - lastUpdateTime.current);\n lastUpdateTime.current = now;\n\n // get velocity\n velocity.current\n .copy(current)\n .sub(prevPointer.current)\n .divideScalar(deltaTime);\n const isUpdate = velocity.current.length() > 0;\n\n //set prev temp pos\n const prevTemp = isMoved.current\n ? prevPointer.current.clone()\n : current;\n if (!isMoved.current && isUpdate) {\n isMoved.current = true;\n }\n prevPointer.current = current;\n\n return {\n currentPointer: current,\n prevPointer: prevTemp,\n diffPointer: diffPointer.current.subVectors(current, prevTemp),\n velocity: velocity.current,\n isVelocityUpdate: isUpdate,\n };\n },\n [lerp]\n );\n\n return pointerTracker;\n};\n","import { useCallback } from \"react\";\nimport { RootState, Size } from \"../../types\";\nimport { SingleFBOUpdateFunction, useSetup } from \"../../../utils\";\nimport { FluidMaterials } from \"../../../materials\";\nimport { usePointerTracker } from \"../../../misc/usePointerTracker\";\n\nexport const useSplat = (\n {\n size,\n dpr,\n ...uniformValues\n }: {\n size: Size;\n dpr: number | false;\n } & FluidMaterials.SplatValuesClient,\n updateRenderTarget: SingleFBOUpdateFunction\n) => {\n const { scene, material, camera } = useSetup({\n size,\n dpr,\n material: FluidMaterials.SplatMaterial,\n geometrySize: {\n width: 1,\n height: 1,\n },\n uniformValues,\n });\n\n const pointerTracker = usePointerTracker();\n\n const render = useCallback(\n (rootState: RootState) => {\n const { gl, pointer } = rootState;\n const { currentPointer, diffPointer } = pointerTracker(pointer);\n\n material.uniforms.center.value.copy(currentPointer);\n material.uniforms.force.value.copy(diffPointer);\n\n updateRenderTarget({ gl, scene, camera, clear: false });\n },\n [updateRenderTarget, material, pointerTracker, scene, camera]\n );\n\n return { render, material };\n};\n","import { useCallback } from \"react\";\nimport { RootState, Size } from \"../../types\";\nimport { FluidMaterials } from \"../../../materials\";\nimport { useSetup, SingleFBOUpdateFunction } from \"../../../utils\";\n\nexport const useDivergence = (\n {\n size,\n dpr,\n ...uniformValues\n }: {\n size: Size;\n dpr: number | false;\n } & FluidMaterials.DivergenceValues,\n updateRenderTarget: SingleFBOUpdateFunction\n) => {\n const { scene, material, camera } = useSetup({\n size,\n dpr,\n material: FluidMaterials.DivergenceMaterial,\n uniformValues,\n });\n\n const render = useCallback(\n (rootState: RootState) => {\n const { gl } = rootState;\n updateRenderTarget({ gl, scene, camera });\n },\n [updateRenderTarget, scene, camera]\n );\n\n return { render, material };\n};\n","import { useCallback } from \"react\";\nimport { RootState, Size } from \"../../types\";\nimport { DoubleFBOUpdateFunction, useSetup } from \"../../../utils\";\nimport { FluidMaterials } from \"../../../materials\";\n\nexport const usePoisson = (\n {\n size,\n dpr,\n pressureIterations,\n ...uniformValues\n }: {\n size: Size;\n dpr: number | false;\n pressureIterations?: number;\n } & Omit,\n updateRenderTarget: DoubleFBOUpdateFunction\n) => {\n const { scene, material, camera } = useSetup({\n size,\n dpr,\n material: FluidMaterials.PoissonMaterial,\n uniformValues,\n customParameters: {\n iterations: pressureIterations,\n },\n });\n\n const render = useCallback(\n (rootState: RootState) => {\n const { gl } = rootState;\n for (let i = 0; i < material.iterations; i++) {\n updateRenderTarget({ gl, scene, camera }, ({ read }) => {\n material.uniforms.pressure.value = read;\n });\n }\n },\n [updateRenderTarget, material, scene, camera]\n );\n\n return { render, material };\n};\n","import { useCallback } from \"react\";\nimport { RootState, Size } from \"../../types\";\nimport { SingleFBOUpdateFunction, useSetup } from \"../../../utils\";\nimport { FluidMaterials } from \"../../../materials\";\n\nexport const usePressure = (\n {\n size,\n dpr,\n ...uniformValues\n }: {\n size: Size;\n dpr: number | false;\n } & FluidMaterials.PressureValues,\n updateRenderTarget: SingleFBOUpdateFunction\n) => {\n const { scene, material, camera } = useSetup({\n size,\n dpr,\n material: FluidMaterials.PressureMaterial,\n uniformValues,\n });\n\n const render = useCallback(\n (rootState: RootState) => {\n const { gl } = rootState;\n updateRenderTarget({ gl, scene, camera });\n },\n [updateRenderTarget, scene, camera]\n );\n\n return { render, material };\n};\n","import { useCallback } from \"react\";\nimport { RootState, Size } from \"../../types\";\nimport { SingleFBOUpdateFunction, useSetup } from \"../../../utils\";\nimport { FluidMaterials } from \"../../../materials\";\n\nexport const useOutput = (\n {\n size,\n dpr,\n ...values\n }: {\n size: Size;\n dpr: number | false;\n } & FluidMaterials.OutputValues,\n updateRenderTarget: SingleFBOUpdateFunction\n) => {\n const { scene, material, camera } = useSetup({\n size,\n dpr,\n material: FluidMaterials.OutputMaterial,\n uniformValues: values,\n });\n\n const render = useCallback(\n (rootState: RootState) => {\n const { gl } = rootState;\n updateRenderTarget({ gl, scene, camera });\n },\n [updateRenderTarget, scene, camera]\n );\n\n return { render, material };\n};\n","import * as THREE from \"three\";\nimport { useCallback } from \"react\";\nimport { useSingleFBO, useDoubleFBO, getDpr } from \"../../utils\";\nimport { HooksProps, HooksReturn, RootState } from \"../types\";\nimport { useAdvection } from \"./scenes/useAdvection\";\nimport { useSplat } from \"./scenes/useSplat\";\nimport { useDivergence } from \"./scenes/useDivergence\";\nimport { usePoisson } from \"./scenes/usePoisson\";\nimport { usePressure } from \"./scenes/usePressure\";\nimport { useOutput } from \"./scenes/useOutput\";\nimport { BasicFxValues, FluidMaterials } from \"../../materials\";\n\nexport type FluidValues = {\n pressureIterations?: number;\n} & BasicFxValues &\n FluidMaterials.AdvectionValuesClient &\n FluidMaterials.DivergenceValuesClient &\n FluidMaterials.PoissonValuesClient &\n FluidMaterials.PressureValuesClient &\n FluidMaterials.SplatValuesClient;\n\nexport type FluidProps = HooksProps & FluidValues;\n\nconst removeUndefined = (obj: T): Partial =>\n Object.fromEntries(\n Object.entries(obj).filter(([, value]) => value !== undefined)\n ) as Partial;\n\nconst extractValues = (values: FluidValues) => {\n const {\n dissipation,\n deltaTime,\n bounce,\n pressureIterations,\n radius,\n forceBias,\n ...basicFxValues\n } = values;\n\n return [\n {\n advection: removeUndefined({ dissipation, deltaTime }),\n divergence: removeUndefined({ bounce, deltaTime }),\n poisson: removeUndefined({ bounce }),\n pressure: removeUndefined({ bounce, deltaTime }),\n splat: removeUndefined({ radius, forceBias }),\n pressureIterations,\n },\n basicFxValues,\n ] as const;\n};\n\n/**\n * @link https://github.com/FunTechInc/use-shader-fx?tab=readme-ov-file#usage\n */\nexport const useFluid = ({\n size,\n dpr,\n fboAutoSetSize,\n renderTargetOptions,\n materialParameters,\n ...uniformValues\n}: FluidProps): HooksReturn<\n FluidValues,\n any,\n {\n /** velocity map */\n velocity: THREE.Texture;\n }\n> => {\n const _dpr = getDpr(dpr);\n\n // fbos\n const fboProps = {\n dpr: _dpr.fbo,\n size,\n fboAutoSetSize,\n type: THREE.HalfFloatType,\n ...renderTargetOptions,\n };\n const [velocity_0, updateVelocity_0] = useSingleFBO(fboProps);\n const [velocity_1, updateVelocity_1] = useSingleFBO(fboProps);\n const [divergenceFBO, updateDivergenceFBO] = useSingleFBO(fboProps);\n const [pressureFBO, updatePressureFBO] = useDoubleFBO(fboProps);\n const [outputFBO, updateOutputFBO] = useSingleFBO(fboProps);\n\n // scenes\n const [extractedValues, basicFxValues] = extractValues(uniformValues);\n\n const SceneSize = { size, dpr: _dpr.shader };\n const advection = useAdvection(\n {\n ...SceneSize,\n ...extractedValues.advection,\n velocity: velocity_0.texture,\n },\n updateVelocity_1\n );\n const splat = useSplat(\n {\n ...SceneSize,\n ...extractedValues.splat,\n },\n updateVelocity_1\n );\n const divergence = useDivergence(\n {\n ...SceneSize,\n ...extractedValues.divergence,\n velocity: velocity_1.texture,\n },\n updateDivergenceFBO\n );\n const poisson = usePoisson(\n {\n ...SceneSize,\n ...extractedValues.poisson,\n divergence: divergenceFBO.texture,\n pressureIterations: extractedValues.pressureIterations,\n },\n updatePressureFBO\n );\n const pressure = usePressure(\n {\n ...SceneSize,\n ...extractedValues.pressure,\n velocity: velocity_1.texture,\n pressure: pressureFBO.read.texture,\n },\n updateVelocity_0\n );\n const output = useOutput(\n {\n ...SceneSize,\n ...basicFxValues,\n src: velocity_0.texture,\n },\n updateOutputFBO\n );\n\n const setValues = useCallback(\n (newValues: FluidValues, needsUpdate: boolean = true) => {\n const [_extractedValues, _basicFxValues] = extractValues(newValues);\n\n output.material.setUniformValues(_basicFxValues, needsUpdate);\n advection.material.setUniformValues(_extractedValues.advection);\n divergence.material.setUniformValues(_extractedValues.divergence);\n poisson.material.setUniformValues(_extractedValues.poisson);\n pressure.material.setUniformValues(_extractedValues.pressure);\n splat.material.setUniformValues(_extractedValues.splat);\n if (_extractedValues.pressureIterations) {\n poisson.material.iterations = _extractedValues.pressureIterations;\n }\n },\n [output, advection, divergence, poisson, pressure, splat]\n );\n\n const render = useCallback(\n (rootState: RootState, newValues?: FluidValues) => {\n newValues && setValues(newValues, false);\n\n [advection, splat, divergence, poisson, pressure, output].forEach(\n (shader) => shader?.render(rootState)\n );\n\n return outputFBO.texture;\n },\n [\n setValues,\n outputFBO.texture,\n advection,\n splat,\n divergence,\n poisson,\n pressure,\n output,\n ]\n );\n\n return {\n render,\n setValues,\n texture: outputFBO.texture,\n velocity: velocity_0.texture,\n };\n};\n","import { useCallback } from \"react\";\nimport { useSingleFBO, getDpr, useSetup } from \"../../utils\";\nimport { HooksProps, HooksReturn, RootState } from \"../types\";\nimport {\n BufferMaterial,\n BufferMaterialProps,\n BufferValues,\n} from \"../../materials\";\n\nexport type BufferProps = HooksProps & BufferValues;\n\n/**\n * @link https://github.com/FunTechInc/use-shader-fx?tab=readme-ov-file#usage\n */\nexport const useBuffer = ({\n size,\n dpr,\n fboAutoSetSize,\n renderTargetOptions,\n materialParameters,\n ...uniformValues\n}: BufferProps): HooksReturn<\n BufferValues,\n BufferMaterial & BufferMaterialProps\n> => {\n const _dpr = getDpr(dpr);\n\n const { scene, material, camera } = useSetup({\n size,\n dpr: _dpr.shader,\n material: BufferMaterial,\n uniformValues,\n materialParameters,\n });\n\n const [renderTarget, updateRenderTarget] = useSingleFBO({\n scene,\n camera,\n size,\n dpr: _dpr.fbo,\n fboAutoSetSize,\n ...renderTargetOptions,\n });\n\n const setValues = useCallback(\n (newValues: BufferValues, needsUpdate: boolean = true) => {\n material.setUniformValues(newValues, needsUpdate);\n },\n [material]\n );\n\n const render = useCallback(\n (rootState: RootState, newValues?: BufferValues) => {\n const { gl } = rootState;\n newValues && setValues(newValues, false);\n return updateRenderTarget({ gl });\n },\n [setValues, updateRenderTarget]\n );\n\n return {\n render,\n setValues,\n texture: renderTarget.texture,\n material,\n scene,\n camera,\n renderTarget,\n };\n};\n","import { useCallback } from \"react\";\nimport { useSingleFBO, getDpr, useSetup } from \"../../utils\";\nimport { HooksProps, HooksReturn, RootState } from \"../types\";\nimport { RawBlankMaterial } from \"../../materials\";\nimport { ShaderWithUniforms } from \"../../shaders/uniformsUtils\";\n\nexport type RawBlankProps = HooksProps & ShaderWithUniforms;\n\n/**\n * type DefaultUniforms = {\n resolution: { value: THREE.Vector2 };\n texelSize: { value: THREE.Vector2 };\n aspectRatio: { value: number };\n maxAspect: { value: THREE.Vector2 };\n renderCount: { value: number };\n\tはデフォルトである\n\tあとvaringでvUvつかえる\n\t\n * @link https://github.com/FunTechInc/use-shader-fx?tab=readme-ov-file#usage\n */\nexport const useRawBlank = ({\n size,\n dpr,\n fboAutoSetSize,\n renderTargetOptions,\n materialParameters,\n ...shaderWithUniforms\n}: RawBlankProps): HooksReturn<{}, RawBlankMaterial> => {\n const _dpr = getDpr(dpr);\n\n const { scene, material, camera } = useSetup({\n size,\n dpr: _dpr.shader,\n material: RawBlankMaterial,\n materialParameters,\n ...shaderWithUniforms,\n });\n\n const [renderTarget, updateRenderTarget] = useSingleFBO({\n scene,\n camera,\n size,\n dpr: _dpr.fbo,\n fboAutoSetSize,\n ...renderTargetOptions,\n });\n\n const setValues = useCallback(\n (newValues: {}) => {\n material.setUniformValues(newValues);\n },\n [material]\n );\n\n const render = useCallback(\n (rootState: RootState, newValues?: {}) => {\n const { gl } = rootState;\n newValues && setValues(newValues);\n return updateRenderTarget({ gl });\n },\n [setValues, updateRenderTarget]\n );\n\n return {\n render,\n setValues,\n texture: renderTarget.texture,\n material,\n scene,\n camera,\n renderTarget,\n };\n};\n","import { useCallback } from \"react\";\nimport {\n useSingleFBO,\n getDpr,\n useSetup,\n useDoubleFBO,\n useMutableState,\n} from \"../../utils\";\nimport { HooksProps, HooksReturn, RootState } from \"../types\";\nimport { BlankMaterial } from \"../../materials\";\nimport { ShaderWithUniforms } from \"../../shaders/uniformsUtils\";\n\ntype BlankConfig = {\n pointerLerp?: number;\n};\n\nexport type BlankProps = HooksProps & ShaderWithUniforms;\n\n/**\n * type DefaultUniforms = {\n resolution: { value: THREE.Vector2 };\n texelSize: { value: THREE.Vector2 };\n aspectRatio: { value: number };\n maxAspect: { value: THREE.Vector2 };\n renderCount: { value: number };\n\tはデフォルトである\n\tあとvaringでvUvつかえる\n\n\t加えて、\n\ttime\n\tpointer\n\tbackbuffer\n\tもデフォルトで使える\n\n\tあと、pointerLerp使えるよ\n\n * @link https://github.com/FunTechInc/use-shader-fx?tab=readme-ov-file#usage\n */\nexport const useBlank = ({\n size,\n dpr,\n fboAutoSetSize,\n renderTargetOptions,\n materialParameters,\n pointerLerp = 1,\n ...shaderWithUniforms\n}: BlankProps & BlankConfig): HooksReturn<{}, BlankMaterial> => {\n const _dpr = getDpr(dpr);\n\n const { scene, material, camera } = useSetup({\n size,\n dpr: _dpr.shader,\n material: BlankMaterial,\n materialParameters,\n ...shaderWithUniforms,\n });\n\n const fboParams = {\n scene,\n camera,\n size,\n dpr: _dpr.fbo,\n fboAutoSetSize,\n ...renderTargetOptions,\n };\n const [renderTarget, updateRenderTarget] = useSingleFBO(fboParams);\n const [_, updateBackbuffer] = useDoubleFBO(fboParams);\n\n const [confing, setConfig] = useMutableState({ pointerLerp });\n\n const setValues = useCallback(\n ({ pointerLerp, ...newValues }: {} & BlankConfig) => {\n material.setUniformValues(newValues);\n if (pointerLerp) setConfig({ pointerLerp });\n },\n [material, setConfig]\n );\n\n const render = useCallback(\n (rootState: RootState, newValues?: {} & BlankConfig) => {\n const { gl, clock, pointer } = rootState;\n if (newValues) setValues(newValues);\n material.uniforms.time.value = clock.getElapsedTime();\n material.uniforms.pointer.value.lerp(\n pointer,\n confing.current.pointerLerp!\n );\n updateBackbuffer(\n { gl },\n ({ read }) => (material.uniforms.backbuffer.value = read)\n );\n return updateRenderTarget({ gl });\n },\n [setValues, updateRenderTarget, material, updateBackbuffer, confing]\n );\n\n return {\n render,\n setValues,\n texture: renderTarget.texture,\n material,\n scene,\n camera,\n renderTarget,\n };\n};\n","import { useCallback } from \"react\";\nimport { useSingleFBO, getDpr, useSetup } from \"../../utils\";\nimport { HooksProps, HooksReturn, RootState } from \"../types\";\nimport { GridMaterial, GridValues, GridMaterialProps } from \"../../materials\";\n\nexport type GridProps = HooksProps & GridValues;\n\n/**\n * @link https://github.com/FunTechInc/use-shader-fx?tab=readme-ov-file#usage\n */\nexport const useGrid = ({\n size,\n dpr,\n fboAutoSetSize,\n renderTargetOptions,\n materialParameters,\n ...uniformValues\n}: GridProps): HooksReturn => {\n const _dpr = getDpr(dpr);\n\n const { scene, material, camera } = useSetup({\n size,\n dpr: _dpr.shader,\n material: GridMaterial,\n uniformValues,\n materialParameters,\n });\n\n const [renderTarget, updateRenderTarget] = useSingleFBO({\n scene,\n camera,\n size,\n dpr: _dpr.fbo,\n fboAutoSetSize,\n ...renderTargetOptions,\n });\n\n const setValues = useCallback(\n (newValues: GridValues, needsUpdate: boolean = true) => {\n material.setUniformValues(newValues, needsUpdate);\n material.setNearestFilter();\n },\n [material]\n );\n\n const render = useCallback(\n (rootState: RootState, newValues?: GridValues) => {\n const { gl, clock } = rootState;\n newValues && setValues(newValues, false);\n material.uniforms.tick.value =\n typeof newValues?.tick === \"function\"\n ? newValues.tick(material.uniforms.tick.value)\n : newValues?.tick || clock.getElapsedTime();\n return updateRenderTarget({ gl });\n },\n [setValues, updateRenderTarget, material]\n );\n\n return {\n render,\n setValues,\n texture: renderTarget.texture,\n material,\n scene,\n camera,\n renderTarget,\n };\n};\n","export type EasingTypes =\n | \"easeInSine\"\n | \"easeOutSine\"\n | \"easeInOutSine\"\n | \"easeInQuad\"\n | \"easeOutQuad\"\n | \"easeInOutQuad\"\n | \"easeInCubic\"\n | \"easeOutCubic\"\n | \"easeInOutCubic\"\n | \"easeInQuart\"\n | \"easeOutQuart\"\n | \"easeInOutQuart\"\n | \"easeInQuint\"\n | \"easeOutQuint\"\n | \"easeInOutQuint\"\n | \"easeInExpo\"\n | \"easeOutExpo\"\n | \"easeInOutExpo\"\n | \"easeInCirc\"\n | \"easeOutCirc\"\n | \"easeInOutCirc\"\n | \"easeInBack\"\n | \"easeOutBack\"\n | \"easeInOutBack\"\n | \"easeInElastic\"\n | \"easeOutElastic\"\n | \"easeInOutElastic\"\n | \"easeInBounce\"\n | \"easeOutBounce\"\n | \"easeInOutBounce\";\n\ntype EasingFunctions = {\n [K in EasingTypes]: (x: number) => number;\n};\n\n/**\n * from https://github.com/ai/easings.net\n */\nexport const Easing: EasingFunctions = Object.freeze({\n easeInSine(x: number): number {\n return 1 - Math.cos((x * Math.PI) / 2);\n },\n easeOutSine(x: number): number {\n return Math.sin((x * Math.PI) / 2);\n },\n easeInOutSine(x: number): number {\n return -(Math.cos(Math.PI * x) - 1) / 2;\n },\n easeInQuad(x: number): number {\n return x * x;\n },\n easeOutQuad(x: number): number {\n return 1 - (1 - x) * (1 - x);\n },\n easeInOutQuad(x: number): number {\n return x < 0.5 ? 2 * x * x : 1 - Math.pow(-2 * x + 2, 2) / 2;\n },\n easeInCubic(x: number): number {\n return x * x * x;\n },\n easeOutCubic(x: number): number {\n return 1 - Math.pow(1 - x, 3);\n },\n easeInOutCubic(x: number): number {\n return x < 0.5 ? 4 * x * x * x : 1 - Math.pow(-2 * x + 2, 3) / 2;\n },\n easeInQuart(x: number): number {\n return x * x * x * x;\n },\n easeOutQuart(x: number): number {\n return 1 - Math.pow(1 - x, 4);\n },\n easeInOutQuart(x: number): number {\n return x < 0.5 ? 8 * x * x * x * x : 1 - Math.pow(-2 * x + 2, 4) / 2;\n },\n easeInQuint(x: number): number {\n return x * x * x * x * x;\n },\n easeOutQuint(x: number): number {\n return 1 - Math.pow(1 - x, 5);\n },\n easeInOutQuint(x: number): number {\n return x < 0.5 ? 16 * x * x * x * x * x : 1 - Math.pow(-2 * x + 2, 5) / 2;\n },\n easeInExpo(x: number): number {\n return x === 0 ? 0 : Math.pow(2, 10 * x - 10);\n },\n easeOutExpo(x: number): number {\n return x === 1 ? 1 : 1 - Math.pow(2, -10 * x);\n },\n easeInOutExpo(x: number): number {\n return x === 0\n ? 0\n : x === 1\n ? 1\n : x < 0.5\n ? Math.pow(2, 20 * x - 10) / 2\n : (2 - Math.pow(2, -20 * x + 10)) / 2;\n },\n easeInCirc(x: number): number {\n return 1 - Math.sqrt(1 - Math.pow(x, 2));\n },\n easeOutCirc(x: number): number {\n return Math.sqrt(1 - Math.pow(x - 1, 2));\n },\n easeInOutCirc(x: number): number {\n return x < 0.5\n ? (1 - Math.sqrt(1 - Math.pow(2 * x, 2))) / 2\n : (Math.sqrt(1 - Math.pow(-2 * x + 2, 2)) + 1) / 2;\n },\n easeInBack(x: number): number {\n const c1 = 1.70158;\n const c3 = c1 + 1;\n\n return c3 * x * x * x - c1 * x * x;\n },\n easeOutBack(x: number): number {\n const c1 = 1.70158;\n const c3 = c1 + 1;\n\n return 1 + c3 * Math.pow(x - 1, 3) + c1 * Math.pow(x - 1, 2);\n },\n easeInOutBack(x: number): number {\n const c1 = 1.70158;\n const c2 = c1 * 1.525;\n\n return x < 0.5\n ? (Math.pow(2 * x, 2) * ((c2 + 1) * 2 * x - c2)) / 2\n : (Math.pow(2 * x - 2, 2) * ((c2 + 1) * (x * 2 - 2) + c2) + 2) / 2;\n },\n easeInElastic(x: number): number {\n const c4 = (2 * Math.PI) / 3;\n\n return x === 0\n ? 0\n : x === 1\n ? 1\n : -Math.pow(2, 10 * x - 10) * Math.sin((x * 10 - 10.75) * c4);\n },\n easeOutElastic(x: number): number {\n const c4 = (2 * Math.PI) / 3;\n\n return x === 0\n ? 0\n : x === 1\n ? 1\n : Math.pow(2, -10 * x) * Math.sin((x * 10 - 0.75) * c4) + 1;\n },\n easeInOutElastic(x: number): number {\n const c5 = (2 * Math.PI) / 4.5;\n\n return x === 0\n ? 0\n : x === 1\n ? 1\n : x < 0.5\n ? -(Math.pow(2, 20 * x - 10) * Math.sin((20 * x - 11.125) * c5)) / 2\n : (Math.pow(2, -20 * x + 10) * Math.sin((20 * x - 11.125) * c5)) / 2 +\n 1;\n },\n easeInBounce(x: number): number {\n return 1 - Easing.easeOutBounce(1 - x);\n },\n easeOutBounce(x: number): number {\n const n1 = 7.5625;\n const d1 = 2.75;\n\n if (x < 1 / d1) {\n return n1 * x * x;\n } else if (x < 2 / d1) {\n return n1 * (x -= 1.5 / d1) * x + 0.75;\n } else if (x < 2.5 / d1) {\n return n1 * (x -= 2.25 / d1) * x + 0.9375;\n } else {\n return n1 * (x -= 2.625 / d1) * x + 0.984375;\n }\n },\n easeInOutBounce(x: number): number {\n return x < 0.5\n ? (1 - Easing.easeOutBounce(1 - 2 * x)) / 2\n : (1 + Easing.easeOutBounce(2 * x - 1)) / 2;\n },\n});\n","import * as THREE from \"three\";\nimport { Easing, EasingTypes } from \"../libs/Easings\";\nimport { useCallback } from \"react\";\n\n/** Returns a unique hash specific to the beat */\nfunction getHash(input: number) {\n let n = Math.sin(input * 12.9898) * 43758.5453;\n return n - Math.floor(n);\n}\n\ntype BeatValues = {\n beat: number;\n floor: number;\n fract: number;\n /** unique hash specific to the beat */\n hash: number;\n};\n\n/**\n * @param ease easing functions are referenced from https://github.com/ai/easings.net , default : \"easeOutQuart\"\n */\nexport const useBeat = (bpm: number, ease: EasingTypes = \"easeOutQuart\") => {\n const rhythm = bpm / 60;\n const easing = Easing[ease];\n const updateBeat = useCallback(\n (clock: THREE.Clock) => {\n let beat = clock.getElapsedTime() * rhythm;\n const floor = Math.floor(beat);\n const fract = easing(beat - floor);\n beat = fract + floor;\n const hash = getHash(floor);\n return {\n beat,\n floor,\n fract,\n hash,\n } as BeatValues;\n },\n [rhythm, easing]\n );\n return updateBeat;\n};\n","import { useEffect, useRef } from \"react\";\nimport * as THREE from \"three\";\nimport { Size } from \"../hooks/types\";\n\nconst PASSIVE = { passive: true };\n\n/**\n * @param size Size\n * @returns THREE.Vector2\n */\nexport const useWindowPointer = (size: Size) => {\n const windowPointer = useRef(new THREE.Vector2(0));\n\n useEffect(() => {\n const compute = (x: number, y: number) => {\n windowPointer.current.set(\n ((x - size.left) / size.width) * 2 - 1,\n -((y - size.top) / size.height) * 2 + 1\n );\n };\n const handleTouchMove = (event: TouchEvent) => {\n const touch = event.touches[0];\n compute(touch.clientX, touch.clientY);\n };\n const handlePointerMove = (event: PointerEvent) => {\n compute(event.clientX, event.clientY);\n };\n\n window.addEventListener(\"touchmove\", handleTouchMove, PASSIVE);\n window.addEventListener(\"pointermove\", handlePointerMove, PASSIVE);\n\n return () => {\n window.removeEventListener(\"touchmove\", handleTouchMove);\n window.removeEventListener(\"pointermove\", handlePointerMove);\n };\n }, [size]);\n\n return windowPointer.current;\n};\n"],"names":["getDpr","dpr","useResolution","size","_width","_height","resolution","useState","THREE","getCameraProps","width","height","frustumSize","aspect","w","h","useCamera","cameraType","near","far","camera","FBO_DEFAULT_OPTION","renderFBO","gl","fbo","scene","clear","onBeforeRender","onSwap","clearCache","useSingleFBO","props","fboAutoSetSize","depth","renderTargetOptions","renderTarget","target","useEffect","temp","updateRenderTarget","useCallback","renderProps","useDoubleFBO","read","write","_a","_b","useObject3D","geometry","material","Proto","object3D","useSetup","geometrySize","materialProps","_geometry","_material","useMutableState","state","ref","useRef","setRef","value","ISDEV","DEFAULT_TEXTURE","APP_NAME","THREE_FLAG_PROPS","warn","text","BASICFX_VALUES","handleUpdateFxDefines","fxKey","mixSrc","mixDst","srcSystem","levels","contrast","colorBalance","hsv","posterize","grayscale","getFxKeyFromUniforms","uniforms","isMixSrc","isMixDst","plane_vertex_default","default_vertex_default","default_pars_vertex_default","default_pars_fragment_default","basicFx_vertex_default","basicFx_pars_vertex_default","basicFx_pars_fragment_default","basicFx_fragment_begin_default","basicFx_fragment_end_default","samplingFx_vertex_default","samplingFx_pars_vertex_default","samplingFx_pars_fragment_default","ShaderLib","plane_vertex","default_vertex","default_pars_vertex","default_pars_fragment","basicFx_vertex","basicFx_pars_vertex","basicFx_pars_fragment","basicFx_fragment_begin","basicFx_fragment_end","samplingFx_vertex","samplingFx_pars_vertex","samplingFx_pars_fragment","noiseVertex","noiseFragment","srcSystem_pars_vertex_default","srcSystem_pars_fragment_default","mixSrc_pars_vertex_default","mixSrc_vertex_default","mixSrc_pars_fragment_default","mixSrc_fragment_begin_default","mixSrc_fragment_end_default","mixDst_pars_vertex_default","mixDst_vertex_default","mixDst_pars_fragment_default","mixDst_fragment_default","texture_vertex_default","texture_pars_vertex_default","texture_pars_fragment_default","adjustments_fragment_default","adjustments_pars_fragment_default","calcSrcUv_default","ShaderChunk","srcSystem_pars_vertex","srcSystem_pars_fragment","mixSrc_vertex","mixSrc_pars_vertex","mixSrc_pars_fragment","mixSrc_fragment_begin","mixSrc_fragment_end","mixDst_pars_vertex","mixDst_vertex","mixDst_pars_fragment","mixDst_fragment","texture_vertex","texture_pars_vertex","texture_pars_fragment","adjustments_fragment","adjustments_pars_fragment","calcSrcUv","mergeShaderCode","prefix","string","mergeShaderLib","vertexShader","fragmentShader","type","vertex","fragment","ShaderLibs","vertexPars","vertexMain","fragmentPars","includePattern","includeReplacer","match","include","resolveIncludes","isTHREE","property","prop","flattenUniformValues","obj","flatObject","flatten","currentObj","parentKey","key","val","newKey","FxMaterial","uniformValues","materialParameters","maxAspect","values","flattenedValues","curretUniform","onSet","v","BasicFxMaterial","rest","BasicFxLib.BASICFX_VALUES","_cache","diffCount","newFxKey","BasicFxLib.getFxKeyFromUniforms","BasicFxLib.handleUpdateFxDefines","source","src","fitType","srcAspectRatio","fitScale","baseAspectRatio","sourceData","needsUpdate","_NoiseMaterial","NoiseMaterial","boxVarying","getPosition","bounce","getBoxCompute","diff","vertex$1","advection_default","AdvectionMaterial","DELTA_TIME","divergence_default","DivergenceMaterial","pressure_default","PressureMaterial","poisson_default","PoissonMaterial","customParameters","splat_default","SplatMaterial","OutputMaterial","SAMPLINGFX_VALUES","SamplingFxMaterial","_BufferMaterial","BufferMaterial","RawBlankMaterial","SHADER_PARS","BlankMaterial","gridVertex","gridFragment","GridMaterial","useNoise","_dpr","setValues","newValues","rootState","clock","useAdvection","FluidMaterials.AdvectionMaterial","usePointerTracker","lerp","prevPointer","diffPointer","lerpPointer","lastUpdateTime","velocity","isMoved","currentPointer","now","current","deltaTime","isUpdate","prevTemp","useSplat","FluidMaterials.SplatMaterial","pointerTracker","pointer","useDivergence","FluidMaterials.DivergenceMaterial","usePoisson","pressureIterations","FluidMaterials.PoissonMaterial","i","usePressure","FluidMaterials.PressureMaterial","useOutput","FluidMaterials.OutputMaterial","removeUndefined","extractValues","dissipation","radius","forceBias","basicFxValues","useFluid","fboProps","velocity_0","updateVelocity_0","velocity_1","updateVelocity_1","divergenceFBO","updateDivergenceFBO","pressureFBO","updatePressureFBO","outputFBO","updateOutputFBO","extractedValues","SceneSize","advection","splat","divergence","poisson","pressure","output","_extractedValues","_basicFxValues","shader","useBuffer","useRawBlank","shaderWithUniforms","useBlank","pointerLerp","fboParams","_","updateBackbuffer","confing","setConfig","useGrid","Easing","x","c2","c4","c5","getHash","input","n","useBeat","bpm","ease","rhythm","easing","beat","floor","fract","hash","PASSIVE","useWindowPointer","windowPointer","compute","y","handleTouchMove","event","touch","handlePointerMove"],"mappings":"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AA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IA6EzBd,EAAU,sBAAsB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAMhCA,EAAU,oBAAoB;AAAA;AAAA;AAAA;AAAA;AAAA;AC3FlC,IAAAZ,KAAA,sCCAA2B,KAAA;AAAA;AAAA;AAAA;AAAA,SCAAC,KAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,SCAA3B,KAAA,aCAAC,KAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,0BCAAC,KAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,2BCAA0B,KAAA;AAAA;AAAA;AAAA,SCAAC,KAAA;AAAA;AAAA,SCAAC,KAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,SCAAC,KAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,SCAAC,KAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,SCAAC,KAAA;AAAA;AAAA;AAAA,SCAAC,KAAA;AAAA;AAAA,SCAAC,KAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,SCAAC,KAAA;AAAA;AAAA;AAAA;AAAA;AAAA;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"} \ No newline at end of file diff --git a/packages/use-shader-fx/build/use-shader-fx.umd.cjs b/packages/use-shader-fx/build/use-shader-fx.umd.cjs new file mode 100644 index 00000000..2376f86f --- /dev/null +++ b/packages/use-shader-fx/build/use-shader-fx.umd.cjs @@ -0,0 +1,609 @@ +(function(d,k){typeof exports=="object"&&typeof module<"u"?k(exports,require("three"),require("react")):typeof define=="function"&&define.amd?define(["exports","three","react"],k):(d=typeof globalThis<"u"?globalThis:d||self,k(d["use-shader-fx"]={},d.THREE,d.React))})(this,function(d,k,_){"use strict";function Ce(e){const t=Object.create(null,{[Symbol.toStringTag]:{value:"Module"}});if(e){for(const r in e)if(r!=="default"){const a=Object.getOwnPropertyDescriptor(e,r);Object.defineProperty(t,r,a.get?a:{enumerable:!0,get:()=>e[r]})}}return t.default=e,Object.freeze(t)}const o=Ce(k),R=e=>typeof e=="number"?{shader:e,fbo:e}:{shader:e.shader??!1,fbo:e.fbo??!1},A=(e,t=!1)=>{const r=t?e.width*t:e.width,a=t?e.height*t:e.height,[n]=_.useState(()=>new o.Vector2(r,a));return n.set(r,a),n},we=(e,t)=>{const r=t,a=e/t,[n,i]=[r*a/2,r/2];return{width:n,height:i,near:-1e3,far:1e3}},Te=(e,t="OrthographicCamera")=>{const r=A(e),{width:a,height:n,near:i,far:s}=we(r.x,r.y),[c]=_.useState(()=>t==="OrthographicCamera"?new o.OrthographicCamera(-a,a,n,-n,i,s):new o.PerspectiveCamera(50,a/n));return c instanceof o.OrthographicCamera?(c.left=-a,c.right=a,c.top=n,c.bottom=-n,c.near=i,c.far=s,c.updateProjectionMatrix()):c instanceof o.PerspectiveCamera&&(c.aspect=a/n,c.updateProjectionMatrix()),c},te={depthBuffer:!1},le=({gl:e,fbo:t,scene:r,camera:a,clear:n=!0,onBeforeRender:i,onSwap:s})=>{if(!r||!a)return;const c=e.autoClear;e.autoClear=n,e.setRenderTarget(t),i(),e.render(r,a),s&&s(),e.setRenderTarget(null),e.autoClear=c},D=e=>{const{scene:t,camera:r,size:a,dpr:n=!1,fboAutoSetSize:i=!1,depth:s=!1,...c}=e,u=A(a,n),[l]=_.useState(()=>{const v=new o.WebGLRenderTarget(u.x,u.y,{...te,...c});return s&&(v.depthTexture=new o.DepthTexture(u.x,u.y,o.FloatType)),v});i&&l.setSize(u.x,u.y),_.useEffect(()=>{const v=l;return()=>{v==null||v.dispose()}},[l]);const m=_.useCallback((v,p)=>{const h=l;return le({...v,scene:v.scene||t,camera:v.camera||r,fbo:h,onBeforeRender:()=>p==null?void 0:p({read:h.texture})}),h.texture},[t,r,l]);return[l,m]},re=e=>{var v,p;const{scene:t,camera:r,size:a,dpr:n=!1,fboAutoSetSize:i=!1,depth:s=!1,...c}=e,u=A(a,n),[l]=_.useState(()=>{const h=new o.WebGLRenderTarget(u.x,u.y,{...te,...c}),x=new o.WebGLRenderTarget(u.x,u.y,{...te,...c});return s&&(h.depthTexture=new o.DepthTexture(u.x,u.y,o.FloatType),x.depthTexture=new o.DepthTexture(u.x,u.y,o.FloatType)),{read:h,write:x,swap:function(){let f=this.read;this.read=this.write,this.write=f}}});i&&((v=l.read)==null||v.setSize(u.x,u.y),(p=l.write)==null||p.setSize(u.x,u.y)),_.useEffect(()=>{const h=l;return()=>{var x,f;(x=h.read)==null||x.dispose(),(f=h.write)==null||f.dispose()}},[l]);const m=_.useCallback((h,x)=>{var S;const f=l;return le({...h,scene:h.scene||t,camera:h.camera||r,fbo:f.write,onBeforeRender:()=>x==null?void 0:x({read:f.read.texture,write:f.write.texture}),onSwap:()=>f.swap()}),(S=f.read)==null?void 0:S.texture},[t,r,l]);return[{read:l.read,write:l.write},m]},Ee=(e,t,r,a)=>{const[n]=_.useState(()=>new a(t,r));return _.useEffect(()=>(e&&e.add(n),()=>{e&&e.remove(n),t.dispose(),r.dispose()}),[e,t,r,n]),n},F=({size:e,dpr:t,material:r,geometry:a=o.PlaneGeometry,geometrySize:n,...i})=>{const[s]=_.useState(()=>new o.Scene),[c]=_.useState(()=>new a((n==null?void 0:n.width)||2,(n==null?void 0:n.height)||2)),[u]=_.useState(()=>new r(i)),l=A(e,t);u.updateResolution(l.x,l.y),Ee(s,c,u,o.Mesh);const m=Te(e);return{scene:s,material:u,camera:m}},Oe=e=>{const t=_.useRef(e),r=_.useCallback(a=>{t.current=typeof a=="function"?a(t.current):a},[]);return[t,r]},Pe=(()=>{try{return process.env.NODE_ENV==="development"}catch{return!1}})(),y=new o.DataTexture(new Uint8Array([0,0,0,0]),1,1,o.RGBAFormat),Re="use-shader-fx",Be=["isColor","isMatrix3","isMatrix4","isVector2","isVector3","isVector4","isTexture","isQuaternion","isWebGLRenderTarget","isEuler","isBufferGeometry","isMaterial","isCamera","isLight","isObject3D","isBone","isVideoTexture"],$=e=>{Pe&&console.warn(`${Re}: ${e}`)},j={mixSrc:{value:!1},mixSrc_src:{value:new o.Texture},mixSrc_fit:{value:0},mixSrc_fitScale:{value:new o.Vector2(1,1)},mixSrc_uv:{value:!1},mixSrc_uv_ch:{value:0},mixSrc_uv_factor:{value:0},mixSrc_uv_offset:{value:new o.Vector2(0,0)},mixSrc_uv_radius:{value:.5},mixSrc_uv_position:{value:new o.Vector2(.5,.5)},mixSrc_uv_range:{value:new o.Vector2(0,1)},mixSrc_uv_mixMap:{value:!1},mixSrc_uv_mixMap_src:{value:y},mixSrc_uv_mixMap_ch:{value:0},mixSrc_color:{value:!1},mixSrc_color_factor:{value:0},mixSrc_color_radius:{value:.5},mixSrc_color_position:{value:new o.Vector2(.5,.5)},mixSrc_color_range:{value:new o.Vector2(0,1)},mixSrc_color_mixMap:{value:!1},mixSrc_color_mixMap_src:{value:y},mixSrc_color_mixMap_ch:{value:0},mixSrc_alpha:{value:!1},mixSrc_alpha_factor:{value:0},mixSrc_alpha_radius:{value:.5},mixSrc_alpha_position:{value:new o.Vector2(.5,.5)},mixSrc_alpha_range:{value:new o.Vector2(0,1)},mixSrc_alpha_mixMap:{value:!1},mixSrc_alpha_mixMap_src:{value:y},mixSrc_alpha_mixMap_ch:{value:0},mixDst:{value:!1},mixDst_src:{value:new o.Texture},mixDst_fit:{value:0},mixDst_fitScale:{value:new o.Vector2(1,1)},mixDst_uv:{value:!1},mixDst_uv_ch:{value:0},mixDst_uv_factor:{value:0},mixDst_uv_offset:{value:new o.Vector2(0,0)},mixDst_uv_radius:{value:.5},mixDst_uv_position:{value:new o.Vector2(.5,.5)},mixDst_uv_range:{value:new o.Vector2(0,1)},mixDst_uv_mixMap:{value:!1},mixDst_uv_mixMap_src:{value:y},mixDst_uv_mixMap_ch:{value:0},mixDst_color:{value:!1},mixDst_color_factor:{value:0},mixDst_color_radius:{value:.5},mixDst_color_position:{value:new o.Vector2(.5,.5)},mixDst_color_range:{value:new o.Vector2(0,1)},mixDst_color_mixMap:{value:!1},mixDst_color_mixMap_src:{value:y},mixDst_color_mixMap_ch:{value:0},mixDst_alpha:{value:!1},mixDst_alpha_factor:{value:0},mixDst_alpha_radius:{value:.5},mixDst_alpha_position:{value:new o.Vector2(.5,.5)},mixDst_alpha_range:{value:new o.Vector2(0,1)},mixDst_alpha_mixMap:{value:!1},mixDst_alpha_mixMap_src:{value:y},mixDst_alpha_mixMap_ch:{value:0},levels:{value:!1},levels_shadows:{value:new o.Vector4(0,0,0,0)},levels_midtones:{value:new o.Vector4(1,1,1,1)},levels_highlights:{value:new o.Vector4(1,1,1,1)},levels_outputMin:{value:new o.Vector4(0,0,0,0)},levels_outputMax:{value:new o.Vector4(1,1,1,1)},contrast:{value:!1},contrast_factor:{value:new o.Vector4(1,1,1,1)},colorBalance:{value:!1},colorBalance_factor:{value:new o.Vector3(1,1,1)},hsv:{value:!1},hsv_hueShift:{value:0},hsv_saturation:{value:1},hsv_brightness:{value:1},posterize:{value:!1},posterize_levels:{value:new o.Vector4(0,0,0,0)},grayscale:{value:!1},grayscale_weight:{value:new o.Vector3(0,0,0)},grayscale_duotone:{value:!1},grayscale_duotone_color0:{value:new o.Color(0)},grayscale_duotone_color1:{value:new o.Color(16777215)},grayscale_threshold:{value:-1}};function fe(e){const{mixSrc:t,mixDst:r,srcSystem:a,levels:n,contrast:i,colorBalance:s,hsv:c,posterize:u,grayscale:l}=e;return{USF_USE_SRC_SYSTEM:a,USF_USE_MIXSRC:t,USF_USE_MIXDST:r,USF_USE_LEVELS:n,USF_USE_CONTRAST:i,USF_USE_COLORBALANCE:s,USF_USE_HSV:c,USF_USE_POSTERIZE:u,USF_USE_GRAYSCALE:l}}function ae(e){const t=!!e.mixSrc.value,r=!!e.mixDst.value;return{mixSrc:t,mixDst:r,srcSystem:t||r,levels:!!e.levels.value,contrast:!!e.contrast.value,colorBalance:!!e.colorBalance.value,hsv:!!e.hsv.value,posterize:!!e.posterize.value,grayscale:!!e.grayscale.value}}var Ve="#usf ",ke="#usf ",Ie="#usf ",Le="#usf ",Ae=`#usf +#usf `,$e=`#usf +#usf +#usf `,je=`#usf +#usf +#usf +#usf `,ze="#usf ",Ne=`#usf +#usf +#usf `,Ke="#usf ",Xe="#usf ",qe="#usf ";const g=Object.freeze({plane_vertex:Ve,default_vertex:ke,default_pars_vertex:Ie,default_pars_fragment:Le,basicFx_vertex:Ae,basicFx_pars_vertex:$e,basicFx_pars_fragment:je,basicFx_fragment_begin:ze,basicFx_fragment_end:Ne,samplingFx_vertex:Ke,samplingFx_pars_vertex:Xe,samplingFx_pars_fragment:qe}),Ge=` + void main() { + ${g.plane_vertex} + } +`,He=` + precision highp int; + + uniform float tick; + uniform float timeStrength; + uniform int noiseOctaves; + uniform int fbmOctaves; + uniform int warpOctaves; + uniform vec2 warpDirection; + uniform float warpStrength; + uniform float scale; + uniform float timeOffset; + + const float per = 0.5; + const float PI = 3.14159265359; + + float rnd(vec2 n) { + float a = 0.129898; + float b = 0.78233; + float c = 437.585453; + float dt= dot(n ,vec2(a, b)); + float sn= mod(dt, PI); + return fract(sin(sn) * c); + } + + float interpolate(float a, float b, float x){ + float f = (1.0 - cos(x * PI)) * 0.5; + return a * (1.0 - f) + b * f; + } + + float irnd(vec2 p){ + vec2 i = floor(p); + vec2 f = fract(p); + vec4 v = vec4(rnd(vec2(i.x,i.y)),rnd(vec2(i.x + 1.0,i.y)),rnd(vec2(i.x,i.y + 1.0)),rnd(vec2(i.x + 1.0, i.y + 1.0))); + return interpolate(interpolate(v.x, v.y, f.x), interpolate(v.z, v.w, f.x), f.y); + } + + // Based on The Book of Shaders + // https://thebookofshaders.com/13/ + float noise(vec2 p, float time){ + float _time = time + timeOffset; + float t = 0.0; + for(int i = 0; i < noiseOctaves; i++){ + float freq = pow(2.0, float(i)); + float amp = pow(per, float(noiseOctaves - i)); + t += irnd(vec2(p.y / freq + _time, p.x / freq + _time)) * amp; + } + return t; + } + + float fbm(vec2 x, float time) { + float v = 0.0; + float a = 0.5; + vec2 shift = vec2(100); + mat2 rot = mat2(cos(0.5), sin(0.5), -sin(0.5), cos(0.5)); + float sign = 1.0; + for (int i = 0; i < fbmOctaves; ++i) { + v += a * noise(x, time * sign); + x = rot * x * 2.0 + shift; + a *= 0.5; + sign *= -1.0; + } + return v; + } + + float warp(vec2 x, float g,float time){ + float val = 0.0; + for (int i = 0; i < warpOctaves; i++){ + val = fbm(x + g * vec2(cos(warpDirection.x * val), sin(warpDirection.y * val)), time); + } + return val; + } + + void main() { + + vec2 usf_Uv = gl_FragCoord.xy * scale; + + ${g.basicFx_fragment_begin} + + float noise = warp(usf_Uv ,warpStrength,tick * timeStrength); + + vec4 usf_FragColor = vec4(noise); + + ${g.basicFx_fragment_end} + + gl_FragColor = usf_FragColor; + + } +`;var Qe="gl_Position = vec4(position, 1.0);",Ye=`#ifdef USF_USE_SRC_SYSTEM + + #usf + +#endif`,We=`#ifdef USF_USE_SRC_SYSTEM + + #usf + + float calcMixCirclePower(vec2 center, float radius, vec2 range) + { + vec2 adjustedUV = (vUv - 0.5) * vec2(aspectRatio, 1.0) + 0.5; + vec2 adjustedCenter = (center - 0.5) * vec2(aspectRatio, 1.0) + 0.5; + + float dist = length(adjustedUV - adjustedCenter); + float power = radius > 0.0 ? 1.0 - dist / radius : 1.0; + return smoothstep(range.x,range.y,power); + } + + float calcMixMapPower(sampler2D map,vec2 range, int ch) + { + return smoothstep(range.x,range.y, texture2D(map, vUv)[ch]); + } + + vec4 fitTexture(sampler2D src , vec2 uv, int fitType) + { + + float a = fitType == 2 ? step(0.0, uv.x) * step(uv.x, 1.0) * step(0.0, uv.y) * step(uv.y, 1.0) : 1.; + return mix(vec4(0.), texture2D(src, uv), a); + } + +#endif`,Ze="vUv = uv;",Je=`precision highp float; + +varying vec2 vUv; +uniform vec2 resolution; +uniform vec2 texelSize; +uniform float aspectRatio; +uniform vec2 maxAspect;`,et=`precision highp float; + +varying vec2 vUv; +uniform vec2 resolution; +uniform vec2 texelSize; +uniform float aspectRatio; +uniform vec2 maxAspect; +uniform int renderCount;`,tt=`#ifdef USF_USE_MIXSRC + varying vec2 vMixSrcCoverUv; + uniform vec2 mixSrc_fitScale; +#endif`,rt=`#ifdef USF_USE_MIXSRC + vMixSrcCoverUv = calcSrcUv(vUv, mixSrc_fitScale); +#endif`,at=`#ifdef USF_USE_MIXSRC + varying vec2 vMixSrcCoverUv; + uniform sampler2D mixSrc_src; + uniform int mixSrc_fit; + + uniform bool mixSrc_uv; + uniform int mixSrc_uv_ch; + uniform float mixSrc_uv_factor; + uniform vec2 mixSrc_uv_offset; + uniform float mixSrc_uv_radius; + uniform vec2 mixSrc_uv_position; + uniform vec2 mixSrc_uv_range; + uniform bool mixSrc_uv_mixMap; + uniform sampler2D mixSrc_uv_mixMap_src; + uniform int mixSrc_uv_mixMap_ch; + + uniform bool mixSrc_color; + uniform float mixSrc_color_factor; + uniform float mixSrc_color_radius; + uniform vec2 mixSrc_color_position; + uniform vec2 mixSrc_color_range; + uniform bool mixSrc_color_mixMap; + uniform sampler2D mixSrc_color_mixMap_src; + uniform int mixSrc_color_mixMap_ch; + + uniform bool mixSrc_alpha; + uniform float mixSrc_alpha_factor; + uniform float mixSrc_alpha_radius; + uniform vec2 mixSrc_alpha_position; + uniform vec2 mixSrc_alpha_range; + uniform bool mixSrc_alpha_mixMap; + uniform sampler2D mixSrc_alpha_mixMap_src; + uniform int mixSrc_alpha_mixMap_ch; + +#endif`,nt=`#ifdef USF_USE_MIXSRC + + vec4 mixSrcColor = fitTexture(mixSrc_src, vMixSrcCoverUv, mixSrc_fit); + + usf_Uv += mixSrc_uv + ? (mixSrc_uv_offset + (vec2(mixSrcColor[mixSrc_uv_ch]) * 2. - 1.)) * + (mixSrc_uv_mixMap + ? calcMixMapPower(mixSrc_uv_mixMap_src,mixSrc_uv_range,mixSrc_uv_mixMap_ch) + : calcMixCirclePower(mixSrc_uv_position,mixSrc_uv_radius,mixSrc_uv_range)) * mixSrc_uv_factor + : vec2(0.); + +#endif`,st=`#ifdef USF_USE_MIXSRC + + usf_FragColor = mixSrc_color + ? mix(usf_FragColor, mixSrcColor, + (mixSrc_color_mixMap + ? calcMixMapPower(mixSrc_color_mixMap_src,mixSrc_color_range,mixSrc_color_mixMap_ch) + : calcMixCirclePower(mixSrc_color_position,mixSrc_color_radius,mixSrc_color_range)) * mixSrc_color_factor) + : usf_FragColor; + + + usf_FragColor = mixSrc_alpha + ? mix(usf_FragColor, mixSrcColor, + (mixSrc_alpha_mixMap + ? calcMixMapPower(mixSrc_alpha_mixMap_src,mixSrc_alpha_range,mixSrc_alpha_mixMap_ch) + : calcMixCirclePower(mixSrc_alpha_position,mixSrc_alpha_radius,mixSrc_alpha_range)) * mixSrc_alpha_factor * mixSrcColor.a) + : usf_FragColor; + +#endif`,it=`#ifdef USF_USE_MIXDST + varying vec2 vMixDstCoverUv; + uniform vec2 mixDst_fitScale; +#endif`,ot=`#ifdef USF_USE_MIXDST + vMixDstCoverUv = calcSrcUv(vUv, mixDst_fitScale); +#endif`,ct=`#ifdef USF_USE_MIXDST + + varying vec2 vMixDstCoverUv; + uniform sampler2D mixDst_src; + uniform int mixDst_fit; + + uniform bool mixDst_uv; + uniform int mixDst_uv_ch; + uniform float mixDst_uv_factor; + uniform vec2 mixDst_uv_offset; + uniform float mixDst_uv_radius; + uniform vec2 mixDst_uv_position; + uniform vec2 mixDst_uv_range; + uniform bool mixDst_uv_mixMap; + uniform sampler2D mixDst_uv_mixMap_src; + uniform int mixDst_uv_mixMap_ch; + + uniform bool mixDst_color; + uniform float mixDst_color_factor; + uniform float mixDst_color_radius; + uniform vec2 mixDst_color_position; + uniform vec2 mixDst_color_range; + uniform bool mixDst_color_mixMap; + uniform sampler2D mixDst_color_mixMap_src; + uniform int mixDst_color_mixMap_ch; + + uniform bool mixDst_alpha; + uniform float mixDst_alpha_factor; + uniform float mixDst_alpha_radius; + uniform vec2 mixDst_alpha_position; + uniform vec2 mixDst_alpha_range; + uniform bool mixDst_alpha_mixMap; + uniform sampler2D mixDst_alpha_mixMap_src; + uniform int mixDst_alpha_mixMap_ch; + +#endif`,ut=`#ifdef USF_USE_MIXDST + + + vec2 mixedUv = vMixDstCoverUv; + mixedUv += mixDst_uv + ? (mixDst_uv_offset + (vec2(usf_FragColor[mixDst_uv_ch]) * 2. - 1.)) * + (mixDst_uv_mixMap + ? calcMixMapPower(mixDst_uv_mixMap_src,mixDst_uv_range,mixDst_uv_mixMap_ch) + : calcMixCirclePower(mixDst_uv_position,mixDst_uv_radius,mixDst_uv_range)) * mixDst_uv_factor + : vec2(0.); + vec4 mixDstColor = fitTexture(mixDst_src, mixedUv , mixDst_fit); + + + usf_FragColor = mixDst_color + ? mix(usf_FragColor, mixDstColor, + (mixDst_color_mixMap + ? calcMixMapPower(mixDst_color_mixMap_src,mixDst_color_range,mixDst_color_mixMap_ch) + : calcMixCirclePower(mixDst_color_position,mixDst_color_radius,mixDst_color_range)) * mixDst_color_factor) + : usf_FragColor; + + + usf_FragColor = mixDst_alpha + ? mix(usf_FragColor, mixDstColor, + (mixDst_alpha_mixMap + ? calcMixMapPower(mixDst_alpha_mixMap_src,mixDst_alpha_range,mixDst_alpha_mixMap_ch) + : calcMixCirclePower(mixDst_alpha_position,mixDst_alpha_radius,mixDst_alpha_range)) * mixDst_alpha_factor * mixDstColor.a) + : usf_FragColor; + +#endif`,lt=`#ifdef USF_USE_TEXTURE + vTextureCoverUv = calcSrcUv(vUv, texture_fitScale); +#endif`,ft=`#ifdef USF_USE_TEXTURE + varying vec2 vTextureCoverUv; + uniform vec2 texture_fitScale; +#endif`,_t=`#ifdef USF_USE_TEXTURE + varying vec2 vTextureCoverUv; + uniform sampler2D texture_src; + uniform int texture_fit; + uniform vec2 texture_fitScale; +#endif`,vt=`#ifdef USF_USE_LEVELS + usf_FragColor = (usf_FragColor - vec4(levels_shadows)) / (vec4(levels_highlights) - vec4(levels_shadows)); + usf_FragColor = pow(usf_FragColor, vec4(1.0 / levels_midtones)); + usf_FragColor = usf_FragColor * (vec4(levels_outputMax) - vec4(levels_outputMin)) + vec4(levels_outputMin); +#endif + +#ifdef USF_USE_CONTRAST + usf_FragColor = clamp(((usf_FragColor-.5)*contrast_factor)+.5, 0., 1.); +#endif + +#ifdef USF_USE_COLORBALANCE + usf_FragColor.rgb = clamp(usf_FragColor.rgb * colorBalance_factor, 0., 1.); +#endif + +#ifdef USF_USE_HSV + vec3 hsv = rgb2hsv(usf_FragColor.rgb); + hsv.x = fract(hsv.x + hsv_hueShift); + hsv.y = clamp(hsv.y * hsv_saturation, 0.0, 1.0); + hsv.z = clamp(hsv.z * hsv_brightness, 0.0, 1.0); + usf_FragColor.rgb = hsv2rgb(hsv); +#endif + +#ifdef USF_USE_POSTERIZE + usf_FragColor = posterize(usf_FragColor, posterize_levels); +#endif + +#ifdef USF_USE_GRAYSCALE + float grayscale = dot(usf_FragColor.rgb, vec3(0.299 + grayscale_weight.r, 0.587 + grayscale_weight.g, 0.114 + grayscale_weight.b)); + grayscale = grayscale_threshold > 0.0 ? step(grayscale_threshold, grayscale) : grayscale; + vec3 duotoneColor = mix(grayscale_duotone_color0, grayscale_duotone_color1, grayscale); + usf_FragColor.rgb = grayscale_duotone ? duotoneColor : vec3(grayscale); +#endif`,mt=`#ifdef USF_USE_LEVELS + uniform vec4 levels_shadows; + uniform vec4 levels_midtones; + uniform vec4 levels_highlights; + uniform vec4 levels_outputMin; + uniform vec4 levels_outputMax; +#endif + +#ifdef USF_USE_CONTRAST + uniform vec4 contrast_factor; +#endif + +#ifdef USF_USE_COLORBALANCE + uniform vec3 colorBalance_factor; +#endif + +#ifdef USF_USE_HSV + uniform float hsv_hueShift; + uniform float hsv_saturation; + uniform float hsv_brightness; + vec3 hsv2rgb(vec3 c) + { + vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0); + vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www); + return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y); + } + vec3 rgb2hsv(vec3 c) + { + vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0); + vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g)); + vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r)); + + float d = q.x - min(q.w, q.y); + float e = 1.0e-10; + return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x); + } +#endif + +#ifdef USF_USE_POSTERIZE + uniform vec4 posterize_levels; + vec4 posterize(vec4 color, vec4 levels) + { + return vec4( + levels.x > 1. ? floor(color.r * levels.x) / levels.x : color.r, + levels.y > 1. ? floor(color.g * levels.y) / levels.y : color.g, + levels.z > 1. ? floor(color.b * levels.z) / levels.z : color.b, + levels.w > 1. ? floor(color.a * levels.w) / levels.w : color.a + ); + } +#endif + +#ifdef USF_USE_GRAYSCALE + uniform vec3 grayscale_weight; + uniform bool grayscale_duotone; + uniform vec3 grayscale_duotone_color0; + uniform vec3 grayscale_duotone_color1; + uniform float grayscale_threshold; +#endif`,pt=`vec2 calcSrcUv(vec2 uv, vec2 fitScale) { + return uv * fitScale + (1.0 - fitScale) * .5; +}`;const xt=Object.freeze({plane_vertex:Qe,srcSystem_pars_vertex:Ye,srcSystem_pars_fragment:We,default_vertex:Ze,default_pars_vertex:Je,default_pars_fragment:et,mixSrc_vertex:rt,mixSrc_pars_vertex:tt,mixSrc_pars_fragment:at,mixSrc_fragment_begin:nt,mixSrc_fragment_end:st,mixDst_pars_vertex:it,mixDst_vertex:ot,mixDst_pars_fragment:ct,mixDst_fragment:ut,texture_vertex:lt,texture_pars_vertex:ft,texture_pars_fragment:_t,adjustments_fragment:vt,adjustments_pars_fragment:mt,calcSrcUv:pt});function E(e){return e.filter(t=>t!=="").join(` +`)}function ne(e,t,r){let a,n;const i={default:{vertexPars:g.default_pars_vertex,vertexMain:g.default_vertex,fragmentPars:g.default_pars_fragment},basicFx:{vertexPars:g.basicFx_pars_vertex,vertexMain:g.basicFx_vertex,fragmentPars:g.basicFx_pars_fragment},samplingFx:{vertexPars:E([g.basicFx_pars_vertex,g.samplingFx_pars_vertex]),vertexMain:E([g.basicFx_vertex,g.samplingFx_vertex]),fragmentPars:E([g.basicFx_pars_fragment,g.samplingFx_pars_fragment])}},s=i[r].vertexPars,c=i[r].vertexMain,u=i[r].fragmentPars;return e&&(a=E([s,e]),a=a.replace(/void\s+main\s*\(\)\s*\{/,`void main() { +${c}`)),t&&(n=E([u,t])),[a,n]}const dt=/^[ \t]*#usf +<([\w\d./]+)>/gm;function ht(e,t){return se(xt[t]||"")}function se(e){return e.replace(dt,ht)}function gt(e){return e&&Be.some(t=>e[t]===!0)}function St(e){const t={},r=(a,n="")=>{for(const[i,s]of Object.entries(a)){const c=n?`${n}_${i}`:i;s&&typeof s=="object"&&!Array.isArray(s)&&!gt(s)?(t[c]=!0,r(s,c)):(t.hasOwnProperty(c)&&$(`${c} already exists and will be overwritten.`),t[c]=s)}};return r(e),t}class C extends o.ShaderMaterial{constructor({uniformValues:t,materialParameters:r={},uniforms:a,vertexShader:n,fragmentShader:i}={}){super(r),this.uniforms={resolution:{value:new o.Vector2},texelSize:{value:new o.Vector2},aspectRatio:{value:0},maxAspect:{value:new o.Vector2},renderCount:{value:0},...a},this._setupShaders(n,i),this.setUniformValues(t),this._defineUniformAccessors()}updateResolution(t,r){const a=Math.max(t,r);this.uniforms.resolution.value.set(t,r),this.uniforms.texelSize.value.set(1/t,1/r),this.uniforms.aspectRatio.value=t/r,this.uniforms.maxAspect.value.set(a/t,a/r)}_setupShaders(t,r){if(!t&&!r)return;const[a,n]=ne(t,r,"default");this.vertexShader=a?se(a):this.vertexShader,this.fragmentShader=n?se(n):this.fragmentShader}setUniformValues(t){if(t===void 0)return;const r=St(t);for(const[a,n]of Object.entries(r)){if(n===void 0){$(`parameter '${a}' has value of undefined.`);continue}const i=this.uniforms[a];if(i===void 0){$(`'${a}' is not a uniform property of ${this.type}.`);continue}i.value=typeof n=="function"?n(i.value):n}return r}_defineUniformAccessors(t){for(const r of Object.keys(this.uniforms)){if(this.hasOwnProperty(r)){$(`'${r}' is already defined in ${this.type}.`);continue}Object.defineProperty(this,r,{get:()=>this.uniforms[r].value,set:a=>{this.uniforms[r].value=a,t==null||t()}})}}}C.key=o.MathUtils.generateUUID();class ie extends C{constructor({uniforms:t,vertexShader:r,fragmentShader:a,...n}={}){var i;super({...n,uniforms:{...o.UniformsUtils.clone(j),...t}}),this.defines={...(i=n==null?void 0:n.materialParameters)==null?void 0:i.defines},this.programCache=0,this.fxKey=this._setupFxKey(this.uniforms),this._setupFxShaders(r,a)}_setupFxShaders(t,r){if(!t&&!r)return;this._updateFxDefines();const[a,n]=this._handleMergeShaderLib(t,r);super._setupShaders(a,n)}_handleMergeShaderLib(t,r){return ne(t,r,"basicFx")}_updateFxShaders(){if(!this.fxKey)return;const t=this.programCache,{diffCount:r,newFxKey:a}=this._handleUpdateFxShaders();this.programCache+=r,this.fxKey=a,t!==this.programCache&&(this._updateFxDefines(),this.needsUpdate=!0)}_handleUpdateFxShaders(){const t=ae(this.uniforms);return{diffCount:Object.keys(t).filter(a=>this.fxKey[a]!==t[a]).length,newFxKey:t}}_updateFxDefines(){Object.assign(this.defines,this._handleUpdateFxDefines())}_handleUpdateFxDefines(){return fe(this.fxKey)}_isContainsBasicFxValues(t,r){return t?Object.keys(t).some(a=>Object.keys(r??j).includes(a)):!1}_setupFxKey(t){return ae(t)}_calcFitScale(t,r){var c;let a=1;const n=new o.Vector2(1,1),i=this.uniforms.aspectRatio.value,s=(c=t==null?void 0:t.source)==null?void 0:c.data;return s!=null&&s.width&&(s!=null&&s.height)?a=s.width/s.height:a=i,r===1?n.set(Math.min(i/a,1),Math.min(a/i,1)):r===2&&n.set(Math.max(i/a,1),Math.max(a/i,1)),n}_setFitScale(t){const r=this.uniforms;r[`${t}_fitScale`].value=this._calcFitScale(r[`${t}_src`].value,r[`${t}_fit`].value)}_updateFitScale(){var t,r;(t=this.fxKey)!=null&&t.mixSrc&&this._setFitScale("mixSrc"),(r=this.fxKey)!=null&&r.mixDst&&this._setFitScale("mixDst")}setUniformValues(t,r=!0){const a=super.setUniformValues(t);return r&&this._isContainsBasicFxValues(a)&&(this._updateFxShaders(),this._updateFitScale()),a}_defineUniformAccessors(t){super._defineUniformAccessors(()=>{this._updateFxShaders(),this._updateFitScale(),t==null||t()})}updateResolution(t,r){super.updateResolution(t,r),this._updateFitScale()}}const _e=class De extends ie{constructor(t={}){super({...t,vertexShader:Ge,fragmentShader:He,uniforms:{tick:{value:0},scale:{value:.03},timeStrength:{value:.3},noiseOctaves:{value:2},fbmOctaves:{value:2},warpOctaves:{value:2},warpDirection:{value:new o.Vector2(2,2)},warpStrength:{value:8},timeOffset:{value:0}}}),this.type=De.type}static get type(){return"NoiseMaterial"}};_e.key=o.MathUtils.generateUUID();let ve=_e;const me=` + uniform bool bounce; + varying vec2 vL; + varying vec2 vR; + varying vec2 vT; + varying vec2 vB; +`,oe=(e=!0)=>` + vec3 pos = position; + vec2 scale = ${e?"bounce ? vec2(1.,1.) : 1.-texelSize*2.":"1.-texelSize*2."}; + pos.xy = pos.xy * scale; + vUv = vec2(.5)+(pos.xy)*.5; + `,pe=e=>` + vL = vUv - vec2(texelSize.x * ${e}, 0.0); + vR = vUv + vec2(texelSize.x * ${e}, 0.0); + vT = vUv + vec2(0.0, texelSize.y * ${e}); + vB = vUv - vec2(0.0, texelSize.y * ${e}); + `,I={main:` + ${me} + + void main(){ + + ${oe()} + ${pe("1.")} + + gl_Position = vec4(pos, 1.0); + } + `,poisson:` + ${me} + + void main(){ + + ${oe()} + ${pe("2.")} + + gl_Position = vec4(pos, 1.0); + } + `,advection:` + void main(){ + ${oe(!1)} + gl_Position = vec4(pos, 1.0); + } + `,splat:` + uniform vec2 center; + uniform vec2 radius; + void main(){ + vec2 pos = position.xy * radius * 2.0 * texelSize + center; + gl_Position = vec4(pos, 0.0, 1.0); + } + `};var yt=`uniform float deltaTime; +uniform sampler2D velocity; +uniform float dissipation; + +void main(){ + vec2 vel = texture2D(velocity, vUv).xy; + vec2 uv2 = vUv - vel * deltaTime * maxAspect; + vec2 newVel = texture2D(velocity, uv2).xy; + gl_FragColor = vec4(dissipation * newVel, 0.0, 0.0); +}`;class z extends C{constructor(t){super({...t,vertexShader:I.advection,fragmentShader:yt,uniforms:{dissipation:{value:.99},velocity:{value:y},deltaTime:{value:H}}}),this.type=z.type}static get type(){return"AdvectionMaterial"}}var Ft=`uniform float deltaTime; +uniform sampler2D velocity; + +varying vec2 vL; +varying vec2 vR; +varying vec2 vT; +varying vec2 vB; + +void main(){ + float L = texture2D(velocity, vL).r; + float R = texture2D(velocity, vR).r; + float B = texture2D(velocity, vB).g; + float T = texture2D(velocity, vT).g; + + float divergence = (R-L + T-B) / 2.0; + gl_FragColor = vec4(divergence / deltaTime); +}`;class N extends C{constructor(t){super({...t,vertexShader:I.main,fragmentShader:Ft,uniforms:{bounce:{value:!0},velocity:{value:y},deltaTime:{value:H}}}),this.type=N.type}static get type(){return"DivergenceMaterial"}}var Mt=`uniform float deltaTime; +uniform sampler2D pressure; +uniform sampler2D velocity; + +varying vec2 vL; +varying vec2 vR; +varying vec2 vT; +varying vec2 vB; + +void main(){ + + float L = texture2D(pressure, vL).r; + float R = texture2D(pressure, vR).r; + float B = texture2D(pressure, vB).r; + float T = texture2D(pressure, vT).r; + + vec2 v = texture2D(velocity, vUv).xy; + vec2 gradP = vec2(R - L, T - B) * 0.5; + v = v - gradP * deltaTime; + + gl_FragColor = vec4(v, 0.0, 1.0); + +}`;class K extends C{constructor(t){super({...t,vertexShader:I.main,fragmentShader:Mt,uniforms:{bounce:{value:!0},deltaTime:{value:H},pressure:{value:y},velocity:{value:y}}}),this.type=K.type}static get type(){return"PressureMaterial"}}var Ut=`uniform sampler2D pressure; +uniform sampler2D divergence; + +varying vec2 vL; +varying vec2 vR; +varying vec2 vT; +varying vec2 vB; + +void main(){ + + float L = texture2D(pressure, vL).r; + float R = texture2D(pressure, vR).r; + float B = texture2D(pressure, vB).r; + float T = texture2D(pressure, vT).r; + + float div = texture2D(divergence, vUv).r; + + float newP = (L + R + B + T) / 4.0 - div; + + gl_FragColor = vec4(newP); +}`;class X extends C{constructor({customParameters:t,...r}){super({...r,vertexShader:I.poisson,fragmentShader:Ut,uniforms:{bounce:{value:!0},pressure:{value:y},divergence:{value:y}}}),this.iterations=(t==null?void 0:t.iterations)??32,this.type=X.type}static get type(){return"PoissonMaterial"}}var Dt=`uniform vec2 force; +uniform float forceBias; + +void main(){ + gl_FragColor = vec4(force * forceBias * pow(1.0 - clamp(2.0 * distance(vUv, vec2(0.5)), 0.0, 1.0), 2.0), 0.0, 1.0); +}`;class q extends C{constructor(t){super({...t,vertexShader:I.splat,fragmentShader:Dt,uniforms:{forceBias:{value:20},radius:{value:new o.Vector2(50,50)},force:{value:new o.Vector2(0,0)},center:{value:new o.Vector2(0,0)}}}),this.type=q.type,this.blending=o.AdditiveBlending}static get type(){return"SplatMaterial"}}class G extends ie{constructor(t={}){super({...t,vertexShader:` + void main() { + ${g.plane_vertex} + } + `,fragmentShader:` + uniform sampler2D src; + void main() { + vec2 usf_Uv = vUv; + + ${g.basicFx_fragment_begin} + + vec4 usf_FragColor = vec4(length(texture2D(src,usf_Uv).rg)); + + ${g.basicFx_fragment_end} + + gl_FragColor = usf_FragColor; + } + `,uniforms:{src:{value:y}}}),this.type=G.type}static get type(){return"OutputMaterial"}}const H=.008,bt=Object.freeze(Object.defineProperty({__proto__:null,AdvectionMaterial:z,DELTA_TIME:H,DivergenceMaterial:N,OutputMaterial:G,PoissonMaterial:X,PressureMaterial:K,SplatMaterial:q},Symbol.toStringTag,{value:"Module"})),xe={texture:{value:!0},texture_src:{value:y},texture_fit:{value:0},texture_fitScale:{value:new o.Vector2(1,1)}};class de extends ie{constructor({uniforms:t,...r}){super({...r,uniforms:{...o.UniformsUtils.clone(xe),...t}})}_handleMergeShaderLib(t,r){return ne(t,r,"samplingFx")}_isContainsBasicFxValues(t){return super._isContainsBasicFxValues(t,{...j,...xe})}_updateFitScale(){super._updateFitScale(),this._setFitScale("texture")}_setupFxKey(t){const r=super._setupFxKey(t);return r.srcSystem=!0,r}_handleUpdateFxShaders(){const{diffCount:t,newFxKey:r}=super._handleUpdateFxShaders();return r.srcSystem=!0,{diffCount:t,newFxKey:r}}_handleUpdateFxDefines(){return Object.assign(super._handleUpdateFxDefines(),{USF_USE_TEXTURE:!0})}}const he=class be extends de{constructor(t={}){super({...t,vertexShader:` + void main() { + ${g.plane_vertex} + } + `,fragmentShader:` + void main() { + vec2 usf_Uv = vTextureCoverUv; + + ${g.basicFx_fragment_begin} + + vec4 usf_FragColor = fitTexture(texture_src,usf_Uv,texture_fit); + + ${g.basicFx_fragment_end} + + gl_FragColor = usf_FragColor; + } + `}),this.type=be.type}static get type(){return"BufferMaterial"}};he.key=o.MathUtils.generateUUID();let ge=he;class Q extends C{static get type(){return"RawBlankMaterial"}constructor(t){super(t),this.type=Q.type}}const Se=` + uniform float time; + uniform vec2 pointer; + uniform sampler2D backbuffer; +`;class Y extends C{constructor({vertexShader:t,fragmentShader:r,uniforms:a,...n}){super({...n,vertexShader:t&&E([Se,t]),fragmentShader:r&&E([Se,r]),uniforms:{time:{value:0},pointer:{value:new o.Vector2},backbuffer:{value:new o.Texture},...a}}),this.type=Y.type}static get type(){return"BlankMaterial"}}const Ct=` + void main() { + ${g.plane_vertex} + } +`,wt=` + uniform vec2 count; + uniform bool autoScale; + uniform float tick; + uniform bool shuffle; + uniform float shuffle_frequency; + uniform float shuffle_range; + + uniform bool sprite; + uniform sampler2D sprite_src; + uniform float sprite_length; + uniform float sprite_shuffleSpeed; + + float hash(vec2 p) { + return fract(sin(dot(p, vec2(12.9898, 78.233))) * 43758.5453); + } + + vec2 shuffleIndex(vec2 cellIndex , vec2 count) { + + float discreteTime = floor(tick * shuffle_frequency); + + float r1 = hash(cellIndex + vec2(0.123, discreteTime)); + float r2 = hash(cellIndex + vec2(0.789, discreteTime)); + + // -range ~ +range + float offsetX = floor(r1 * (shuffle_range * 2.0 + 1.0)) - shuffle_range; + float offsetY = floor(r2 * (shuffle_range * 2.0 + 1.0)) - shuffle_range; + vec2 offset = vec2(offsetX, offsetY); + + return mod(cellIndex + offset, count); + } + + void main() { + vec2 usf_Uv = vUv; + ${g.basicFx_fragment_begin} + + vec2 n_count = count; + n_count.x *= autoScale ? aspectRatio : 1.; + + vec2 cellIndex = ceil(usf_Uv * n_count); + + vec2 shuffledIndex = shuffle ? shuffleIndex(cellIndex, n_count) : cellIndex; + + vec2 cellCenter = calcSrcUv((shuffledIndex - .5) / n_count, texture_fitScale); + + vec4 gridTextureColor = fitTexture(texture_src, cellCenter, texture_fit); + + if(sprite){ + vec2 cellUv = fract(usf_Uv * n_count); + float cellHash = hash(cellIndex); + float spritePos = fract(cellHash + tick * sprite_shuffleSpeed); + float spriteIndex = floor(spritePos * sprite_length); + float spriteSize = 1.0 / sprite_length; + float spriteOffset = spriteIndex * spriteSize; + float spriteU = spriteOffset + cellUv.x * spriteSize; + vec2 spriteUv = vec2(spriteU, cellUv.y); + vec4 spriteColor = texture2D(sprite_src, spriteUv); + gridTextureColor *= spriteColor; + } + + vec4 usf_FragColor = gridTextureColor; + ${g.basicFx_fragment_end} + + gl_FragColor = usf_FragColor; + + } +`;class W extends de{constructor(t){super({...t,vertexShader:Ct,fragmentShader:wt,uniforms:{count:{value:new o.Vector2(20,20)},autoScale:{value:!0},tick:{value:0},shuffle:{value:!1},shuffle_frequency:{value:5},shuffle_range:{value:2},sprite:{value:!1},sprite_src:{value:new o.Texture},sprite_length:{value:10},sprite_shuffleSpeed:{value:0}}}),this.setNearestFilter(),this.type=W.type}static get type(){return"GridMaterial"}setNearestFilter(){this.uniforms.texture_src.value.magFilter=o.NearestFilter,this.uniforms.texture_src.value.minFilter=o.NearestFilter,this.uniforms.sprite_src.value.magFilter=o.NearestFilter,this.uniforms.sprite_src.value.minFilter=o.NearestFilter}}const Tt=({size:e,dpr:t,fboAutoSetSize:r,renderTargetOptions:a,materialParameters:n,...i})=>{const s=R(t),{scene:c,material:u,camera:l}=F({size:e,dpr:s.shader,material:ve,uniformValues:i,materialParameters:n}),[m,v]=D({scene:c,camera:l,size:e,dpr:s.fbo,fboAutoSetSize:r,...a}),p=_.useCallback((x,f=!0)=>{u.setUniformValues(x,f)},[u]);return{render:_.useCallback((x,f)=>{const{gl:S,clock:T}=x;return f&&p(f,!1),u.uniforms.tick.value=typeof(f==null?void 0:f.tick)=="function"?f.tick(u.uniforms.tick.value):(f==null?void 0:f.tick)||T.getElapsedTime(),v({gl:S})},[p,v,u]),setValues:p,texture:m.texture,material:u,scene:c,camera:l,renderTarget:m}},Et=({size:e,dpr:t,...r},a)=>{const{scene:n,material:i,camera:s}=F({size:e,dpr:t,material:z,uniformValues:r});return{render:_.useCallback(u=>{const{gl:l}=u;a({gl:l,scene:n,camera:s})},[a,n,s]),material:i}},ye=(e=0)=>{const t=_.useRef(new o.Vector2(0,0)),r=_.useRef(new o.Vector2(0,0)),a=_.useRef(new o.Vector2(0,0)),n=_.useRef(0),i=_.useRef(new o.Vector2(0,0)),s=_.useRef(!1);return _.useCallback(u=>{const l=performance.now();let m;s.current&&e?(a.current=a.current.lerp(u,1-e),m=a.current.clone()):(m=u.clone(),a.current=m),n.current===0&&(n.current=l,t.current=m);const v=Math.max(1,l-n.current);n.current=l,i.current.copy(m).sub(t.current).divideScalar(v);const p=i.current.length()>0,h=s.current?t.current.clone():m;return!s.current&&p&&(s.current=!0),t.current=m,{currentPointer:m,prevPointer:h,diffPointer:r.current.subVectors(m,h),velocity:i.current,isVelocityUpdate:p}},[e])},Ot=({size:e,dpr:t,...r},a)=>{const{scene:n,material:i,camera:s}=F({size:e,dpr:t,material:q,geometrySize:{width:1,height:1},uniformValues:r}),c=ye();return{render:_.useCallback(l=>{const{gl:m,pointer:v}=l,{currentPointer:p,diffPointer:h}=c(v);i.uniforms.center.value.copy(p),i.uniforms.force.value.copy(h),a({gl:m,scene:n,camera:s,clear:!1})},[a,i,c,n,s]),material:i}},Pt=({size:e,dpr:t,...r},a)=>{const{scene:n,material:i,camera:s}=F({size:e,dpr:t,material:N,uniformValues:r});return{render:_.useCallback(u=>{const{gl:l}=u;a({gl:l,scene:n,camera:s})},[a,n,s]),material:i}},Rt=({size:e,dpr:t,pressureIterations:r,...a},n)=>{const{scene:i,material:s,camera:c}=F({size:e,dpr:t,material:X,uniformValues:a,customParameters:{iterations:r}});return{render:_.useCallback(l=>{const{gl:m}=l;for(let v=0;v{s.uniforms.pressure.value=p})},[n,s,i,c]),material:s}},Bt=({size:e,dpr:t,...r},a)=>{const{scene:n,material:i,camera:s}=F({size:e,dpr:t,material:K,uniformValues:r});return{render:_.useCallback(u=>{const{gl:l}=u;a({gl:l,scene:n,camera:s})},[a,n,s]),material:i}},Vt=({size:e,dpr:t,...r},a)=>{const{scene:n,material:i,camera:s}=F({size:e,dpr:t,material:G,uniformValues:r});return{render:_.useCallback(u=>{const{gl:l}=u;a({gl:l,scene:n,camera:s})},[a,n,s]),material:i}},L=e=>Object.fromEntries(Object.entries(e).filter(([,t])=>t!==void 0)),Fe=e=>{const{dissipation:t,deltaTime:r,bounce:a,pressureIterations:n,radius:i,forceBias:s,...c}=e;return[{advection:L({dissipation:t,deltaTime:r}),divergence:L({bounce:a,deltaTime:r}),poisson:L({bounce:a}),pressure:L({bounce:a,deltaTime:r}),splat:L({radius:i,forceBias:s}),pressureIterations:n},c]},kt=({size:e,dpr:t,fboAutoSetSize:r,renderTargetOptions:a,materialParameters:n,...i})=>{const s=R(t),c={dpr:s.fbo,size:e,fboAutoSetSize:r,type:o.HalfFloatType,...a},[u,l]=D(c),[m,v]=D(c),[p,h]=D(c),[x,f]=re(c),[S,T]=D(c),[b,Ue]=Fe(i),M={size:e,dpr:s.shader},w=Et({...M,...b.advection,velocity:u.texture},v),O=Ot({...M,...b.splat},v),B=Pt({...M,...b.divergence,velocity:m.texture},h),P=Rt({...M,...b.poisson,divergence:p.texture,pressureIterations:b.pressureIterations},f),V=Bt({...M,...b.pressure,velocity:m.texture,pressure:x.read.texture},l),J=Vt({...M,...Ue,src:u.texture},T),ce=_.useCallback((ue,ee=!0)=>{const[U,Kt]=Fe(ue);J.material.setUniformValues(Kt,ee),w.material.setUniformValues(U.advection),B.material.setUniformValues(U.divergence),P.material.setUniformValues(U.poisson),V.material.setUniformValues(U.pressure),O.material.setUniformValues(U.splat),U.pressureIterations&&(P.material.iterations=U.pressureIterations)},[J,w,B,P,V,O]);return{render:_.useCallback((ue,ee)=>(ee&&ce(ee,!1),[w,O,B,P,V,J].forEach(U=>U==null?void 0:U.render(ue)),S.texture),[ce,S.texture,w,O,B,P,V,J]),setValues:ce,texture:S.texture,velocity:u.texture}},It=({size:e,dpr:t,fboAutoSetSize:r,renderTargetOptions:a,materialParameters:n,...i})=>{const s=R(t),{scene:c,material:u,camera:l}=F({size:e,dpr:s.shader,material:ge,uniformValues:i,materialParameters:n}),[m,v]=D({scene:c,camera:l,size:e,dpr:s.fbo,fboAutoSetSize:r,...a}),p=_.useCallback((x,f=!0)=>{u.setUniformValues(x,f)},[u]);return{render:_.useCallback((x,f)=>{const{gl:S}=x;return f&&p(f,!1),v({gl:S})},[p,v]),setValues:p,texture:m.texture,material:u,scene:c,camera:l,renderTarget:m}},Lt=({size:e,dpr:t,fboAutoSetSize:r,renderTargetOptions:a,materialParameters:n,...i})=>{const s=R(t),{scene:c,material:u,camera:l}=F({size:e,dpr:s.shader,material:Q,materialParameters:n,...i}),[m,v]=D({scene:c,camera:l,size:e,dpr:s.fbo,fboAutoSetSize:r,...a}),p=_.useCallback(x=>{u.setUniformValues(x)},[u]);return{render:_.useCallback((x,f)=>{const{gl:S}=x;return f&&p(f),v({gl:S})},[p,v]),setValues:p,texture:m.texture,material:u,scene:c,camera:l,renderTarget:m}},At=({size:e,dpr:t,fboAutoSetSize:r,renderTargetOptions:a,materialParameters:n,pointerLerp:i=1,...s})=>{const c=R(t),{scene:u,material:l,camera:m}=F({size:e,dpr:c.shader,material:Y,materialParameters:n,...s}),v={scene:u,camera:m,size:e,dpr:c.fbo,fboAutoSetSize:r,...a},[p,h]=D(v),[x,f]=re(v),[S,T]=Oe({pointerLerp:i}),b=_.useCallback(({pointerLerp:M,...w})=>{l.setUniformValues(w),M&&T({pointerLerp:M})},[l,T]);return{render:_.useCallback((M,w)=>{const{gl:O,clock:B,pointer:P}=M;return w&&b(w),l.uniforms.time.value=B.getElapsedTime(),l.uniforms.pointer.value.lerp(P,S.current.pointerLerp),f({gl:O},({read:V})=>l.uniforms.backbuffer.value=V),h({gl:O})},[b,h,l,f,S]),setValues:b,texture:p.texture,material:l,scene:u,camera:m,renderTarget:p}},$t=({size:e,dpr:t,fboAutoSetSize:r,renderTargetOptions:a,materialParameters:n,...i})=>{const s=R(t),{scene:c,material:u,camera:l}=F({size:e,dpr:s.shader,material:W,uniformValues:i,materialParameters:n}),[m,v]=D({scene:c,camera:l,size:e,dpr:s.fbo,fboAutoSetSize:r,...a}),p=_.useCallback((x,f=!0)=>{u.setUniformValues(x,f),u.setNearestFilter()},[u]);return{render:_.useCallback((x,f)=>{const{gl:S,clock:T}=x;return f&&p(f,!1),u.uniforms.tick.value=typeof(f==null?void 0:f.tick)=="function"?f.tick(u.uniforms.tick.value):(f==null?void 0:f.tick)||T.getElapsedTime(),v({gl:S})},[p,v,u]),setValues:p,texture:m.texture,material:u,scene:c,camera:l,renderTarget:m}},Z=Object.freeze({easeInSine(e){return 1-Math.cos(e*Math.PI/2)},easeOutSine(e){return Math.sin(e*Math.PI/2)},easeInOutSine(e){return-(Math.cos(Math.PI*e)-1)/2},easeInQuad(e){return e*e},easeOutQuad(e){return 1-(1-e)*(1-e)},easeInOutQuad(e){return e<.5?2*e*e:1-Math.pow(-2*e+2,2)/2},easeInCubic(e){return e*e*e},easeOutCubic(e){return 1-Math.pow(1-e,3)},easeInOutCubic(e){return e<.5?4*e*e*e:1-Math.pow(-2*e+2,3)/2},easeInQuart(e){return e*e*e*e},easeOutQuart(e){return 1-Math.pow(1-e,4)},easeInOutQuart(e){return e<.5?8*e*e*e*e:1-Math.pow(-2*e+2,4)/2},easeInQuint(e){return e*e*e*e*e},easeOutQuint(e){return 1-Math.pow(1-e,5)},easeInOutQuint(e){return e<.5?16*e*e*e*e*e:1-Math.pow(-2*e+2,5)/2},easeInExpo(e){return e===0?0:Math.pow(2,10*e-10)},easeOutExpo(e){return e===1?1:1-Math.pow(2,-10*e)},easeInOutExpo(e){return e===0?0:e===1?1:e<.5?Math.pow(2,20*e-10)/2:(2-Math.pow(2,-20*e+10))/2},easeInCirc(e){return 1-Math.sqrt(1-Math.pow(e,2))},easeOutCirc(e){return Math.sqrt(1-Math.pow(e-1,2))},easeInOutCirc(e){return e<.5?(1-Math.sqrt(1-Math.pow(2*e,2)))/2:(Math.sqrt(1-Math.pow(-2*e+2,2))+1)/2},easeInBack(e){return 2.70158*e*e*e-1.70158*e*e},easeOutBack(e){return 1+2.70158*Math.pow(e-1,3)+1.70158*Math.pow(e-1,2)},easeInOutBack(e){const r=2.5949095;return e<.5?Math.pow(2*e,2)*((r+1)*2*e-r)/2:(Math.pow(2*e-2,2)*((r+1)*(e*2-2)+r)+2)/2},easeInElastic(e){const t=2*Math.PI/3;return e===0?0:e===1?1:-Math.pow(2,10*e-10)*Math.sin((e*10-10.75)*t)},easeOutElastic(e){const t=2*Math.PI/3;return e===0?0:e===1?1:Math.pow(2,-10*e)*Math.sin((e*10-.75)*t)+1},easeInOutElastic(e){const t=2*Math.PI/4.5;return e===0?0:e===1?1:e<.5?-(Math.pow(2,20*e-10)*Math.sin((20*e-11.125)*t))/2:Math.pow(2,-20*e+10)*Math.sin((20*e-11.125)*t)/2+1},easeInBounce(e){return 1-Z.easeOutBounce(1-e)},easeOutBounce(e){return e<1/2.75?7.5625*e*e:e<2/2.75?7.5625*(e-=1.5/2.75)*e+.75:e<2.5/2.75?7.5625*(e-=2.25/2.75)*e+.9375:7.5625*(e-=2.625/2.75)*e+.984375},easeInOutBounce(e){return e<.5?(1-Z.easeOutBounce(1-2*e))/2:(1+Z.easeOutBounce(2*e-1))/2}});function jt(e){let t=Math.sin(e*12.9898)*43758.5453;return t-Math.floor(t)}const zt=(e,t="easeOutQuart")=>{const r=e/60,a=Z[t];return _.useCallback(i=>{let s=i.getElapsedTime()*r;const c=Math.floor(s),u=a(s-c);s=u+c;const l=jt(c);return{beat:s,floor:c,fract:u,hash:l}},[r,a])},Me={passive:!0},Nt=e=>{const t=_.useRef(new o.Vector2(0));return _.useEffect(()=>{const r=(i,s)=>{t.current.set((i-e.left)/e.width*2-1,-((s-e.top)/e.height)*2+1)},a=i=>{const s=i.touches[0];r(s.clientX,s.clientY)},n=i=>{r(i.clientX,i.clientY)};return window.addEventListener("touchmove",a,Me),window.addEventListener("pointermove",n,Me),()=>{window.removeEventListener("touchmove",a),window.removeEventListener("pointermove",n)}},[e]),t.current};d.BASICFX_VALUES=j,d.BlankMaterial=Y,d.BufferMaterial=ge,d.FluidMaterials=bt,d.GridMaterial=W,d.NoiseMaterial=ve,d.RawBlankMaterial=Q,d.getFxKeyFromUniforms=ae,d.handleUpdateFxDefines=fe,d.useBeat=zt,d.useBlank=At,d.useBuffer=It,d.useDoubleFBO=re,d.useFluid=kt,d.useGrid=$t,d.useNoise=Tt,d.usePointerTracker=ye,d.useRawBlank=Lt,d.useSingleFBO=D,d.useWindowPointer=Nt,Object.defineProperty(d,Symbol.toStringTag,{value:"Module"})}); +//# sourceMappingURL=use-shader-fx.umd.cjs.map diff --git a/packages/use-shader-fx/build/use-shader-fx.umd.cjs.map b/packages/use-shader-fx/build/use-shader-fx.umd.cjs.map new file mode 100644 index 00000000..38ff9446 --- /dev/null +++ b/packages/use-shader-fx/build/use-shader-fx.umd.cjs.map @@ -0,0 +1 @@ +{"version":3,"file":"use-shader-fx.umd.cjs","sources":["../src/utils/getDpr.ts","../src/utils/useResolution.ts","../src/utils/useCamera.ts","../src/utils/useSingleFBO.ts","../src/utils/useDoubleFBO.ts","../src/utils/useSetup.ts","../src/utils/useMutableState.ts","../src/libs/constants.ts","../src/utils/warn.ts","../src/materials/core/BasicFxLib.ts","../src/shaders/ShaderLib/plane_vertex.glsl","../src/shaders/ShaderLib/default_vertex.glsl","../src/shaders/ShaderLib/default_pars_vertex.glsl","../src/shaders/ShaderLib/default_pars_fragment.glsl","../src/shaders/ShaderLib/basicFx_vertex.glsl","../src/shaders/ShaderLib/basicFx_pars_vertex.glsl","../src/shaders/ShaderLib/basicFx_pars_fragment.glsl","../src/shaders/ShaderLib/basicFx_fragment_begin.glsl","../src/shaders/ShaderLib/basicFx_fragment_end.glsl","../src/shaders/ShaderLib/samplingFx_vertex.glsl","../src/shaders/ShaderLib/samplingFx_pars_vertex.glsl","../src/shaders/ShaderLib/samplingFx_pars_fragment.glsl","../src/shaders/ShaderLib.ts","../src/materials/impl/noise/noise.glsl.ts","../src/shaders/ShaderChunk/plane_vertex.glsl","../src/shaders/ShaderChunk/srcSystem_pars_vertex.glsl","../src/shaders/ShaderChunk/srcSystem_pars_fragment.glsl","../src/shaders/ShaderChunk/default_vertex.glsl","../src/shaders/ShaderChunk/default_pars_vertex.glsl","../src/shaders/ShaderChunk/default_pars_fragment.glsl","../src/shaders/ShaderChunk/mixSrc_pars_vertex.glsl","../src/shaders/ShaderChunk/mixSrc_vertex.glsl","../src/shaders/ShaderChunk/mixSrc_pars_fragment.glsl","../src/shaders/ShaderChunk/mixSrc_fragment_begin.glsl","../src/shaders/ShaderChunk/mixSrc_fragment_end.glsl","../src/shaders/ShaderChunk/mixDst_pars_vertex.glsl","../src/shaders/ShaderChunk/mixDst_vertex.glsl","../src/shaders/ShaderChunk/mixDst_pars_fragment.glsl","../src/shaders/ShaderChunk/mixDst_fragment.glsl","../src/shaders/ShaderChunk/texture_vertex.glsl","../src/shaders/ShaderChunk/texture_pars_vertex.glsl","../src/shaders/ShaderChunk/texture_pars_fragment.glsl","../src/shaders/ShaderChunk/adjustments_fragment.glsl","../src/shaders/ShaderChunk/adjustments_pars_fragment.glsl","../src/shaders/ShaderChunk/calcSrcUv.glsl","../src/shaders/ShaderChunk.ts","../src/shaders/shaderUtils.ts","../src/shaders/uniformsUtils.ts","../src/materials/core/FxMaterial.ts","../src/materials/core/BasicFxMaterial.ts","../src/materials/impl/noise/NoiseMaterial.ts","../src/materials/impl/fluid/shaders/vertex.ts","../src/materials/impl/fluid/shaders/advection.frag","../src/materials/impl/fluid/AdvectionMaterial.ts","../src/materials/impl/fluid/shaders/divergence.frag","../src/materials/impl/fluid/DivergenceMaterial.ts","../src/materials/impl/fluid/shaders/pressure.frag","../src/materials/impl/fluid/PressureMaterial.ts","../src/materials/impl/fluid/shaders/poisson.frag","../src/materials/impl/fluid/PoissonMaterial.ts","../src/materials/impl/fluid/shaders/splat.frag","../src/materials/impl/fluid/SplatMaterial.ts","../src/materials/impl/fluid/OutputMaterial.ts","../src/materials/impl/fluid/index.js","../src/materials/core/SamplingFxMaterial.ts","../src/materials/impl/buffer/BufferMaterial.ts","../src/materials/impl/rawBlank/RawBlankMaterial.ts","../src/materials/impl/blank/BlankMaterial.ts","../src/materials/impl/grid/grid.glsl.ts","../src/materials/impl/grid/GridMaterial.ts","../src/hooks/useNoise/index.ts","../src/hooks/useFluid/scenes/useAdvection.ts","../src/misc/usePointerTracker.ts","../src/hooks/useFluid/scenes/useSplat.ts","../src/hooks/useFluid/scenes/useDivergence.ts","../src/hooks/useFluid/scenes/usePoisson.ts","../src/hooks/useFluid/scenes/usePressure.ts","../src/hooks/useFluid/scenes/useOutput.ts","../src/hooks/useFluid/index.ts","../src/hooks/useBuffer/index.tsx","../src/hooks/useRawBlank/index.tsx","../src/hooks/useBlank/index.tsx","../src/hooks/useGrid/index.ts","../src/libs/Easings.ts","../src/misc/useBeat.ts","../src/misc/useWindowPointer.ts"],"sourcesContent":["import { Dpr } from \"../hooks/types\";\n\nexport const getDpr = (\n dpr: Dpr\n): { shader: number | false; fbo: number | false } => {\n if (typeof dpr === \"number\") {\n return { shader: dpr, fbo: dpr };\n }\n return {\n shader: dpr.shader ?? false,\n fbo: dpr.fbo ?? false,\n };\n};\n","import * as THREE from \"three\";\nimport { useState } from \"react\";\nimport { Size } from \"../hooks/types\";\n\n/**\n * @params dpr if dpr is set, it returns the resolution which is size multiplied by dpr.\n */\nexport const useResolution = (size: Size, dpr: number | false = false) => {\n const _width = dpr ? size.width * dpr : size.width;\n const _height = dpr ? size.height * dpr : size.height;\n\n const [resolution] = useState(() => new THREE.Vector2(_width, _height));\n resolution.set(_width, _height);\n\n return resolution;\n};\n","import * as THREE from \"three\";\nimport { useResolution } from \"./useResolution\";\nimport { useState } from \"react\";\nimport { Size } from \"../hooks/types\";\n\nconst getCameraProps = (width: number, height: number) => {\n const frustumSize = height;\n const aspect = width / height;\n const [w, h] = [(frustumSize * aspect) / 2, frustumSize / 2];\n return { width: w, height: h, near: -1000, far: 1000 };\n};\n\nexport const useCamera = (\n size: Size,\n cameraType: \"OrthographicCamera\" | \"PerspectiveCamera\" = \"OrthographicCamera\"\n) => {\n const resolution = useResolution(size);\n const { width, height, near, far } = getCameraProps(\n resolution.x,\n resolution.y\n );\n\n const [camera] = useState(() => {\n return cameraType === \"OrthographicCamera\"\n ? new THREE.OrthographicCamera(\n -width,\n width,\n height,\n -height,\n near,\n far\n )\n : new THREE.PerspectiveCamera(50, width / height);\n });\n\n if (camera instanceof THREE.OrthographicCamera) {\n camera.left = -width;\n camera.right = width;\n camera.top = height;\n camera.bottom = -height;\n camera.near = near;\n camera.far = far;\n camera.updateProjectionMatrix();\n } else if (camera instanceof THREE.PerspectiveCamera) {\n camera.aspect = width / height;\n camera.updateProjectionMatrix();\n }\n\n return camera;\n};\n","import * as THREE from \"three\";\nimport { useCallback, useEffect, useState } from \"react\";\nimport { useResolution } from \"./useResolution\";\nimport { Size } from \"../hooks/types\";\n\nexport const FBO_DEFAULT_OPTION: THREE.RenderTargetOptions = {\n depthBuffer: false,\n};\n\nexport type UseFboProps = {\n scene?: THREE.Scene;\n camera?: THREE.Camera;\n size: Size;\n /** If dpr is set, dpr will be multiplied, default : `false` */\n dpr?: number | false;\n /** Whether to resize when resizing occurs. If isDpr is true, set FBO to setSize even if dpr is changed, default : `false` */\n fboAutoSetSize?: boolean;\n /** If set, the scene depth will be rendered into buffer.depthTexture. default : `false` */\n depth?: boolean;\n} & THREE.RenderTargetOptions;\n\nexport type RenderProps = {\n gl: THREE.WebGLRenderer;\n scene?: THREE.Scene;\n camera?: THREE.Camera;\n clear?: boolean;\n};\n\nexport const renderFBO = ({\n gl,\n fbo,\n scene,\n camera,\n clear = true,\n onBeforeRender,\n onSwap,\n}: {\n fbo: THREE.WebGLRenderTarget;\n onBeforeRender: () => void;\n onSwap?: () => void;\n} & RenderProps) => {\n if (!scene || !camera) return;\n const clearCache = gl.autoClear;\n gl.autoClear = clear;\n gl.setRenderTarget(fbo);\n onBeforeRender();\n gl.render(scene, camera);\n onSwap && onSwap();\n gl.setRenderTarget(null);\n gl.autoClear = clearCache;\n};\n\nexport type SingleFBOUpdateFunction = (\n renderProps: RenderProps,\n /** call before FBO is rendered */\n onBeforeRender?: ({ read }: { read: THREE.Texture }) => void\n) => THREE.Texture;\n\ntype UseSingleFBOReturn = [THREE.WebGLRenderTarget, SingleFBOUpdateFunction];\n\n/**\n * @param dpr If dpr is set, dpr will be multiplied, default:false\n * @param fboAutoSetSize Whether to resize when resizing occurs. If isDpr is true, set FBO to setSize even if dpr is changed, default:false\n * @param depthBuffer Unlike the default in three.js, the default is `false`.\n * @returns [THREE.WebGLRenderTarget , updateFBO] -Receives the RenderTarget as the first argument and the update function as the second argument.\n */\nexport const useSingleFBO = (props: UseFboProps): UseSingleFBOReturn => {\n const {\n scene,\n camera,\n size,\n dpr = false,\n fboAutoSetSize = false,\n depth = false,\n ...renderTargetOptions\n } = props;\n\n const resolution = useResolution(size, dpr);\n\n const [renderTarget] = useState(() => {\n const target = new THREE.WebGLRenderTarget(resolution.x, resolution.y, {\n ...FBO_DEFAULT_OPTION,\n ...renderTargetOptions,\n });\n if (depth) {\n target.depthTexture = new THREE.DepthTexture(\n resolution.x,\n resolution.y,\n THREE.FloatType\n );\n }\n return target;\n });\n\n if (fboAutoSetSize) {\n renderTarget.setSize(resolution.x, resolution.y);\n }\n\n useEffect(() => {\n const temp = renderTarget;\n return () => {\n temp?.dispose();\n };\n }, [renderTarget]);\n\n const updateRenderTarget: SingleFBOUpdateFunction = useCallback(\n (renderProps, onBeforeRender) => {\n const fbo = renderTarget!;\n renderFBO({\n ...renderProps,\n scene: renderProps.scene || scene,\n camera: renderProps.camera || camera,\n fbo,\n onBeforeRender: () => onBeforeRender?.({ read: fbo.texture }),\n });\n return fbo.texture;\n },\n [scene, camera, renderTarget]\n );\n\n return [renderTarget, updateRenderTarget];\n};\n","import * as THREE from \"three\";\nimport { useCallback, useEffect, useState } from \"react\";\nimport {\n FBO_DEFAULT_OPTION,\n UseFboProps,\n renderFBO,\n RenderProps,\n} from \"./useSingleFBO\";\nimport { useResolution } from \"./useResolution\";\n\nexport type DoubleRenderTarget = {\n read: THREE.WebGLRenderTarget;\n write: THREE.WebGLRenderTarget;\n};\n\ninterface WebGLDoubleRenderTarget extends DoubleRenderTarget {\n swap: () => void;\n}\n\nexport type DoubleFBOUpdateFunction = (\n renderProps: RenderProps,\n /** call before FBO is rendered */\n onBeforeRender?: ({\n read,\n write,\n }: {\n read: THREE.Texture;\n write: THREE.Texture;\n }) => void\n) => THREE.Texture;\n\ntype UseDoubleFBOReturn = [\n { read: THREE.WebGLRenderTarget; write: THREE.WebGLRenderTarget },\n DoubleFBOUpdateFunction\n];\n\n/**\n * @description Custom hook for setting up double buffering with WebGL render targets.\n * @param UseFboProps same as `useSingleFBO`\n */\nexport const useDoubleFBO = (props: UseFboProps): UseDoubleFBOReturn => {\n const {\n scene,\n camera,\n size,\n dpr = false,\n fboAutoSetSize = false,\n depth = false,\n ...renderTargetOptions\n } = props;\n\n const resolution = useResolution(size, dpr);\n\n const [renderTarget] = useState(() => {\n const read = new THREE.WebGLRenderTarget(resolution.x, resolution.y, {\n ...FBO_DEFAULT_OPTION,\n ...renderTargetOptions,\n });\n const write = new THREE.WebGLRenderTarget(resolution.x, resolution.y, {\n ...FBO_DEFAULT_OPTION,\n ...renderTargetOptions,\n });\n\n if (depth) {\n read.depthTexture = new THREE.DepthTexture(\n resolution.x,\n resolution.y,\n THREE.FloatType\n );\n write.depthTexture = new THREE.DepthTexture(\n resolution.x,\n resolution.y,\n THREE.FloatType\n );\n }\n\n return {\n read: read,\n write: write,\n swap: function () {\n let temp = this.read;\n this.read = this.write;\n this.write = temp;\n },\n };\n });\n\n if (fboAutoSetSize) {\n renderTarget.read?.setSize(resolution.x, resolution.y);\n renderTarget.write?.setSize(resolution.x, resolution.y);\n }\n\n useEffect(() => {\n const temp = renderTarget;\n return () => {\n temp.read?.dispose();\n temp.write?.dispose();\n };\n }, [renderTarget]);\n\n const updateRenderTarget: DoubleFBOUpdateFunction = useCallback(\n (renderProps, onBeforeRender) => {\n const fbo = renderTarget;\n renderFBO({\n ...renderProps,\n scene: renderProps.scene || scene,\n camera: renderProps.camera || camera,\n fbo: fbo.write!,\n onBeforeRender: () =>\n onBeforeRender?.({\n read: fbo.read!.texture,\n write: fbo.write!.texture,\n }),\n onSwap: () => fbo.swap(),\n });\n return fbo.read?.texture as THREE.Texture;\n },\n [scene, camera, renderTarget]\n );\n\n return [\n { read: renderTarget.read, write: renderTarget.write },\n updateRenderTarget,\n ];\n};\n","import * as THREE from \"three\";\nimport { useEffect, useState } from \"react\";\nimport { Size } from \"../hooks/types\";\nimport { useResolution } from \"./useResolution\";\nimport { FxMaterial, FxMaterialProps } from \"../materials/core/FxMaterial\";\nimport { useCamera } from \"./useCamera\";\n\ntype Object3DConstructor = new (\n geometry: THREE.BufferGeometry,\n material: M\n) => T;\n\ntype MaterialConstructor = new (props: FxMaterialProps) => M;\n\ntype GeometryConstructor = new (\n width: number,\n height: number\n) => THREE.BufferGeometry;\n\n/**\n * Add geometry and material to Object3D and add them to scene.\n */\nconst useObject3D = (\n scene: THREE.Scene | false,\n geometry: THREE.BufferGeometry,\n material: M,\n Proto: Object3DConstructor\n) => {\n const [object3D] = useState(() => new Proto(geometry, material));\n\n useEffect(() => {\n scene && scene.add(object3D);\n return () => {\n scene && scene.remove(object3D);\n geometry.dispose();\n material.dispose();\n };\n }, [scene, geometry, material, object3D]);\n\n return object3D;\n};\n\nexport const useSetup = ({\n size,\n dpr,\n material,\n geometry = THREE.PlaneGeometry,\n geometrySize,\n ...materialProps\n}: {\n size: Size;\n dpr: number | false;\n material: MaterialConstructor;\n geometry?: GeometryConstructor;\n geometrySize?: {\n width: number;\n height: number;\n };\n} & FxMaterialProps) => {\n // Mutable THREE objects should retain their values in useState\n // https://github.com/FunTechInc/use-shader-fx/issues/145\n const [scene] = useState(() => new THREE.Scene());\n const [_geometry] = useState(\n () => new geometry(geometrySize?.width || 2, geometrySize?.height || 2)\n );\n const [_material] = useState(() => new material(materialProps));\n\n // materialのresolutionはreactiveに更新する\n const resolution = useResolution(size, dpr);\n _material.updateResolution(resolution.x, resolution.y);\n\n useObject3D(scene, _geometry, _material, THREE.Mesh);\n\n const camera = useCamera(size);\n\n return {\n scene,\n material: _material,\n camera,\n };\n};\n","import { useCallback, useRef } from \"react\";\n\nexport const useMutableState = (state: S) => {\n const ref = useRef(state);\n const setRef = useCallback((value: S | ((prevState: S) => S)) => {\n ref.current =\n typeof value === \"function\"\n ? (value as (prevState: S) => S)(ref.current)\n : value;\n }, []);\n\n return [ref, setRef] as const;\n};\n","import * as THREE from \"three\";\n\n// CDNとして使う場合、processがundefinedになるので、その場合はfalseを返す\nexport const ISDEV = (() => {\n try {\n return process.env.NODE_ENV === \"development\";\n } catch (error) {\n return false;\n }\n})();\n\nexport const MATERIAL_BASIC_PARAMS = {\n transparent: false,\n depthTest: false,\n depthWrite: false,\n};\n\nexport const DEFAULT_TEXTURE = new THREE.DataTexture(\n new Uint8Array([0, 0, 0, 0]),\n 1,\n 1,\n THREE.RGBAFormat\n);\n\nexport const APP_NAME = \"use-shader-fx\";\n\nexport const THREE_FLAG_PROPS = [\n \"isColor\",\n \"isMatrix3\",\n \"isMatrix4\",\n \"isVector2\",\n \"isVector3\",\n \"isVector4\",\n \"isTexture\",\n \"isQuaternion\",\n \"isWebGLRenderTarget\",\n \"isEuler\",\n \"isBufferGeometry\",\n \"isMaterial\",\n \"isCamera\",\n \"isLight\",\n \"isObject3D\",\n \"isBone\",\n \"isVideoTexture\",\n];\n","import { APP_NAME, ISDEV } from \"../libs/constants\";\n\nexport const warn = (text: string) => {\n if (ISDEV) {\n console.warn(`${APP_NAME}: ${text}`);\n }\n};\n","import * as THREE from \"three\";\nimport { DefaultUniforms } from \"./FxMaterial\";\nimport {\n NestUniformValues,\n UniformParentKey,\n} from \"../../shaders/uniformsUtils\";\nimport { DEFAULT_TEXTURE } from \"../../libs/constants\";\nimport type { Vec4Channel } from \"../../libs/types\";\n\n/*===============================================\ntypes\n===============================================*/\n/** 0:`fill` 1:`cover` 2:`contain` */\nexport type FitType = 0 | 1 | 2;\n\nexport type BasicFxUniformsUnique = {\n /*===============================================\n\tmixSrc\n\t===============================================*/\n mixSrc: { value: UniformParentKey };\n mixSrc_src: { value: THREE.Texture };\n mixSrc_fit: { value: FitType };\n // uv\n mixSrc_uv: { value: UniformParentKey };\n mixSrc_uv_ch: { value: Vec4Channel }; // mixSrcのどのchを使って、このfxのuvをノイズさせるか\n mixSrc_uv_factor: { value: number };\n mixSrc_uv_offset: { value: THREE.Vector2 };\n mixSrc_uv_radius: { value: number }; // 負の値は画面全体\n mixSrc_uv_position: { value: THREE.Vector2 };\n mixSrc_uv_range: { value: THREE.Vector2 };\n mixSrc_uv_mixMap: { value: UniformParentKey };\n mixSrc_uv_mixMap_src: { value: THREE.Texture };\n mixSrc_uv_mixMap_ch: { value: Vec4Channel }; // どのチャンネルでmixするか\n\n // color\n mixSrc_color: { value: UniformParentKey };\n mixSrc_color_factor: { value: number };\n mixSrc_color_radius: { value: number }; // 負の値は画面全体\n mixSrc_color_position: { value: THREE.Vector2 };\n mixSrc_color_range: { value: THREE.Vector2 };\n mixSrc_color_mixMap: { value: UniformParentKey };\n mixSrc_color_mixMap_src: { value: THREE.Texture };\n mixSrc_color_mixMap_ch: { value: Vec4Channel }; // どのチャンネルでmixするか\n\n // alpha\n mixSrc_alpha: { value: UniformParentKey };\n mixSrc_alpha_factor: { value: number };\n mixSrc_alpha_radius: { value: number }; // 負の値は画面全体\n mixSrc_alpha_position: { value: THREE.Vector2 };\n mixSrc_alpha_range: { value: THREE.Vector2 };\n mixSrc_alpha_mixMap: { value: UniformParentKey };\n mixSrc_alpha_mixMap_src: { value: THREE.Texture };\n mixSrc_alpha_mixMap_ch: { value: Vec4Channel }; // どのチャンネルでmixするか\n\n /*===============================================\n\tmixDst\n\t===============================================*/\n mixDst: { value: UniformParentKey };\n mixDst_src: { value: THREE.Texture };\n mixDst_fit: { value: FitType };\n // uv\n mixDst_uv: { value: UniformParentKey };\n mixDst_uv_ch: { value: Vec4Channel }; // このfxのどのchを使ってmixDstのuvをノイズさせるか\n mixDst_uv_factor: { value: number };\n mixDst_uv_offset: { value: THREE.Vector2 };\n mixDst_uv_radius: { value: number }; // 負の値は画面全体\n mixDst_uv_position: { value: THREE.Vector2 };\n mixDst_uv_range: { value: THREE.Vector2 };\n mixDst_uv_mixMap: { value: UniformParentKey };\n mixDst_uv_mixMap_src: { value: THREE.Texture };\n mixDst_uv_mixMap_ch: { value: Vec4Channel }; // どのチャンネルでmixするか\n // color\n mixDst_color: { value: UniformParentKey };\n mixDst_color_factor: { value: number };\n mixDst_color_radius: { value: number }; // 負の値は画面全体\n mixDst_color_position: { value: THREE.Vector2 };\n mixDst_color_range: { value: THREE.Vector2 };\n mixDst_color_mixMap: { value: UniformParentKey };\n mixDst_color_mixMap_src: { value: THREE.Texture };\n mixDst_color_mixMap_ch: { value: Vec4Channel }; // どのチャンネルでmixするか\n // alpha\n mixDst_alpha: { value: UniformParentKey };\n mixDst_alpha_factor: { value: number };\n mixDst_alpha_radius: { value: number }; // 負の値は画面全体\n mixDst_alpha_position: { value: THREE.Vector2 };\n mixDst_alpha_range: { value: THREE.Vector2 };\n mixDst_alpha_mixMap: { value: UniformParentKey };\n mixDst_alpha_mixMap_src: { value: THREE.Texture };\n mixDst_alpha_mixMap_ch: { value: Vec4Channel }; // どのチャンネルでmixするか\n\n /*===============================================\n\tadjustments\n\t===============================================*/\n // levels\n levels: { value: UniformParentKey };\n levels_shadows: { value: THREE.Vector4 };\n levels_midtones: { value: THREE.Vector4 };\n levels_highlights: { value: THREE.Vector4 };\n levels_outputMin: { value: THREE.Vector4 };\n levels_outputMax: { value: THREE.Vector4 };\n // contrast\n contrast: { value: UniformParentKey };\n contrast_factor: { value: THREE.Vector4 };\n // colorBalance\n colorBalance: { value: UniformParentKey };\n colorBalance_factor: { value: THREE.Vector3 };\n // hsv\n hsv: { value: UniformParentKey };\n hsv_hueShift: { value: number }; // 色相を +X 度分回転 (0.0~1.0 で0~360度)\n hsv_saturation: { value: number }; // 彩度乗算 (1.0で変化なし)\n hsv_brightness: { value: number }; // 明度乗算 (1.0で変化なし)\n // posterize\n posterize: { value: UniformParentKey };\n posterize_levels: { value: THREE.Vector4 };\n // grayscale\n grayscale: { value: UniformParentKey };\n grayscale_weight: { value: THREE.Vector3 };\n grayscale_duotone: { value: UniformParentKey };\n grayscale_duotone_color0: { value: THREE.Color };\n grayscale_duotone_color1: { value: THREE.Color };\n grayscale_threshold: { value: number }; // 0~1 負の値は処理をスキップする\n};\n\n// BasicFxValuesの型からfitScaleを排除する\ntype BasicFxUniformsFitScale = {\n mixSrc_fitScale: { value: THREE.Vector2 };\n mixDst_fitScale: { value: THREE.Vector2 };\n};\n\nexport type BasicFxUniforms = BasicFxUniformsUnique & DefaultUniforms;\n\nexport type BasicFxValues = NestUniformValues;\n\nexport type FxKey = {\n srcSystem: boolean;\n mixSrc: boolean;\n mixDst: boolean;\n levels: boolean;\n contrast: boolean;\n colorBalance: boolean;\n hsv: boolean;\n posterize: boolean;\n grayscale: boolean;\n};\n\nexport type SrcSystemKey = \"mixSrc\" | \"mixDst\" | \"texture\";\n\n/*===============================================\nconstants\n===============================================*/\nexport const BASICFX_VALUES: BasicFxUniformsUnique & BasicFxUniformsFitScale = {\n /*===============================================\n\tmixSrc\n\t===============================================*/\n mixSrc: { value: false },\n mixSrc_src: { value: new THREE.Texture() },\n mixSrc_fit: { value: 0 },\n mixSrc_fitScale: { value: new THREE.Vector2(1, 1) },\n // uv\n mixSrc_uv: { value: false },\n mixSrc_uv_ch: { value: 0 },\n mixSrc_uv_factor: { value: 0 },\n mixSrc_uv_offset: { value: new THREE.Vector2(0, 0) },\n mixSrc_uv_radius: { value: 0.5 },\n mixSrc_uv_position: { value: new THREE.Vector2(0.5, 0.5) },\n mixSrc_uv_range: { value: new THREE.Vector2(0.0, 1.0) },\n mixSrc_uv_mixMap: { value: false },\n mixSrc_uv_mixMap_src: { value: DEFAULT_TEXTURE },\n mixSrc_uv_mixMap_ch: { value: 0 },\n\n // color\n mixSrc_color: { value: false },\n mixSrc_color_factor: { value: 0 },\n mixSrc_color_radius: { value: 0.5 },\n mixSrc_color_position: { value: new THREE.Vector2(0.5, 0.5) },\n mixSrc_color_range: { value: new THREE.Vector2(0.0, 1.0) },\n mixSrc_color_mixMap: { value: false },\n mixSrc_color_mixMap_src: { value: DEFAULT_TEXTURE },\n mixSrc_color_mixMap_ch: { value: 0 },\n\n // alpha\n mixSrc_alpha: { value: false },\n mixSrc_alpha_factor: { value: 0 },\n mixSrc_alpha_radius: { value: 0.5 },\n mixSrc_alpha_position: { value: new THREE.Vector2(0.5, 0.5) },\n mixSrc_alpha_range: { value: new THREE.Vector2(0.0, 1.0) },\n mixSrc_alpha_mixMap: { value: false },\n mixSrc_alpha_mixMap_src: { value: DEFAULT_TEXTURE },\n mixSrc_alpha_mixMap_ch: { value: 0 },\n\n /*===============================================\n\tmixDst\n\t===============================================*/\n mixDst: { value: false },\n mixDst_src: { value: new THREE.Texture() },\n mixDst_fit: { value: 0 },\n mixDst_fitScale: { value: new THREE.Vector2(1, 1) },\n\n // uv\n mixDst_uv: { value: false },\n mixDst_uv_ch: { value: 0 },\n mixDst_uv_factor: { value: 0 },\n mixDst_uv_offset: { value: new THREE.Vector2(0, 0) },\n mixDst_uv_radius: { value: 0.5 },\n mixDst_uv_position: { value: new THREE.Vector2(0.5, 0.5) },\n mixDst_uv_range: { value: new THREE.Vector2(0.0, 1.0) },\n mixDst_uv_mixMap: { value: false },\n mixDst_uv_mixMap_src: { value: DEFAULT_TEXTURE },\n mixDst_uv_mixMap_ch: { value: 0 },\n\n // color\n mixDst_color: { value: false },\n mixDst_color_factor: { value: 0 },\n mixDst_color_radius: { value: 0.5 },\n mixDst_color_position: { value: new THREE.Vector2(0.5, 0.5) },\n mixDst_color_range: { value: new THREE.Vector2(0.0, 1.0) },\n mixDst_color_mixMap: { value: false },\n mixDst_color_mixMap_src: { value: DEFAULT_TEXTURE },\n mixDst_color_mixMap_ch: { value: 0 },\n\n // alpha\n mixDst_alpha: { value: false },\n mixDst_alpha_factor: { value: 0 },\n mixDst_alpha_radius: { value: 0.5 },\n mixDst_alpha_position: { value: new THREE.Vector2(0.5, 0.5) },\n mixDst_alpha_range: { value: new THREE.Vector2(0.0, 1.0) },\n mixDst_alpha_mixMap: { value: false },\n mixDst_alpha_mixMap_src: { value: DEFAULT_TEXTURE },\n mixDst_alpha_mixMap_ch: { value: 0 },\n\n /*===============================================\n\tadjustments\n\t===============================================*/\n // levels\n levels: { value: false },\n levels_shadows: { value: new THREE.Vector4(0, 0, 0, 0) },\n levels_midtones: { value: new THREE.Vector4(1, 1, 1, 1) },\n levels_highlights: { value: new THREE.Vector4(1, 1, 1, 1) },\n levels_outputMin: { value: new THREE.Vector4(0, 0, 0, 0) },\n levels_outputMax: { value: new THREE.Vector4(1, 1, 1, 1) },\n // contrast\n contrast: { value: false },\n contrast_factor: { value: new THREE.Vector4(1, 1, 1, 1) },\n // colorBalance\n colorBalance: { value: false },\n colorBalance_factor: { value: new THREE.Vector3(1, 1, 1) },\n // hsv\n hsv: { value: false },\n hsv_hueShift: { value: 0 },\n hsv_saturation: { value: 1 },\n hsv_brightness: { value: 1 },\n // posterize\n posterize: { value: false },\n posterize_levels: { value: new THREE.Vector4(0, 0, 0, 0) },\n // grayscale\n grayscale: { value: false },\n grayscale_weight: { value: new THREE.Vector3(0, 0, 0) },\n grayscale_duotone: { value: false },\n grayscale_duotone_color0: { value: new THREE.Color(0x000000) },\n grayscale_duotone_color1: { value: new THREE.Color(0xffffff) },\n grayscale_threshold: { value: -1 },\n};\n\n/*===============================================\nfunctions\n===============================================*/\nexport function handleUpdateFxDefines(fxKey: FxKey): {\n [key: string]: any;\n} {\n const {\n mixSrc,\n mixDst,\n srcSystem,\n levels,\n contrast,\n colorBalance,\n hsv,\n posterize,\n grayscale,\n } = fxKey;\n return {\n USF_USE_SRC_SYSTEM: srcSystem,\n USF_USE_MIXSRC: mixSrc,\n USF_USE_MIXDST: mixDst,\n USF_USE_LEVELS: levels,\n USF_USE_CONTRAST: contrast,\n USF_USE_COLORBALANCE: colorBalance,\n USF_USE_HSV: hsv,\n USF_USE_POSTERIZE: posterize,\n USF_USE_GRAYSCALE: grayscale,\n };\n}\n\n/** setterで定義される場合もあるため、valuesではなくuniformsから判定する */\nexport function getFxKeyFromUniforms(uniforms: BasicFxUniformsUnique): FxKey {\n const isMixSrc = uniforms.mixSrc.value ? true : false;\n const isMixDst = uniforms.mixDst.value ? true : false;\n const isSrcSystem = isMixSrc || isMixDst;\n return {\n mixSrc: isMixSrc,\n mixDst: isMixDst,\n srcSystem: isSrcSystem,\n levels: uniforms.levels.value ? true : false,\n contrast: uniforms.contrast.value ? true : false,\n colorBalance: uniforms.colorBalance.value ? true : false,\n hsv: uniforms.hsv.value ? true : false,\n posterize: uniforms.posterize.value ? true : false,\n grayscale: uniforms.grayscale.value ? true : false,\n };\n}\n","#usf ","#usf ","#usf ","#usf ","#usf \n#usf ","#usf \n#usf \n#usf ","#usf \n#usf \n#usf \n#usf ","#usf ","#usf \n#usf \n#usf ","#usf ","#usf ","#usf ","import plane_vertex from \"./ShaderLib/plane_vertex.glsl\";\nimport default_vertex from \"./ShaderLib/default_vertex.glsl\";\nimport default_pars_vertex from \"./ShaderLib/default_pars_vertex.glsl\";\nimport default_pars_fragment from \"./ShaderLib/default_pars_fragment.glsl\";\nimport basicFx_vertex from \"./ShaderLib/basicFx_vertex.glsl\";\nimport basicFx_pars_vertex from \"./ShaderLib/basicFx_pars_vertex.glsl\";\nimport basicFx_pars_fragment from \"./ShaderLib/basicFx_pars_fragment.glsl\";\nimport basicFx_fragment_begin from \"./ShaderLib/basicFx_fragment_begin.glsl\";\nimport basicFx_fragment_end from \"./ShaderLib/basicFx_fragment_end.glsl\";\nimport samplingFx_vertex from \"./ShaderLib/samplingFx_vertex.glsl\";\nimport samplingFx_pars_vertex from \"./ShaderLib/samplingFx_pars_vertex.glsl\";\nimport samplingFx_pars_fragment from \"./ShaderLib/samplingFx_pars_fragment.glsl\";\n\nexport type ShaderLibTypes =\n | \"plane_vertex\"\n | \"default_vertex\"\n | \"default_pars_vertex\"\n | \"default_pars_fragment\"\n | \"basicFx_vertex\"\n | \"basicFx_pars_vertex\"\n | \"basicFx_pars_fragment\"\n | \"basicFx_fragment_begin\"\n | \"basicFx_fragment_end\"\n | \"samplingFx_vertex\"\n | \"samplingFx_pars_vertex\"\n | \"samplingFx_pars_fragment\";\n\nexport const ShaderLib: { [K in ShaderLibTypes]: string } = Object.freeze({\n plane_vertex,\n default_vertex,\n default_pars_vertex,\n default_pars_fragment,\n basicFx_vertex,\n basicFx_pars_vertex,\n basicFx_pars_fragment,\n basicFx_fragment_begin,\n basicFx_fragment_end,\n samplingFx_vertex,\n samplingFx_pars_vertex,\n samplingFx_pars_fragment,\n});\n","import { ShaderLib } from \"../../../shaders/ShaderLib\";\n\nexport const noiseVertex = `\n\tvoid main() {\n\t\t${ShaderLib.plane_vertex}\n\t}\n`;\n\nexport const noiseFragment = `\n\tprecision highp int;\n\n\tuniform float tick;\n\tuniform float timeStrength;\n\tuniform int noiseOctaves;\n\tuniform int fbmOctaves;\n\tuniform int warpOctaves;\n\tuniform vec2 warpDirection;\n\tuniform float warpStrength;\n\tuniform float scale;\n\tuniform float timeOffset;\n\n\tconst float per = 0.5;\n\tconst float PI = 3.14159265359;\n\n\tfloat rnd(vec2 n) {\n\t\tfloat a = 0.129898;\n\t\tfloat b = 0.78233;\n\t\tfloat c = 437.585453;\n\t\tfloat dt= dot(n ,vec2(a, b));\n\t\tfloat sn= mod(dt, PI);\n\t\treturn fract(sin(sn) * c);\n\t}\n\n\tfloat interpolate(float a, float b, float x){\n\t\tfloat f = (1.0 - cos(x * PI)) * 0.5;\n\t\treturn a * (1.0 - f) + b * f;\n\t}\n\n\tfloat irnd(vec2 p){\n\t\tvec2 i = floor(p);\n\t\tvec2 f = fract(p);\n\t\tvec4 v = vec4(rnd(vec2(i.x,i.y)),rnd(vec2(i.x + 1.0,i.y)),rnd(vec2(i.x,i.y + 1.0)),rnd(vec2(i.x + 1.0, i.y + 1.0)));\n\t\treturn interpolate(interpolate(v.x, v.y, f.x), interpolate(v.z, v.w, f.x), f.y);\n\t}\n\n\t// Based on The Book of Shaders\n\t// https://thebookofshaders.com/13/\n\tfloat noise(vec2 p, float time){\n\t\tfloat _time = time + timeOffset;\n\t\tfloat t = 0.0;\n\t\tfor(int i = 0; i < noiseOctaves; i++){\n\t\t\tfloat freq = pow(2.0, float(i));\n\t\t\tfloat amp = pow(per, float(noiseOctaves - i));\n\t\t\tt += irnd(vec2(p.y / freq + _time, p.x / freq + _time)) * amp;\n\t\t}\n\t\treturn t;\n\t}\n\n\tfloat fbm(vec2 x, float time) {\n\t\tfloat v = 0.0;\n\t\tfloat a = 0.5;\n\t\tvec2 shift = vec2(100);\n\t\tmat2 rot = mat2(cos(0.5), sin(0.5), -sin(0.5), cos(0.5));\n\t\tfloat sign = 1.0;\n\t\tfor (int i = 0; i < fbmOctaves; ++i) {\n\t\t\tv += a * noise(x, time * sign);\n\t\t\tx = rot * x * 2.0 + shift;\n\t\t\ta *= 0.5;\n\t\t\tsign *= -1.0;\n\t\t}\n\t\treturn v;\n\t}\n\n\tfloat warp(vec2 x, float g,float time){\n\t\tfloat val = 0.0;\n\t\tfor (int i = 0; i < warpOctaves; i++){\n\t\t\tval = fbm(x + g * vec2(cos(warpDirection.x * val), sin(warpDirection.y * val)), time);\n\t\t}\n\t\treturn val;\n\t}\n\n\tvoid main() {\n\n\t\tvec2 usf_Uv = gl_FragCoord.xy * scale;\n\n\t\t${ShaderLib.basicFx_fragment_begin}\n\n\t\tfloat noise = warp(usf_Uv ,warpStrength,tick * timeStrength);\n\n\t\tvec4 usf_FragColor = vec4(noise);\n\n\t\t${ShaderLib.basicFx_fragment_end}\n\n\t\tgl_FragColor = usf_FragColor;\n\n\t}\n`;\n","gl_Position = vec4(position, 1.0);","#ifdef USF_USE_SRC_SYSTEM\n\n\t#usf \n\n#endif\n","#ifdef USF_USE_SRC_SYSTEM\n\n\t#usf \n\n\tfloat calcMixCirclePower(vec2 center, float radius, vec2 range)\n\t{\n\t\tvec2 adjustedUV = (vUv - 0.5) * vec2(aspectRatio, 1.0) + 0.5;\n\t\tvec2 adjustedCenter = (center - 0.5) * vec2(aspectRatio, 1.0) + 0.5;\n\t\t\n\t\tfloat dist = length(adjustedUV - adjustedCenter);\n\t\tfloat power = radius > 0.0 ? 1.0 - dist / radius : 1.0;\n\t\treturn smoothstep(range.x,range.y,power);\n\t}\n\n\tfloat calcMixMapPower(sampler2D map,vec2 range, int ch)\n\t{\n\t\treturn smoothstep(range.x,range.y, texture2D(map, vUv)[ch]);\n\t}\n\n\tvec4 fitTexture(sampler2D src , vec2 uv, int fitType)\n\t{\n\t\t// fitTypeがcontainの場合だけ範囲外を透過する\n\t\tfloat a = fitType == 2 ? step(0.0, uv.x) * step(uv.x, 1.0) * step(0.0, uv.y) * step(uv.y, 1.0) : 1.;\n\t\treturn mix(vec4(0.), texture2D(src, uv), a);\n\t}\n\n#endif\n","vUv = uv;","precision highp float;\n\nvarying vec2 vUv;\nuniform vec2 resolution;\nuniform vec2 texelSize;\nuniform float aspectRatio;\nuniform vec2 maxAspect;","precision highp float;\n\nvarying vec2 vUv;\nuniform vec2 resolution;\nuniform vec2 texelSize;\nuniform float aspectRatio;\nuniform vec2 maxAspect;\nuniform int renderCount;","#ifdef USF_USE_MIXSRC\n\tvarying vec2 vMixSrcCoverUv;\n\tuniform vec2 mixSrc_fitScale;\n#endif","#ifdef USF_USE_MIXSRC\t\t\t\n\tvMixSrcCoverUv = calcSrcUv(vUv, mixSrc_fitScale);\t\n#endif","#ifdef USF_USE_MIXSRC\n\tvarying vec2 vMixSrcCoverUv;\n\tuniform sampler2D mixSrc_src;\n\tuniform int mixSrc_fit;\n\n\tuniform bool mixSrc_uv;\n\tuniform int mixSrc_uv_ch;\n\tuniform float mixSrc_uv_factor;\n\tuniform vec2 mixSrc_uv_offset;\n\tuniform float mixSrc_uv_radius;\n\tuniform vec2 mixSrc_uv_position;\n\tuniform vec2 mixSrc_uv_range;\n\tuniform bool mixSrc_uv_mixMap;\n\tuniform sampler2D mixSrc_uv_mixMap_src;\n\tuniform int mixSrc_uv_mixMap_ch;\n\n\tuniform bool mixSrc_color;\n\tuniform float mixSrc_color_factor;\n\tuniform float mixSrc_color_radius;\n\tuniform vec2 mixSrc_color_position;\n\tuniform vec2 mixSrc_color_range;\n\tuniform bool mixSrc_color_mixMap;\n\tuniform sampler2D mixSrc_color_mixMap_src;\n\tuniform int mixSrc_color_mixMap_ch;\n\n\tuniform bool mixSrc_alpha;\n\tuniform float mixSrc_alpha_factor;\n\tuniform float mixSrc_alpha_radius;\n\tuniform vec2 mixSrc_alpha_position;\n\tuniform vec2 mixSrc_alpha_range;\n\tuniform bool mixSrc_alpha_mixMap;\n\tuniform sampler2D mixSrc_alpha_mixMap_src;\n\tuniform int mixSrc_alpha_mixMap_ch;\n\n#endif","#ifdef USF_USE_MIXSRC\n\n\tvec4 mixSrcColor = fitTexture(mixSrc_src, vMixSrcCoverUv, mixSrc_fit);\n\n\tusf_Uv += mixSrc_uv \n\t\t? (mixSrc_uv_offset + (vec2(mixSrcColor[mixSrc_uv_ch]) * 2. - 1.)) * \n\t\t\t(mixSrc_uv_mixMap \n\t\t\t\t? calcMixMapPower(mixSrc_uv_mixMap_src,mixSrc_uv_range,mixSrc_uv_mixMap_ch)\n\t\t\t\t: calcMixCirclePower(mixSrc_uv_position,mixSrc_uv_radius,mixSrc_uv_range)) * mixSrc_uv_factor\n\t\t: vec2(0.);\n\n#endif","#ifdef USF_USE_MIXSRC\n\t// color\n\tusf_FragColor = mixSrc_color \n\t\t? mix(usf_FragColor, mixSrcColor,\n\t\t\t(mixSrc_color_mixMap\n\t\t\t\t? calcMixMapPower(mixSrc_color_mixMap_src,mixSrc_color_range,mixSrc_color_mixMap_ch)\n\t\t\t\t: calcMixCirclePower(mixSrc_color_position,mixSrc_color_radius,mixSrc_color_range)) * mixSrc_color_factor) \n\t\t: usf_FragColor;\n\t\n\t// alpha\n\tusf_FragColor = mixSrc_alpha \n\t\t? mix(usf_FragColor, mixSrcColor, \n\t\t\t(mixSrc_alpha_mixMap\n\t\t\t\t? calcMixMapPower(mixSrc_alpha_mixMap_src,mixSrc_alpha_range,mixSrc_alpha_mixMap_ch)\n\t\t\t\t: calcMixCirclePower(mixSrc_alpha_position,mixSrc_alpha_radius,mixSrc_alpha_range)) * mixSrc_alpha_factor * mixSrcColor.a)\n\t\t: usf_FragColor;\n\n#endif","#ifdef USF_USE_MIXDST\n\tvarying vec2 vMixDstCoverUv;\n\tuniform vec2 mixDst_fitScale;\n#endif","#ifdef USF_USE_MIXDST\t\t\n\tvMixDstCoverUv = calcSrcUv(vUv, mixDst_fitScale);\t\n#endif","#ifdef USF_USE_MIXDST\n\n\tvarying vec2 vMixDstCoverUv;\n\tuniform sampler2D mixDst_src;\n\tuniform int mixDst_fit;\n\t\n\tuniform bool mixDst_uv;\n\tuniform int mixDst_uv_ch;\n\tuniform float mixDst_uv_factor;\n\tuniform vec2 mixDst_uv_offset;\n\tuniform float mixDst_uv_radius;\n\tuniform vec2 mixDst_uv_position;\n\tuniform vec2 mixDst_uv_range;\n\tuniform bool mixDst_uv_mixMap;\n\tuniform sampler2D mixDst_uv_mixMap_src;\n\tuniform int mixDst_uv_mixMap_ch;\n\n\tuniform bool mixDst_color;\n\tuniform float mixDst_color_factor;\n\tuniform float mixDst_color_radius;\n\tuniform vec2 mixDst_color_position;\n\tuniform vec2 mixDst_color_range;\n\tuniform bool mixDst_color_mixMap;\n\tuniform sampler2D mixDst_color_mixMap_src;\n\tuniform int mixDst_color_mixMap_ch;\n\n\tuniform bool mixDst_alpha;\n\tuniform float mixDst_alpha_factor;\n\tuniform float mixDst_alpha_radius;\n\tuniform vec2 mixDst_alpha_position;\n\tuniform vec2 mixDst_alpha_range;\n\tuniform bool mixDst_alpha_mixMap;\n\tuniform sampler2D mixDst_alpha_mixMap_src;\n\tuniform int mixDst_alpha_mixMap_ch;\n\n#endif","#ifdef USF_USE_MIXDST\n\n\t// uv\n\tvec2 mixedUv = vMixDstCoverUv;\n\tmixedUv += mixDst_uv \n\t\t? (mixDst_uv_offset + (vec2(usf_FragColor[mixDst_uv_ch]) * 2. - 1.)) * \n\t\t\t(mixDst_uv_mixMap \n\t\t\t\t? calcMixMapPower(mixDst_uv_mixMap_src,mixDst_uv_range,mixDst_uv_mixMap_ch)\n\t\t\t\t: calcMixCirclePower(mixDst_uv_position,mixDst_uv_radius,mixDst_uv_range)) * mixDst_uv_factor\n\t\t: vec2(0.);\n\tvec4 mixDstColor = fitTexture(mixDst_src, mixedUv , mixDst_fit);\n\n\t// color\n\tusf_FragColor = mixDst_color \n\t\t? mix(usf_FragColor, mixDstColor,\n\t\t\t(mixDst_color_mixMap\n\t\t\t\t? calcMixMapPower(mixDst_color_mixMap_src,mixDst_color_range,mixDst_color_mixMap_ch)\n\t\t\t\t: calcMixCirclePower(mixDst_color_position,mixDst_color_radius,mixDst_color_range)) * mixDst_color_factor) \n\t\t: usf_FragColor;\n\n\t// alpha\n\tusf_FragColor = mixDst_alpha \n\t\t? mix(usf_FragColor, mixDstColor, \n\t\t\t(mixDst_alpha_mixMap\n\t\t\t\t? calcMixMapPower(mixDst_alpha_mixMap_src,mixDst_alpha_range,mixDst_alpha_mixMap_ch)\n\t\t\t\t: calcMixCirclePower(mixDst_alpha_position,mixDst_alpha_radius,mixDst_alpha_range)) * mixDst_alpha_factor * mixDstColor.a)\n\t\t: usf_FragColor;\n\n#endif\n\n","#ifdef USF_USE_TEXTURE\t\t\n\tvTextureCoverUv = calcSrcUv(vUv, texture_fitScale);\n#endif","#ifdef USF_USE_TEXTURE\n\tvarying vec2 vTextureCoverUv;\n\tuniform vec2 texture_fitScale;\n#endif","#ifdef USF_USE_TEXTURE\t\n\tvarying vec2 vTextureCoverUv;\n\tuniform sampler2D texture_src;\n\tuniform int texture_fit;\n\tuniform vec2 texture_fitScale;\n#endif","#ifdef USF_USE_LEVELS\n\tusf_FragColor = (usf_FragColor - vec4(levels_shadows)) / (vec4(levels_highlights) - vec4(levels_shadows));\n\tusf_FragColor = pow(usf_FragColor, vec4(1.0 / levels_midtones));\n\tusf_FragColor = usf_FragColor * (vec4(levels_outputMax) - vec4(levels_outputMin)) + vec4(levels_outputMin);\n#endif\n\n#ifdef USF_USE_CONTRAST\n\tusf_FragColor = clamp(((usf_FragColor-.5)*contrast_factor)+.5, 0., 1.);\n#endif\n\n#ifdef USF_USE_COLORBALANCE\n\tusf_FragColor.rgb = clamp(usf_FragColor.rgb * colorBalance_factor, 0., 1.);\n#endif\n\n#ifdef USF_USE_HSV\n\tvec3 hsv = rgb2hsv(usf_FragColor.rgb);\n\thsv.x = fract(hsv.x + hsv_hueShift);\n\thsv.y = clamp(hsv.y * hsv_saturation, 0.0, 1.0);\n\thsv.z = clamp(hsv.z * hsv_brightness, 0.0, 1.0);\n\tusf_FragColor.rgb = hsv2rgb(hsv);\n#endif\n\n#ifdef USF_USE_POSTERIZE\n\tusf_FragColor = posterize(usf_FragColor, posterize_levels);\n#endif\n\n#ifdef USF_USE_GRAYSCALE\n\tfloat grayscale = dot(usf_FragColor.rgb, vec3(0.299 + grayscale_weight.r, 0.587 + grayscale_weight.g, 0.114 + grayscale_weight.b));\n\tgrayscale = grayscale_threshold > 0.0 ? step(grayscale_threshold, grayscale) : grayscale;\n\tvec3 duotoneColor = mix(grayscale_duotone_color0, grayscale_duotone_color1, grayscale);\n\tusf_FragColor.rgb = grayscale_duotone ? duotoneColor : vec3(grayscale);\n#endif\n","#ifdef USF_USE_LEVELS\n\tuniform vec4 levels_shadows;\n\tuniform vec4 levels_midtones;\n\tuniform vec4 levels_highlights;\n\tuniform vec4 levels_outputMin;\n\tuniform vec4 levels_outputMax;\n#endif\n\n#ifdef USF_USE_CONTRAST\n\tuniform vec4 contrast_factor;\n#endif\n\n#ifdef USF_USE_COLORBALANCE\n\tuniform vec3 colorBalance_factor;\n#endif\n\n#ifdef USF_USE_HSV\n\tuniform float hsv_hueShift;\n\tuniform float hsv_saturation;\n\tuniform float hsv_brightness;\n\tvec3 hsv2rgb(vec3 c)\n\t{\n\t\tvec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);\n\t\tvec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);\n\t\treturn c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);\n\t}\n\tvec3 rgb2hsv(vec3 c)\n\t{\n\t\tvec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);\n\t\tvec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g));\n\t\tvec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r));\n\n\t\tfloat d = q.x - min(q.w, q.y);\n\t\tfloat e = 1.0e-10;\n\t\treturn vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);\n\t}\n#endif\n\n#ifdef USF_USE_POSTERIZE\n\tuniform vec4 posterize_levels;\n\tvec4 posterize(vec4 color, vec4 levels) \n\t{\n\t\treturn vec4(\n\t\t\tlevels.x > 1. ? floor(color.r * levels.x) / levels.x : color.r,\n\t\t\tlevels.y > 1. ? floor(color.g * levels.y) / levels.y : color.g,\n\t\t\tlevels.z > 1. ? floor(color.b * levels.z) / levels.z : color.b,\n\t\t\tlevels.w > 1. ? floor(color.a * levels.w) / levels.w : color.a\n\t\t);\n\t}\n#endif\n\n#ifdef USF_USE_GRAYSCALE\n\tuniform vec3 grayscale_weight;\n\tuniform bool grayscale_duotone;\n\tuniform vec3 grayscale_duotone_color0;\n\tuniform vec3 grayscale_duotone_color1;\n\tuniform float grayscale_threshold;\n#endif","vec2 calcSrcUv(vec2 uv, vec2 fitScale) {\n\treturn uv * fitScale + (1.0 - fitScale) * .5;\n}","import plane_vertex from \"./ShaderChunk/plane_vertex.glsl\";\nimport srcSystem_pars_vertex from \"./ShaderChunk/srcSystem_pars_vertex.glsl\";\nimport srcSystem_pars_fragment from \"./ShaderChunk/srcSystem_pars_fragment.glsl\";\nimport default_vertex from \"./ShaderChunk/default_vertex.glsl\";\nimport default_pars_vertex from \"./ShaderChunk/default_pars_vertex.glsl\";\nimport default_pars_fragment from \"./ShaderChunk/default_pars_fragment.glsl\";\nimport mixSrc_pars_vertex from \"./ShaderChunk/mixSrc_pars_vertex.glsl\";\nimport mixSrc_vertex from \"./ShaderChunk/mixSrc_vertex.glsl\";\nimport mixSrc_pars_fragment from \"./ShaderChunk/mixSrc_pars_fragment.glsl\";\nimport mixSrc_fragment_begin from \"./ShaderChunk/mixSrc_fragment_begin.glsl\";\nimport mixSrc_fragment_end from \"./ShaderChunk/mixSrc_fragment_end.glsl\";\nimport mixDst_pars_vertex from \"./ShaderChunk/mixDst_pars_vertex.glsl\";\nimport mixDst_vertex from \"./ShaderChunk/mixDst_vertex.glsl\";\nimport mixDst_pars_fragment from \"./ShaderChunk/mixDst_pars_fragment.glsl\";\nimport mixDst_fragment from \"./ShaderChunk/mixDst_fragment.glsl\";\nimport texture_vertex from \"./ShaderChunk/texture_vertex.glsl\";\nimport texture_pars_vertex from \"./ShaderChunk/texture_pars_vertex.glsl\";\nimport texture_pars_fragment from \"./ShaderChunk/texture_pars_fragment.glsl\";\nimport adjustments_fragment from \"./ShaderChunk/adjustments_fragment.glsl\";\nimport adjustments_pars_fragment from \"./ShaderChunk/adjustments_pars_fragment.glsl\";\nimport calcSrcUv from \"./ShaderChunk/calcSrcUv.glsl\";\n\nexport type ShaderChunkTypes =\n | \"default_pars_fragment\"\n | \"srcSystem_pars_vertex\"\n | \"srcSystem_pars_fragment\"\n | \"default_pars_vertex\"\n | \"default_vertex\"\n | \"plane_vertex\"\n | \"mixSrc_fragment_begin\"\n | \"mixSrc_fragment_end\"\n | \"mixSrc_pars_fragment\"\n | \"mixSrc_pars_vertex\"\n | \"mixSrc_vertex\"\n | \"mixDst_fragment\"\n | \"mixDst_pars_fragment\"\n | \"mixDst_pars_vertex\"\n | \"mixDst_vertex\"\n | \"texture_pars_fragment\"\n | \"texture_pars_vertex\"\n | \"texture_vertex\"\n | \"adjustments_fragment\"\n | \"adjustments_pars_fragment\"\n | \"calcSrcUv\";\n\nexport const ShaderChunk: { [K in ShaderChunkTypes]: string } = Object.freeze({\n plane_vertex,\n srcSystem_pars_vertex,\n srcSystem_pars_fragment,\n default_vertex,\n default_pars_vertex,\n default_pars_fragment,\n mixSrc_vertex,\n mixSrc_pars_vertex,\n mixSrc_pars_fragment,\n mixSrc_fragment_begin,\n mixSrc_fragment_end,\n mixDst_pars_vertex,\n mixDst_vertex,\n mixDst_pars_fragment,\n mixDst_fragment,\n texture_vertex,\n texture_pars_vertex,\n texture_pars_fragment,\n adjustments_fragment,\n adjustments_pars_fragment,\n calcSrcUv,\n});\n","import { ShaderLib } from \"./ShaderLib\";\nimport { ShaderChunk, ShaderChunkTypes } from \"./ShaderChunk\";\n\n/** merge shader codes */\nexport function mergeShaderCode(prefix: string[]): string {\n return prefix.filter((string) => string !== \"\").join(\"\\n\");\n}\n\n/*===============================================\nMEMO\n- SamplingFxMaterialをさらに拡張する場合（例えばuseTextureTransitionとかで、複数のtextureのfitScaleが必要な場合）、ここでShaderLibTypeを追加する。\n===============================================*/\n\nexport type ShaderLibType = \"default\" | \"basicFx\" | \"samplingFx\";\n/**\n * merge ShaderLib to shader\n * basicFx_fragment_begin, basicFx_fragment_endは含まない。これらは各FXでカスタマイズする必要があるため。\n */\nexport function mergeShaderLib(\n vertexShader: string | undefined,\n fragmentShader: string | undefined,\n type: ShaderLibType\n): [string | undefined, string | undefined] {\n let vertex,\n fragment = undefined;\n\n const ShaderLibs = {\n default: {\n vertexPars: ShaderLib.default_pars_vertex,\n vertexMain: ShaderLib.default_vertex,\n fragmentPars: ShaderLib.default_pars_fragment,\n },\n basicFx: {\n vertexPars: ShaderLib.basicFx_pars_vertex,\n vertexMain: ShaderLib.basicFx_vertex,\n fragmentPars: ShaderLib.basicFx_pars_fragment,\n },\n samplingFx: {\n vertexPars: mergeShaderCode([\n ShaderLib.basicFx_pars_vertex,\n ShaderLib.samplingFx_pars_vertex,\n ]),\n vertexMain: mergeShaderCode([\n ShaderLib.basicFx_vertex,\n ShaderLib.samplingFx_vertex,\n ]),\n fragmentPars: mergeShaderCode([\n ShaderLib.basicFx_pars_fragment,\n ShaderLib.samplingFx_pars_fragment,\n ]),\n },\n };\n\n const vertexPars = ShaderLibs[type].vertexPars;\n const vertexMain = ShaderLibs[type].vertexMain;\n const fragmentPars = ShaderLibs[type].fragmentPars;\n\n if (vertexShader) {\n vertex = mergeShaderCode([vertexPars, vertexShader]);\n vertex = vertex.replace(\n /void\\s+main\\s*\\(\\)\\s*\\{/,\n `void main() {\\n${vertexMain}`\n );\n }\n\n if (fragmentShader) {\n fragment = mergeShaderCode([fragmentPars, fragmentShader]);\n }\n\n return [vertex, fragment];\n}\n\nconst includePattern = /^[ \\t]*#usf +<([\\w\\d./]+)>/gm;\nfunction includeReplacer(match: string, include: ShaderChunkTypes): string {\n return resolveIncludes(ShaderChunk[include] || \"\");\n}\n/** Resolve Includes */\nexport function resolveIncludes(string: string): string {\n return string.replace(includePattern, includeReplacer);\n}\n","import * as THREE from \"three\";\nimport { warn } from \"../utils\";\nimport { THREE_FLAG_PROPS } from \"../libs/constants\";\n\nexport type Uniforms = { [uniform: string]: THREE.IUniform };\n\n/** typescriptトリックで{}を許容しているが、実際にuniformに渡る際にはbooleanのみ */\nexport type UniformParentKey = boolean | {};\n\nexport type ShaderWithUniforms = {\n uniforms?: Uniforms;\n vertexShader?: string;\n fragmentShader?: string;\n};\n\n/**\n * test:{value:number} => test:number\n * materialのprops型を定義する\n * materialにはuniformsのsetter/getterが定義されている.その型推論のため.\n */\nexport type ExtractUniformValues = {\n [K in keyof T]?: T[K] extends { value: infer U } ? U : never;\n};\n\n/**\n * test_test:{value:number} => { test: { test: number | (value:number)=>number } }\n */\ntype Nest = K extends `${infer First}_${infer Rest}`\n ? { [P in First]?: Nest }\n : { [P in K]?: V | ((value: V) => V) };\n\ntype UnionToIntersection = (U extends any ? (k: U) => void : never) extends (\n k: infer I\n) => void\n ? I\n : never;\nexport type NestUniformValues = UnionToIntersection<\n { [K in keyof U]: Nest, U[K][\"value\"]> }[keyof U]\n>;\n\n/**\n * Determines whether the given property is a three.js object by checking for the presence\n * of known boolean flag properties (e.g., `isTexture`, `isVector2`, etc.) that are typically\n * set to true on three.js instances.\n */\nfunction isTHREE(property: any) {\n return property && THREE_FLAG_PROPS.some((prop) => property[prop] === true);\n}\n\n/**\n * {test:{test:1}} => {test_test:1} に変換する\n * この時、条件分岐用uniform値として親のkey{test:true}を追加する\n */\nexport function flattenUniformValues(\n obj: Record\n): Record {\n const flatObject: Record = {};\n\n const flatten = (currentObj: any, parentKey = \"\"): void => {\n for (const [key, val] of Object.entries(currentObj)) {\n const newKey = parentKey ? `${parentKey}_${key}` : key;\n if (\n val &&\n typeof val === \"object\" &&\n !Array.isArray(val) &&\n !isTHREE(val)\n ) {\n (flatObject[newKey] as UniformParentKey) = true; // 親のkey{test:true}を追加する\n flatten(val, newKey);\n } else {\n if (flatObject.hasOwnProperty(newKey)) {\n warn(`${newKey} already exists and will be overwritten.`);\n }\n flatObject[newKey] = val;\n }\n }\n };\n\n flatten(obj);\n return flatObject;\n}\n","import * as THREE from \"three\";\nimport { resolveIncludes, mergeShaderLib } from \"../../shaders/shaderUtils\";\nimport {\n flattenUniformValues,\n ShaderWithUniforms,\n} from \"../../shaders/uniformsUtils\";\nimport { warn } from \"../../utils\";\n\nexport type DefaultUniforms = {\n resolution: { value: THREE.Vector2 };\n texelSize: { value: THREE.Vector2 };\n aspectRatio: { value: number };\n maxAspect: { value: THREE.Vector2 };\n renderCount: { value: number };\n};\n\nexport type FxMaterialProps = {\n uniformValues?: T;\n materialParameters?: THREE.ShaderMaterialParameters;\n customParameters?: { [key: string]: any };\n} & ShaderWithUniforms;\n\nexport class FxMaterial extends THREE.ShaderMaterial {\n public static readonly key: string = THREE.MathUtils.generateUUID();\n\n constructor({\n uniformValues,\n materialParameters = {},\n uniforms,\n vertexShader,\n fragmentShader,\n }: FxMaterialProps = {}) {\n super(materialParameters);\n\n this.uniforms = {\n resolution: { value: new THREE.Vector2() },\n texelSize: { value: new THREE.Vector2() },\n aspectRatio: { value: 0 },\n maxAspect: { value: new THREE.Vector2() },\n // 一部のFXでiterationをカウントする必要があるため\n renderCount: { value: 0 },\n ...uniforms,\n } as DefaultUniforms;\n\n this._setupShaders(vertexShader, fragmentShader);\n\n this.setUniformValues(uniformValues);\n\n this._defineUniformAccessors();\n }\n\n /** This is updated in useFxScene */\n public updateResolution(width: number, height: number) {\n const maxAspect = Math.max(width, height);\n this.uniforms.resolution.value.set(width, height);\n this.uniforms.texelSize.value.set(1 / width, 1 / height);\n this.uniforms.aspectRatio.value = width / height;\n this.uniforms.maxAspect.value.set(maxAspect / width, maxAspect / height);\n }\n\n protected _setupShaders(vertexShader?: string, fragmentShader?: string) {\n if (!vertexShader && !fragmentShader) return;\n\n const [vertex, fragment] = mergeShaderLib(\n vertexShader,\n fragmentShader,\n \"default\"\n );\n this.vertexShader = vertex ? resolveIncludes(vertex) : this.vertexShader;\n this.fragmentShader = fragment\n ? resolveIncludes(fragment)\n : this.fragmentShader;\n }\n\n public setUniformValues(values?: { [key: string]: any }) {\n if (values === undefined) return;\n const flattenedValues = flattenUniformValues(values);\n\n for (const [key, value] of Object.entries(flattenedValues)) {\n if (value === undefined) {\n warn(`parameter '${key}' has value of undefined.`);\n continue;\n }\n\n const curretUniform = this.uniforms[key];\n\n if (curretUniform === undefined) {\n warn(`'${key}' is not a uniform property of ${this.type}.`);\n continue;\n }\n\n curretUniform.value =\n typeof value === \"function\" ? value(curretUniform.value) : value;\n }\n\n return flattenedValues;\n }\n\n /** define getter/setters　*/\n protected _defineUniformAccessors(onSet?: () => void) {\n for (const key of Object.keys(this.uniforms)) {\n if (this.hasOwnProperty(key)) {\n warn(`'${key}' is already defined in ${this.type}.`);\n continue;\n }\n Object.defineProperty(this, key, {\n get: () => this.uniforms[key].value,\n set: (v) => {\n this.uniforms[key].value = v;\n onSet?.();\n },\n });\n }\n }\n}\n","import * as THREE from \"three\";\nimport { FxMaterial, FxMaterialProps } from \"./FxMaterial\";\nimport { mergeShaderLib } from \"../../shaders/shaderUtils\";\nimport * as BasicFxLib from \"./BasicFxLib\";\n\nexport class BasicFxMaterial extends FxMaterial {\n fxKey: BasicFxLib.FxKey;\n\n uniforms!: BasicFxLib.BasicFxUniforms;\n programCache: number;\n\n constructor({\n uniforms,\n vertexShader,\n fragmentShader,\n ...rest\n }: FxMaterialProps = {}) {\n super({\n ...rest,\n uniforms: {\n ...THREE.UniformsUtils.clone(BasicFxLib.BASICFX_VALUES),\n ...uniforms,\n },\n });\n\n this.defines = {\n ...rest?.materialParameters?.defines,\n };\n\n this.programCache = 0;\n\n this.fxKey = this._setupFxKey(this.uniforms);\n\n this._setupFxShaders(vertexShader, fragmentShader);\n }\n\n private _setupFxShaders(vertexShader?: string, fragmentShader?: string) {\n if (!vertexShader && !fragmentShader) return;\n\n this._updateFxDefines();\n\n const [vertex, fragment] = this._handleMergeShaderLib(\n vertexShader,\n fragmentShader\n );\n\n super._setupShaders(vertex, fragment);\n }\n\n /** SamplingFxMaterialで継承するため、handlerとして独立させる */\n protected _handleMergeShaderLib(\n vertexShader?: string,\n fragmentShader?: string\n ) {\n return mergeShaderLib(vertexShader, fragmentShader, \"basicFx\");\n }\n\n private _updateFxShaders() {\n // FxMaterialの初期化時にsetUniformValuesが呼ばれるが、isContainsBasicFxValuesがtrueを返すと、このメソッドが実行されてしまう。BasicFxMaterialの初期化前にはこの処理をスキップする。\n if (!this.fxKey) return;\n\n const _cache = this.programCache;\n\n const { diffCount, newFxKey } = this._handleUpdateFxShaders();\n\n this.programCache += diffCount;\n this.fxKey = newFxKey;\n\n if (_cache !== this.programCache) {\n this._updateFxDefines();\n this.needsUpdate = true;\n }\n }\n\n /** SamplingFxMaterialで継承するため、handlerとして独立させる */\n protected _handleUpdateFxShaders(): {\n diffCount: number;\n newFxKey: BasicFxLib.FxKey;\n } {\n const newFxKey = BasicFxLib.getFxKeyFromUniforms(this.uniforms);\n const diffCount = (\n Object.keys(newFxKey) as (keyof BasicFxLib.FxKey)[]\n ).filter((key) => this.fxKey[key] !== newFxKey[key]).length;\n return {\n diffCount,\n newFxKey,\n };\n }\n\n private _updateFxDefines() {\n Object.assign(this.defines, this._handleUpdateFxDefines());\n }\n\n /** SamplingFxMaterialで継承するため、handlerとして独立させる */\n protected _handleUpdateFxDefines(): {\n [key: string]: any;\n } {\n return BasicFxLib.handleUpdateFxDefines(this.fxKey);\n }\n\n protected _isContainsBasicFxValues(\n target?: { [key: string]: any },\n source?: { [key: string]: any }\n ): boolean {\n if (!target) return false;\n return Object.keys(target).some((key) =>\n Object.keys(source ?? BasicFxLib.BASICFX_VALUES).includes(key)\n );\n }\n\n protected _setupFxKey(\n uniforms: BasicFxLib.BasicFxUniforms\n ): BasicFxLib.FxKey {\n return BasicFxLib.getFxKeyFromUniforms(uniforms);\n }\n\n /*===============================================\n\tFit Scale\n\t===============================================*/\n private _calcFitScale(\n src: THREE.Texture,\n fitType: BasicFxLib.FitType\n ): THREE.Vector2 {\n let srcAspectRatio = 1;\n const fitScale = new THREE.Vector2(1, 1);\n const baseAspectRatio = this.uniforms.aspectRatio.value;\n\n const sourceData = src?.source?.data;\n\n if (sourceData?.width && sourceData?.height) {\n srcAspectRatio = sourceData.width / sourceData.height;\n } else {\n srcAspectRatio = baseAspectRatio;\n }\n\n if (fitType === 1) {\n fitScale.set(\n Math.min(baseAspectRatio / srcAspectRatio, 1),\n Math.min(srcAspectRatio / baseAspectRatio, 1)\n );\n } else if (fitType === 2) {\n fitScale.set(\n Math.max(baseAspectRatio / srcAspectRatio, 1),\n Math.max(srcAspectRatio / baseAspectRatio, 1)\n );\n }\n\n return fitScale;\n }\n\n protected _setFitScale(key: BasicFxLib.SrcSystemKey) {\n const uniforms = this.uniforms as any;\n uniforms[`${key}_fitScale`].value = this._calcFitScale(\n uniforms[`${key}_src`].value,\n uniforms[`${key}_fit`].value\n );\n }\n\n protected _updateFitScale() {\n if (this.fxKey?.mixSrc) this._setFitScale(\"mixSrc\");\n if (this.fxKey?.mixDst) this._setFitScale(\"mixDst\");\n }\n\n /*===============================================\n\tsuper FxMaterial\n\t===============================================*/\n /**\n * @param needsUpdate default : `true`\n */\n public setUniformValues(\n values?: { [key: string]: any },\n needsUpdate: boolean = true\n ) {\n const flattenedValues = super.setUniformValues(values);\n if (needsUpdate && this._isContainsBasicFxValues(flattenedValues)) {\n this._updateFxShaders();\n this._updateFitScale();\n }\n return flattenedValues;\n }\n\n protected _defineUniformAccessors(onSet?: () => void) {\n super._defineUniformAccessors(() => {\n this._updateFxShaders();\n this._updateFitScale();\n onSet?.();\n });\n }\n\n public updateResolution(width: number, height: number): void {\n super.updateResolution(width, height);\n this._updateFitScale();\n }\n}\n","import * as THREE from \"three\";\nimport { noiseFragment, noiseVertex } from \"./noise.glsl\";\nimport { BasicFxMaterial } from \"../../core/BasicFxMaterial\";\nimport { FxMaterialProps } from \"../../core/FxMaterial\";\nimport { BasicFxUniforms, BasicFxValues } from \"../../core/BasicFxLib\";\nimport {\n ExtractUniformValues,\n NestUniformValues,\n} from \"../../../shaders/uniformsUtils\";\n\ntype NoiseUniforms = {\n /** useBeatを渡せば、リズムを変えられる。 */\n tick: { value: number };\n /** noise scale , default : `0.004` */\n scale: { value: number };\n /** time factor default : `0.3` */\n timeStrength: { value: number };\n /** noiseOctaves, affects performance default : `2` */\n noiseOctaves: { value: number };\n /** fbmOctaves, affects performance default : `2` */\n fbmOctaves: { value: number };\n /** domain warping octaves , affects performance default : `2` */\n warpOctaves: { value: number };\n /** direction of domain warping , default : `(2.0,2,0)` */\n warpDirection: { value: THREE.Vector2 };\n /** strength of domain warping , default : `8.0` */\n warpStrength: { value: number };\n /** offset of the time */\n timeOffset: { value: number };\n} & BasicFxUniforms;\n\nexport type NoiseValues = NestUniformValues & BasicFxValues;\n\nexport type NoiseMaterialProps = ExtractUniformValues;\n\nexport class NoiseMaterial extends BasicFxMaterial {\n public static readonly key: string = THREE.MathUtils.generateUUID();\n\n static get type() {\n return \"NoiseMaterial\";\n }\n\n uniforms!: NoiseUniforms;\n\n constructor(props: FxMaterialProps = {}) {\n super({\n ...props,\n vertexShader: noiseVertex,\n fragmentShader: noiseFragment,\n uniforms: {\n tick: { value: 0.0 },\n scale: { value: 0.03 },\n timeStrength: { value: 0.3 },\n noiseOctaves: { value: 2 },\n fbmOctaves: { value: 2 },\n warpOctaves: { value: 2 },\n warpDirection: { value: new THREE.Vector2(2.0, 2.0) },\n warpStrength: { value: 8 },\n timeOffset: { value: 0 },\n } as NoiseUniforms,\n });\n this.type = NoiseMaterial.type;\n }\n}\n","const boxVarying = `\n\tuniform bool bounce;\n\tvarying vec2 vL;\n\tvarying vec2 vR;\n\tvarying vec2 vT;\n\tvarying vec2 vB;\n`;\n\nconst getPosition = (bounce: boolean = true) => {\n return `\n\t\tvec3 pos = position;\n\t\tvec2 scale = ${\n bounce ? \"bounce ? vec2(1.,1.) : 1.-texelSize*2.\" : \"1.-texelSize*2.\"\n };\n\t\tpos.xy = pos.xy * scale;\n\t\tvUv = vec2(.5)+(pos.xy)*.5;\n\t`;\n};\n\nconst getBoxCompute = (diff: string) => {\n return `\n\t\tvL = vUv - vec2(texelSize.x * ${diff}, 0.0);\n\t\tvR = vUv + vec2(texelSize.x * ${diff}, 0.0);\n\t\tvT = vUv + vec2(0.0, texelSize.y * ${diff});\n\t\tvB = vUv - vec2(0.0, texelSize.y * ${diff});\n\t`;\n};\n\nconst vertex = {\n main: `\n\t\t${boxVarying}\n\n\t\tvoid main(){\n\t\t\n\t\t\t${getPosition()}\n\t\t\t${getBoxCompute(\"1.\")}\n\n\t\t\tgl_Position = vec4(pos, 1.0);\n\t\t}\n\t`,\n poisson: `\n\t\t${boxVarying}\n\t\t\n\t\tvoid main(){\n\n\t\t\t${getPosition()}\n\t\t\t${getBoxCompute(\"2.\")}\n\n\t\t\tgl_Position = vec4(pos, 1.0);\n\t\t}\n\t`,\n advection: `\n\t\tvoid main(){\n\t\t\t${getPosition(false)}\n\t\t\tgl_Position = vec4(pos, 1.0);\n\t\t}\n\t`,\n splat: `\n\t\tuniform vec2 center;\n\t\tuniform vec2 radius;\n\t\tvoid main(){\t\t\n\t\t\tvec2 pos = position.xy * radius * 2.0 * texelSize + center;\n\t\t\tgl_Position = vec4(pos, 0.0, 1.0);\n\t\t}\n\t`,\n};\n\nexport default vertex;\n","uniform float deltaTime;\nuniform sampler2D velocity;\nuniform float dissipation;\n\nvoid main(){\n\tvec2 vel = texture2D(velocity, vUv).xy;\n\tvec2 uv2 = vUv - vel * deltaTime * maxAspect;\n\tvec2 newVel = texture2D(velocity, uv2).xy;\n\tgl_FragColor = vec4(dissipation * newVel, 0.0, 0.0);\n}","import * as THREE from \"three\";\nimport vertex from \"./shaders/vertex\";\nimport fragment from \"./shaders/advection.frag\";\nimport {\n FxMaterial,\n FxMaterialProps,\n} from \"../../../materials/core/FxMaterial\";\nimport { DEFAULT_TEXTURE } from \"../../../libs/constants\";\nimport { DELTA_TIME } from \".\";\nimport { NestUniformValues } from \"../../../shaders/uniformsUtils\";\n\ntype AdvectionUniforms = {\n dissipation: { value: number };\n deltaTime: { value: number };\n velocity: { value: THREE.Texture };\n};\n\nexport type AdvectionValues = NestUniformValues;\nexport type AdvectionValuesClient = Omit;\n\nexport class AdvectionMaterial extends FxMaterial {\n static get type() {\n return \"AdvectionMaterial\";\n }\n\n uniforms!: AdvectionUniforms;\n\n constructor(props: FxMaterialProps) {\n super({\n ...props,\n vertexShader: vertex.advection,\n fragmentShader: fragment,\n uniforms: {\n dissipation: { value: 0.99 },\n velocity: { value: DEFAULT_TEXTURE },\n deltaTime: { value: DELTA_TIME },\n } as AdvectionUniforms,\n });\n this.type = AdvectionMaterial.type;\n }\n}\n","uniform float deltaTime;\nuniform sampler2D velocity;\n\nvarying vec2 vL;\nvarying vec2 vR;\nvarying vec2 vT;\nvarying vec2 vB;\n\nvoid main(){\n float L = texture2D(velocity, vL).r;\n float R = texture2D(velocity, vR).r;\n float B = texture2D(velocity, vB).g;\n float T = texture2D(velocity, vT).g;\n\t \n float divergence = (R-L + T-B) / 2.0;\n gl_FragColor = vec4(divergence / deltaTime);\n}\n","import * as THREE from \"three\";\nimport vertex from \"./shaders/vertex\";\nimport fragment from \"./shaders/divergence.frag\";\nimport {\n FxMaterial,\n FxMaterialProps,\n} from \"../../../materials/core/FxMaterial\";\nimport { DEFAULT_TEXTURE } from \"../../../libs/constants\";\nimport { DELTA_TIME } from \".\";\nimport { NestUniformValues } from \"../../../shaders/uniformsUtils\";\n\ntype DivergenceUniforms = {\n bounce: { value: boolean };\n deltaTime: { value: number };\n velocity: { value: THREE.Texture };\n};\n\nexport type DivergenceValues = NestUniformValues;\nexport type DivergenceValuesClient = Omit;\n\nexport class DivergenceMaterial extends FxMaterial {\n static get type() {\n return \"DivergenceMaterial\";\n }\n\n uniforms!: DivergenceUniforms;\n\n constructor(props: FxMaterialProps) {\n super({\n ...props,\n vertexShader: vertex.main,\n fragmentShader: fragment,\n uniforms: {\n bounce: { value: true },\n velocity: { value: DEFAULT_TEXTURE },\n deltaTime: { value: DELTA_TIME },\n } as DivergenceUniforms,\n });\n\n this.type = DivergenceMaterial.type;\n }\n}\n","uniform float deltaTime;\nuniform sampler2D pressure;\nuniform sampler2D velocity;\n\nvarying vec2 vL;\nvarying vec2 vR;\nvarying vec2 vT;\nvarying vec2 vB;\n\nvoid main(){\n\n\tfloat L = texture2D(pressure, vL).r;\n\tfloat R = texture2D(pressure, vR).r;\n\tfloat B = texture2D(pressure, vB).r;\n\tfloat T = texture2D(pressure, vT).r;\n\n\tvec2 v = texture2D(velocity, vUv).xy;\n\tvec2 gradP = vec2(R - L, T - B) * 0.5;\n\tv = v - gradP * deltaTime;\n\n\tgl_FragColor = vec4(v, 0.0, 1.0);\n\n}","import * as THREE from \"three\";\nimport vertex from \"./shaders/vertex\";\nimport fragment from \"./shaders/pressure.frag\";\nimport {\n FxMaterial,\n FxMaterialProps,\n} from \"../../../materials/core/FxMaterial\";\nimport { DEFAULT_TEXTURE } from \"../../../libs/constants\";\nimport { DELTA_TIME } from \".\";\nimport { NestUniformValues } from \"../../../shaders/uniformsUtils\";\n\ntype PressureUniforms = {\n bounce: { value: boolean };\n deltaTime: { value: number };\n pressure: { value: THREE.Texture };\n velocity: { value: THREE.Texture };\n};\n\nexport type PressureValues = NestUniformValues;\nexport type PressureValuesClient = Omit<\n PressureValues,\n \"velocity\" | \"pressure\"\n>;\n\nexport class PressureMaterial extends FxMaterial {\n static get type() {\n return \"PressureMaterial\";\n }\n\n uniforms!: PressureUniforms;\n\n constructor(props: FxMaterialProps) {\n super({\n ...props,\n vertexShader: vertex.main,\n fragmentShader: fragment,\n uniforms: {\n bounce: { value: true },\n deltaTime: { value: DELTA_TIME },\n pressure: { value: DEFAULT_TEXTURE },\n velocity: { value: DEFAULT_TEXTURE },\n } as PressureUniforms,\n });\n\n this.type = PressureMaterial.type;\n }\n}\n","uniform sampler2D pressure;\nuniform sampler2D divergence;\n\nvarying vec2 vL;\nvarying vec2 vR;\nvarying vec2 vT;\nvarying vec2 vB;\n\nvoid main(){ \n\n\tfloat L = texture2D(pressure, vL).r;\n\tfloat R = texture2D(pressure, vR).r;\n\tfloat B = texture2D(pressure, vB).r;\n\tfloat T = texture2D(pressure, vT).r;\n\n\tfloat div = texture2D(divergence, vUv).r;\n\t\n\tfloat newP = (L + R + B + T) / 4.0 - div;\n\n\tgl_FragColor = vec4(newP);\n}\n","import * as THREE from \"three\";\nimport vertex from \"./shaders/vertex\";\nimport fragment from \"./shaders/poisson.frag\";\nimport {\n FxMaterial,\n FxMaterialProps,\n} from \"../../../materials/core/FxMaterial\";\nimport { DEFAULT_TEXTURE } from \"../../../libs/constants\";\nimport { NestUniformValues } from \"../../../shaders/uniformsUtils\";\n\ntype PoissonUniforms = {\n bounce: { value: boolean };\n pressure: { value: THREE.Texture };\n divergence: { value: THREE.Texture };\n};\n\nexport type PoissonValues = NestUniformValues;\nexport type PoissonValuesClient = Omit<\n PoissonValues,\n \"pressure\" | \"divergence\"\n>;\n\nexport class PoissonMaterial extends FxMaterial {\n static get type() {\n return \"PoissonMaterial\";\n }\n\n uniforms!: PoissonUniforms;\n\n iterations: number;\n\n constructor({ customParameters, ...rest }: FxMaterialProps) {\n super({\n ...rest,\n vertexShader: vertex.poisson,\n fragmentShader: fragment,\n uniforms: {\n bounce: { value: true },\n pressure: { value: DEFAULT_TEXTURE },\n divergence: { value: DEFAULT_TEXTURE },\n } as PoissonUniforms,\n });\n this.iterations = customParameters?.iterations ?? 32;\n this.type = PoissonMaterial.type;\n }\n}\n","uniform vec2 force;\nuniform float forceBias;\n\nvoid main(){\n\tgl_FragColor = vec4(force * forceBias * pow(1.0 - clamp(2.0 * distance(vUv, vec2(0.5)), 0.0, 1.0), 2.0), 0.0, 1.0);\n}","import * as THREE from \"three\";\nimport vertex from \"./shaders/vertex\";\nimport fragment from \"./shaders/splat.frag\";\nimport {\n FxMaterial,\n FxMaterialProps,\n} from \"../../../materials/core/FxMaterial\";\nimport { NestUniformValues } from \"../../../shaders/uniformsUtils\";\n\ntype SplatUniforms = {\n forceBias: { value: number };\n radius: { value: THREE.Vector2 };\n force: { value: THREE.Vector2 };\n center: { value: THREE.Vector2 };\n};\n\nexport type SplatValues = NestUniformValues;\nexport type SplatValuesClient = Omit;\n\nexport class SplatMaterial extends FxMaterial {\n static get type() {\n return \"SplatMaterial\";\n }\n\n uniforms!: SplatUniforms;\n\n constructor(props: FxMaterialProps) {\n super({\n ...props,\n vertexShader: vertex.splat,\n fragmentShader: fragment,\n uniforms: {\n forceBias: { value: 20 },\n radius: { value: new THREE.Vector2(50, 50) },\n force: { value: new THREE.Vector2(0, 0) },\n center: { value: new THREE.Vector2(0, 0) },\n } as SplatUniforms,\n });\n\n this.type = SplatMaterial.type;\n\n this.blending = THREE.AdditiveBlending;\n }\n}\n","import * as THREE from \"three\";\nimport { FxMaterialProps } from \"../../core/FxMaterial\";\nimport { BasicFxUniforms, BasicFxValues } from \"../../core/BasicFxLib\";\nimport { BasicFxMaterial } from \"../../core/BasicFxMaterial\";\nimport { NestUniformValues } from \"../../../shaders/uniformsUtils\";\nimport { DEFAULT_TEXTURE } from \"../../../libs/constants\";\nimport { ShaderLib } from \"../../../shaders/ShaderLib\";\n\ntype OutputUniforms = {\n src: { value: THREE.Texture };\n} & BasicFxUniforms;\n\nexport type OutputValues = NestUniformValues & BasicFxValues;\n\nexport class OutputMaterial extends BasicFxMaterial {\n static get type() {\n return \"OutputMaterial\";\n }\n\n uniforms!: OutputUniforms;\n\n constructor(props: FxMaterialProps = {}) {\n super({\n ...props,\n vertexShader: `\n\t\t\t\tvoid main() {\n\t\t\t\t\t${ShaderLib.plane_vertex}\n\t\t\t\t}\n\t\t\t`,\n fragmentShader: `\n\t\t\t\tuniform sampler2D src;\n\t\t\t\tvoid main() {\n\t\t\t\t\tvec2 usf_Uv = vUv;\n\t\t\t\t\t\n\t\t\t\t\t${ShaderLib.basicFx_fragment_begin}\n\n\t\t\t\t\tvec4 usf_FragColor = vec4(length(texture2D(src,usf_Uv).rg));\n\n\t\t\t\t\t${ShaderLib.basicFx_fragment_end}\n\n\t\t\t\t\tgl_FragColor = usf_FragColor;\n\t\t\t\t}\n\t\t\t`,\n uniforms: {\n src: { value: DEFAULT_TEXTURE },\n },\n });\n this.type = OutputMaterial.type;\n }\n}\n","export * from \"./AdvectionMaterial\";\nexport * from \"./DivergenceMaterial\";\nexport * from \"./PressureMaterial\";\nexport * from \"./PoissonMaterial\";\nexport * from \"./SplatMaterial\";\nexport * from \"./OutputMaterial\";\n\nexport const DELTA_TIME = 0.008;\n","import * as THREE from \"three\";\nimport { FxMaterialProps } from \"./FxMaterial\";\nimport {\n NestUniformValues,\n UniformParentKey,\n} from \"../../shaders/uniformsUtils\";\nimport { mergeShaderLib } from \"../../shaders/shaderUtils\";\nimport { BasicFxMaterial } from \"./BasicFxMaterial\";\nimport * as BasicFxLib from \"./BasicFxLib\";\nimport { DEFAULT_TEXTURE } from \"../../libs/constants\";\n\n/*===============================================\ntypes\n===============================================*/\ntype SamplingFxUniformsUnique = {\n texture: { value: UniformParentKey };\n texture_src: { value: THREE.Texture };\n texture_fit: { value: BasicFxLib.FitType };\n};\ntype SamplingFxUniformsFitScale = {\n texture_fitScale: { value: THREE.Vector2 };\n};\nexport type SamplingFxUniforms = SamplingFxUniformsUnique &\n BasicFxLib.BasicFxUniforms;\nexport type SamplingFxValues = NestUniformValues;\n\n/*===============================================\nconstants\n===============================================*/\nconst SAMPLINGFX_VALUES: SamplingFxUniformsUnique & SamplingFxUniformsFitScale =\n {\n texture: { value: true },\n texture_src: { value: DEFAULT_TEXTURE },\n texture_fit: { value: 0 },\n texture_fitScale: { value: new THREE.Vector2(1, 1) },\n };\n\n/**\n * SamplingFxMaterialでは常にtextureはtrueであるはずなので、BasicFxMaterialを継承して、srcSystemは常にtrueになるように、継承する\n */\nexport class SamplingFxMaterial extends BasicFxMaterial {\n uniforms!: SamplingFxUniforms;\n\n constructor({ uniforms, ...rest }: FxMaterialProps) {\n super({\n ...rest,\n uniforms: {\n ...THREE.UniformsUtils.clone(SAMPLINGFX_VALUES),\n ...uniforms,\n },\n });\n }\n\n protected _handleMergeShaderLib(\n vertexShader?: string,\n fragmentShader?: string\n ) {\n return mergeShaderLib(vertexShader, fragmentShader, \"samplingFx\");\n }\n\n protected _isContainsBasicFxValues(values?: {\n [key: string]: any;\n }): boolean {\n return super._isContainsBasicFxValues(values, {\n ...BasicFxLib.BASICFX_VALUES,\n ...SAMPLINGFX_VALUES,\n });\n }\n\n protected _updateFitScale() {\n super._updateFitScale();\n this._setFitScale(\"texture\");\n }\n\n protected _setupFxKey(\n uniforms: BasicFxLib.BasicFxUniforms\n ): BasicFxLib.FxKey {\n const key = super._setupFxKey(uniforms);\n key.srcSystem = true;\n return key;\n }\n\n protected _handleUpdateFxShaders(): {\n diffCount: number;\n newFxKey: BasicFxLib.FxKey;\n } {\n const { diffCount, newFxKey } = super._handleUpdateFxShaders();\n newFxKey.srcSystem = true;\n return {\n diffCount,\n newFxKey,\n };\n }\n\n protected _handleUpdateFxDefines(): {\n [key: string]: any;\n } {\n return Object.assign(super._handleUpdateFxDefines(), {\n USF_USE_TEXTURE: true,\n });\n }\n}\n","import * as THREE from \"three\";\nimport {\n SamplingFxUniforms,\n SamplingFxValues,\n SamplingFxMaterial,\n} from \"../../core/SamplingFxMaterial\";\nimport { FxMaterialProps } from \"../../core/FxMaterial\";\nimport {\n ExtractUniformValues,\n NestUniformValues,\n} from \"../../../shaders/uniformsUtils\";\nimport { ShaderLib } from \"../../../shaders/ShaderLib\";\n\n/*===============================================\nmemo\n\n- BufferMaterialはMaterialをそのまま、r3fでextendしてコンポーネントとして使うケースが考えられる\nので、keyを持たせる\n- また、globalで型定義する\n===============================================*/\n\ntype BufferUniforms = SamplingFxUniforms;\n\nexport type BufferValues = NestUniformValues & SamplingFxValues;\n\nexport type BufferMaterialProps = ExtractUniformValues;\n\nexport class BufferMaterial extends SamplingFxMaterial {\n public static readonly key: string = THREE.MathUtils.generateUUID();\n\n static get type() {\n return \"BufferMaterial\";\n }\n\n uniforms!: BufferUniforms;\n\n constructor(props: FxMaterialProps = {}) {\n super({\n ...props,\n vertexShader: `\n\t\t\t\tvoid main() {\n\t\t\t\t\t${ShaderLib.plane_vertex}\n\t\t\t\t}\n\t\t\t`,\n fragmentShader: `\n\t\t\t\tvoid main() {\n\t\t\t\t\tvec2 usf_Uv = vTextureCoverUv;\n\n\t\t\t\t\t${ShaderLib.basicFx_fragment_begin}\n\n\t\t\t\t\tvec4 usf_FragColor = fitTexture(texture_src,usf_Uv,texture_fit);\n\n\t\t\t\t\t${ShaderLib.basicFx_fragment_end}\n\n\t\t\t\t\tgl_FragColor = usf_FragColor;\n\t\t\t\t}\n\t\t\t`,\n });\n\n this.type = BufferMaterial.type;\n }\n}\n\ndeclare global {\n namespace JSX {\n interface IntrinsicElements {\n bufferMaterial: BufferMaterialProps & {\n ref?: React.RefObject;\n key?: React.Key;\n };\n }\n }\n}\n","import { FxMaterial, FxMaterialProps } from \"../../core/FxMaterial\";\n\nexport class RawBlankMaterial extends FxMaterial {\n static get type() {\n return \"RawBlankMaterial\";\n }\n constructor(props: FxMaterialProps) {\n super(props);\n this.type = RawBlankMaterial.type;\n }\n}\n","import * as THREE from \"three\";\nimport {\n DefaultUniforms,\n FxMaterial,\n FxMaterialProps,\n} from \"../../core/FxMaterial\";\nimport { mergeShaderCode } from \"../../../shaders/shaderUtils\";\n\ntype BlankUniforms = {\n time: { value: number };\n pointer: { value: THREE.Vector2 };\n backbuffer: { value: THREE.Texture };\n} & DefaultUniforms;\n\nconst SHADER_PARS = `\n\tuniform float time;\n\tuniform vec2 pointer;\n\tuniform sampler2D backbuffer;\n`;\n\nexport class BlankMaterial extends FxMaterial {\n static get type() {\n return \"BlankMaterial\";\n }\n\n uniforms!: BlankUniforms;\n\n constructor({\n vertexShader,\n fragmentShader,\n uniforms,\n ...rest\n }: FxMaterialProps) {\n super({\n ...rest,\n vertexShader:\n vertexShader && mergeShaderCode([SHADER_PARS, vertexShader]),\n fragmentShader:\n fragmentShader && mergeShaderCode([SHADER_PARS, fragmentShader]),\n uniforms: {\n time: { value: 0.0 },\n pointer: { value: new THREE.Vector2() },\n backbuffer: { value: new THREE.Texture() },\n ...uniforms,\n } as BlankUniforms,\n });\n this.type = BlankMaterial.type;\n }\n}\n","import { ShaderLib } from \"../../../shaders/ShaderLib\";\n\nexport const gridVertex = `\n\tvoid main() {\n\t\t${ShaderLib.plane_vertex}\n\t}\n`;\n\nexport const gridFragment = `\n\tuniform vec2 count;\n\tuniform bool autoScale;\n\tuniform float tick;\n\tuniform bool shuffle;\n\tuniform float shuffle_frequency;\n\tuniform float shuffle_range;\n\n\tuniform bool sprite;\n\tuniform sampler2D sprite_src;\n\tuniform float sprite_length;\n\tuniform float sprite_shuffleSpeed;\n\n\tfloat hash(vec2 p) {\n\t\treturn fract(sin(dot(p, vec2(12.9898, 78.233))) * 43758.5453);\n\t}\n\n\tvec2 shuffleIndex(vec2 cellIndex , vec2 count) {\n\n\t\tfloat discreteTime = floor(tick * shuffle_frequency);\n\n\t\tfloat r1 = hash(cellIndex + vec2(0.123, discreteTime));\n\t\tfloat r2 = hash(cellIndex + vec2(0.789, discreteTime));\n\n\t\t// -range ~ +range\n\t\tfloat offsetX = floor(r1 * (shuffle_range * 2.0 + 1.0)) - shuffle_range;\n\t\tfloat offsetY = floor(r2 * (shuffle_range * 2.0 + 1.0)) - shuffle_range;\n\t\tvec2 offset = vec2(offsetX, offsetY);\n\n\t\treturn mod(cellIndex + offset, count);\n\t}\n\n\tvoid main() {\n\t\tvec2 usf_Uv = vUv;\n\t\t${ShaderLib.basicFx_fragment_begin}\n\n\t\tvec2 n_count = count;\n\t\tn_count.x *= autoScale ? aspectRatio : 1.;\n\n\t\tvec2 cellIndex = ceil(usf_Uv * n_count);\n\n\t\tvec2 shuffledIndex = shuffle ? shuffleIndex(cellIndex, n_count) : cellIndex;\n\n\t\tvec2 cellCenter = calcSrcUv((shuffledIndex - .5) / n_count, texture_fitScale);\n\n\t\tvec4 gridTextureColor = fitTexture(texture_src, cellCenter, texture_fit);\n\n\t\tif(sprite){\n\t\t\tvec2 cellUv = fract(usf_Uv * n_count);\n\t\t\tfloat cellHash = hash(cellIndex);\n\t\t\tfloat spritePos = fract(cellHash + tick * sprite_shuffleSpeed);\n\t\t\tfloat spriteIndex = floor(spritePos * sprite_length);\n\t\t\tfloat spriteSize = 1.0 / sprite_length;\n\t\t\tfloat spriteOffset = spriteIndex * spriteSize;\n\t\t\tfloat spriteU = spriteOffset + cellUv.x * spriteSize;\n\t\t\tvec2 spriteUv = vec2(spriteU, cellUv.y);\n\t\t\tvec4 spriteColor = texture2D(sprite_src, spriteUv);\n\t\t\tgridTextureColor *= spriteColor;\n\t\t}\n\n\t\tvec4 usf_FragColor = gridTextureColor;\n\t\t${ShaderLib.basicFx_fragment_end}\n\n\t\tgl_FragColor = usf_FragColor;\n\n\t}\n`;\n","import * as THREE from \"three\";\nimport {\n SamplingFxUniforms,\n SamplingFxValues,\n SamplingFxMaterial,\n} from \"../../core/SamplingFxMaterial\";\nimport { FxMaterialProps } from \"../../core/FxMaterial\";\nimport {\n ExtractUniformValues,\n NestUniformValues,\n UniformParentKey,\n} from \"../../../shaders/uniformsUtils\";\nimport { gridVertex, gridFragment } from \"./grid.glsl\";\n\ntype GridUniforms = {\n /** グリッドのマス数 */\n count: { value: THREE.Vector2 };\n /** 自動で画面のアスペクト比に合わせて正方形にscaleする */\n autoScale: { value: boolean };\n /** tick */\n tick: { value: number };\n shuffle: { value: UniformParentKey };\n shuffle_frequency: { value: number };\n shuffle_range: { value: number };\n /** スプライトテクスチャ */\n sprite: { value: UniformParentKey };\n sprite_src: { value: THREE.Texture };\n sprite_length: { value: number };\n sprite_shuffleSpeed: { value: number };\n} & SamplingFxUniforms;\n\nexport type GridValues = NestUniformValues & SamplingFxValues;\n\nexport type GridMaterialProps = ExtractUniformValues;\n\nexport class GridMaterial extends SamplingFxMaterial {\n static get type() {\n return \"GridMaterial\";\n }\n\n uniforms!: GridUniforms;\n\n constructor(props: FxMaterialProps) {\n super({\n ...props,\n vertexShader: gridVertex,\n fragmentShader: gridFragment,\n uniforms: {\n count: { value: new THREE.Vector2(20, 20) },\n autoScale: { value: true },\n tick: { value: 0 },\n shuffle: { value: false },\n shuffle_frequency: { value: 5 },\n shuffle_range: { value: 2 },\n sprite: { value: false },\n sprite_src: { value: new THREE.Texture() },\n sprite_length: { value: 10 },\n sprite_shuffleSpeed: { value: 0 },\n } as GridUniforms,\n });\n\n this.setNearestFilter();\n\n this.type = GridMaterial.type;\n }\n\n /** When gridding with floor, you must use NearestFilter. */\n public setNearestFilter() {\n this.uniforms.texture_src.value.magFilter = THREE.NearestFilter;\n this.uniforms.texture_src.value.minFilter = THREE.NearestFilter;\n this.uniforms.sprite_src.value.magFilter = THREE.NearestFilter;\n this.uniforms.sprite_src.value.minFilter = THREE.NearestFilter;\n }\n}\n","import { useCallback } from \"react\";\nimport { useSingleFBO, getDpr, useSetup } from \"../../utils\";\nimport { HooksProps, HooksReturn, RootState } from \"../types\";\nimport {\n NoiseMaterial,\n NoiseMaterialProps,\n NoiseValues,\n} from \"../../materials\";\n\nexport type NoiseProps = HooksProps & NoiseValues;\n\n/**\n * @link https://github.com/FunTechInc/use-shader-fx?tab=readme-ov-file#usage\n */\nexport const useNoise = ({\n size,\n dpr,\n fboAutoSetSize,\n renderTargetOptions,\n materialParameters,\n ...uniformValues\n}: NoiseProps): HooksReturn<\n NoiseValues,\n NoiseMaterial & NoiseMaterialProps\n> => {\n const _dpr = getDpr(dpr);\n\n const { scene, material, camera } = useSetup({\n size,\n dpr: _dpr.shader,\n material: NoiseMaterial,\n uniformValues,\n materialParameters,\n });\n\n const [renderTarget, updateRenderTarget] = useSingleFBO({\n scene,\n camera,\n size,\n dpr: _dpr.fbo,\n fboAutoSetSize,\n ...renderTargetOptions,\n });\n\n const setValues = useCallback(\n (newValues: NoiseValues, needsUpdate: boolean = true) => {\n material.setUniformValues(newValues, needsUpdate);\n },\n [material]\n );\n\n const render = useCallback(\n (rootState: RootState, newValues?: NoiseValues) => {\n const { gl, clock } = rootState;\n newValues && setValues(newValues, false);\n material.uniforms.tick.value =\n typeof newValues?.tick === \"function\"\n ? newValues.tick(material.uniforms.tick.value)\n : newValues?.tick || clock.getElapsedTime();\n return updateRenderTarget({ gl });\n },\n [setValues, updateRenderTarget, material]\n );\n\n return {\n render,\n setValues,\n texture: renderTarget.texture,\n material,\n scene,\n camera,\n renderTarget,\n };\n};\n","import { useCallback } from \"react\";\nimport { RootState, Size } from \"../../types\";\nimport { FluidMaterials } from \"../../../materials\";\nimport { SingleFBOUpdateFunction, useSetup } from \"../../../utils\";\n\nexport const useAdvection = (\n {\n size,\n dpr,\n ...uniformValues\n }: {\n size: Size;\n dpr: number | false;\n } & FluidMaterials.AdvectionValues,\n updateRenderTarget: SingleFBOUpdateFunction\n) => {\n const { scene, material, camera } = useSetup({\n size,\n dpr,\n material: FluidMaterials.AdvectionMaterial,\n uniformValues,\n });\n\n const render = useCallback(\n (rootState: RootState) => {\n const { gl } = rootState;\n updateRenderTarget({ gl, scene, camera });\n },\n [updateRenderTarget, scene, camera]\n );\n\n return { render, material };\n};\n","import * as THREE from \"three\";\nimport { useCallback, useRef } from \"react\";\n\nexport type PointerValues = {\n currentPointer: THREE.Vector2;\n prevPointer: THREE.Vector2;\n diffPointer: THREE.Vector2;\n velocity: THREE.Vector2;\n isVelocityUpdate: boolean;\n};\n\ntype PointerTracker = (currentPointer: THREE.Vector2) => PointerValues;\n\n/**\n * @description When given the pointer vector2 from r3f's RootState, it generates an update function that returns {`currentPointer`, `prevPointer`, `diffPointer`, `isVelocityUpdate`, `velocity`}.\n * @description When calling custom in a `useFrame` loop, you can avoid duplication of execution by passing `pointerValues` to the update function of a Pointer-activated fxHook, such as `useBrush`.\n * @param lerp 0~1, lerp intensity (0 to less than 1) , default : `0`\n */\nexport const usePointerTracker = (lerp: number = 0): PointerTracker => {\n const prevPointer = useRef(new THREE.Vector2(0, 0));\n const diffPointer = useRef(new THREE.Vector2(0, 0));\n const lerpPointer = useRef(new THREE.Vector2(0, 0));\n const lastUpdateTime = useRef(0);\n const velocity = useRef(new THREE.Vector2(0, 0));\n const isMoved = useRef(false);\n\n const pointerTracker = useCallback(\n (currentPointer: THREE.Vector2) => {\n const now = performance.now();\n\n // lerp\n let current: THREE.Vector2;\n if (isMoved.current && lerp) {\n lerpPointer.current = lerpPointer.current.lerp(\n currentPointer,\n 1 - lerp\n );\n current = lerpPointer.current.clone();\n } else {\n current = currentPointer.clone();\n lerpPointer.current = current;\n }\n\n // first frame\n if (lastUpdateTime.current === 0) {\n lastUpdateTime.current = now;\n prevPointer.current = current;\n }\n const deltaTime = Math.max(1, now - lastUpdateTime.current);\n lastUpdateTime.current = now;\n\n // get velocity\n velocity.current\n .copy(current)\n .sub(prevPointer.current)\n .divideScalar(deltaTime);\n const isUpdate = velocity.current.length() > 0;\n\n //set prev temp pos\n const prevTemp = isMoved.current\n ? prevPointer.current.clone()\n : current;\n if (!isMoved.current && isUpdate) {\n isMoved.current = true;\n }\n prevPointer.current = current;\n\n return {\n currentPointer: current,\n prevPointer: prevTemp,\n diffPointer: diffPointer.current.subVectors(current, prevTemp),\n velocity: velocity.current,\n isVelocityUpdate: isUpdate,\n };\n },\n [lerp]\n );\n\n return pointerTracker;\n};\n","import { useCallback } from \"react\";\nimport { RootState, Size } from \"../../types\";\nimport { SingleFBOUpdateFunction, useSetup } from \"../../../utils\";\nimport { FluidMaterials } from \"../../../materials\";\nimport { usePointerTracker } from \"../../../misc/usePointerTracker\";\n\nexport const useSplat = (\n {\n size,\n dpr,\n ...uniformValues\n }: {\n size: Size;\n dpr: number | false;\n } & FluidMaterials.SplatValuesClient,\n updateRenderTarget: SingleFBOUpdateFunction\n) => {\n const { scene, material, camera } = useSetup({\n size,\n dpr,\n material: FluidMaterials.SplatMaterial,\n geometrySize: {\n width: 1,\n height: 1,\n },\n uniformValues,\n });\n\n const pointerTracker = usePointerTracker();\n\n const render = useCallback(\n (rootState: RootState) => {\n const { gl, pointer } = rootState;\n const { currentPointer, diffPointer } = pointerTracker(pointer);\n\n material.uniforms.center.value.copy(currentPointer);\n material.uniforms.force.value.copy(diffPointer);\n\n updateRenderTarget({ gl, scene, camera, clear: false });\n },\n [updateRenderTarget, material, pointerTracker, scene, camera]\n );\n\n return { render, material };\n};\n","import { useCallback } from \"react\";\nimport { RootState, Size } from \"../../types\";\nimport { FluidMaterials } from \"../../../materials\";\nimport { useSetup, SingleFBOUpdateFunction } from \"../../../utils\";\n\nexport const useDivergence = (\n {\n size,\n dpr,\n ...uniformValues\n }: {\n size: Size;\n dpr: number | false;\n } & FluidMaterials.DivergenceValues,\n updateRenderTarget: SingleFBOUpdateFunction\n) => {\n const { scene, material, camera } = useSetup({\n size,\n dpr,\n material: FluidMaterials.DivergenceMaterial,\n uniformValues,\n });\n\n const render = useCallback(\n (rootState: RootState) => {\n const { gl } = rootState;\n updateRenderTarget({ gl, scene, camera });\n },\n [updateRenderTarget, scene, camera]\n );\n\n return { render, material };\n};\n","import { useCallback } from \"react\";\nimport { RootState, Size } from \"../../types\";\nimport { DoubleFBOUpdateFunction, useSetup } from \"../../../utils\";\nimport { FluidMaterials } from \"../../../materials\";\n\nexport const usePoisson = (\n {\n size,\n dpr,\n pressureIterations,\n ...uniformValues\n }: {\n size: Size;\n dpr: number | false;\n pressureIterations?: number;\n } & Omit,\n updateRenderTarget: DoubleFBOUpdateFunction\n) => {\n const { scene, material, camera } = useSetup({\n size,\n dpr,\n material: FluidMaterials.PoissonMaterial,\n uniformValues,\n customParameters: {\n iterations: pressureIterations,\n },\n });\n\n const render = useCallback(\n (rootState: RootState) => {\n const { gl } = rootState;\n for (let i = 0; i < material.iterations; i++) {\n updateRenderTarget({ gl, scene, camera }, ({ read }) => {\n material.uniforms.pressure.value = read;\n });\n }\n },\n [updateRenderTarget, material, scene, camera]\n );\n\n return { render, material };\n};\n","import { useCallback } from \"react\";\nimport { RootState, Size } from \"../../types\";\nimport { SingleFBOUpdateFunction, useSetup } from \"../../../utils\";\nimport { FluidMaterials } from \"../../../materials\";\n\nexport const usePressure = (\n {\n size,\n dpr,\n ...uniformValues\n }: {\n size: Size;\n dpr: number | false;\n } & FluidMaterials.PressureValues,\n updateRenderTarget: SingleFBOUpdateFunction\n) => {\n const { scene, material, camera } = useSetup({\n size,\n dpr,\n material: FluidMaterials.PressureMaterial,\n uniformValues,\n });\n\n const render = useCallback(\n (rootState: RootState) => {\n const { gl } = rootState;\n updateRenderTarget({ gl, scene, camera });\n },\n [updateRenderTarget, scene, camera]\n );\n\n return { render, material };\n};\n","import { useCallback } from \"react\";\nimport { RootState, Size } from \"../../types\";\nimport { SingleFBOUpdateFunction, useSetup } from \"../../../utils\";\nimport { FluidMaterials } from \"../../../materials\";\n\nexport const useOutput = (\n {\n size,\n dpr,\n ...values\n }: {\n size: Size;\n dpr: number | false;\n } & FluidMaterials.OutputValues,\n updateRenderTarget: SingleFBOUpdateFunction\n) => {\n const { scene, material, camera } = useSetup({\n size,\n dpr,\n material: FluidMaterials.OutputMaterial,\n uniformValues: values,\n });\n\n const render = useCallback(\n (rootState: RootState) => {\n const { gl } = rootState;\n updateRenderTarget({ gl, scene, camera });\n },\n [updateRenderTarget, scene, camera]\n );\n\n return { render, material };\n};\n","import * as THREE from \"three\";\nimport { useCallback } from \"react\";\nimport { useSingleFBO, useDoubleFBO, getDpr } from \"../../utils\";\nimport { HooksProps, HooksReturn, RootState } from \"../types\";\nimport { useAdvection } from \"./scenes/useAdvection\";\nimport { useSplat } from \"./scenes/useSplat\";\nimport { useDivergence } from \"./scenes/useDivergence\";\nimport { usePoisson } from \"./scenes/usePoisson\";\nimport { usePressure } from \"./scenes/usePressure\";\nimport { useOutput } from \"./scenes/useOutput\";\nimport { BasicFxValues, FluidMaterials } from \"../../materials\";\n\nexport type FluidValues = {\n pressureIterations?: number;\n} & BasicFxValues &\n FluidMaterials.AdvectionValuesClient &\n FluidMaterials.DivergenceValuesClient &\n FluidMaterials.PoissonValuesClient &\n FluidMaterials.PressureValuesClient &\n FluidMaterials.SplatValuesClient;\n\nexport type FluidProps = HooksProps & FluidValues;\n\nconst removeUndefined = (obj: T): Partial =>\n Object.fromEntries(\n Object.entries(obj).filter(([, value]) => value !== undefined)\n ) as Partial;\n\nconst extractValues = (values: FluidValues) => {\n const {\n dissipation,\n deltaTime,\n bounce,\n pressureIterations,\n radius,\n forceBias,\n ...basicFxValues\n } = values;\n\n return [\n {\n advection: removeUndefined({ dissipation, deltaTime }),\n divergence: removeUndefined({ bounce, deltaTime }),\n poisson: removeUndefined({ bounce }),\n pressure: removeUndefined({ bounce, deltaTime }),\n splat: removeUndefined({ radius, forceBias }),\n pressureIterations,\n },\n basicFxValues,\n ] as const;\n};\n\n/**\n * @link https://github.com/FunTechInc/use-shader-fx?tab=readme-ov-file#usage\n */\nexport const useFluid = ({\n size,\n dpr,\n fboAutoSetSize,\n renderTargetOptions,\n materialParameters,\n ...uniformValues\n}: FluidProps): HooksReturn<\n FluidValues,\n any,\n {\n /** velocity map */\n velocity: THREE.Texture;\n }\n> => {\n const _dpr = getDpr(dpr);\n\n // fbos\n const fboProps = {\n dpr: _dpr.fbo,\n size,\n fboAutoSetSize,\n type: THREE.HalfFloatType,\n ...renderTargetOptions,\n };\n const [velocity_0, updateVelocity_0] = useSingleFBO(fboProps);\n const [velocity_1, updateVelocity_1] = useSingleFBO(fboProps);\n const [divergenceFBO, updateDivergenceFBO] = useSingleFBO(fboProps);\n const [pressureFBO, updatePressureFBO] = useDoubleFBO(fboProps);\n const [outputFBO, updateOutputFBO] = useSingleFBO(fboProps);\n\n // scenes\n const [extractedValues, basicFxValues] = extractValues(uniformValues);\n\n const SceneSize = { size, dpr: _dpr.shader };\n const advection = useAdvection(\n {\n ...SceneSize,\n ...extractedValues.advection,\n velocity: velocity_0.texture,\n },\n updateVelocity_1\n );\n const splat = useSplat(\n {\n ...SceneSize,\n ...extractedValues.splat,\n },\n updateVelocity_1\n );\n const divergence = useDivergence(\n {\n ...SceneSize,\n ...extractedValues.divergence,\n velocity: velocity_1.texture,\n },\n updateDivergenceFBO\n );\n const poisson = usePoisson(\n {\n ...SceneSize,\n ...extractedValues.poisson,\n divergence: divergenceFBO.texture,\n pressureIterations: extractedValues.pressureIterations,\n },\n updatePressureFBO\n );\n const pressure = usePressure(\n {\n ...SceneSize,\n ...extractedValues.pressure,\n velocity: velocity_1.texture,\n pressure: pressureFBO.read.texture,\n },\n updateVelocity_0\n );\n const output = useOutput(\n {\n ...SceneSize,\n ...basicFxValues,\n src: velocity_0.texture,\n },\n updateOutputFBO\n );\n\n const setValues = useCallback(\n (newValues: FluidValues, needsUpdate: boolean = true) => {\n const [_extractedValues, _basicFxValues] = extractValues(newValues);\n\n output.material.setUniformValues(_basicFxValues, needsUpdate);\n advection.material.setUniformValues(_extractedValues.advection);\n divergence.material.setUniformValues(_extractedValues.divergence);\n poisson.material.setUniformValues(_extractedValues.poisson);\n pressure.material.setUniformValues(_extractedValues.pressure);\n splat.material.setUniformValues(_extractedValues.splat);\n if (_extractedValues.pressureIterations) {\n poisson.material.iterations = _extractedValues.pressureIterations;\n }\n },\n [output, advection, divergence, poisson, pressure, splat]\n );\n\n const render = useCallback(\n (rootState: RootState, newValues?: FluidValues) => {\n newValues && setValues(newValues, false);\n\n [advection, splat, divergence, poisson, pressure, output].forEach(\n (shader) => shader?.render(rootState)\n );\n\n return outputFBO.texture;\n },\n [\n setValues,\n outputFBO.texture,\n advection,\n splat,\n divergence,\n poisson,\n pressure,\n output,\n ]\n );\n\n return {\n render,\n setValues,\n texture: outputFBO.texture,\n velocity: velocity_0.texture,\n };\n};\n","import { useCallback } from \"react\";\nimport { useSingleFBO, getDpr, useSetup } from \"../../utils\";\nimport { HooksProps, HooksReturn, RootState } from \"../types\";\nimport {\n BufferMaterial,\n BufferMaterialProps,\n BufferValues,\n} from \"../../materials\";\n\nexport type BufferProps = HooksProps & BufferValues;\n\n/**\n * @link https://github.com/FunTechInc/use-shader-fx?tab=readme-ov-file#usage\n */\nexport const useBuffer = ({\n size,\n dpr,\n fboAutoSetSize,\n renderTargetOptions,\n materialParameters,\n ...uniformValues\n}: BufferProps): HooksReturn<\n BufferValues,\n BufferMaterial & BufferMaterialProps\n> => {\n const _dpr = getDpr(dpr);\n\n const { scene, material, camera } = useSetup({\n size,\n dpr: _dpr.shader,\n material: BufferMaterial,\n uniformValues,\n materialParameters,\n });\n\n const [renderTarget, updateRenderTarget] = useSingleFBO({\n scene,\n camera,\n size,\n dpr: _dpr.fbo,\n fboAutoSetSize,\n ...renderTargetOptions,\n });\n\n const setValues = useCallback(\n (newValues: BufferValues, needsUpdate: boolean = true) => {\n material.setUniformValues(newValues, needsUpdate);\n },\n [material]\n );\n\n const render = useCallback(\n (rootState: RootState, newValues?: BufferValues) => {\n const { gl } = rootState;\n newValues && setValues(newValues, false);\n return updateRenderTarget({ gl });\n },\n [setValues, updateRenderTarget]\n );\n\n return {\n render,\n setValues,\n texture: renderTarget.texture,\n material,\n scene,\n camera,\n renderTarget,\n };\n};\n","import { useCallback } from \"react\";\nimport { useSingleFBO, getDpr, useSetup } from \"../../utils\";\nimport { HooksProps, HooksReturn, RootState } from \"../types\";\nimport { RawBlankMaterial } from \"../../materials\";\nimport { ShaderWithUniforms } from \"../../shaders/uniformsUtils\";\n\nexport type RawBlankProps = HooksProps & ShaderWithUniforms;\n\n/**\n * type DefaultUniforms = {\n resolution: { value: THREE.Vector2 };\n texelSize: { value: THREE.Vector2 };\n aspectRatio: { value: number };\n maxAspect: { value: THREE.Vector2 };\n renderCount: { value: number };\n\tはデフォルトである\n\tあとvaringでvUvつかえる\n\t\n * @link https://github.com/FunTechInc/use-shader-fx?tab=readme-ov-file#usage\n */\nexport const useRawBlank = ({\n size,\n dpr,\n fboAutoSetSize,\n renderTargetOptions,\n materialParameters,\n ...shaderWithUniforms\n}: RawBlankProps): HooksReturn<{}, RawBlankMaterial> => {\n const _dpr = getDpr(dpr);\n\n const { scene, material, camera } = useSetup({\n size,\n dpr: _dpr.shader,\n material: RawBlankMaterial,\n materialParameters,\n ...shaderWithUniforms,\n });\n\n const [renderTarget, updateRenderTarget] = useSingleFBO({\n scene,\n camera,\n size,\n dpr: _dpr.fbo,\n fboAutoSetSize,\n ...renderTargetOptions,\n });\n\n const setValues = useCallback(\n (newValues: {}) => {\n material.setUniformValues(newValues);\n },\n [material]\n );\n\n const render = useCallback(\n (rootState: RootState, newValues?: {}) => {\n const { gl } = rootState;\n newValues && setValues(newValues);\n return updateRenderTarget({ gl });\n },\n [setValues, updateRenderTarget]\n );\n\n return {\n render,\n setValues,\n texture: renderTarget.texture,\n material,\n scene,\n camera,\n renderTarget,\n };\n};\n","import { useCallback } from \"react\";\nimport {\n useSingleFBO,\n getDpr,\n useSetup,\n useDoubleFBO,\n useMutableState,\n} from \"../../utils\";\nimport { HooksProps, HooksReturn, RootState } from \"../types\";\nimport { BlankMaterial } from \"../../materials\";\nimport { ShaderWithUniforms } from \"../../shaders/uniformsUtils\";\n\ntype BlankConfig = {\n pointerLerp?: number;\n};\n\nexport type BlankProps = HooksProps & ShaderWithUniforms;\n\n/**\n * type DefaultUniforms = {\n resolution: { value: THREE.Vector2 };\n texelSize: { value: THREE.Vector2 };\n aspectRatio: { value: number };\n maxAspect: { value: THREE.Vector2 };\n renderCount: { value: number };\n\tはデフォルトである\n\tあとvaringでvUvつかえる\n\n\t加えて、\n\ttime\n\tpointer\n\tbackbuffer\n\tもデフォルトで使える\n\n\tあと、pointerLerp使えるよ\n\n * @link https://github.com/FunTechInc/use-shader-fx?tab=readme-ov-file#usage\n */\nexport const useBlank = ({\n size,\n dpr,\n fboAutoSetSize,\n renderTargetOptions,\n materialParameters,\n pointerLerp = 1,\n ...shaderWithUniforms\n}: BlankProps & BlankConfig): HooksReturn<{}, BlankMaterial> => {\n const _dpr = getDpr(dpr);\n\n const { scene, material, camera } = useSetup({\n size,\n dpr: _dpr.shader,\n material: BlankMaterial,\n materialParameters,\n ...shaderWithUniforms,\n });\n\n const fboParams = {\n scene,\n camera,\n size,\n dpr: _dpr.fbo,\n fboAutoSetSize,\n ...renderTargetOptions,\n };\n const [renderTarget, updateRenderTarget] = useSingleFBO(fboParams);\n const [_, updateBackbuffer] = useDoubleFBO(fboParams);\n\n const [confing, setConfig] = useMutableState({ pointerLerp });\n\n const setValues = useCallback(\n ({ pointerLerp, ...newValues }: {} & BlankConfig) => {\n material.setUniformValues(newValues);\n if (pointerLerp) setConfig({ pointerLerp });\n },\n [material, setConfig]\n );\n\n const render = useCallback(\n (rootState: RootState, newValues?: {} & BlankConfig) => {\n const { gl, clock, pointer } = rootState;\n if (newValues) setValues(newValues);\n material.uniforms.time.value = clock.getElapsedTime();\n material.uniforms.pointer.value.lerp(\n pointer,\n confing.current.pointerLerp!\n );\n updateBackbuffer(\n { gl },\n ({ read }) => (material.uniforms.backbuffer.value = read)\n );\n return updateRenderTarget({ gl });\n },\n [setValues, updateRenderTarget, material, updateBackbuffer, confing]\n );\n\n return {\n render,\n setValues,\n texture: renderTarget.texture,\n material,\n scene,\n camera,\n renderTarget,\n };\n};\n","import { useCallback } from \"react\";\nimport { useSingleFBO, getDpr, useSetup } from \"../../utils\";\nimport { HooksProps, HooksReturn, RootState } from \"../types\";\nimport { GridMaterial, GridValues, GridMaterialProps } from \"../../materials\";\n\nexport type GridProps = HooksProps & GridValues;\n\n/**\n * @link https://github.com/FunTechInc/use-shader-fx?tab=readme-ov-file#usage\n */\nexport const useGrid = ({\n size,\n dpr,\n fboAutoSetSize,\n renderTargetOptions,\n materialParameters,\n ...uniformValues\n}: GridProps): HooksReturn => {\n const _dpr = getDpr(dpr);\n\n const { scene, material, camera } = useSetup({\n size,\n dpr: _dpr.shader,\n material: GridMaterial,\n uniformValues,\n materialParameters,\n });\n\n const [renderTarget, updateRenderTarget] = useSingleFBO({\n scene,\n camera,\n size,\n dpr: _dpr.fbo,\n fboAutoSetSize,\n ...renderTargetOptions,\n });\n\n const setValues = useCallback(\n (newValues: GridValues, needsUpdate: boolean = true) => {\n material.setUniformValues(newValues, needsUpdate);\n material.setNearestFilter();\n },\n [material]\n );\n\n const render = useCallback(\n (rootState: RootState, newValues?: GridValues) => {\n const { gl, clock } = rootState;\n newValues && setValues(newValues, false);\n material.uniforms.tick.value =\n typeof newValues?.tick === \"function\"\n ? newValues.tick(material.uniforms.tick.value)\n : newValues?.tick || clock.getElapsedTime();\n return updateRenderTarget({ gl });\n },\n [setValues, updateRenderTarget, material]\n );\n\n return {\n render,\n setValues,\n texture: renderTarget.texture,\n material,\n scene,\n camera,\n renderTarget,\n };\n};\n","export type EasingTypes =\n | \"easeInSine\"\n | \"easeOutSine\"\n | \"easeInOutSine\"\n | \"easeInQuad\"\n | \"easeOutQuad\"\n | \"easeInOutQuad\"\n | \"easeInCubic\"\n | \"easeOutCubic\"\n | \"easeInOutCubic\"\n | \"easeInQuart\"\n | \"easeOutQuart\"\n | \"easeInOutQuart\"\n | \"easeInQuint\"\n | \"easeOutQuint\"\n | \"easeInOutQuint\"\n | \"easeInExpo\"\n | \"easeOutExpo\"\n | \"easeInOutExpo\"\n | \"easeInCirc\"\n | \"easeOutCirc\"\n | \"easeInOutCirc\"\n | \"easeInBack\"\n | \"easeOutBack\"\n | \"easeInOutBack\"\n | \"easeInElastic\"\n | \"easeOutElastic\"\n | \"easeInOutElastic\"\n | \"easeInBounce\"\n | \"easeOutBounce\"\n | \"easeInOutBounce\";\n\ntype EasingFunctions = {\n [K in EasingTypes]: (x: number) => number;\n};\n\n/**\n * from https://github.com/ai/easings.net\n */\nexport const Easing: EasingFunctions = Object.freeze({\n easeInSine(x: number): number {\n return 1 - Math.cos((x * Math.PI) / 2);\n },\n easeOutSine(x: number): number {\n return Math.sin((x * Math.PI) / 2);\n },\n easeInOutSine(x: number): number {\n return -(Math.cos(Math.PI * x) - 1) / 2;\n },\n easeInQuad(x: number): number {\n return x * x;\n },\n easeOutQuad(x: number): number {\n return 1 - (1 - x) * (1 - x);\n },\n easeInOutQuad(x: number): number {\n return x < 0.5 ? 2 * x * x : 1 - Math.pow(-2 * x + 2, 2) / 2;\n },\n easeInCubic(x: number): number {\n return x * x * x;\n },\n easeOutCubic(x: number): number {\n return 1 - Math.pow(1 - x, 3);\n },\n easeInOutCubic(x: number): number {\n return x < 0.5 ? 4 * x * x * x : 1 - Math.pow(-2 * x + 2, 3) / 2;\n },\n easeInQuart(x: number): number {\n return x * x * x * x;\n },\n easeOutQuart(x: number): number {\n return 1 - Math.pow(1 - x, 4);\n },\n easeInOutQuart(x: number): number {\n return x < 0.5 ? 8 * x * x * x * x : 1 - Math.pow(-2 * x + 2, 4) / 2;\n },\n easeInQuint(x: number): number {\n return x * x * x * x * x;\n },\n easeOutQuint(x: number): number {\n return 1 - Math.pow(1 - x, 5);\n },\n easeInOutQuint(x: number): number {\n return x < 0.5 ? 16 * x * x * x * x * x : 1 - Math.pow(-2 * x + 2, 5) / 2;\n },\n easeInExpo(x: number): number {\n return x === 0 ? 0 : Math.pow(2, 10 * x - 10);\n },\n easeOutExpo(x: number): number {\n return x === 1 ? 1 : 1 - Math.pow(2, -10 * x);\n },\n easeInOutExpo(x: number): number {\n return x === 0\n ? 0\n : x === 1\n ? 1\n : x < 0.5\n ? Math.pow(2, 20 * x - 10) / 2\n : (2 - Math.pow(2, -20 * x + 10)) / 2;\n },\n easeInCirc(x: number): number {\n return 1 - Math.sqrt(1 - Math.pow(x, 2));\n },\n easeOutCirc(x: number): number {\n return Math.sqrt(1 - Math.pow(x - 1, 2));\n },\n easeInOutCirc(x: number): number {\n return x < 0.5\n ? (1 - Math.sqrt(1 - Math.pow(2 * x, 2))) / 2\n : (Math.sqrt(1 - Math.pow(-2 * x + 2, 2)) + 1) / 2;\n },\n easeInBack(x: number): number {\n const c1 = 1.70158;\n const c3 = c1 + 1;\n\n return c3 * x * x * x - c1 * x * x;\n },\n easeOutBack(x: number): number {\n const c1 = 1.70158;\n const c3 = c1 + 1;\n\n return 1 + c3 * Math.pow(x - 1, 3) + c1 * Math.pow(x - 1, 2);\n },\n easeInOutBack(x: number): number {\n const c1 = 1.70158;\n const c2 = c1 * 1.525;\n\n return x < 0.5\n ? (Math.pow(2 * x, 2) * ((c2 + 1) * 2 * x - c2)) / 2\n : (Math.pow(2 * x - 2, 2) * ((c2 + 1) * (x * 2 - 2) + c2) + 2) / 2;\n },\n easeInElastic(x: number): number {\n const c4 = (2 * Math.PI) / 3;\n\n return x === 0\n ? 0\n : x === 1\n ? 1\n : -Math.pow(2, 10 * x - 10) * Math.sin((x * 10 - 10.75) * c4);\n },\n easeOutElastic(x: number): number {\n const c4 = (2 * Math.PI) / 3;\n\n return x === 0\n ? 0\n : x === 1\n ? 1\n : Math.pow(2, -10 * x) * Math.sin((x * 10 - 0.75) * c4) + 1;\n },\n easeInOutElastic(x: number): number {\n const c5 = (2 * Math.PI) / 4.5;\n\n return x === 0\n ? 0\n : x === 1\n ? 1\n : x < 0.5\n ? -(Math.pow(2, 20 * x - 10) * Math.sin((20 * x - 11.125) * c5)) / 2\n : (Math.pow(2, -20 * x + 10) * Math.sin((20 * x - 11.125) * c5)) / 2 +\n 1;\n },\n easeInBounce(x: number): number {\n return 1 - Easing.easeOutBounce(1 - x);\n },\n easeOutBounce(x: number): number {\n const n1 = 7.5625;\n const d1 = 2.75;\n\n if (x < 1 / d1) {\n return n1 * x * x;\n } else if (x < 2 / d1) {\n return n1 * (x -= 1.5 / d1) * x + 0.75;\n } else if (x < 2.5 / d1) {\n return n1 * (x -= 2.25 / d1) * x + 0.9375;\n } else {\n return n1 * (x -= 2.625 / d1) * x + 0.984375;\n }\n },\n easeInOutBounce(x: number): number {\n return x < 0.5\n ? (1 - Easing.easeOutBounce(1 - 2 * x)) / 2\n : (1 + Easing.easeOutBounce(2 * x - 1)) / 2;\n },\n});\n","import * as THREE from \"three\";\nimport { Easing, EasingTypes } from \"../libs/Easings\";\nimport { useCallback } from \"react\";\n\n/** Returns a unique hash specific to the beat */\nfunction getHash(input: number) {\n let n = Math.sin(input * 12.9898) * 43758.5453;\n return n - Math.floor(n);\n}\n\ntype BeatValues = {\n beat: number;\n floor: number;\n fract: number;\n /** unique hash specific to the beat */\n hash: number;\n};\n\n/**\n * @param ease easing functions are referenced from https://github.com/ai/easings.net , default : \"easeOutQuart\"\n */\nexport const useBeat = (bpm: number, ease: EasingTypes = \"easeOutQuart\") => {\n const rhythm = bpm / 60;\n const easing = Easing[ease];\n const updateBeat = useCallback(\n (clock: THREE.Clock) => {\n let beat = clock.getElapsedTime() * rhythm;\n const floor = Math.floor(beat);\n const fract = easing(beat - floor);\n beat = fract + floor;\n const hash = getHash(floor);\n return {\n beat,\n floor,\n fract,\n hash,\n } as BeatValues;\n },\n [rhythm, easing]\n );\n return updateBeat;\n};\n","import { useEffect, useRef } from \"react\";\nimport * as THREE from \"three\";\nimport { Size } from \"../hooks/types\";\n\nconst PASSIVE = { passive: true };\n\n/**\n * @param size Size\n * @returns THREE.Vector2\n */\nexport const useWindowPointer = (size: Size) => {\n const windowPointer = useRef(new THREE.Vector2(0));\n\n useEffect(() => {\n const compute = (x: number, y: number) => {\n windowPointer.current.set(\n ((x - size.left) / size.width) * 2 - 1,\n -((y - size.top) / size.height) * 2 + 1\n );\n };\n const handleTouchMove = (event: TouchEvent) => {\n const touch = event.touches[0];\n compute(touch.clientX, touch.clientY);\n };\n const handlePointerMove = (event: PointerEvent) => {\n compute(event.clientX, event.clientY);\n };\n\n window.addEventListener(\"touchmove\", handleTouchMove, PASSIVE);\n window.addEventListener(\"pointermove\", handlePointerMove, PASSIVE);\n\n return () => {\n window.removeEventListener(\"touchmove\", handleTouchMove);\n window.removeEventListener(\"pointermove\", handlePointerMove);\n };\n }, [size]);\n\n return windowPointer.current;\n};\n"],"names":["getDpr","dpr","useResolution","size","_width","_height","resolution","useState","THREE","getCameraProps","width","height","frustumSize","aspect","w","h","useCamera","cameraType","near","far","camera","FBO_DEFAULT_OPTION","renderFBO","gl","fbo","scene","clear","onBeforeRender","onSwap","clearCache","useSingleFBO","props","fboAutoSetSize","depth","renderTargetOptions","renderTarget","target","useEffect","temp","updateRenderTarget","useCallback","renderProps","useDoubleFBO","read","write","_a","_b","useObject3D","geometry","material","Proto","object3D","useSetup","geometrySize","materialProps","_geometry","_material","useMutableState","state","ref","useRef","setRef","value","ISDEV","DEFAULT_TEXTURE","APP_NAME","THREE_FLAG_PROPS","warn","text","BASICFX_VALUES","handleUpdateFxDefines","fxKey","mixSrc","mixDst","srcSystem","levels","contrast","colorBalance","hsv","posterize","grayscale","getFxKeyFromUniforms","uniforms","isMixSrc","isMixDst","plane_vertex_default","default_vertex_default","default_pars_vertex_default","default_pars_fragment_default","basicFx_vertex_default","basicFx_pars_vertex_default","basicFx_pars_fragment_default","basicFx_fragment_begin_default","basicFx_fragment_end_default","samplingFx_vertex_default","samplingFx_pars_vertex_default","samplingFx_pars_fragment_default","ShaderLib","plane_vertex","default_vertex","default_pars_vertex","default_pars_fragment","basicFx_vertex","basicFx_pars_vertex","basicFx_pars_fragment","basicFx_fragment_begin","basicFx_fragment_end","samplingFx_vertex","samplingFx_pars_vertex","samplingFx_pars_fragment","noiseVertex","noiseFragment","srcSystem_pars_vertex_default","srcSystem_pars_fragment_default","mixSrc_pars_vertex_default","mixSrc_vertex_default","mixSrc_pars_fragment_default","mixSrc_fragment_begin_default","mixSrc_fragment_end_default","mixDst_pars_vertex_default","mixDst_vertex_default","mixDst_pars_fragment_default","mixDst_fragment_default","texture_vertex_default","texture_pars_vertex_default","texture_pars_fragment_default","adjustments_fragment_default","adjustments_pars_fragment_default","calcSrcUv_default","ShaderChunk","srcSystem_pars_vertex","srcSystem_pars_fragment","mixSrc_vertex","mixSrc_pars_vertex","mixSrc_pars_fragment","mixSrc_fragment_begin","mixSrc_fragment_end","mixDst_pars_vertex","mixDst_vertex","mixDst_pars_fragment","mixDst_fragment","texture_vertex","texture_pars_vertex","texture_pars_fragment","adjustments_fragment","adjustments_pars_fragment","calcSrcUv","mergeShaderCode","prefix","string","mergeShaderLib","vertexShader","fragmentShader","type","vertex","fragment","ShaderLibs","vertexPars","vertexMain","fragmentPars","includePattern","includeReplacer","match","include","resolveIncludes","isTHREE","property","prop","flattenUniformValues","obj","flatObject","flatten","currentObj","parentKey","key","val","newKey","FxMaterial","uniformValues","materialParameters","maxAspect","values","flattenedValues","curretUniform","onSet","v","BasicFxMaterial","rest","BasicFxLib.BASICFX_VALUES","_cache","diffCount","newFxKey","BasicFxLib.getFxKeyFromUniforms","BasicFxLib.handleUpdateFxDefines","source","src","fitType","srcAspectRatio","fitScale","baseAspectRatio","sourceData","needsUpdate","_NoiseMaterial","NoiseMaterial","boxVarying","getPosition","bounce","getBoxCompute","diff","vertex$1","advection_default","AdvectionMaterial","DELTA_TIME","divergence_default","DivergenceMaterial","pressure_default","PressureMaterial","poisson_default","PoissonMaterial","customParameters","splat_default","SplatMaterial","OutputMaterial","SAMPLINGFX_VALUES","SamplingFxMaterial","_BufferMaterial","BufferMaterial","RawBlankMaterial","SHADER_PARS","BlankMaterial","gridVertex","gridFragment","GridMaterial","useNoise","_dpr","setValues","newValues","rootState","clock","useAdvection","FluidMaterials.AdvectionMaterial","usePointerTracker","lerp","prevPointer","diffPointer","lerpPointer","lastUpdateTime","velocity","isMoved","currentPointer","now","current","deltaTime","isUpdate","prevTemp","useSplat","FluidMaterials.SplatMaterial","pointerTracker","pointer","useDivergence","FluidMaterials.DivergenceMaterial","usePoisson","pressureIterations","FluidMaterials.PoissonMaterial","i","usePressure","FluidMaterials.PressureMaterial","useOutput","FluidMaterials.OutputMaterial","removeUndefined","extractValues","dissipation","radius","forceBias","basicFxValues","useFluid","fboProps","velocity_0","updateVelocity_0","velocity_1","updateVelocity_1","divergenceFBO","updateDivergenceFBO","pressureFBO","updatePressureFBO","outputFBO","updateOutputFBO","extractedValues","SceneSize","advection","splat","divergence","poisson","pressure","output","_extractedValues","_basicFxValues","shader","useBuffer","useRawBlank","shaderWithUniforms","useBlank","pointerLerp","fboParams","_","updateBackbuffer","confing","setConfig","useGrid","Easing","x","c2","c4","c5","getHash","input","n","useBeat","bpm","ease","rhythm","easing","beat","floor","fract","hash","PASSIVE","useWindowPointer","windowPointer","compute","y","handleTouchMove","event","touch","handlePointerMove"],"mappings":"0kBAEaA,EACVC,GAEI,OAAOA,GAAQ,SACT,CAAE,OAAQA,EAAK,IAAKA,CAAI,EAE3B,CACJ,OAAQA,EAAI,QAAU,GACtB,IAAKA,EAAI,KAAO,EAAA,ECHTC,EAAgB,CAACC,EAAYF,EAAsB,KAAU,CACvE,MAAMG,EAASH,EAAME,EAAK,MAAQF,EAAME,EAAK,MACvCE,EAAUJ,EAAME,EAAK,OAASF,EAAME,EAAK,OAEzC,CAACG,CAAU,EAAIC,EAAAA,SAAS,IAAM,IAAIC,EAAM,QAAQJ,EAAQC,CAAO,CAAC,EAC3D,OAAAC,EAAA,IAAIF,EAAQC,CAAO,EAEvBC,CACV,ECVMG,GAAiB,CAACC,EAAeC,IAAmB,CACvD,MAAMC,EAAcD,EACdE,EAASH,EAAQC,EACjB,CAACG,EAAGC,CAAC,EAAI,CAAEH,EAAcC,EAAU,EAAGD,EAAc,CAAC,EACpD,MAAA,CAAE,MAAOE,EAAG,OAAQC,EAAG,KAAM,KAAO,IAAK,IACnD,EAEaC,GAAY,CACtBb,EACAc,EAAyD,uBACvD,CACI,MAAAX,EAAaJ,EAAcC,CAAI,EAC/B,CAAE,MAAAO,EAAO,OAAAC,EAAQ,KAAAO,EAAM,IAAAC,CAAQ,EAAAV,GAClCH,EAAW,EACXA,EAAW,CAAA,EAGR,CAACc,CAAM,EAAIb,EAAAA,SAAS,IAChBU,IAAe,qBACjB,IAAIT,EAAM,mBACP,CAACE,EACDA,EACAC,EACA,CAACA,EACDO,EACAC,CAAA,EAEH,IAAIX,EAAM,kBAAkB,GAAIE,EAAQC,CAAM,CACrD,EAEG,OAAAS,aAAkBZ,EAAM,oBACzBY,EAAO,KAAO,CAACV,EACfU,EAAO,MAAQV,EACfU,EAAO,IAAMT,EACbS,EAAO,OAAS,CAACT,EACjBS,EAAO,KAAOF,EACdE,EAAO,IAAMD,EACbC,EAAO,uBAAuB,GACtBA,aAAkBZ,EAAM,oBAChCY,EAAO,OAASV,EAAQC,EACxBS,EAAO,uBAAuB,GAG1BA,CACV,EC5CaC,GAAgD,CAC1D,YAAa,EAChB,EAqBaC,GAAY,CAAC,CACvB,GAAAC,EACA,IAAAC,EACA,MAAAC,EACA,OAAAL,EACA,MAAAM,EAAQ,GACR,eAAAC,EACA,OAAAC,CACH,IAIoB,CACb,GAAA,CAACH,GAAS,CAACL,EAAQ,OACvB,MAAMS,EAAaN,EAAG,UACtBA,EAAG,UAAYG,EACfH,EAAG,gBAAgBC,CAAG,EACPG,IACZJ,EAAA,OAAOE,EAAOL,CAAM,EACvBQ,GAAUA,EAAO,EACjBL,EAAG,gBAAgB,IAAI,EACvBA,EAAG,UAAYM,CAClB,EAgBaC,EAAgBC,GAA2C,CAC/D,KAAA,CACH,MAAAN,EACA,OAAAL,EACA,KAAAjB,EACA,IAAAF,EAAM,GACN,eAAA+B,EAAiB,GACjB,MAAAC,EAAQ,GACR,GAAGC,CACF,EAAAH,EAEEzB,EAAaJ,EAAcC,EAAMF,CAAG,EAEpC,CAACkC,CAAY,EAAI5B,EAAAA,SAAS,IAAM,CACnC,MAAM6B,EAAS,IAAI5B,EAAM,kBAAkBF,EAAW,EAAGA,EAAW,EAAG,CACpE,GAAGe,GACH,GAAGa,CAAA,CACL,EACD,OAAID,IACMG,EAAA,aAAe,IAAI5B,EAAM,aAC7BF,EAAW,EACXA,EAAW,EACXE,EAAM,SAAA,GAGL4B,CAAA,CACT,EAEGJ,GACDG,EAAa,QAAQ7B,EAAW,EAAGA,EAAW,CAAC,EAGlD+B,EAAAA,UAAU,IAAM,CACb,MAAMC,EAAOH,EACb,MAAO,IAAM,CACVG,GAAA,MAAAA,EAAM,SAAQ,CACjB,EACA,CAACH,CAAY,CAAC,EAEjB,MAAMI,EAA8CC,EAAA,YACjD,CAACC,EAAad,IAAmB,CAC9B,MAAMH,EAAMW,EACF,OAAAb,GAAA,CACP,GAAGmB,EACH,MAAOA,EAAY,OAAShB,EAC5B,OAAQgB,EAAY,QAAUrB,EAC9B,IAAAI,EACA,eAAgB,IAAMG,GAAA,YAAAA,EAAiB,CAAE,KAAMH,EAAI,SAAS,CAC9D,EACMA,EAAI,OACd,EACA,CAACC,EAAOL,EAAQe,CAAY,CAAA,EAGxB,MAAA,CAACA,EAAcI,CAAkB,CAC3C,ECjFaG,GAAgBX,GAA2C,SAC/D,KAAA,CACH,MAAAN,EACA,OAAAL,EACA,KAAAjB,EACA,IAAAF,EAAM,GACN,eAAA+B,EAAiB,GACjB,MAAAC,EAAQ,GACR,GAAGC,CACF,EAAAH,EAEEzB,EAAaJ,EAAcC,EAAMF,CAAG,EAEpC,CAACkC,CAAY,EAAI5B,EAAAA,SAAkC,IAAM,CAC5D,MAAMoC,EAAO,IAAInC,EAAM,kBAAkBF,EAAW,EAAGA,EAAW,EAAG,CAClE,GAAGe,GACH,GAAGa,CAAA,CACL,EACKU,EAAQ,IAAIpC,EAAM,kBAAkBF,EAAW,EAAGA,EAAW,EAAG,CACnE,GAAGe,GACH,GAAGa,CAAA,CACL,EAED,OAAID,IACIU,EAAA,aAAe,IAAInC,EAAM,aAC3BF,EAAW,EACXA,EAAW,EACXE,EAAM,SAAA,EAEHoC,EAAA,aAAe,IAAIpC,EAAM,aAC5BF,EAAW,EACXA,EAAW,EACXE,EAAM,SAAA,GAIL,CACJ,KAAAmC,EACA,MAAAC,EACA,KAAM,UAAY,CACf,IAAIN,EAAO,KAAK,KAChB,KAAK,KAAO,KAAK,MACjB,KAAK,MAAQA,CAChB,CAAA,CACH,CACF,EAEGN,KACDa,EAAAV,EAAa,OAAb,MAAAU,EAAmB,QAAQvC,EAAW,EAAGA,EAAW,IACpDwC,EAAAX,EAAa,QAAb,MAAAW,EAAoB,QAAQxC,EAAW,EAAGA,EAAW,IAGxD+B,EAAAA,UAAU,IAAM,CACb,MAAMC,EAAOH,EACb,MAAO,IAAM,UACVU,EAAAP,EAAK,OAAL,MAAAO,EAAW,WACXC,EAAAR,EAAK,QAAL,MAAAQ,EAAY,SAAQ,CACvB,EACA,CAACX,CAAY,CAAC,EAEjB,MAAMI,EAA8CC,EAAA,YACjD,CAACC,EAAad,IAAmB,OAC9B,MAAMH,EAAMW,EACF,OAAAb,GAAA,CACP,GAAGmB,EACH,MAAOA,EAAY,OAAShB,EAC5B,OAAQgB,EAAY,QAAUrB,EAC9B,IAAKI,EAAI,MACT,eAAgB,IACbG,GAAA,YAAAA,EAAiB,CACd,KAAMH,EAAI,KAAM,QAChB,MAAOA,EAAI,MAAO,OAAA,GAExB,OAAQ,IAAMA,EAAI,KAAK,CAAA,CACzB,GACMqB,EAAArB,EAAI,OAAJ,YAAAqB,EAAU,OACpB,EACA,CAACpB,EAAOL,EAAQe,CAAY,CAAA,EAGxB,MAAA,CACJ,CAAE,KAAMA,EAAa,KAAM,MAAOA,EAAa,KAAM,EACrDI,CAAA,CAEN,ECtGMQ,GAAc,CACjBtB,EACAuB,EACAC,EACAC,IACE,CACI,KAAA,CAACC,CAAQ,EAAI5C,WAAS,IAAM,IAAI2C,EAAMF,EAAUC,CAAQ,CAAC,EAE/DZ,OAAAA,EAAAA,UAAU,KACEZ,GAAAA,EAAM,IAAI0B,CAAQ,EACpB,IAAM,CACD1B,GAAAA,EAAM,OAAO0B,CAAQ,EAC9BH,EAAS,QAAQ,EACjBC,EAAS,QAAQ,CAAA,GAEpB,CAACxB,EAAOuB,EAAUC,EAAUE,CAAQ,CAAC,EAEjCA,CACV,EAEaC,EAAW,CAAuB,CAC5C,KAAAjD,EACA,IAAAF,EACA,SAAAgD,EACA,SAAAD,EAAWxC,EAAM,cACjB,aAAA6C,EACA,GAAGC,CACN,IASwB,CAGf,KAAA,CAAC7B,CAAK,EAAIlB,EAAA,SAAS,IAAM,IAAIC,EAAM,KAAO,EAC1C,CAAC+C,CAAS,EAAIhD,EAAA,SACjB,IAAM,IAAIyC,GAASK,GAAA,YAAAA,EAAc,QAAS,GAAGA,GAAA,YAAAA,EAAc,SAAU,CAAC,CAAA,EAEnE,CAACG,CAAS,EAAIjD,EAAA,SAAS,IAAM,IAAI0C,EAASK,CAAa,CAAC,EAGxDhD,EAAaJ,EAAcC,EAAMF,CAAG,EAC1CuD,EAAU,iBAAiBlD,EAAW,EAAGA,EAAW,CAAC,EAErDyC,GAAYtB,EAAO8B,EAAWC,EAAWhD,EAAM,IAAI,EAE7C,MAAAY,EAASJ,GAAUb,CAAI,EAEtB,MAAA,CACJ,MAAAsB,EACA,SAAU+B,EACV,OAAApC,CAAA,CAEN,EC9EaqC,GAAsBC,GAAa,CACvC,MAAAC,EAAMC,SAAOF,CAAK,EAClBG,EAASrB,cAAasB,GAAqC,CAC9DH,EAAI,QACD,OAAOG,GAAU,WACXA,EAA8BH,EAAI,OAAO,EAC1CG,CACX,EAAG,CAAE,CAAA,EAEE,MAAA,CAACH,EAAKE,CAAM,CACtB,ECTaE,IAAS,IAAM,CACrB,GAAA,CACM,OAAA,QAAQ,IAAI,WAAa,mBACnB,CACN,MAAA,EACV,CACH,KAQaC,EAAkB,IAAIxD,EAAM,YACtC,IAAI,WAAW,CAAC,EAAG,EAAG,EAAG,CAAC,CAAC,EAC3B,EACA,EACAA,EAAM,UACT,EAEayD,GAAW,gBAEXC,GAAmB,CAC7B,UACA,YACA,YACA,YACA,YACA,YACA,YACA,eACA,sBACA,UACA,mBACA,aACA,WACA,UACA,aACA,SACA,gBACH,EC1CaC,EAAQC,GAAiB,CAC/BL,IACD,QAAQ,KAAK,GAAGE,EAAQ,KAAKG,CAAI,EAAE,CAEzC,ECgJaC,EAAkE,CAI5E,OAAQ,CAAE,MAAO,EAAM,EACvB,WAAY,CAAE,MAAO,IAAI7D,EAAM,OAAU,EACzC,WAAY,CAAE,MAAO,CAAE,EACvB,gBAAiB,CAAE,MAAO,IAAIA,EAAM,QAAQ,EAAG,CAAC,CAAE,EAElD,UAAW,CAAE,MAAO,EAAM,EAC1B,aAAc,CAAE,MAAO,CAAE,EACzB,iBAAkB,CAAE,MAAO,CAAE,EAC7B,iBAAkB,CAAE,MAAO,IAAIA,EAAM,QAAQ,EAAG,CAAC,CAAE,EACnD,iBAAkB,CAAE,MAAO,EAAI,EAC/B,mBAAoB,CAAE,MAAO,IAAIA,EAAM,QAAQ,GAAK,EAAG,CAAE,EACzD,gBAAiB,CAAE,MAAO,IAAIA,EAAM,QAAQ,EAAK,CAAG,CAAE,EACtD,iBAAkB,CAAE,MAAO,EAAM,EACjC,qBAAsB,CAAE,MAAOwD,CAAgB,EAC/C,oBAAqB,CAAE,MAAO,CAAE,EAGhC,aAAc,CAAE,MAAO,EAAM,EAC7B,oBAAqB,CAAE,MAAO,CAAE,EAChC,oBAAqB,CAAE,MAAO,EAAI,EAClC,sBAAuB,CAAE,MAAO,IAAIxD,EAAM,QAAQ,GAAK,EAAG,CAAE,EAC5D,mBAAoB,CAAE,MAAO,IAAIA,EAAM,QAAQ,EAAK,CAAG,CAAE,EACzD,oBAAqB,CAAE,MAAO,EAAM,EACpC,wBAAyB,CAAE,MAAOwD,CAAgB,EAClD,uBAAwB,CAAE,MAAO,CAAE,EAGnC,aAAc,CAAE,MAAO,EAAM,EAC7B,oBAAqB,CAAE,MAAO,CAAE,EAChC,oBAAqB,CAAE,MAAO,EAAI,EAClC,sBAAuB,CAAE,MAAO,IAAIxD,EAAM,QAAQ,GAAK,EAAG,CAAE,EAC5D,mBAAoB,CAAE,MAAO,IAAIA,EAAM,QAAQ,EAAK,CAAG,CAAE,EACzD,oBAAqB,CAAE,MAAO,EAAM,EACpC,wBAAyB,CAAE,MAAOwD,CAAgB,EAClD,uBAAwB,CAAE,MAAO,CAAE,EAKnC,OAAQ,CAAE,MAAO,EAAM,EACvB,WAAY,CAAE,MAAO,IAAIxD,EAAM,OAAU,EACzC,WAAY,CAAE,MAAO,CAAE,EACvB,gBAAiB,CAAE,MAAO,IAAIA,EAAM,QAAQ,EAAG,CAAC,CAAE,EAGlD,UAAW,CAAE,MAAO,EAAM,EAC1B,aAAc,CAAE,MAAO,CAAE,EACzB,iBAAkB,CAAE,MAAO,CAAE,EAC7B,iBAAkB,CAAE,MAAO,IAAIA,EAAM,QAAQ,EAAG,CAAC,CAAE,EACnD,iBAAkB,CAAE,MAAO,EAAI,EAC/B,mBAAoB,CAAE,MAAO,IAAIA,EAAM,QAAQ,GAAK,EAAG,CAAE,EACzD,gBAAiB,CAAE,MAAO,IAAIA,EAAM,QAAQ,EAAK,CAAG,CAAE,EACtD,iBAAkB,CAAE,MAAO,EAAM,EACjC,qBAAsB,CAAE,MAAOwD,CAAgB,EAC/C,oBAAqB,CAAE,MAAO,CAAE,EAGhC,aAAc,CAAE,MAAO,EAAM,EAC7B,oBAAqB,CAAE,MAAO,CAAE,EAChC,oBAAqB,CAAE,MAAO,EAAI,EAClC,sBAAuB,CAAE,MAAO,IAAIxD,EAAM,QAAQ,GAAK,EAAG,CAAE,EAC5D,mBAAoB,CAAE,MAAO,IAAIA,EAAM,QAAQ,EAAK,CAAG,CAAE,EACzD,oBAAqB,CAAE,MAAO,EAAM,EACpC,wBAAyB,CAAE,MAAOwD,CAAgB,EAClD,uBAAwB,CAAE,MAAO,CAAE,EAGnC,aAAc,CAAE,MAAO,EAAM,EAC7B,oBAAqB,CAAE,MAAO,CAAE,EAChC,oBAAqB,CAAE,MAAO,EAAI,EAClC,sBAAuB,CAAE,MAAO,IAAIxD,EAAM,QAAQ,GAAK,EAAG,CAAE,EAC5D,mBAAoB,CAAE,MAAO,IAAIA,EAAM,QAAQ,EAAK,CAAG,CAAE,EACzD,oBAAqB,CAAE,MAAO,EAAM,EACpC,wBAAyB,CAAE,MAAOwD,CAAgB,EAClD,uBAAwB,CAAE,MAAO,CAAE,EAMnC,OAAQ,CAAE,MAAO,EAAM,EACvB,eAAgB,CAAE,MAAO,IAAIxD,EAAM,QAAQ,EAAG,EAAG,EAAG,CAAC,CAAE,EACvD,gBAAiB,CAAE,MAAO,IAAIA,EAAM,QAAQ,EAAG,EAAG,EAAG,CAAC,CAAE,EACxD,kBAAmB,CAAE,MAAO,IAAIA,EAAM,QAAQ,EAAG,EAAG,EAAG,CAAC,CAAE,EAC1D,iBAAkB,CAAE,MAAO,IAAIA,EAAM,QAAQ,EAAG,EAAG,EAAG,CAAC,CAAE,EACzD,iBAAkB,CAAE,MAAO,IAAIA,EAAM,QAAQ,EAAG,EAAG,EAAG,CAAC,CAAE,EAEzD,SAAU,CAAE,MAAO,EAAM,EACzB,gBAAiB,CAAE,MAAO,IAAIA,EAAM,QAAQ,EAAG,EAAG,EAAG,CAAC,CAAE,EAExD,aAAc,CAAE,MAAO,EAAM,EAC7B,oBAAqB,CAAE,MAAO,IAAIA,EAAM,QAAQ,EAAG,EAAG,CAAC,CAAE,EAEzD,IAAK,CAAE,MAAO,EAAM,EACpB,aAAc,CAAE,MAAO,CAAE,EACzB,eAAgB,CAAE,MAAO,CAAE,EAC3B,eAAgB,CAAE,MAAO,CAAE,EAE3B,UAAW,CAAE,MAAO,EAAM,EAC1B,iBAAkB,CAAE,MAAO,IAAIA,EAAM,QAAQ,EAAG,EAAG,EAAG,CAAC,CAAE,EAEzD,UAAW,CAAE,MAAO,EAAM,EAC1B,iBAAkB,CAAE,MAAO,IAAIA,EAAM,QAAQ,EAAG,EAAG,CAAC,CAAE,EACtD,kBAAmB,CAAE,MAAO,EAAM,EAClC,yBAA0B,CAAE,MAAO,IAAIA,EAAM,MAAM,CAAQ,CAAE,EAC7D,yBAA0B,CAAE,MAAO,IAAIA,EAAM,MAAM,QAAQ,CAAE,EAC7D,oBAAqB,CAAE,MAAO,EAAG,CACpC,EAKO,SAAS8D,GAAsBC,EAEpC,CACO,KAAA,CACH,OAAAC,EACA,OAAAC,EACA,UAAAC,EACA,OAAAC,EACA,SAAAC,EACA,aAAAC,EACA,IAAAC,EACA,UAAAC,EACA,UAAAC,CACC,EAAAT,EACG,MAAA,CACJ,mBAAoBG,EACpB,eAAgBF,EAChB,eAAgBC,EAChB,eAAgBE,EAChB,iBAAkBC,EAClB,qBAAsBC,EACtB,YAAaC,EACb,kBAAmBC,EACnB,kBAAmBC,CAAA,CAEzB,CAGO,SAASC,GAAqBC,EAAwC,CAC1E,MAAMC,EAAW,EAAAD,EAAS,OAAO,MAC3BE,EAAW,EAAAF,EAAS,OAAO,MAE1B,MAAA,CACJ,OAAQC,EACR,OAAQC,EACR,UAJiBD,GAAYC,EAK7B,OAAQ,EAAAF,EAAS,OAAO,MACxB,SAAU,EAAAA,EAAS,SAAS,MAC5B,aAAc,EAAAA,EAAS,aAAa,MACpC,IAAK,EAAAA,EAAS,IAAI,MAClB,UAAW,EAAAA,EAAS,UAAU,MAC9B,UAAW,EAAAA,EAAS,UAAU,KAAe,CAEnD,CCrTA,IAAAG,GAAA,sBCAAC,GAAA,wBCAAC,GAAA,6BCAAC,GAAA,+BCAAC,GAAA;AAAA,sBCAAC,GAAA;AAAA;AAAA,2BCAAC,GAAA;AAAA;AAAA;AAAA,kCCAAC,GAAA,+BCAAC,GAAA;AAAA;AAAA,6BCAAC,GAAA,wBCAAC,GAAA,6BCAAC,GAAA,+BC2Ba,MAAAC,EAA+C,OAAO,OAAO,CAAA,aACvEC,GAAA,eACAC,GAAA,oBACAC,GAAA,sBACAC,GAAA,eACAC,GAAA,oBACAC,GAAA,sBACAC,GAAA,uBACAC,GAAA,qBACAC,GAAA,kBACAC,GAAA,uBACAC,GAAA,yBACAC,EACH,CAAC,ECtCYC,GAAc;AAAA;AAAA,IAEvBb,EAAU,YAAY;AAAA;AAAA,EAIbc,GAAgB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IA6EzBd,EAAU,sBAAsB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAMhCA,EAAU,oBAAoB;AAAA;AAAA;AAAA;AAAA;AAAA,EC3FlC,IAAAZ,GAAA,qCCAA2B,GAAA;AAAA;AAAA;AAAA;AAAA,QCAAC,GAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,QCAA3B,GAAA,YCAAC,GAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,yBCAAC,GAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,0BCAA0B,GAAA;AAAA;AAAA;AAAA,QCAAC,GAAA;AAAA;AAAA,QCAAC,GAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,QCAAC,GAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,QCAAC,GAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,QCAAC,GAAA;AAAA;AAAA;AAAA,QCAAC,GAAA;AAAA;AAAA,QCAAC,GAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,QCAAC,GAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,QCAAC,GAAA;AAAA;AAAA,QCAAC,GAAA;AAAA;AAAA;AAAA,QCAAC,GAAA;AAAA;AAAA;AAAA;AAAA;AAAA,QCAAC,GAAA;AAAA;AAA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"} \ No newline at end of file diff --git a/packages/use-shader-fx/package-lock.json b/packages/use-shader-fx/package-lock.json index 3434344b..6df88478 100644 --- a/packages/use-shader-fx/package-lock.json +++ b/packages/use-shader-fx/package-lock.json @@ -1,12 +1,12 @@ { "name": "@funtech-inc/use-shader-fx", - "version": "2.0.4", + "version": "2.0.5", "lockfileVersion": 3, "requires": true, "packages": { "": { "name": "@funtech-inc/use-shader-fx", - "version": "2.0.4", + "version": "2.0.5", "license": "MIT", "devDependencies": { "@types/node": "20.5.6", diff --git a/packages/use-shader-fx/package.json b/packages/use-shader-fx/package.json index a5668115..bed1764e 100644 --- a/packages/use-shader-fx/package.json +++ b/packages/use-shader-fx/package.json @@ -1,6 +1,6 @@ { "name": "@funtech-inc/use-shader-fx", - "version": "2.0.4", + "version": "2.0.5", "description": "⚡️ More FXs, Less GLSL", "main": "./build/use-shader-fx.umd.cjs", "module": "./build/use-shader-fx.js", diff --git a/packages/use-shader-fx/src/hooks/useGrid/index.ts b/packages/use-shader-fx/src/hooks/useGrid/index.ts index c55477a6..b47020a1 100644 --- a/packages/use-shader-fx/src/hooks/useGrid/index.ts +++ b/packages/use-shader-fx/src/hooks/useGrid/index.ts @@ -48,7 +48,9 @@ export const useGrid = ({ const { gl, clock } = rootState; newValues && setValues(newValues, false); material.uniforms.tick.value = - newValues?.tick || clock.getElapsedTime(); + typeof newValues?.tick === "function" + ? newValues.tick(material.uniforms.tick.value) + : newValues?.tick || clock.getElapsedTime(); return updateRenderTarget({ gl }); }, [setValues, updateRenderTarget, material] diff --git a/packages/use-shader-fx/src/hooks/useNoise/index.ts b/packages/use-shader-fx/src/hooks/useNoise/index.ts index 2d7f7dbe..c912bd4a 100644 --- a/packages/use-shader-fx/src/hooks/useNoise/index.ts +++ b/packages/use-shader-fx/src/hooks/useNoise/index.ts @@ -54,7 +54,9 @@ export const useNoise = ({ const { gl, clock } = rootState; newValues && setValues(newValues, false); material.uniforms.tick.value = - newValues?.tick || clock.getElapsedTime(); + typeof newValues?.tick === "function" + ? newValues.tick(material.uniforms.tick.value) + : newValues?.tick || clock.getElapsedTime(); return updateRenderTarget({ gl }); }, [setValues, updateRenderTarget, material] diff --git a/packages/use-shader-fx/types/hooks/index.d.ts b/packages/use-shader-fx/types/hooks/index.d.ts new file mode 100644 index 00000000..bb28ce5f --- /dev/null +++ b/packages/use-shader-fx/types/hooks/index.d.ts @@ -0,0 +1,9 @@ +import { useNoise, NoiseProps } from "./useNoise"; +export type FxTypes = typeof useNoise; +export type FxProps = T extends typeof useNoise ? NoiseProps : never; +export * from "./useNoise"; +export * from "./useFluid"; +export * from "./useBuffer"; +export * from "./useRawBlank"; +export * from "./useBlank"; +export * from "./useGrid"; diff --git a/packages/use-shader-fx/types/hooks/types/index.d.ts b/packages/use-shader-fx/types/hooks/types/index.d.ts new file mode 100644 index 00000000..a18406d5 --- /dev/null +++ b/packages/use-shader-fx/types/hooks/types/index.d.ts @@ -0,0 +1,73 @@ +import * as THREE from "three"; +import { BasicFxMaterial } from "../../materials/core/BasicFxMaterial"; +import { DoubleRenderTarget } from "../../utils"; +export type Size = { + width: number; + height: number; + top: number; + left: number; + updateStyle?: boolean; +}; +export type Dpr = number | { + /** you can set whether `dpr` affects `shader`. default : `false` */ + shader?: false | number; + /** you can set whether `dpr` affects `fbo`. default : `false` */ + fbo?: false | number; +}; +export type RootState = { + /** The instance of the renderer */ + gl: THREE.WebGLRenderer; + /** Default clock */ + clock: THREE.Clock; + /** Normalized event coordinates */ + pointer: THREE.Vector2; + /** Reactive pixel-size of the canvas */ + size: Size; +}; +/** + * sceneやmaterialなどはミュータブルなオブジェクトであり、non-reactiveであるべき + */ +export interface HooksProps { + /** Width,Height in pixels, or `size` from r3f */ + size: Size; + /** Pixel-ratio, use `window.devicePixelRatio` or viewport.dpr from r3f */ + dpr: Dpr; + /** Whether to `setSize` the FBO when updating size or dpr. default : `false` */ + fboAutoSetSize?: boolean; + /** + * @type `THREE.RenderTargetOptions` + * @param depthBuffer Unlike the default in three.js, the default is `false`. + */ + renderTargetOptions?: THREE.RenderTargetOptions; + materialParameters?: THREE.ShaderMaterialParameters; +} +/** + * @returns {HooksReturn} + * render - Functions to update parameters and render. + * setValues - Function to update parameters only. + * texture - texture + * material - material + * scene - scene + * + * @template V The type for the FX parameters. + * @template O The type for the material. + */ +export type HooksReturn = { + /** + * Functions to update parameters and render. + * @param rootState RootState + * @param newValues params of fxHooks. basicFxの追加/削除による再コンパイルや、fitの変更によるresolutionの変更は伴わない。再コンパイルを伴う場合はsetValuesを使う。 + */ + render: (rootState: RootState, newValues?: V) => THREE.Texture; + /** + * Function to update parameters only. + * @param newValues params of fxHooks + * @param needsUpdate basicFxの追加/削除による再コンパイルや、fitの変更によるresolutionの変更を伴うかどうか. default : `true` + */ + setValues: (newValues: V, needsUpdate?: boolean) => void; + texture: THREE.Texture; + material?: M; + scene?: THREE.Scene; + camera?: THREE.Camera; + renderTarget?: THREE.WebGLRenderTarget | DoubleRenderTarget; +} & A; diff --git a/packages/use-shader-fx/types/hooks/useBlank/index.d.ts b/packages/use-shader-fx/types/hooks/useBlank/index.d.ts new file mode 100644 index 00000000..ce8730b8 --- /dev/null +++ b/packages/use-shader-fx/types/hooks/useBlank/index.d.ts @@ -0,0 +1,29 @@ +import { HooksProps, HooksReturn } from "../types"; +import { BlankMaterial } from "../../materials"; +import { ShaderWithUniforms } from "../../shaders/uniformsUtils"; +type BlankConfig = { + pointerLerp?: number; +}; +export type BlankProps = HooksProps & ShaderWithUniforms; +/** + * type DefaultUniforms = { + resolution: { value: THREE.Vector2 }; + texelSize: { value: THREE.Vector2 }; + aspectRatio: { value: number }; + maxAspect: { value: THREE.Vector2 }; + renderCount: { value: number }; + はデフォルトである + あとvaringでvUvつかえる + + 加えて、 + time + pointer + backbuffer + もデフォルトで使える + + あと、pointerLerp使えるよ + + * @link https://github.com/FunTechInc/use-shader-fx?tab=readme-ov-file#usage + */ +export declare const useBlank: ({ size, dpr, fboAutoSetSize, renderTargetOptions, materialParameters, pointerLerp, ...shaderWithUniforms }: BlankProps & BlankConfig) => HooksReturn<{}, BlankMaterial>; +export {}; diff --git a/packages/use-shader-fx/types/hooks/useBuffer/index.d.ts b/packages/use-shader-fx/types/hooks/useBuffer/index.d.ts new file mode 100644 index 00000000..d9caf436 --- /dev/null +++ b/packages/use-shader-fx/types/hooks/useBuffer/index.d.ts @@ -0,0 +1,7 @@ +import { HooksProps, HooksReturn } from "../types"; +import { BufferMaterial, BufferMaterialProps, BufferValues } from "../../materials"; +export type BufferProps = HooksProps & BufferValues; +/** + * @link https://github.com/FunTechInc/use-shader-fx?tab=readme-ov-file#usage + */ +export declare const useBuffer: ({ size, dpr, fboAutoSetSize, renderTargetOptions, materialParameters, ...uniformValues }: BufferProps) => HooksReturn; diff --git a/packages/use-shader-fx/types/hooks/useFluid/index.d.ts b/packages/use-shader-fx/types/hooks/useFluid/index.d.ts new file mode 100644 index 00000000..24486e5f --- /dev/null +++ b/packages/use-shader-fx/types/hooks/useFluid/index.d.ts @@ -0,0 +1,14 @@ +import * as THREE from "three"; +import { HooksProps, HooksReturn } from "../types"; +import { BasicFxValues, FluidMaterials } from "../../materials"; +export type FluidValues = { + pressureIterations?: number; +} & BasicFxValues & FluidMaterials.AdvectionValuesClient & FluidMaterials.DivergenceValuesClient & FluidMaterials.PoissonValuesClient & FluidMaterials.PressureValuesClient & FluidMaterials.SplatValuesClient; +export type FluidProps = HooksProps & FluidValues; +/** + * @link https://github.com/FunTechInc/use-shader-fx?tab=readme-ov-file#usage + */ +export declare const useFluid: ({ size, dpr, fboAutoSetSize, renderTargetOptions, materialParameters, ...uniformValues }: FluidProps) => HooksReturn; diff --git a/packages/use-shader-fx/types/hooks/useFluid/scenes/useAdvection.d.ts b/packages/use-shader-fx/types/hooks/useFluid/scenes/useAdvection.d.ts new file mode 100644 index 00000000..9ca0287d --- /dev/null +++ b/packages/use-shader-fx/types/hooks/useFluid/scenes/useAdvection.d.ts @@ -0,0 +1,10 @@ +import { RootState, Size } from "../../types"; +import { FluidMaterials } from "../../../materials"; +import { SingleFBOUpdateFunction } from "../../../utils"; +export declare const useAdvection: ({ size, dpr, ...uniformValues }: { + size: Size; + dpr: number | false; +} & FluidMaterials.AdvectionValues, updateRenderTarget: SingleFBOUpdateFunction) => { + render: (rootState: RootState) => void; + material: FluidMaterials.AdvectionMaterial; +}; diff --git a/packages/use-shader-fx/types/hooks/useFluid/scenes/useDivergence.d.ts b/packages/use-shader-fx/types/hooks/useFluid/scenes/useDivergence.d.ts new file mode 100644 index 00000000..7e9f716f --- /dev/null +++ b/packages/use-shader-fx/types/hooks/useFluid/scenes/useDivergence.d.ts @@ -0,0 +1,10 @@ +import { RootState, Size } from "../../types"; +import { FluidMaterials } from "../../../materials"; +import { SingleFBOUpdateFunction } from "../../../utils"; +export declare const useDivergence: ({ size, dpr, ...uniformValues }: { + size: Size; + dpr: number | false; +} & FluidMaterials.DivergenceValues, updateRenderTarget: SingleFBOUpdateFunction) => { + render: (rootState: RootState) => void; + material: FluidMaterials.DivergenceMaterial; +}; diff --git a/packages/use-shader-fx/types/hooks/useFluid/scenes/useOutput.d.ts b/packages/use-shader-fx/types/hooks/useFluid/scenes/useOutput.d.ts new file mode 100644 index 00000000..237f8ddf --- /dev/null +++ b/packages/use-shader-fx/types/hooks/useFluid/scenes/useOutput.d.ts @@ -0,0 +1,10 @@ +import { RootState, Size } from "../../types"; +import { SingleFBOUpdateFunction } from "../../../utils"; +import { FluidMaterials } from "../../../materials"; +export declare const useOutput: ({ size, dpr, ...values }: { + size: Size; + dpr: number | false; +} & FluidMaterials.OutputValues, updateRenderTarget: SingleFBOUpdateFunction) => { + render: (rootState: RootState) => void; + material: FluidMaterials.OutputMaterial; +}; diff --git a/packages/use-shader-fx/types/hooks/useFluid/scenes/usePoisson.d.ts b/packages/use-shader-fx/types/hooks/useFluid/scenes/usePoisson.d.ts new file mode 100644 index 00000000..616f99e1 --- /dev/null +++ b/packages/use-shader-fx/types/hooks/useFluid/scenes/usePoisson.d.ts @@ -0,0 +1,11 @@ +import { RootState, Size } from "../../types"; +import { DoubleFBOUpdateFunction } from "../../../utils"; +import { FluidMaterials } from "../../../materials"; +export declare const usePoisson: ({ size, dpr, pressureIterations, ...uniformValues }: { + size: Size; + dpr: number | false; + pressureIterations?: number; +} & Omit, updateRenderTarget: DoubleFBOUpdateFunction) => { + render: (rootState: RootState) => void; + material: FluidMaterials.PoissonMaterial; +}; diff --git a/packages/use-shader-fx/types/hooks/useFluid/scenes/usePressure.d.ts b/packages/use-shader-fx/types/hooks/useFluid/scenes/usePressure.d.ts new file mode 100644 index 00000000..ad9be767 --- /dev/null +++ b/packages/use-shader-fx/types/hooks/useFluid/scenes/usePressure.d.ts @@ -0,0 +1,10 @@ +import { RootState, Size } from "../../types"; +import { SingleFBOUpdateFunction } from "../../../utils"; +import { FluidMaterials } from "../../../materials"; +export declare const usePressure: ({ size, dpr, ...uniformValues }: { + size: Size; + dpr: number | false; +} & FluidMaterials.PressureValues, updateRenderTarget: SingleFBOUpdateFunction) => { + render: (rootState: RootState) => void; + material: FluidMaterials.PressureMaterial; +}; diff --git a/packages/use-shader-fx/types/hooks/useFluid/scenes/useSplat.d.ts b/packages/use-shader-fx/types/hooks/useFluid/scenes/useSplat.d.ts new file mode 100644 index 00000000..4cdd4b5c --- /dev/null +++ b/packages/use-shader-fx/types/hooks/useFluid/scenes/useSplat.d.ts @@ -0,0 +1,10 @@ +import { RootState, Size } from "../../types"; +import { SingleFBOUpdateFunction } from "../../../utils"; +import { FluidMaterials } from "../../../materials"; +export declare const useSplat: ({ size, dpr, ...uniformValues }: { + size: Size; + dpr: number | false; +} & FluidMaterials.SplatValuesClient, updateRenderTarget: SingleFBOUpdateFunction) => { + render: (rootState: RootState) => void; + material: FluidMaterials.SplatMaterial; +}; diff --git a/packages/use-shader-fx/types/hooks/useGrid/index.d.ts b/packages/use-shader-fx/types/hooks/useGrid/index.d.ts new file mode 100644 index 00000000..6e245f73 --- /dev/null +++ b/packages/use-shader-fx/types/hooks/useGrid/index.d.ts @@ -0,0 +1,7 @@ +import { HooksProps, HooksReturn } from "../types"; +import { GridMaterial, GridValues, GridMaterialProps } from "../../materials"; +export type GridProps = HooksProps & GridValues; +/** + * @link https://github.com/FunTechInc/use-shader-fx?tab=readme-ov-file#usage + */ +export declare const useGrid: ({ size, dpr, fboAutoSetSize, renderTargetOptions, materialParameters, ...uniformValues }: GridProps) => HooksReturn; diff --git a/packages/use-shader-fx/types/hooks/useNoise/index.d.ts b/packages/use-shader-fx/types/hooks/useNoise/index.d.ts new file mode 100644 index 00000000..d2b333d8 --- /dev/null +++ b/packages/use-shader-fx/types/hooks/useNoise/index.d.ts @@ -0,0 +1,7 @@ +import { HooksProps, HooksReturn } from "../types"; +import { NoiseMaterial, NoiseMaterialProps, NoiseValues } from "../../materials"; +export type NoiseProps = HooksProps & NoiseValues; +/** + * @link https://github.com/FunTechInc/use-shader-fx?tab=readme-ov-file#usage + */ +export declare const useNoise: ({ size, dpr, fboAutoSetSize, renderTargetOptions, materialParameters, ...uniformValues }: NoiseProps) => HooksReturn; diff --git a/packages/use-shader-fx/types/hooks/useRawBlank/index.d.ts b/packages/use-shader-fx/types/hooks/useRawBlank/index.d.ts new file mode 100644 index 00000000..29c5611e --- /dev/null +++ b/packages/use-shader-fx/types/hooks/useRawBlank/index.d.ts @@ -0,0 +1,17 @@ +import { HooksProps, HooksReturn } from "../types"; +import { RawBlankMaterial } from "../../materials"; +import { ShaderWithUniforms } from "../../shaders/uniformsUtils"; +export type RawBlankProps = HooksProps & ShaderWithUniforms; +/** + * type DefaultUniforms = { + resolution: { value: THREE.Vector2 }; + texelSize: { value: THREE.Vector2 }; + aspectRatio: { value: number }; + maxAspect: { value: THREE.Vector2 }; + renderCount: { value: number }; + はデフォルトである + あとvaringでvUvつかえる + + * @link https://github.com/FunTechInc/use-shader-fx?tab=readme-ov-file#usage + */ +export declare const useRawBlank: ({ size, dpr, fboAutoSetSize, renderTargetOptions, materialParameters, ...shaderWithUniforms }: RawBlankProps) => HooksReturn<{}, RawBlankMaterial>; diff --git a/packages/use-shader-fx/types/index.d.ts b/packages/use-shader-fx/types/index.d.ts new file mode 100644 index 00000000..8c9e7f5c --- /dev/null +++ b/packages/use-shader-fx/types/index.d.ts @@ -0,0 +1,4 @@ +export * from "./hooks"; +export * from "./materials"; +export * from "./misc"; +export { useDoubleFBO, useSingleFBO } from "./utils"; diff --git a/packages/use-shader-fx/types/libs/Easings.d.ts b/packages/use-shader-fx/types/libs/Easings.d.ts new file mode 100644 index 00000000..41ba49de --- /dev/null +++ b/packages/use-shader-fx/types/libs/Easings.d.ts @@ -0,0 +1,9 @@ +export type EasingTypes = "easeInSine" | "easeOutSine" | "easeInOutSine" | "easeInQuad" | "easeOutQuad" | "easeInOutQuad" | "easeInCubic" | "easeOutCubic" | "easeInOutCubic" | "easeInQuart" | "easeOutQuart" | "easeInOutQuart" | "easeInQuint" | "easeOutQuint" | "easeInOutQuint" | "easeInExpo" | "easeOutExpo" | "easeInOutExpo" | "easeInCirc" | "easeOutCirc" | "easeInOutCirc" | "easeInBack" | "easeOutBack" | "easeInOutBack" | "easeInElastic" | "easeOutElastic" | "easeInOutElastic" | "easeInBounce" | "easeOutBounce" | "easeInOutBounce"; +type EasingFunctions = { + [K in EasingTypes]: (x: number) => number; +}; +/** + * from https://github.com/ai/easings.net + */ +export declare const Easing: EasingFunctions; +export {}; diff --git a/packages/use-shader-fx/types/libs/constants.d.ts b/packages/use-shader-fx/types/libs/constants.d.ts new file mode 100644 index 00000000..3838bde0 --- /dev/null +++ b/packages/use-shader-fx/types/libs/constants.d.ts @@ -0,0 +1,10 @@ +import * as THREE from "three"; +export declare const ISDEV: boolean; +export declare const MATERIAL_BASIC_PARAMS: { + transparent: boolean; + depthTest: boolean; + depthWrite: boolean; +}; +export declare const DEFAULT_TEXTURE: THREE.DataTexture; +export declare const APP_NAME = "use-shader-fx"; +export declare const THREE_FLAG_PROPS: string[]; diff --git a/packages/use-shader-fx/types/libs/types.d.ts b/packages/use-shader-fx/types/libs/types.d.ts new file mode 100644 index 00000000..e6acf0dc --- /dev/null +++ b/packages/use-shader-fx/types/libs/types.d.ts @@ -0,0 +1,2 @@ +/** 0:r,1:g,2:b,3:a */ +export type Vec4Channel = 0 | 1 | 2 | 3; diff --git a/packages/use-shader-fx/types/materials/core/BasicFxLib.d.ts b/packages/use-shader-fx/types/materials/core/BasicFxLib.d.ts new file mode 100644 index 00000000..e4569bca --- /dev/null +++ b/packages/use-shader-fx/types/materials/core/BasicFxLib.d.ts @@ -0,0 +1,277 @@ +import * as THREE from "three"; +import { DefaultUniforms } from "./FxMaterial"; +import { NestUniformValues, UniformParentKey } from "../../shaders/uniformsUtils"; +import type { Vec4Channel } from "../../libs/types"; +/** 0:`fill` 1:`cover` 2:`contain` */ +export type FitType = 0 | 1 | 2; +export type BasicFxUniformsUnique = { + mixSrc: { + value: UniformParentKey; + }; + mixSrc_src: { + value: THREE.Texture; + }; + mixSrc_fit: { + value: FitType; + }; + mixSrc_uv: { + value: UniformParentKey; + }; + mixSrc_uv_ch: { + value: Vec4Channel; + }; + mixSrc_uv_factor: { + value: number; + }; + mixSrc_uv_offset: { + value: THREE.Vector2; + }; + mixSrc_uv_radius: { + value: number; + }; + mixSrc_uv_position: { + value: THREE.Vector2; + }; + mixSrc_uv_range: { + value: THREE.Vector2; + }; + mixSrc_uv_mixMap: { + value: UniformParentKey; + }; + mixSrc_uv_mixMap_src: { + value: THREE.Texture; + }; + mixSrc_uv_mixMap_ch: { + value: Vec4Channel; + }; + mixSrc_color: { + value: UniformParentKey; + }; + mixSrc_color_factor: { + value: number; + }; + mixSrc_color_radius: { + value: number; + }; + mixSrc_color_position: { + value: THREE.Vector2; + }; + mixSrc_color_range: { + value: THREE.Vector2; + }; + mixSrc_color_mixMap: { + value: UniformParentKey; + }; + mixSrc_color_mixMap_src: { + value: THREE.Texture; + }; + mixSrc_color_mixMap_ch: { + value: Vec4Channel; + }; + mixSrc_alpha: { + value: UniformParentKey; + }; + mixSrc_alpha_factor: { + value: number; + }; + mixSrc_alpha_radius: { + value: number; + }; + mixSrc_alpha_position: { + value: THREE.Vector2; + }; + mixSrc_alpha_range: { + value: THREE.Vector2; + }; + mixSrc_alpha_mixMap: { + value: UniformParentKey; + }; + mixSrc_alpha_mixMap_src: { + value: THREE.Texture; + }; + mixSrc_alpha_mixMap_ch: { + value: Vec4Channel; + }; + mixDst: { + value: UniformParentKey; + }; + mixDst_src: { + value: THREE.Texture; + }; + mixDst_fit: { + value: FitType; + }; + mixDst_uv: { + value: UniformParentKey; + }; + mixDst_uv_ch: { + value: Vec4Channel; + }; + mixDst_uv_factor: { + value: number; + }; + mixDst_uv_offset: { + value: THREE.Vector2; + }; + mixDst_uv_radius: { + value: number; + }; + mixDst_uv_position: { + value: THREE.Vector2; + }; + mixDst_uv_range: { + value: THREE.Vector2; + }; + mixDst_uv_mixMap: { + value: UniformParentKey; + }; + mixDst_uv_mixMap_src: { + value: THREE.Texture; + }; + mixDst_uv_mixMap_ch: { + value: Vec4Channel; + }; + mixDst_color: { + value: UniformParentKey; + }; + mixDst_color_factor: { + value: number; + }; + mixDst_color_radius: { + value: number; + }; + mixDst_color_position: { + value: THREE.Vector2; + }; + mixDst_color_range: { + value: THREE.Vector2; + }; + mixDst_color_mixMap: { + value: UniformParentKey; + }; + mixDst_color_mixMap_src: { + value: THREE.Texture; + }; + mixDst_color_mixMap_ch: { + value: Vec4Channel; + }; + mixDst_alpha: { + value: UniformParentKey; + }; + mixDst_alpha_factor: { + value: number; + }; + mixDst_alpha_radius: { + value: number; + }; + mixDst_alpha_position: { + value: THREE.Vector2; + }; + mixDst_alpha_range: { + value: THREE.Vector2; + }; + mixDst_alpha_mixMap: { + value: UniformParentKey; + }; + mixDst_alpha_mixMap_src: { + value: THREE.Texture; + }; + mixDst_alpha_mixMap_ch: { + value: Vec4Channel; + }; + levels: { + value: UniformParentKey; + }; + levels_shadows: { + value: THREE.Vector4; + }; + levels_midtones: { + value: THREE.Vector4; + }; + levels_highlights: { + value: THREE.Vector4; + }; + levels_outputMin: { + value: THREE.Vector4; + }; + levels_outputMax: { + value: THREE.Vector4; + }; + contrast: { + value: UniformParentKey; + }; + contrast_factor: { + value: THREE.Vector4; + }; + colorBalance: { + value: UniformParentKey; + }; + colorBalance_factor: { + value: THREE.Vector3; + }; + hsv: { + value: UniformParentKey; + }; + hsv_hueShift: { + value: number; + }; + hsv_saturation: { + value: number; + }; + hsv_brightness: { + value: number; + }; + posterize: { + value: UniformParentKey; + }; + posterize_levels: { + value: THREE.Vector4; + }; + grayscale: { + value: UniformParentKey; + }; + grayscale_weight: { + value: THREE.Vector3; + }; + grayscale_duotone: { + value: UniformParentKey; + }; + grayscale_duotone_color0: { + value: THREE.Color; + }; + grayscale_duotone_color1: { + value: THREE.Color; + }; + grayscale_threshold: { + value: number; + }; +}; +type BasicFxUniformsFitScale = { + mixSrc_fitScale: { + value: THREE.Vector2; + }; + mixDst_fitScale: { + value: THREE.Vector2; + }; +}; +export type BasicFxUniforms = BasicFxUniformsUnique & DefaultUniforms; +export type BasicFxValues = NestUniformValues; +export type FxKey = { + srcSystem: boolean; + mixSrc: boolean; + mixDst: boolean; + levels: boolean; + contrast: boolean; + colorBalance: boolean; + hsv: boolean; + posterize: boolean; + grayscale: boolean; +}; +export type SrcSystemKey = "mixSrc" | "mixDst" | "texture"; +export declare const BASICFX_VALUES: BasicFxUniformsUnique & BasicFxUniformsFitScale; +export declare function handleUpdateFxDefines(fxKey: FxKey): { + [key: string]: any; +}; +/** setterで定義される場合もあるため、valuesではなくuniformsから判定する */ +export declare function getFxKeyFromUniforms(uniforms: BasicFxUniformsUnique): FxKey; +export {}; diff --git a/packages/use-shader-fx/types/materials/core/BasicFxMaterial.d.ts b/packages/use-shader-fx/types/materials/core/BasicFxMaterial.d.ts new file mode 100644 index 00000000..ab87a5f1 --- /dev/null +++ b/packages/use-shader-fx/types/materials/core/BasicFxMaterial.d.ts @@ -0,0 +1,39 @@ +import { FxMaterial, FxMaterialProps } from "./FxMaterial"; +import * as BasicFxLib from "./BasicFxLib"; +export declare class BasicFxMaterial extends FxMaterial { + fxKey: BasicFxLib.FxKey; + uniforms: BasicFxLib.BasicFxUniforms; + programCache: number; + constructor({ uniforms, vertexShader, fragmentShader, ...rest }?: FxMaterialProps); + private _setupFxShaders; + /** SamplingFxMaterialで継承するため、handlerとして独立させる */ + protected _handleMergeShaderLib(vertexShader?: string, fragmentShader?: string): [string | undefined, string | undefined]; + private _updateFxShaders; + /** SamplingFxMaterialで継承するため、handlerとして独立させる */ + protected _handleUpdateFxShaders(): { + diffCount: number; + newFxKey: BasicFxLib.FxKey; + }; + private _updateFxDefines; + /** SamplingFxMaterialで継承するため、handlerとして独立させる */ + protected _handleUpdateFxDefines(): { + [key: string]: any; + }; + protected _isContainsBasicFxValues(target?: { + [key: string]: any; + }, source?: { + [key: string]: any; + }): boolean; + protected _setupFxKey(uniforms: BasicFxLib.BasicFxUniforms): BasicFxLib.FxKey; + private _calcFitScale; + protected _setFitScale(key: BasicFxLib.SrcSystemKey): void; + protected _updateFitScale(): void; + /** + * @param needsUpdate default : `true` + */ + setUniformValues(values?: { + [key: string]: any; + }, needsUpdate?: boolean): Record | undefined; + protected _defineUniformAccessors(onSet?: () => void): void; + updateResolution(width: number, height: number): void; +} diff --git a/packages/use-shader-fx/types/materials/core/FxMaterial.d.ts b/packages/use-shader-fx/types/materials/core/FxMaterial.d.ts new file mode 100644 index 00000000..42aa690f --- /dev/null +++ b/packages/use-shader-fx/types/materials/core/FxMaterial.d.ts @@ -0,0 +1,38 @@ +import * as THREE from "three"; +import { ShaderWithUniforms } from "../../shaders/uniformsUtils"; +export type DefaultUniforms = { + resolution: { + value: THREE.Vector2; + }; + texelSize: { + value: THREE.Vector2; + }; + aspectRatio: { + value: number; + }; + maxAspect: { + value: THREE.Vector2; + }; + renderCount: { + value: number; + }; +}; +export type FxMaterialProps = { + uniformValues?: T; + materialParameters?: THREE.ShaderMaterialParameters; + customParameters?: { + [key: string]: any; + }; +} & ShaderWithUniforms; +export declare class FxMaterial extends THREE.ShaderMaterial { + static readonly key: string; + constructor({ uniformValues, materialParameters, uniforms, vertexShader, fragmentShader, }?: FxMaterialProps); + /** This is updated in useFxScene */ + updateResolution(width: number, height: number): void; + protected _setupShaders(vertexShader?: string, fragmentShader?: string): void; + setUniformValues(values?: { + [key: string]: any; + }): Record | undefined; + /** define getter/setters　*/ + protected _defineUniformAccessors(onSet?: () => void): void; +} diff --git a/packages/use-shader-fx/types/materials/core/SamplingFxMaterial.d.ts b/packages/use-shader-fx/types/materials/core/SamplingFxMaterial.d.ts new file mode 100644 index 00000000..4c0da789 --- /dev/null +++ b/packages/use-shader-fx/types/materials/core/SamplingFxMaterial.d.ts @@ -0,0 +1,39 @@ +import * as THREE from "three"; +import { FxMaterialProps } from "./FxMaterial"; +import { NestUniformValues, UniformParentKey } from "../../shaders/uniformsUtils"; +import { BasicFxMaterial } from "./BasicFxMaterial"; +import * as BasicFxLib from "./BasicFxLib"; +type SamplingFxUniformsUnique = { + texture: { + value: UniformParentKey; + }; + texture_src: { + value: THREE.Texture; + }; + texture_fit: { + value: BasicFxLib.FitType; + }; +}; +export type SamplingFxUniforms = SamplingFxUniformsUnique & BasicFxLib.BasicFxUniforms; +export type SamplingFxValues = NestUniformValues; +/** + * SamplingFxMaterialでは常にtextureはtrueであるはずなので、BasicFxMaterialを継承して、srcSystemは常にtrueになるように、継承する + */ +export declare class SamplingFxMaterial extends BasicFxMaterial { + uniforms: SamplingFxUniforms; + constructor({ uniforms, ...rest }: FxMaterialProps); + protected _handleMergeShaderLib(vertexShader?: string, fragmentShader?: string): [string | undefined, string | undefined]; + protected _isContainsBasicFxValues(values?: { + [key: string]: any; + }): boolean; + protected _updateFitScale(): void; + protected _setupFxKey(uniforms: BasicFxLib.BasicFxUniforms): BasicFxLib.FxKey; + protected _handleUpdateFxShaders(): { + diffCount: number; + newFxKey: BasicFxLib.FxKey; + }; + protected _handleUpdateFxDefines(): { + [key: string]: any; + }; +} +export {}; diff --git a/packages/use-shader-fx/types/materials/impl/blank/BlankMaterial.d.ts b/packages/use-shader-fx/types/materials/impl/blank/BlankMaterial.d.ts new file mode 100644 index 00000000..1d2f0314 --- /dev/null +++ b/packages/use-shader-fx/types/materials/impl/blank/BlankMaterial.d.ts @@ -0,0 +1,19 @@ +import * as THREE from "three"; +import { DefaultUniforms, FxMaterial, FxMaterialProps } from "../../core/FxMaterial"; +type BlankUniforms = { + time: { + value: number; + }; + pointer: { + value: THREE.Vector2; + }; + backbuffer: { + value: THREE.Texture; + }; +} & DefaultUniforms; +export declare class BlankMaterial extends FxMaterial { + static get type(): string; + uniforms: BlankUniforms; + constructor({ vertexShader, fragmentShader, uniforms, ...rest }: FxMaterialProps); +} +export {}; diff --git a/packages/use-shader-fx/types/materials/impl/buffer/BufferMaterial.d.ts b/packages/use-shader-fx/types/materials/impl/buffer/BufferMaterial.d.ts new file mode 100644 index 00000000..59affdda --- /dev/null +++ b/packages/use-shader-fx/types/materials/impl/buffer/BufferMaterial.d.ts @@ -0,0 +1,23 @@ +import { SamplingFxUniforms, SamplingFxValues, SamplingFxMaterial } from "../../core/SamplingFxMaterial"; +import { FxMaterialProps } from "../../core/FxMaterial"; +import { ExtractUniformValues, NestUniformValues } from "../../../shaders/uniformsUtils"; +type BufferUniforms = SamplingFxUniforms; +export type BufferValues = NestUniformValues & SamplingFxValues; +export type BufferMaterialProps = ExtractUniformValues; +export declare class BufferMaterial extends SamplingFxMaterial { + static readonly key: string; + static get type(): string; + uniforms: BufferUniforms; + constructor(props?: FxMaterialProps); +} +declare global { + namespace JSX { + interface IntrinsicElements { + bufferMaterial: BufferMaterialProps & { + ref?: React.RefObject; + key?: React.Key; + }; + } + } +} +export {}; diff --git a/packages/use-shader-fx/types/materials/impl/fluid/AdvectionMaterial.d.ts b/packages/use-shader-fx/types/materials/impl/fluid/AdvectionMaterial.d.ts new file mode 100644 index 00000000..ffce3720 --- /dev/null +++ b/packages/use-shader-fx/types/materials/impl/fluid/AdvectionMaterial.d.ts @@ -0,0 +1,22 @@ +import * as THREE from "three"; +import { FxMaterial, FxMaterialProps } from "../../../materials/core/FxMaterial"; +import { NestUniformValues } from "../../../shaders/uniformsUtils"; +type AdvectionUniforms = { + dissipation: { + value: number; + }; + deltaTime: { + value: number; + }; + velocity: { + value: THREE.Texture; + }; +}; +export type AdvectionValues = NestUniformValues; +export type AdvectionValuesClient = Omit; +export declare class AdvectionMaterial extends FxMaterial { + static get type(): string; + uniforms: AdvectionUniforms; + constructor(props: FxMaterialProps); +} +export {}; diff --git a/packages/use-shader-fx/types/materials/impl/fluid/DivergenceMaterial.d.ts b/packages/use-shader-fx/types/materials/impl/fluid/DivergenceMaterial.d.ts new file mode 100644 index 00000000..90770150 --- /dev/null +++ b/packages/use-shader-fx/types/materials/impl/fluid/DivergenceMaterial.d.ts @@ -0,0 +1,22 @@ +import * as THREE from "three"; +import { FxMaterial, FxMaterialProps } from "../../../materials/core/FxMaterial"; +import { NestUniformValues } from "../../../shaders/uniformsUtils"; +type DivergenceUniforms = { + bounce: { + value: boolean; + }; + deltaTime: { + value: number; + }; + velocity: { + value: THREE.Texture; + }; +}; +export type DivergenceValues = NestUniformValues; +export type DivergenceValuesClient = Omit; +export declare class DivergenceMaterial extends FxMaterial { + static get type(): string; + uniforms: DivergenceUniforms; + constructor(props: FxMaterialProps); +} +export {}; diff --git a/packages/use-shader-fx/types/materials/impl/fluid/OutputMaterial.d.ts b/packages/use-shader-fx/types/materials/impl/fluid/OutputMaterial.d.ts new file mode 100644 index 00000000..a3cb78c0 --- /dev/null +++ b/packages/use-shader-fx/types/materials/impl/fluid/OutputMaterial.d.ts @@ -0,0 +1,17 @@ +import * as THREE from "three"; +import { FxMaterialProps } from "../../core/FxMaterial"; +import { BasicFxUniforms, BasicFxValues } from "../../core/BasicFxLib"; +import { BasicFxMaterial } from "../../core/BasicFxMaterial"; +import { NestUniformValues } from "../../../shaders/uniformsUtils"; +type OutputUniforms = { + src: { + value: THREE.Texture; + }; +} & BasicFxUniforms; +export type OutputValues = NestUniformValues & BasicFxValues; +export declare class OutputMaterial extends BasicFxMaterial { + static get type(): string; + uniforms: OutputUniforms; + constructor(props?: FxMaterialProps); +} +export {}; diff --git a/packages/use-shader-fx/types/materials/impl/fluid/PoissonMaterial.d.ts b/packages/use-shader-fx/types/materials/impl/fluid/PoissonMaterial.d.ts new file mode 100644 index 00000000..86eeb9d4 --- /dev/null +++ b/packages/use-shader-fx/types/materials/impl/fluid/PoissonMaterial.d.ts @@ -0,0 +1,23 @@ +import * as THREE from "three"; +import { FxMaterial, FxMaterialProps } from "../../../materials/core/FxMaterial"; +import { NestUniformValues } from "../../../shaders/uniformsUtils"; +type PoissonUniforms = { + bounce: { + value: boolean; + }; + pressure: { + value: THREE.Texture; + }; + divergence: { + value: THREE.Texture; + }; +}; +export type PoissonValues = NestUniformValues; +export type PoissonValuesClient = Omit; +export declare class PoissonMaterial extends FxMaterial { + static get type(): string; + uniforms: PoissonUniforms; + iterations: number; + constructor({ customParameters, ...rest }: FxMaterialProps); +} +export {}; diff --git a/packages/use-shader-fx/types/materials/impl/fluid/PressureMaterial.d.ts b/packages/use-shader-fx/types/materials/impl/fluid/PressureMaterial.d.ts new file mode 100644 index 00000000..07632ba1 --- /dev/null +++ b/packages/use-shader-fx/types/materials/impl/fluid/PressureMaterial.d.ts @@ -0,0 +1,25 @@ +import * as THREE from "three"; +import { FxMaterial, FxMaterialProps } from "../../../materials/core/FxMaterial"; +import { NestUniformValues } from "../../../shaders/uniformsUtils"; +type PressureUniforms = { + bounce: { + value: boolean; + }; + deltaTime: { + value: number; + }; + pressure: { + value: THREE.Texture; + }; + velocity: { + value: THREE.Texture; + }; +}; +export type PressureValues = NestUniformValues; +export type PressureValuesClient = Omit; +export declare class PressureMaterial extends FxMaterial { + static get type(): string; + uniforms: PressureUniforms; + constructor(props: FxMaterialProps); +} +export {}; diff --git a/packages/use-shader-fx/types/materials/impl/fluid/SplatMaterial.d.ts b/packages/use-shader-fx/types/materials/impl/fluid/SplatMaterial.d.ts new file mode 100644 index 00000000..0981d591 --- /dev/null +++ b/packages/use-shader-fx/types/materials/impl/fluid/SplatMaterial.d.ts @@ -0,0 +1,25 @@ +import * as THREE from "three"; +import { FxMaterial, FxMaterialProps } from "../../../materials/core/FxMaterial"; +import { NestUniformValues } from "../../../shaders/uniformsUtils"; +type SplatUniforms = { + forceBias: { + value: number; + }; + radius: { + value: THREE.Vector2; + }; + force: { + value: THREE.Vector2; + }; + center: { + value: THREE.Vector2; + }; +}; +export type SplatValues = NestUniformValues; +export type SplatValuesClient = Omit; +export declare class SplatMaterial extends FxMaterial { + static get type(): string; + uniforms: SplatUniforms; + constructor(props: FxMaterialProps); +} +export {}; diff --git a/packages/use-shader-fx/types/materials/impl/fluid/index.d.ts b/packages/use-shader-fx/types/materials/impl/fluid/index.d.ts new file mode 100644 index 00000000..99569454 --- /dev/null +++ b/packages/use-shader-fx/types/materials/impl/fluid/index.d.ts @@ -0,0 +1,7 @@ +export * from "./AdvectionMaterial"; +export * from "./DivergenceMaterial"; +export * from "./PressureMaterial"; +export * from "./PoissonMaterial"; +export * from "./SplatMaterial"; +export * from "./OutputMaterial"; +export const DELTA_TIME: 0.008; diff --git a/packages/use-shader-fx/types/materials/impl/fluid/shaders/vertex.d.ts b/packages/use-shader-fx/types/materials/impl/fluid/shaders/vertex.d.ts new file mode 100644 index 00000000..17a40e45 --- /dev/null +++ b/packages/use-shader-fx/types/materials/impl/fluid/shaders/vertex.d.ts @@ -0,0 +1,7 @@ +declare const vertex: { + main: string; + poisson: string; + advection: string; + splat: string; +}; +export default vertex; diff --git a/packages/use-shader-fx/types/materials/impl/grid/GridMaterial.d.ts b/packages/use-shader-fx/types/materials/impl/grid/GridMaterial.d.ts new file mode 100644 index 00000000..e5a1315c --- /dev/null +++ b/packages/use-shader-fx/types/materials/impl/grid/GridMaterial.d.ts @@ -0,0 +1,50 @@ +import * as THREE from "three"; +import { SamplingFxUniforms, SamplingFxValues, SamplingFxMaterial } from "../../core/SamplingFxMaterial"; +import { FxMaterialProps } from "../../core/FxMaterial"; +import { ExtractUniformValues, NestUniformValues, UniformParentKey } from "../../../shaders/uniformsUtils"; +type GridUniforms = { + /** グリッドのマス数 */ + count: { + value: THREE.Vector2; + }; + /** 自動で画面のアスペクト比に合わせて正方形にscaleする */ + autoScale: { + value: boolean; + }; + /** tick */ + tick: { + value: number; + }; + shuffle: { + value: UniformParentKey; + }; + shuffle_frequency: { + value: number; + }; + shuffle_range: { + value: number; + }; + /** スプライトテクスチャ */ + sprite: { + value: UniformParentKey; + }; + sprite_src: { + value: THREE.Texture; + }; + sprite_length: { + value: number; + }; + sprite_shuffleSpeed: { + value: number; + }; +} & SamplingFxUniforms; +export type GridValues = NestUniformValues & SamplingFxValues; +export type GridMaterialProps = ExtractUniformValues; +export declare class GridMaterial extends SamplingFxMaterial { + static get type(): string; + uniforms: GridUniforms; + constructor(props: FxMaterialProps); + /** When gridding with floor, you must use NearestFilter. */ + setNearestFilter(): void; +} +export {}; diff --git a/packages/use-shader-fx/types/materials/impl/grid/grid.glsl.d.ts b/packages/use-shader-fx/types/materials/impl/grid/grid.glsl.d.ts new file mode 100644 index 00000000..140a494f --- /dev/null +++ b/packages/use-shader-fx/types/materials/impl/grid/grid.glsl.d.ts @@ -0,0 +1,2 @@ +export declare const gridVertex: string; +export declare const gridFragment: string; diff --git a/packages/use-shader-fx/types/materials/impl/noise/NoiseMaterial.d.ts b/packages/use-shader-fx/types/materials/impl/noise/NoiseMaterial.d.ts new file mode 100644 index 00000000..3354cb65 --- /dev/null +++ b/packages/use-shader-fx/types/materials/impl/noise/NoiseMaterial.d.ts @@ -0,0 +1,52 @@ +import * as THREE from "three"; +import { BasicFxMaterial } from "../../core/BasicFxMaterial"; +import { FxMaterialProps } from "../../core/FxMaterial"; +import { BasicFxUniforms, BasicFxValues } from "../../core/BasicFxLib"; +import { ExtractUniformValues, NestUniformValues } from "../../../shaders/uniformsUtils"; +type NoiseUniforms = { + /** useBeatを渡せば、リズムを変えられる。 */ + tick: { + value: number; + }; + /** noise scale , default : `0.004` */ + scale: { + value: number; + }; + /** time factor default : `0.3` */ + timeStrength: { + value: number; + }; + /** noiseOctaves, affects performance default : `2` */ + noiseOctaves: { + value: number; + }; + /** fbmOctaves, affects performance default : `2` */ + fbmOctaves: { + value: number; + }; + /** domain warping octaves , affects performance default : `2` */ + warpOctaves: { + value: number; + }; + /** direction of domain warping , default : `(2.0,2,0)` */ + warpDirection: { + value: THREE.Vector2; + }; + /** strength of domain warping , default : `8.0` */ + warpStrength: { + value: number; + }; + /** offset of the time */ + timeOffset: { + value: number; + }; +} & BasicFxUniforms; +export type NoiseValues = NestUniformValues & BasicFxValues; +export type NoiseMaterialProps = ExtractUniformValues; +export declare class NoiseMaterial extends BasicFxMaterial { + static readonly key: string; + static get type(): string; + uniforms: NoiseUniforms; + constructor(props?: FxMaterialProps); +} +export {}; diff --git a/packages/use-shader-fx/types/materials/impl/noise/noise.glsl.d.ts b/packages/use-shader-fx/types/materials/impl/noise/noise.glsl.d.ts new file mode 100644 index 00000000..cfda7664 --- /dev/null +++ b/packages/use-shader-fx/types/materials/impl/noise/noise.glsl.d.ts @@ -0,0 +1,2 @@ +export declare const noiseVertex: string; +export declare const noiseFragment: string; diff --git a/packages/use-shader-fx/types/materials/impl/rawBlank/RawBlankMaterial.d.ts b/packages/use-shader-fx/types/materials/impl/rawBlank/RawBlankMaterial.d.ts new file mode 100644 index 00000000..e7ca57ea --- /dev/null +++ b/packages/use-shader-fx/types/materials/impl/rawBlank/RawBlankMaterial.d.ts @@ -0,0 +1,5 @@ +import { FxMaterial, FxMaterialProps } from "../../core/FxMaterial"; +export declare class RawBlankMaterial extends FxMaterial { + static get type(): string; + constructor(props: FxMaterialProps); +} diff --git a/packages/use-shader-fx/types/materials/index.d.ts b/packages/use-shader-fx/types/materials/index.d.ts new file mode 100644 index 00000000..628a12fb --- /dev/null +++ b/packages/use-shader-fx/types/materials/index.d.ts @@ -0,0 +1,7 @@ +export * from "./core/BasicFxLib"; +export * from "./impl/noise/NoiseMaterial"; +export * from "./impl/buffer/BufferMaterial"; +export * from "./impl/rawBlank/RawBlankMaterial"; +export * from "./impl/blank/BlankMaterial"; +export * from "./impl/grid/GridMaterial"; +export * as FluidMaterials from "./impl/fluid"; diff --git a/packages/use-shader-fx/types/misc/index.d.ts b/packages/use-shader-fx/types/misc/index.d.ts new file mode 100644 index 00000000..be8693c0 --- /dev/null +++ b/packages/use-shader-fx/types/misc/index.d.ts @@ -0,0 +1,3 @@ +export * from "./useBeat"; +export * from "./usePointerTracker"; +export * from "./useWindowPointer"; diff --git a/packages/use-shader-fx/types/misc/useBeat.d.ts b/packages/use-shader-fx/types/misc/useBeat.d.ts new file mode 100644 index 00000000..aaf65a33 --- /dev/null +++ b/packages/use-shader-fx/types/misc/useBeat.d.ts @@ -0,0 +1,14 @@ +import * as THREE from "three"; +import { EasingTypes } from "../libs/Easings"; +type BeatValues = { + beat: number; + floor: number; + fract: number; + /** unique hash specific to the beat */ + hash: number; +}; +/** + * @param ease easing functions are referenced from https://github.com/ai/easings.net , default : "easeOutQuart" + */ +export declare const useBeat: (bpm: number, ease?: EasingTypes) => (clock: THREE.Clock) => BeatValues; +export {}; diff --git a/packages/use-shader-fx/types/misc/usePipeline.d.ts b/packages/use-shader-fx/types/misc/usePipeline.d.ts new file mode 100644 index 00000000..e69de29b diff --git a/packages/use-shader-fx/types/misc/usePointerTracker.d.ts b/packages/use-shader-fx/types/misc/usePointerTracker.d.ts new file mode 100644 index 00000000..044f339e --- /dev/null +++ b/packages/use-shader-fx/types/misc/usePointerTracker.d.ts @@ -0,0 +1,16 @@ +import * as THREE from "three"; +export type PointerValues = { + currentPointer: THREE.Vector2; + prevPointer: THREE.Vector2; + diffPointer: THREE.Vector2; + velocity: THREE.Vector2; + isVelocityUpdate: boolean; +}; +type PointerTracker = (currentPointer: THREE.Vector2) => PointerValues; +/** + * @description When given the pointer vector2 from r3f's RootState, it generates an update function that returns {`currentPointer`, `prevPointer`, `diffPointer`, `isVelocityUpdate`, `velocity`}. + * @description When calling custom in a `useFrame` loop, you can avoid duplication of execution by passing `pointerValues` to the update function of a Pointer-activated fxHook, such as `useBrush`. + * @param lerp 0~1, lerp intensity (0 to less than 1) , default : `0` + */ +export declare const usePointerTracker: (lerp?: number) => PointerTracker; +export {}; diff --git a/packages/use-shader-fx/types/misc/useWindowPointer.d.ts b/packages/use-shader-fx/types/misc/useWindowPointer.d.ts new file mode 100644 index 00000000..57548c1e --- /dev/null +++ b/packages/use-shader-fx/types/misc/useWindowPointer.d.ts @@ -0,0 +1,7 @@ +import * as THREE from "three"; +import { Size } from "../hooks/types"; +/** + * @param size Size + * @returns THREE.Vector2 + */ +export declare const useWindowPointer: (size: Size) => THREE.Vector2; diff --git a/packages/use-shader-fx/types/shaders/ShaderChunk.d.ts b/packages/use-shader-fx/types/shaders/ShaderChunk.d.ts new file mode 100644 index 00000000..c684c808 --- /dev/null +++ b/packages/use-shader-fx/types/shaders/ShaderChunk.d.ts @@ -0,0 +1,4 @@ +export type ShaderChunkTypes = "default_pars_fragment" | "srcSystem_pars_vertex" | "srcSystem_pars_fragment" | "default_pars_vertex" | "default_vertex" | "plane_vertex" | "mixSrc_fragment_begin" | "mixSrc_fragment_end" | "mixSrc_pars_fragment" | "mixSrc_pars_vertex" | "mixSrc_vertex" | "mixDst_fragment" | "mixDst_pars_fragment" | "mixDst_pars_vertex" | "mixDst_vertex" | "texture_pars_fragment" | "texture_pars_vertex" | "texture_vertex" | "adjustments_fragment" | "adjustments_pars_fragment" | "calcSrcUv"; +export declare const ShaderChunk: { + [K in ShaderChunkTypes]: string; +}; diff --git a/packages/use-shader-fx/types/shaders/ShaderLib.d.ts b/packages/use-shader-fx/types/shaders/ShaderLib.d.ts new file mode 100644 index 00000000..df2c3e68 --- /dev/null +++ b/packages/use-shader-fx/types/shaders/ShaderLib.d.ts @@ -0,0 +1,4 @@ +export type ShaderLibTypes = "plane_vertex" | "default_vertex" | "default_pars_vertex" | "default_pars_fragment" | "basicFx_vertex" | "basicFx_pars_vertex" | "basicFx_pars_fragment" | "basicFx_fragment_begin" | "basicFx_fragment_end" | "samplingFx_vertex" | "samplingFx_pars_vertex" | "samplingFx_pars_fragment"; +export declare const ShaderLib: { + [K in ShaderLibTypes]: string; +}; diff --git a/packages/use-shader-fx/types/shaders/shaderUtils.d.ts b/packages/use-shader-fx/types/shaders/shaderUtils.d.ts new file mode 100644 index 00000000..a5d8c3c5 --- /dev/null +++ b/packages/use-shader-fx/types/shaders/shaderUtils.d.ts @@ -0,0 +1,10 @@ +/** merge shader codes */ +export declare function mergeShaderCode(prefix: string[]): string; +export type ShaderLibType = "default" | "basicFx" | "samplingFx"; +/** + * merge ShaderLib to shader + * basicFx_fragment_begin, basicFx_fragment_endは含まない。これらは各FXでカスタマイズする必要があるため。 + */ +export declare function mergeShaderLib(vertexShader: string | undefined, fragmentShader: string | undefined, type: ShaderLibType): [string | undefined, string | undefined]; +/** Resolve Includes */ +export declare function resolveIncludes(string: string): string; diff --git a/packages/use-shader-fx/types/shaders/uniformsUtils.d.ts b/packages/use-shader-fx/types/shaders/uniformsUtils.d.ts new file mode 100644 index 00000000..3ebb851a --- /dev/null +++ b/packages/use-shader-fx/types/shaders/uniformsUtils.d.ts @@ -0,0 +1,39 @@ +import * as THREE from "three"; +export type Uniforms = { + [uniform: string]: THREE.IUniform; +}; +/** typescriptトリックで{}を許容しているが、実際にuniformに渡る際にはbooleanのみ */ +export type UniformParentKey = boolean | {}; +export type ShaderWithUniforms = { + uniforms?: Uniforms; + vertexShader?: string; + fragmentShader?: string; +}; +/** + * test:{value:number} => test:number + * materialのprops型を定義する + * materialにはuniformsのsetter/getterが定義されている.その型推論のため. + */ +export type ExtractUniformValues = { + [K in keyof T]?: T[K] extends { + value: infer U; + } ? U : never; +}; +/** + * test_test:{value:number} => { test: { test: number | (value:number)=>number } } + */ +type Nest = K extends `${infer First}_${infer Rest}` ? { + [P in First]?: Nest; +} : { + [P in K]?: V | ((value: V) => V); +}; +type UnionToIntersection = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never; +export type NestUniformValues = UnionToIntersection<{ + [K in keyof U]: Nest, U[K]["value"]>; +}[keyof U]>; +/** + * {test:{test:1}} => {test_test:1} に変換する + * この時、条件分岐用uniform値として親のkey{test:true}を追加する + */ +export declare function flattenUniformValues(obj: Record): Record; +export {}; diff --git a/packages/use-shader-fx/types/utils/getDpr.d.ts b/packages/use-shader-fx/types/utils/getDpr.d.ts new file mode 100644 index 00000000..57928b5c --- /dev/null +++ b/packages/use-shader-fx/types/utils/getDpr.d.ts @@ -0,0 +1,5 @@ +import { Dpr } from "../hooks/types"; +export declare const getDpr: (dpr: Dpr) => { + shader: number | false; + fbo: number | false; +}; diff --git a/packages/use-shader-fx/types/utils/index.d.ts b/packages/use-shader-fx/types/utils/index.d.ts new file mode 100644 index 00000000..ea3c69bb --- /dev/null +++ b/packages/use-shader-fx/types/utils/index.d.ts @@ -0,0 +1,8 @@ +export * from "./getDpr"; +export * from "./useCamera"; +export * from "./useDoubleFBO"; +export * from "./useSetup"; +export * from "./useMutableState"; +export * from "./useResolution"; +export * from "./useSingleFBO"; +export * from "./warn"; diff --git a/packages/use-shader-fx/types/utils/useCamera.d.ts b/packages/use-shader-fx/types/utils/useCamera.d.ts new file mode 100644 index 00000000..fa71d56d --- /dev/null +++ b/packages/use-shader-fx/types/utils/useCamera.d.ts @@ -0,0 +1,3 @@ +import * as THREE from "three"; +import { Size } from "../hooks/types"; +export declare const useCamera: (size: Size, cameraType?: "OrthographicCamera" | "PerspectiveCamera") => THREE.OrthographicCamera | THREE.PerspectiveCamera; diff --git a/packages/use-shader-fx/types/utils/useDoubleFBO.d.ts b/packages/use-shader-fx/types/utils/useDoubleFBO.d.ts new file mode 100644 index 00000000..5d20c0b6 --- /dev/null +++ b/packages/use-shader-fx/types/utils/useDoubleFBO.d.ts @@ -0,0 +1,25 @@ +import * as THREE from "three"; +import { UseFboProps, RenderProps } from "./useSingleFBO"; +export type DoubleRenderTarget = { + read: THREE.WebGLRenderTarget; + write: THREE.WebGLRenderTarget; +}; +export type DoubleFBOUpdateFunction = (renderProps: RenderProps, +/** call before FBO is rendered */ +onBeforeRender?: ({ read, write, }: { + read: THREE.Texture; + write: THREE.Texture; +}) => void) => THREE.Texture; +type UseDoubleFBOReturn = [ + { + read: THREE.WebGLRenderTarget; + write: THREE.WebGLRenderTarget; + }, + DoubleFBOUpdateFunction +]; +/** + * @description Custom hook for setting up double buffering with WebGL render targets. + * @param UseFboProps same as `useSingleFBO` + */ +export declare const useDoubleFBO: (props: UseFboProps) => UseDoubleFBOReturn; +export {}; diff --git a/packages/use-shader-fx/types/utils/useMutableState.d.ts b/packages/use-shader-fx/types/utils/useMutableState.d.ts new file mode 100644 index 00000000..c3f3a3d1 --- /dev/null +++ b/packages/use-shader-fx/types/utils/useMutableState.d.ts @@ -0,0 +1 @@ +export declare const useMutableState: (state: S) => readonly [import("react").MutableRefObject, (value: S | ((prevState: S) => S)) => void]; diff --git a/packages/use-shader-fx/types/utils/useObject3D.d.ts b/packages/use-shader-fx/types/utils/useObject3D.d.ts new file mode 100644 index 00000000..952c7870 --- /dev/null +++ b/packages/use-shader-fx/types/utils/useObject3D.d.ts @@ -0,0 +1,7 @@ +import * as THREE from "three"; +type Object3DConstructor = new (geometry: THREE.BufferGeometry, material: M) => T; +/** + * Add geometry and material to Object3D and add them to scene. + */ +export declare const useObject3D: (scene: THREE.Scene | false, geometry: THREE.BufferGeometry, material: M, Proto: Object3DConstructor) => T; +export {}; diff --git a/packages/use-shader-fx/types/utils/useResolution.d.ts b/packages/use-shader-fx/types/utils/useResolution.d.ts new file mode 100644 index 00000000..ed8a5984 --- /dev/null +++ b/packages/use-shader-fx/types/utils/useResolution.d.ts @@ -0,0 +1,6 @@ +import * as THREE from "three"; +import { Size } from "../hooks/types"; +/** + * @params dpr if dpr is set, it returns the resolution which is size multiplied by dpr. + */ +export declare const useResolution: (size: Size, dpr?: number | false) => THREE.Vector2; diff --git a/packages/use-shader-fx/types/utils/useSetup.d.ts b/packages/use-shader-fx/types/utils/useSetup.d.ts new file mode 100644 index 00000000..633c63c7 --- /dev/null +++ b/packages/use-shader-fx/types/utils/useSetup.d.ts @@ -0,0 +1,20 @@ +import * as THREE from "three"; +import { Size } from "../hooks/types"; +import { FxMaterial, FxMaterialProps } from "../materials/core/FxMaterial"; +type MaterialConstructor = new (props: FxMaterialProps) => M; +type GeometryConstructor = new (width: number, height: number) => THREE.BufferGeometry; +export declare const useSetup: ({ size, dpr, material, geometry, geometrySize, ...materialProps }: { + size: Size; + dpr: number | false; + material: MaterialConstructor; + geometry?: GeometryConstructor; + geometrySize?: { + width: number; + height: number; + }; +} & FxMaterialProps) => { + scene: THREE.Scene; + material: M; + camera: THREE.OrthographicCamera | THREE.PerspectiveCamera; +}; +export {}; diff --git a/packages/use-shader-fx/types/utils/useSingleFBO.d.ts b/packages/use-shader-fx/types/utils/useSingleFBO.d.ts new file mode 100644 index 00000000..0cc43a84 --- /dev/null +++ b/packages/use-shader-fx/types/utils/useSingleFBO.d.ts @@ -0,0 +1,39 @@ +import * as THREE from "three"; +import { Size } from "../hooks/types"; +export declare const FBO_DEFAULT_OPTION: THREE.RenderTargetOptions; +export type UseFboProps = { + scene?: THREE.Scene; + camera?: THREE.Camera; + size: Size; + /** If dpr is set, dpr will be multiplied, default : `false` */ + dpr?: number | false; + /** Whether to resize when resizing occurs. If isDpr is true, set FBO to setSize even if dpr is changed, default : `false` */ + fboAutoSetSize?: boolean; + /** If set, the scene depth will be rendered into buffer.depthTexture. default : `false` */ + depth?: boolean; +} & THREE.RenderTargetOptions; +export type RenderProps = { + gl: THREE.WebGLRenderer; + scene?: THREE.Scene; + camera?: THREE.Camera; + clear?: boolean; +}; +export declare const renderFBO: ({ gl, fbo, scene, camera, clear, onBeforeRender, onSwap, }: { + fbo: THREE.WebGLRenderTarget; + onBeforeRender: () => void; + onSwap?: () => void; +} & RenderProps) => void; +export type SingleFBOUpdateFunction = (renderProps: RenderProps, +/** call before FBO is rendered */ +onBeforeRender?: ({ read }: { + read: THREE.Texture; +}) => void) => THREE.Texture; +type UseSingleFBOReturn = [THREE.WebGLRenderTarget, SingleFBOUpdateFunction]; +/** + * @param dpr If dpr is set, dpr will be multiplied, default:false + * @param fboAutoSetSize Whether to resize when resizing occurs. If isDpr is true, set FBO to setSize even if dpr is changed, default:false + * @param depthBuffer Unlike the default in three.js, the default is `false`. + * @returns [THREE.WebGLRenderTarget , updateFBO] -Receives the RenderTarget as the first argument and the update function as the second argument. + */ +export declare const useSingleFBO: (props: UseFboProps) => UseSingleFBOReturn; +export {}; diff --git a/packages/use-shader-fx/types/utils/warn.d.ts b/packages/use-shader-fx/types/utils/warn.d.ts new file mode 100644 index 00000000..e11ee960 --- /dev/null +++ b/packages/use-shader-fx/types/utils/warn.d.ts @@ -0,0 +1 @@ +export declare const warn: (text: string) => void;