--- title: Nebula Flow description: A breathtaking WebGL space nebula background shader with interactive gravitational swirls and stars density customization. --- ## Installation CLI Manual ```bash npx lightswind@latest add nebula-flow ``` Copy and paste the following code into your project. ```tsx "use client"; import { useEffect, useRef } from "react"; import { useInView } from "framer-motion"; const vertexShaderSource = ` attribute vec4 a_position; void main() { gl_Position = a_position; } `; const fragmentShaderSource = ` precision mediump float; uniform vec2 iResolution; uniform float iTime; uniform vec2 iMouse; uniform float iMouseStrength; // Colors uniform vec3 uColor1; uniform vec3 uColor2; uniform vec3 uColor3; // Configurations uniform float uSpeed; uniform float uScale; uniform float uDensity; uniform float uInteractive; // Hash function float hash(vec2 p) { return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453123); } // 2D Noise float noise(vec2 p) { vec2 i = floor(p); vec2 f = fract(p); vec2 u = f * f * (3.0 - 2.0 * f); return mix(mix(hash(i + vec2(0.0,0.0)), hash(i + vec2(1.0,0.0)), u.x), mix(hash(i + vec2(0.0,1.0)), hash(i + vec2(1.0,1.0)), u.x), u.y); } // Fractal Brownian Motion (FBM) with rotation to create cosmic swirls float fbm(vec2 p) { float value = 0.0; float amplitude = 0.55; float frequency = 1.0; mat2 rot = mat2(0.8, 0.6, -0.6, 0.8); for (int i = 0; i < 5; i++) { value += amplitude * noise(p * frequency); p = rot * p; frequency *= 2.0; amplitude *= 0.5; } return value; } void mainImage(out vec4 fragColor, in vec2 fragCoord) { vec2 uv = fragCoord.xy / iResolution.xy; vec2 p = (2.0 * fragCoord.xy - iResolution.xy) / min(iResolution.x, iResolution.y); // Smooth interactive mouse gravity / swirl force vec2 mouseUV = (2.0 * iMouse - iResolution.xy) / min(iResolution.x, iResolution.y); float mouseDist = length(p - mouseUV); float influence = exp(-mouseDist * mouseDist * 2.5) * iMouseStrength * uInteractive; // Swirl rotation matrix float angle = influence * 2.2 * sin(iTime * 1.2); mat2 swirl = mat2(cos(angle), -sin(angle), sin(angle), cos(angle)); p = swirl * p; // Displace coordinates towards mouse (gravitational pull) p -= (p - mouseUV) * influence * 0.12; // Nebula time flow float t = iTime * uSpeed * 0.15; // Double domain warping FBM to simulate detailed cosmic gas clouds vec2 q = vec2(fbm(p * uScale + vec2(t, t * 0.5)), fbm(p * uScale + vec2(t * 0.2, t))); vec2 r = vec2(fbm(p * uScale + 4.0 * q + vec2(1.7, 9.2) + t * 0.15), fbm(p * uScale + 4.0 * q + vec2(8.3, 2.8) + t * 0.12)); float f = fbm(p * uScale + 4.0 * r); // Interpolate cosmic color gas layers vec3 col = mix(uColor1, uColor2, clamp(f * f * 4.0, 0.0, 1.0)); col = mix(col, uColor3, clamp(length(q), 0.0, 1.0)); // High-energy core highlights (cosmic dust stars) float stars = pow(f, 3.5) * uDensity * 0.75; col += vec3(stars * 1.2, stars * 1.0, stars * 1.3); // Vignette float vignette = 1.0 - dot(uv - 0.5, uv - 0.5) * 1.3; col *= max(0.0, vignette); // Final color grading col = clamp(col, 0.0, 1.0); fragColor = vec4(col, 1.0); } void main() { mainImage(gl_FragColor, gl_FragCoord.xy); } `; export type BlurSize = "none" | "sm" | "md" | "lg" | "xl" | "2xl" | "3xl"; interface NebulaFlowProps { colors?: string[]; speed?: number; scale?: number; density?: number; // Cosmic dust star density factor interactive?: boolean; backdropBlurAmount?: BlurSize; className?: string; } const blurClassMap: Record = { none: "backdrop-blur-none", sm: "backdrop-blur-sm", md: "backdrop-blur-md", lg: "backdrop-blur-lg", xl: "backdrop-blur-xl", "2xl": "backdrop-blur-2xl", "3xl": "backdrop-blur-3xl", }; const hexToRgb = (hex: string): [number, number, number] => { try { const cleaned = hex.replace("#", ""); const num = parseInt(cleaned, 16); return [ ((num >> 16) & 255) / 255, ((num >> 8) & 255) / 255, (num & 255) / 255, ]; } catch { return [0, 0, 0]; } }; const defaultColors = ["#0c061a", "#290d54", "#ec4899"]; // Deep space pink-purple nebula colors const NebulaFlow: React.FC = ({ colors = defaultColors, speed = 1.0, scale = 1.0, density = 1.0, interactive = true, backdropBlurAmount = "none", className = "", }) => { const canvasRef = useRef(null); const containerRef = useRef(null); const isInView = useInView(containerRef); const visibilityRef = useRef(true); // Mouse coords and active strength refs const mouseRef = useRef({ x: 0, y: 0, targetX: 0, targetY: 0 }); const mouseStrengthRef = useRef({ value: 0, targetValue: 0 }); useEffect(() => { visibilityRef.current = isInView; }, [isInView]); useEffect(() => { const canvas = canvasRef.current; if (!canvas) return; // Parse custom colors const colorRGBs: [number, number, number][] = []; const parsed = colors.map(hexToRgb); colorRGBs.push(parsed[0] || [0.0, 0.0, 0.0]); colorRGBs.push(parsed[1] || parsed[0] || [0.0, 0.0, 0.0]); colorRGBs.push(parsed[2] || parsed[1] || parsed[0] || [0.0, 0.0, 0.0]); const gl = canvas.getContext("webgl"); if (!gl) { console.error("WebGL not supported"); return; } const compileShader = (type: number, source: string): WebGLShader | null => { const shader = gl.createShader(type); if (!shader) return null; gl.shaderSource(shader, source); gl.compileShader(shader); if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) { console.error("Shader compilation error:", gl.getShaderInfoLog(shader)); gl.deleteShader(shader); return null; } return shader; }; const vertexShader = compileShader(gl.VERTEX_SHADER, vertexShaderSource); const fragmentShader = compileShader(gl.FRAGMENT_SHADER, fragmentShaderSource); if (!vertexShader || !fragmentShader) return; const program = gl.createProgram(); if (!program) return; gl.attachShader(program, vertexShader); gl.attachShader(program, fragmentShader); gl.linkProgram(program); if (!gl.getProgramParameter(program, gl.LINK_STATUS)) { console.error("Program linking error:", gl.getProgramInfoLog(program)); return; } gl.useProgram(program); const positionBuffer = gl.createBuffer(); gl.bindBuffer(gl.ARRAY_BUFFER, positionBuffer); gl.bufferData( gl.ARRAY_BUFFER, new Float32Array([-1, -1, 1, -1, -1, 1, -1, 1, 1, -1, 1, 1]), gl.STATIC_DRAW ); const positionLocation = gl.getAttribLocation(program, "a_position"); gl.enableVertexAttribArray(positionLocation); gl.vertexAttribPointer(positionLocation, 2, gl.FLOAT, false, 0, 0); const iResolutionLocation = gl.getUniformLocation(program, "iResolution"); const iTimeLocation = gl.getUniformLocation(program, "iTime"); const iMouseLocation = gl.getUniformLocation(program, "iMouse"); const iMouseStrengthLocation = gl.getUniformLocation(program, "iMouseStrength"); const uColor1Location = gl.getUniformLocation(program, "uColor1"); const uColor2Location = gl.getUniformLocation(program, "uColor2"); const uColor3Location = gl.getUniformLocation(program, "uColor3"); const uSpeedLocation = gl.getUniformLocation(program, "uSpeed"); const uScaleLocation = gl.getUniformLocation(program, "uScale"); const uDensityLocation = gl.getUniformLocation(program, "uDensity"); const uInteractiveLocation = gl.getUniformLocation(program, "uInteractive"); // Native mouse and touch listeners const handleMouseMove = (e: MouseEvent) => { if (!interactive) return; const rect = canvas.getBoundingClientRect(); const x = e.clientX - rect.left; const y = rect.height - (e.clientY - rect.top); mouseRef.current.targetX = x; mouseRef.current.targetY = y; }; const handleMouseEnter = () => { if (!interactive) return; mouseStrengthRef.current.targetValue = 1.0; }; const handleMouseLeave = () => { if (!interactive) return; mouseStrengthRef.current.targetValue = 0.0; }; const handleTouchMove = (e: TouchEvent) => { if (!interactive || e.touches.length === 0) return; const rect = canvas.getBoundingClientRect(); const touch = e.touches[0]; const x = touch.clientX - rect.left; const y = rect.height - (touch.clientY - rect.top); mouseRef.current.targetX = x; mouseRef.current.targetY = y; }; const handleTouchStart = (e: TouchEvent) => { if (!interactive) return; mouseStrengthRef.current.targetValue = 1.0; handleTouchMove(e); }; const handleTouchEnd = () => { if (!interactive) return; mouseStrengthRef.current.targetValue = 0.0; }; canvas.addEventListener("mousemove", handleMouseMove); canvas.addEventListener("mouseenter", handleMouseEnter); canvas.addEventListener("mouseleave", handleMouseLeave); canvas.addEventListener("touchstart", handleTouchStart, { passive: true }); canvas.addEventListener("touchmove", handleTouchMove, { passive: true }); canvas.addEventListener("touchend", handleTouchEnd, { passive: true }); let startTime = Date.now(); let animationFrameId: number; const render = () => { if (!visibilityRef.current) { animationFrameId = requestAnimationFrame(render); return; } // Handle resize and match resolution const width = canvas.clientWidth; const height = canvas.clientHeight; if (canvas.width !== width || canvas.height !== height) { canvas.width = width; canvas.height = height; } gl.useProgram(program); gl.viewport(0, 0, width, height); const currentTime = (Date.now() - startTime) / 1000; // Lerp mouse coordinates and strength for smooth momentum const mouse = mouseRef.current; const mouseStrength = mouseStrengthRef.current; mouse.x += (mouse.targetX - mouse.x) * 0.08; mouse.y += (mouse.targetY - mouse.y) * 0.08; mouseStrength.value += (mouseStrength.targetValue - mouseStrength.value) * 0.08; gl.uniform2f(iResolutionLocation, width, height); gl.uniform1f(iTimeLocation, currentTime); gl.uniform2f(iMouseLocation, mouse.x, mouse.y); gl.uniform1f(iMouseStrengthLocation, mouseStrength.value); // Set uniforms gl.uniform3fv(uColor1Location, colorRGBs[0]); gl.uniform3fv(uColor2Location, colorRGBs[1]); gl.uniform3fv(uColor3Location, colorRGBs[2]); gl.uniform1f(uSpeedLocation, speed); gl.uniform1f(uScaleLocation, scale); gl.uniform1f(uDensityLocation, density); gl.uniform1f(uInteractiveLocation, interactive ? 1.0 : 0.0); gl.drawArrays(gl.TRIANGLES, 0, 6); animationFrameId = requestAnimationFrame(render); }; render(); return () => { cancelAnimationFrame(animationFrameId); gl.deleteProgram(program); gl.deleteShader(vertexShader); gl.deleteShader(fragmentShader); gl.deleteBuffer(positionBuffer); canvas.removeEventListener("mousemove", handleMouseMove); canvas.removeEventListener("mouseenter", handleMouseEnter); canvas.removeEventListener("mouseleave", handleMouseLeave); canvas.removeEventListener("touchstart", handleTouchStart); canvas.removeEventListener("touchmove", handleTouchMove); canvas.removeEventListener("touchend", handleTouchEnd); }; }, [colors, speed, scale, density, interactive]); const finalBlurClass = blurClassMap[backdropBlurAmount] || blurClassMap["none"]; return (
); }; export default NebulaFlow; ``` ## Usage ```tsx import NebulaFlow from '@/components/lightswind/nebula-flow'; ``` ```tsx import NebulaFlow from '@/components/lightswind/nebula-flow'; // Basic usage with default pink-purple space theme // Custom space colors and faster speed // Adjust density of cosmic dust stars ```