Nguyên lý phát vòng lặp zoom vô hạn trên Canvas: scale theo cấp số nhân và khâu điểm cắt
Một hiệu ứng zoom vô hạn thường trông như máy quay đang tiến mãi vào trong bức tranh. Ví dụ trong bài này chỉ phát tuần hoàn một dãy hữu hạn khung hình: chi tiết ở giữa mở ra cảnh tiếp theo, rồi cảnh cuối đưa bạn về cảnh đầu. Đó là nguyên lý phát một vòng lặp zoom vô hạn — không phải một canvas vô hạn mà bạn có thể tới vị trí hoặc độ sâu bất kỳ.
Phần dễ sai không nằm ở hiệu ứng, mà ở chỗ bàn giao giữa hai khung hình. Nếu scale tăng đều theo thời gian, mỗi lần chuyển cảnh sẽ có một cái "cục"; nếu nội dung không khớp, vòng lặp sẽ nhảy.
Bài này là một hướng dẫn độc lập do nhóm Infinite Zoom Art viết. Code minh hoạ không đại diện cho kiến trúc kỹ thuật đang chạy trên sản phẩm. Bản rút gọn này chỉ thực hiện zoom vào tâm, hệ số cố định, khung hình vuông và phát tự động trên Canvas 2D; các hàm thuần đã chạy thử bằng node --test. Trang sản phẩm còn giới thiệu thao tác cuộn, pinch và kéo để tự khám phá — những tương tác đó không có trong code dưới đây. Bài không sinh ảnh, chỉ giả định bạn đã có một dãy khung hình nối tiếp nhau.
1. Mỗi cảnh chứa một cửa dẫn sang cảnh sau
Để zoom có lý do, khung hiện tại phải chứa một vùng sẽ trở thành toàn bộ khung sau: một khung tranh, một cửa sổ, một đồng xu, con ngươi. Trong ví dụ này, cửa nằm đúng giữa và có cạnh bằng 1/k cạnh khung. k = 2 nghĩa là mỗi lần bàn giao, máy quay tiến gần gấp đôi, và cửa chiếm một phần tư diện tích.
Điểm then chốt: code không tự xóa đường nối. Nội dung bên trong cửa của khung trước phải trùng với toàn cảnh của khung sau, và khung cuối cũng phải trùng với khung đầu. Đó là việc sắp xếp lúc vẽ hoặc lúc sinh ảnh, không phải việc của bộ phát. Bộ phát chỉ cần biết: khi scale đạt k, cửa đã lấp đầy canvas, lúc đó mới được chuyển index. Nếu cửa lệch, người xem sẽ thấy một cú nhảy đúng lúc cắt cảnh — kể cả khi công thức scale đã đúng.

2. Muốn tốc độ zoom tương đối không đổi, có thể cho scale tăng theo cấp số nhân
Gọi t là tiến độ trên cả vòng lặp, nằm trong [0, 1). Với N khung, mỗi đoạn bàn giao chiếm 1/N vòng. Bên trong một đoạn, nếu muốn giữ tốc độ zoom tương đối không đổi, có thể dùng scale k ** local thay cho nội suy tuyến tính từ 1 đến k. Nội suy tuyến tính làm đoạn đầu chậm, đoạn cuối nhanh (hoặc ngược lại), nên người xem cảm thấy "cục" đúng lúc chuyển cảnh.
/** t trong [0, 1) trên cả vòng lặp -> khung hiện tại, khung sau, và scale. */
export function playhead(t, frameCount, k = 2) {
if (!Number.isInteger(frameCount) || frameCount < 1) return null;
if (!(k > 1) || !Number.isFinite(k)) return null;
if (!Number.isFinite(t)) return null;
const remainder = t % 1;
const u = remainder < 0 ? remainder + 1 : remainder; // [0, 1)
const pos = u * frameCount;
const index = Math.min(Math.floor(pos), frameCount - 1);
const local = pos - index; // [0, 1)
return {
index,
next: (index + 1) % frameCount,
scale: k ** local,
local,
};
}
Hai điểm dễ trượt. Thứ nhất, t = 1 phải quay về khung đầu vì (t % 1) của 1 là 0. t âm thì % trong JavaScript cho kết quả âm, nên chỉ cộng 1 khi remainder âm — không viết ((t % 1) + 1) % 1. Với t = 0.9999999999999999, phép cộng + 1 bị làm tròn thành 2, rồi % 1 cho 0 sớm, bộ phát nhảy về khung đầu trước khi hết vòng. Thứ hai, Math.floor(pos) khi pos sát frameCount vì sai số số thực có thể cho đúng frameCount; Math.min(..., frameCount - 1) giữ index trong phạm vi, còn next dùng % để khép vòng.
3. Vẽ hai lớp và cắt khi scale đạt k
Khung hiện tại được phóng quanh tâm. Khung sau được đặt đúng vào cửa: hình vuông giữa có cạnh size * (scale / k). Khi scale = 1, cửa nhỏ; khi scale tiến tới k, cửa lấp đầy canvas. Nếu nội dung đã khớp, khoảnh khắc chuyển index (scale trở lại 1, khung sau thành khung hiện tại) sẽ không đổi những gì đang hiện trên màn hình.

export function drawHandOff(ctx, images, head, k, size) {
if (!head || !images || images.length === 0) return;
const current = images[head.index];
const next = images[head.next];
if (!current) return;
ctx.save();
ctx.beginPath();
ctx.rect(0, 0, size, size);
ctx.clip();
const cw = size * head.scale;
ctx.drawImage(current, (size - cw) / 2, (size - cw) / 2, cw, cw);
if (next) {
const pw = size * (head.scale / k);
ctx.drawImage(next, (size - pw) / 2, (size - pw) / 2, pw, pw);
}
ctx.restore();
}
Hàm trả về sớm khi không có ảnh, để cây mới hay bước preload chưa xong không đọc images[0]. clip() giới hạn phạm vi vẽ trong canvas. Vòng lặp phát chỉ việc tính t từ thời gian, gọi playhead, rồi drawHandOff:
const started = performance.now();
const durationMs = 16_000; // một vòng, ví dụ 16 giây cho 8 khung
function tick(now) {
const t = (now - started) / durationMs;
const head = playhead(t, images.length, 2);
ctx.clearRect(0, 0, size, size);
drawHandOff(ctx, images, head, 2, size);
requestAnimationFrame(tick);
}
requestAnimationFrame(tick);
playhead tự lấy phần thập phân của t, nên vòng lặp chạy bao lâu cũng không cần tự đặt lại đồng hồ. Không lấy t bằng Date.now() trộn với mốc của performance.now(); một nguồn thời gian là đủ.
4. Khép vòng và các lỗi số học dễ gặp
Với N khung, cần đủ N đường nối, không phải N - 1. Khung cuối phải có cửa trùng với toàn cảnh khung đầu, next mới là 0 một cách tự nhiên. Bộ phát không "đoán" điều đó; nó chỉ làm (index + 1) % frameCount. Nếu ảnh cuối không khớp ảnh đầu, người xem sẽ thấy một cú nhảy đúng một lần mỗi vòng — đó là lỗi dữ liệu, không phải lỗi của playhead, như phía "Lệch" trong hình so sánh ở mục 1.
Sát cuối vòng, t có dạng 0.999…. Phép nhân u * frameCount phải vẫn cho index của khung cuối, chứ không làm tròn sớm lên khung đầu. Test ở cuối bài kiểm tra 1 - 1e-12 và cả 0.9999999999999999 — giá trị sau mới đủ sát biên để phát hiện lỗi làm tròn của công thức cũ.
5. Tải trước ảnh, DPR và bộ nhớ
drawImage với ảnh chưa tải xong sẽ vẽ khung trống, đúng lúc bàn giao thì rất dễ thấy. Tải hết rồi mới bắt đầu tick. Canvas muốn sắc nét trên màn hình mật độ cao thì phải nhân width/height với devicePixelRatio, rồi setTransform để mã vẽ vẫn dùng đơn vị CSS pixel:
export function setupCanvas(canvas, size, dpr = 1) {
const ratio = dpr > 0 && Number.isFinite(dpr) ? dpr : 1;
canvas.width = Math.round(size * ratio);
canvas.height = Math.round(size * ratio);
canvas.style.width = `${size}px`;
canvas.style.height = `${size}px`;
const ctx = canvas.getContext("2d");
ctx.setTransform(ratio, 0, 0, ratio, 0, 0);
return ctx;
}
export function preload(urls) {
return Promise.all(urls.map((src) => new Promise((resolve, reject) => {
const img = new Image();
img.onload = () => resolve(img);
img.onerror = () => reject(new Error(`Không tải được ${src}`));
img.src = src;
})));
}
Nếu dãy ảnh lớn, không giữ bản gốc độ phân giải cao hơn canvas khi không cần; với blob: URL, nhớ URL.revokeObjectURL sau khi ảnh đã tải, để bộ nhớ không giữ file gốc song song với bitmap.
Chạy thử
Các hàm thuần test nhanh bằng bộ chạy có sẵn của Node, tập trung vào đường cong scale, khép vòng và danh sách rỗng.
import test from "node:test";
import assert from "node:assert/strict";
import { playhead, drawHandOff } from "./zoom.mjs";
test("t = 0 đứng ở khung đầu, scale = 1", () => {
const p = playhead(0, 8, 2);
assert.equal(p.index, 0);
assert.equal(p.next, 1);
assert.equal(p.scale, 1);
});
test("giữa đoạn bàn giao dùng cấp số nhân, không phải tuyến tính", () => {
const k = 2;
const p = playhead(0.5 / 8, 8, k);
assert.equal(p.index, 0);
assert.ok(Math.abs(p.scale - Math.sqrt(k)) < 1e-10);
assert.notEqual(p.scale, (1 + k) / 2);
});
test("hết một đoạn bàn giao thì sang khung sau, scale trở lại 1", () => {
const p = playhead(1 / 8, 8, 2);
assert.equal(p.index, 1);
assert.equal(p.next, 2);
assert.ok(Math.abs(p.scale - 1) < 1e-12);
});
test("t = 1 và t âm đều quay về khung đầu", () => {
assert.equal(playhead(1, 8, 2).index, 0);
assert.equal(playhead(1, 8, 2).scale, 1);
assert.equal(playhead(-0.25, 8, 2).index, playhead(0.75, 8, 2).index);
});
test("sát cuối vòng vẫn ở khung cuối, chưa nhảy sớm", () => {
const p = playhead(1 - 1e-12, 8, 2);
assert.equal(p.index, 7);
assert.equal(p.next, 0);
assert.ok(p.scale > 1.9);
});
test("t = 0.9999999999999999 vẫn ở khung cuối, không bị làm tròn về 0", () => {
const p = playhead(0.9999999999999999, 8, 2);
assert.equal(p.index, 7);
assert.equal(p.next, 0);
assert.ok(p.scale > 1.9);
});
test("danh sách rỗng hoặc k không hợp lệ thì trả về null", () => {
assert.equal(playhead(0, 0, 2), null);
assert.equal(playhead(0, -1, 2), null);
assert.equal(playhead(0, 8, 1), null);
assert.equal(playhead(Number.NaN, 8, 2), null);
});
test("drawHandOff không đọc images[0] khi danh sách rỗng", () => {
const ctx = { save() { throw new Error("không được gọi"); } };
assert.equal(drawHandOff(ctx, [], playhead(0, 8, 2), 2, 400), undefined);
assert.equal(drawHandOff(ctx, null, playhead(0, 8, 2), 2, 400), undefined);
});
Chạy bằng node --test test.mjs.
Kết luận
Những điều chúng tôi rút ra khi triển khai một vòng lặp zoom kiểu này:
- Nếu muốn giữ tốc độ zoom tương đối không đổi, có thể cho scale trong mỗi đoạn bàn giao tăng theo cấp số nhân; nội suy tuyến tính tạo ra "cục" đúng lúc cắt cảnh.
- Khung sau luôn được vẽ trong cửa, và chỉ chuyển index khi cửa lấp đầy màn hình.
- Cần đủ
Nđường nối, kể cả đường từ khung cuối về khung đầu; code không tự xóa đường nối, nên lỗi nhảy vòng thường đến từ dữ liệu, không phải từ%. - Đưa
tvề[0, 1)bằng cách chỉ cộng1khi remainder âm — tránh((t % 1) + 1) % 1vì sát1phép cộng có thể bị làm tròn — và kẹp index khi sai số số thực đẩypossátframeCount. - Tải hết ảnh rồi mới phát, và chỉnh canvas theo
devicePixelRatiokẻo đường cắt bị mờ đúng lúc cần sự liền mạch.
All rights reserved