439 lines
13 KiB
TypeScript
439 lines
13 KiB
TypeScript
import { useEffect, useRef, type CSSProperties } from "react";
|
|
import {
|
|
Clock,
|
|
Mesh,
|
|
OrthographicCamera,
|
|
PlaneGeometry,
|
|
Scene,
|
|
ShaderMaterial,
|
|
SRGBColorSpace,
|
|
Vector2,
|
|
Vector3,
|
|
WebGLRenderer,
|
|
type IUniform,
|
|
} from "three";
|
|
import "./ColorBends.css";
|
|
|
|
/**
|
|
* Fond anime "ColorBends" (React Bits), porte en TypeScript pour le projet.
|
|
*
|
|
* Le rendu est un shader plein ecran : aucune image, aucun appel reseau. Le
|
|
* composant respecte `prefers-reduced-motion` en figeant le shader apres une
|
|
* premiere image, et libere le contexte WebGL au demontage.
|
|
*/
|
|
|
|
const MAX_COLORS = 8;
|
|
|
|
const frag = `
|
|
#define MAX_COLORS ${MAX_COLORS}
|
|
uniform vec2 uCanvas;
|
|
uniform float uTime;
|
|
uniform float uSpeed;
|
|
uniform vec2 uRot;
|
|
uniform int uColorCount;
|
|
uniform vec3 uColors[MAX_COLORS];
|
|
uniform int uTransparent;
|
|
uniform float uScale;
|
|
uniform float uFrequency;
|
|
uniform float uWarpStrength;
|
|
uniform vec2 uPointer;
|
|
uniform float uMouseInfluence;
|
|
uniform float uParallax;
|
|
uniform float uNoise;
|
|
uniform int uIterations;
|
|
uniform float uIntensity;
|
|
uniform float uBandWidth;
|
|
varying vec2 vUv;
|
|
|
|
void main() {
|
|
float t = uTime * uSpeed;
|
|
vec2 p = vUv * 2.0 - 1.0;
|
|
p += uPointer * uParallax * 0.1;
|
|
vec2 rp = vec2(p.x * uRot.x - p.y * uRot.y, p.x * uRot.y + p.y * uRot.x);
|
|
vec2 q = vec2(rp.x * (uCanvas.x / uCanvas.y), rp.y);
|
|
q /= max(uScale, 0.0001);
|
|
q /= 0.5 + 0.2 * dot(q, q);
|
|
q += 0.2 * cos(t) - 7.56;
|
|
vec2 toward = (uPointer - rp);
|
|
q += toward * uMouseInfluence * 0.2;
|
|
|
|
for (int j = 0; j < 5; j++) {
|
|
if (j >= uIterations - 1) break;
|
|
vec2 rr = sin(1.5 * (q.yx * uFrequency) + 2.0 * cos(q * uFrequency));
|
|
q += (rr - q) * 0.15;
|
|
}
|
|
|
|
vec3 col = vec3(0.0);
|
|
float a = 1.0;
|
|
|
|
if (uColorCount > 0) {
|
|
vec2 s = q;
|
|
vec3 sumCol = vec3(0.0);
|
|
float cover = 0.0;
|
|
for (int i = 0; i < MAX_COLORS; ++i) {
|
|
if (i >= uColorCount) break;
|
|
s -= 0.01;
|
|
vec2 r = sin(1.5 * (s.yx * uFrequency) + 2.0 * cos(s * uFrequency));
|
|
float m0 = length(r + sin(5.0 * r.y * uFrequency - 3.0 * t + float(i)) / 4.0);
|
|
float kBelow = clamp(uWarpStrength, 0.0, 1.0);
|
|
float kMix = pow(kBelow, 0.3);
|
|
float gain = 1.0 + max(uWarpStrength - 1.0, 0.0);
|
|
vec2 disp = (r - s) * kBelow;
|
|
vec2 warped = s + disp * gain;
|
|
float m1 = length(warped + sin(5.0 * warped.y * uFrequency - 3.0 * t + float(i)) / 4.0);
|
|
float m = mix(m0, m1, kMix);
|
|
float w = 1.0 - exp(-uBandWidth / exp(uBandWidth * m));
|
|
sumCol += uColors[i] * w;
|
|
cover = max(cover, w);
|
|
}
|
|
col = clamp(sumCol, 0.0, 1.0);
|
|
a = uTransparent > 0 ? cover : 1.0;
|
|
} else {
|
|
vec2 s = q;
|
|
for (int k = 0; k < 3; ++k) {
|
|
s -= 0.01;
|
|
vec2 r = sin(1.5 * (s.yx * uFrequency) + 2.0 * cos(s * uFrequency));
|
|
float m0 = length(r + sin(5.0 * r.y * uFrequency - 3.0 * t + float(k)) / 4.0);
|
|
float kBelow = clamp(uWarpStrength, 0.0, 1.0);
|
|
float kMix = pow(kBelow, 0.3);
|
|
float gain = 1.0 + max(uWarpStrength - 1.0, 0.0);
|
|
vec2 disp = (r - s) * kBelow;
|
|
vec2 warped = s + disp * gain;
|
|
float m1 = length(warped + sin(5.0 * warped.y * uFrequency - 3.0 * t + float(k)) / 4.0);
|
|
float m = mix(m0, m1, kMix);
|
|
col[k] = 1.0 - exp(-uBandWidth / exp(uBandWidth * m));
|
|
}
|
|
a = uTransparent > 0 ? max(max(col.r, col.g), col.b) : 1.0;
|
|
}
|
|
|
|
col *= uIntensity;
|
|
|
|
if (uNoise > 0.0001) {
|
|
float n = fract(sin(dot(gl_FragCoord.xy + vec2(uTime), vec2(12.9898, 78.233))) * 43758.5453123);
|
|
col += (n - 0.5) * uNoise;
|
|
col = clamp(col, 0.0, 1.0);
|
|
}
|
|
|
|
vec3 rgb = (uTransparent > 0) ? col * a : col;
|
|
gl_FragColor = vec4(rgb, a);
|
|
}
|
|
`;
|
|
|
|
const vert = `
|
|
varying vec2 vUv;
|
|
void main() {
|
|
vUv = uv;
|
|
gl_Position = vec4(position, 1.0);
|
|
}
|
|
`;
|
|
|
|
export interface ColorBendsProps {
|
|
className?: string;
|
|
style?: CSSProperties;
|
|
rotation?: number;
|
|
speed?: number;
|
|
colors?: string[];
|
|
transparent?: boolean;
|
|
autoRotate?: number;
|
|
scale?: number;
|
|
frequency?: number;
|
|
warpStrength?: number;
|
|
mouseInfluence?: number;
|
|
parallax?: number;
|
|
noise?: number;
|
|
iterations?: number;
|
|
intensity?: number;
|
|
bandWidth?: number;
|
|
}
|
|
|
|
interface ColorBendsUniforms {
|
|
uCanvas: IUniform<Vector2>;
|
|
uTime: IUniform<number>;
|
|
uSpeed: IUniform<number>;
|
|
uRot: IUniform<Vector2>;
|
|
uColorCount: IUniform<number>;
|
|
uColors: IUniform<Vector3[]>;
|
|
uTransparent: IUniform<number>;
|
|
uScale: IUniform<number>;
|
|
uFrequency: IUniform<number>;
|
|
uWarpStrength: IUniform<number>;
|
|
uPointer: IUniform<Vector2>;
|
|
uMouseInfluence: IUniform<number>;
|
|
uParallax: IUniform<number>;
|
|
uNoise: IUniform<number>;
|
|
uIterations: IUniform<number>;
|
|
uIntensity: IUniform<number>;
|
|
uBandWidth: IUniform<number>;
|
|
}
|
|
|
|
const toVec3 = (hex: string): Vector3 => {
|
|
const value = hex.replace("#", "").trim();
|
|
const channels =
|
|
value.length === 3
|
|
? [
|
|
parseInt(value.slice(0, 1).repeat(2), 16),
|
|
parseInt(value.slice(1, 2).repeat(2), 16),
|
|
parseInt(value.slice(2, 3).repeat(2), 16),
|
|
]
|
|
: [
|
|
parseInt(value.slice(0, 2), 16),
|
|
parseInt(value.slice(2, 4), 16),
|
|
parseInt(value.slice(4, 6), 16),
|
|
];
|
|
return new Vector3(channels[0]! / 255, channels[1]! / 255, channels[2]! / 255);
|
|
};
|
|
|
|
export default function ColorBends({
|
|
className,
|
|
style,
|
|
rotation = 90,
|
|
speed = 0.2,
|
|
colors = [],
|
|
transparent = true,
|
|
autoRotate = 0,
|
|
scale = 1,
|
|
frequency = 1,
|
|
warpStrength = 1,
|
|
mouseInfluence = 1,
|
|
parallax = 0.5,
|
|
noise = 0.15,
|
|
iterations = 1,
|
|
intensity = 1.5,
|
|
bandWidth = 6,
|
|
}: ColorBendsProps) {
|
|
const containerRef = useRef<HTMLDivElement>(null);
|
|
const rendererRef = useRef<WebGLRenderer | null>(null);
|
|
const rafRef = useRef<number | null>(null);
|
|
const renderOnceRef = useRef<(() => void) | null>(null);
|
|
const materialRef = useRef<ShaderMaterial | null>(null);
|
|
const resizeObserverRef = useRef<ResizeObserver | null>(null);
|
|
const rotationRef = useRef(rotation);
|
|
const autoRotateRef = useRef(autoRotate);
|
|
const pointerTargetRef = useRef(new Vector2(0, 0));
|
|
const pointerCurrentRef = useRef(new Vector2(0, 0));
|
|
const pointerSmoothRef = useRef(8);
|
|
|
|
useEffect(() => {
|
|
const container = containerRef.current;
|
|
if (!container) return;
|
|
|
|
let renderer: WebGLRenderer;
|
|
try {
|
|
renderer = new WebGLRenderer({
|
|
antialias: false,
|
|
powerPreference: "high-performance",
|
|
alpha: true,
|
|
});
|
|
} catch {
|
|
// Pas de WebGL (navigateur ancien, materiel bloque) : le fond reste
|
|
// simplement absent, l'ecran et le formulaire continuent de fonctionner.
|
|
return;
|
|
}
|
|
|
|
const scene = new Scene();
|
|
const camera = new OrthographicCamera(-1, 1, 1, -1, 0, 1);
|
|
const geometry = new PlaneGeometry(2, 2);
|
|
const uColors = Array.from({ length: MAX_COLORS }, () => new Vector3(0, 0, 0));
|
|
const material = new ShaderMaterial({
|
|
vertexShader: vert,
|
|
fragmentShader: frag,
|
|
uniforms: {
|
|
uCanvas: { value: new Vector2(1, 1) },
|
|
uTime: { value: 0 },
|
|
uSpeed: { value: speed },
|
|
uRot: { value: new Vector2(1, 0) },
|
|
uColorCount: { value: 0 },
|
|
uColors: { value: uColors },
|
|
uTransparent: { value: transparent ? 1 : 0 },
|
|
uScale: { value: scale },
|
|
uFrequency: { value: frequency },
|
|
uWarpStrength: { value: warpStrength },
|
|
uPointer: { value: new Vector2(0, 0) },
|
|
uMouseInfluence: { value: mouseInfluence },
|
|
uParallax: { value: parallax },
|
|
uNoise: { value: noise },
|
|
uIterations: { value: iterations },
|
|
uIntensity: { value: intensity },
|
|
uBandWidth: { value: bandWidth },
|
|
} satisfies ColorBendsUniforms,
|
|
premultipliedAlpha: true,
|
|
transparent: true,
|
|
});
|
|
materialRef.current = material;
|
|
|
|
const mesh = new Mesh(geometry, material);
|
|
scene.add(mesh);
|
|
|
|
rendererRef.current = renderer;
|
|
renderer.outputColorSpace = SRGBColorSpace;
|
|
renderer.setPixelRatio(Math.min(window.devicePixelRatio || 1, 2));
|
|
renderer.setClearColor(0x000000, transparent ? 0 : 1);
|
|
renderer.domElement.style.width = "100%";
|
|
renderer.domElement.style.height = "100%";
|
|
renderer.domElement.style.display = "block";
|
|
container.appendChild(renderer.domElement);
|
|
|
|
const clock = new Clock();
|
|
const motion = window.matchMedia("(prefers-reduced-motion: reduce)");
|
|
let reducedMotion = motion.matches;
|
|
|
|
const handleResize = () => {
|
|
const width = container.clientWidth || 1;
|
|
const height = container.clientHeight || 1;
|
|
renderer.setSize(width, height, false);
|
|
material.uniforms.uCanvas!.value.set(width, height);
|
|
if (reducedMotion) renderer.render(scene, camera);
|
|
};
|
|
|
|
const renderFrame = () => {
|
|
const delta = clock.getDelta();
|
|
const elapsed = clock.elapsedTime;
|
|
material.uniforms.uTime!.value = elapsed;
|
|
|
|
const degrees = (rotationRef.current % 360) + autoRotateRef.current * elapsed;
|
|
const radians = (degrees * Math.PI) / 180;
|
|
material.uniforms.uRot!.value.set(Math.cos(radians), Math.sin(radians));
|
|
|
|
const current = pointerCurrentRef.current;
|
|
current.lerp(pointerTargetRef.current, Math.min(1, delta * pointerSmoothRef.current));
|
|
material.uniforms.uPointer!.value.copy(current);
|
|
renderer.render(scene, camera);
|
|
};
|
|
renderOnceRef.current = renderFrame;
|
|
|
|
const stop = () => {
|
|
if (rafRef.current !== null) {
|
|
cancelAnimationFrame(rafRef.current);
|
|
rafRef.current = null;
|
|
}
|
|
};
|
|
|
|
const loop = () => {
|
|
renderFrame();
|
|
rafRef.current = requestAnimationFrame(loop);
|
|
};
|
|
|
|
const start = () => {
|
|
if (!reducedMotion && rafRef.current === null) {
|
|
clock.start();
|
|
rafRef.current = requestAnimationFrame(loop);
|
|
}
|
|
};
|
|
|
|
handleResize();
|
|
|
|
if (typeof ResizeObserver !== "undefined") {
|
|
const observer = new ResizeObserver(handleResize);
|
|
observer.observe(container);
|
|
resizeObserverRef.current = observer;
|
|
} else {
|
|
window.addEventListener("resize", handleResize);
|
|
}
|
|
|
|
const handleMotionChange = () => {
|
|
reducedMotion = motion.matches;
|
|
if (reducedMotion) {
|
|
stop();
|
|
renderFrame();
|
|
} else {
|
|
start();
|
|
}
|
|
};
|
|
motion.addEventListener("change", handleMotionChange);
|
|
|
|
if (reducedMotion) renderFrame();
|
|
else start();
|
|
|
|
return () => {
|
|
stop();
|
|
motion.removeEventListener("change", handleMotionChange);
|
|
if (resizeObserverRef.current) resizeObserverRef.current.disconnect();
|
|
else window.removeEventListener("resize", handleResize);
|
|
geometry.dispose();
|
|
material.dispose();
|
|
renderer.dispose();
|
|
renderer.forceContextLoss();
|
|
if (renderer.domElement.parentElement === container) {
|
|
container.removeChild(renderer.domElement);
|
|
}
|
|
materialRef.current = null;
|
|
rendererRef.current = null;
|
|
renderOnceRef.current = null;
|
|
resizeObserverRef.current = null;
|
|
};
|
|
// Les uniformes sont mis a jour par l'effet suivant ; ce premier montage ne
|
|
// depend donc que du conteneur et ne recree jamais le contexte WebGL.
|
|
// eslint-disable-next-line react-hooks/exhaustive-deps
|
|
}, []);
|
|
|
|
useEffect(() => {
|
|
const material = materialRef.current;
|
|
if (!material) return;
|
|
|
|
rotationRef.current = rotation;
|
|
autoRotateRef.current = autoRotate;
|
|
material.uniforms.uSpeed!.value = speed;
|
|
material.uniforms.uScale!.value = scale;
|
|
material.uniforms.uFrequency!.value = frequency;
|
|
material.uniforms.uWarpStrength!.value = warpStrength;
|
|
material.uniforms.uMouseInfluence!.value = mouseInfluence;
|
|
material.uniforms.uParallax!.value = parallax;
|
|
material.uniforms.uNoise!.value = noise;
|
|
material.uniforms.uIterations!.value = iterations;
|
|
material.uniforms.uIntensity!.value = intensity;
|
|
material.uniforms.uBandWidth!.value = bandWidth;
|
|
|
|
const parsed = colors.filter(Boolean).slice(0, MAX_COLORS).map(toVec3);
|
|
const target = material.uniforms.uColors!.value as Vector3[];
|
|
for (let index = 0; index < MAX_COLORS; index += 1) {
|
|
const vector = target[index]!;
|
|
if (index < parsed.length) vector.copy(parsed[index]!);
|
|
else vector.set(0, 0, 0);
|
|
}
|
|
material.uniforms.uColorCount!.value = parsed.length;
|
|
|
|
material.uniforms.uTransparent!.value = transparent ? 1 : 0;
|
|
if (rendererRef.current) rendererRef.current.setClearColor(0x000000, transparent ? 0 : 1);
|
|
|
|
// Sans boucle (prefers-reduced-motion), les uniformes viennent de changer :
|
|
// il faut une image de plus pour que la palette soit réellement appliquée.
|
|
if (rafRef.current === null) renderOnceRef.current?.();
|
|
}, [
|
|
rotation,
|
|
autoRotate,
|
|
speed,
|
|
scale,
|
|
frequency,
|
|
warpStrength,
|
|
mouseInfluence,
|
|
parallax,
|
|
noise,
|
|
iterations,
|
|
intensity,
|
|
bandWidth,
|
|
colors,
|
|
transparent,
|
|
]);
|
|
|
|
useEffect(() => {
|
|
const container = containerRef.current;
|
|
if (!container) return;
|
|
|
|
const handlePointerMove = (event: PointerEvent) => {
|
|
const rect = container.getBoundingClientRect();
|
|
const x = ((event.clientX - rect.left) / (rect.width || 1)) * 2 - 1;
|
|
const y = -(((event.clientY - rect.top) / (rect.height || 1)) * 2 - 1);
|
|
pointerTargetRef.current.set(x, y);
|
|
};
|
|
|
|
// Ecoute au niveau de la fenetre : le fond peut etre recouvert par la
|
|
// coque ou par une carte, et doit reagir quand meme au mouvement.
|
|
window.addEventListener("pointermove", handlePointerMove, { passive: true });
|
|
return () => {
|
|
window.removeEventListener("pointermove", handlePointerMove);
|
|
};
|
|
}, []);
|
|
|
|
return <div ref={containerRef} className={`color-bends-container ${className ?? ""}`} style={style} />;
|
|
}
|