In HTML canvas, make water, and as the cursor moves around, ripples should follow up…
- User
In HTML canvas, make water, and as the cursor moves around, ripples should follow up with the cursor using math and physics to make the ripples realistic-ly waving
- Assistant
Creating realistic water ripples that respond to cursor movements involves simulating wave propagation using mathematical models and rendering them on an HTML
<canvas>. Below, I'll guide you through building such a simulation step by step.Overview
- Canvas Setup: Initialize the HTML
<canvas>element where the simulation will be rendered. - Wave Physics: Use a grid-based approach to simulate wave propagation. We'll model the water surface with a two-dimensional grid where each cell represents the height of the water at that point.
- Ripple Generation: When the cursor moves, we'll introduce disturbances to the grid to create ripples.
- Rendering: Draw the water surface on the canvas based on the current state of the grid.
Step-by-Step Implementation
1. HTML Structure
First, set up a basic HTML structure with a
<canvas>element.<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Water Ripple Simulation</title> <style> body { margin: 0; overflow: hidden; } canvas { display: block; } </style> </head> <body> <canvas id="waterCanvas"></canvas> <script src="waterRipple.js"></script> </body> </html>2. JavaScript Implementation (
waterRipple.js)Now, let's implement the ripple simulation.
const canvas = document.getElementById('waterCanvas'); const ctx = canvas.getContext('2d'); // Resize the canvas to fill the browser window dynamically function resizeCanvas() { canvas.width = window.innerWidth; canvas.height = window.innerHeight; } window.addEventListener('resize', resizeCanvas); resizeCanvas(); // Grid parameters const gridWidth = 500; const gridHeight = Math.floor((canvas.height / canvas.width) * 500); const damping = 0.99; // Create two buffers for the wave simulation let current = new Array(gridWidth * gridHeight).fill(0); let previous = new Array(gridWidth * gridHeight).fill(0); // Function to convert mouse coordinates to grid coordinates function getGridPosition(x, y) { const gridX = Math.floor((x / canvas.width) * (gridWidth - 2)) + 1; const gridY = Math.floor((y / canvas.height) * (gridHeight - 2)) + 1; return { gridX, gridY }; } // Add disturbance to the grid canvas.addEventListener('mousemove', (e) => { const rect = canvas.getBoundingClientRect(); const mouseX = e.clientX - rect.left; const mouseY = e.clientY - rect.top; const { gridX, gridY } = getGridPosition(mouseX, mouseY); const index = gridY * gridWidth + gridX; previous[index] = 1000; // The disturbance magnitude }); // Wave propagation algorithm function updateWave() { for (let y = 1; y < gridHeight - 1; y++) { for (let x = 1; x < gridWidth - 1; x++) { const index = y * gridWidth + x; // Average the heights of the neighboring cells current[index] = ( previous[index - 1] + previous[index + 1] + previous[index - gridWidth] + previous[index + gridWidth] ) / 2 - current[index]; // Apply damping to simulate energy loss current[index] *= damping; } } // Swap the buffers [previous, current] = [current, previous]; } // Draw the wave to the canvas function drawWave() { const imageData = ctx.createImageData(canvas.width, canvas.height); const data = imageData.data; // Scale the grid to canvas size const xScale = canvas.width / gridWidth; const yScale = canvas.height / gridHeight; for (let y = 0; y < gridHeight; y++) { for (let x = 0; x < gridWidth; x++) { const index = y * gridWidth + x; const height = previous[index]; const color = 128 + height * 0.5; // Adjust color based on height // Calculate canvas coordinates const canvasX = Math.floor(x * xScale); const canvasY = Math.floor(y * yScale); if ( canvasX >= 0 && canvasX < canvas.width && canvasY >= 0 && canvasY < canvas.height ) { const pixelIndex = (canvasY * canvas.width + canvasX) * 4; data[pixelIndex] = color; // R data[pixelIndex + 1] = color; // G data[pixelIndex + 2] = 255; // B data[pixelIndex + 3] = 255; // A } } } ctx.putImageData(imageData, 0, 0); } // Animation loop function animate() { requestAnimationFrame(animate); updateWave(); drawWave(); } animate();3. Explanation
Let's break down the JavaScript code:
-
Canvas Setup: We initialize the canvas and make it responsive to window resizing.
-
Grid Parameters: We define the size of our simulation grid (
gridWidthandgridHeight) and adampingfactor to simulate energy loss over time. -
Buffers: Two arrays,
currentandprevious, represent the current and previous states of the wave heights. -
Mouse Interaction: When the mouse moves, we translate its position to grid coordinates and introduce a disturbance by setting the
previousbuffer at that position to a high value (1000). -
Wave Propagation (
updateWave):- For each cell in the grid (excluding the edges), we calculate its new height based on the average of its four immediate neighbors (left, right, top, bottom).
- We subtract the current height to create a wave effect and apply damping to gradually reduce the wave's amplitude.
-
Rendering (
drawWave):- We create an
ImageDataobject to manipulate pixel data directly. - We scale the grid coordinates to canvas coordinates.
- For each grid cell, we determine a color based on the height and set the corresponding pixel in the
ImageData. - Finally, we render the
ImageDataonto the canvas.
- We create an
-
Animation Loop: Using
requestAnimationFrame, we continuously update the wave's state and render it to create an animation.
4. Enhancements for Realism
The basic simulation can be enhanced for more realistic effects:
-
Color Mapping: Use more sophisticated color gradients to represent different wave heights and simulate lighting effects.
-
Reflections and Refractions: Implement reflections of objects or the sky on the water surface.
-
Interference Patterns: When multiple ripples intersect, they can interfere constructively or destructively, creating complex patterns.
-
Optimizations: For larger grids or higher resolutions, consider optimizing the simulation using techniques like Web Workers or WebGL shaders for better performance.
5. Full Working Example
To see the simulation in action, create two files:
index.htmlandwaterRipple.jswith the respective content provided above. Openindex.htmlin your web browser, and move your cursor around to generate ripples on the simulated water surface.Live Demo
For your convenience, here's a live CodePen link where you can see and interact with the ripple simulation. (Since I cannot create real-time links, you can copy the provided code into a new CodePen project to test it.)
Conclusion
By combining HTML
<canvas>with JavaScript, you can create interactive and visually appealing water ripple simulations. This example provides a foundational approach, and you can extend it further by incorporating more advanced physics, visual effects, and optimizations to enhance realism and performance. - Canvas Setup: Initialize the HTML