Một cú nhảy để lại làn bụi nhỏ nghe "đã" hơn hẳn cú nhảy trơ trọi. Một nhát kiếm có vệt sáng dễ đọc hơn nhát kiếm không có, và đồng xu bung ra những tia lấp lánh khi bạn nhặt thì thỏa mãn hơn đồng xu biến mất lặng lẽ. Những hiệu ứng này không đổi luật chơi, nhưng khiến game phản hồi nhạy hơn. Người chơi cảm nhận được điều đó, dù họ không giải thích nổi vì sao.
Bài này đi qua hai hiệu ứng hữu ích nhất trong bộ công cụ của chúng tôi, tự viết từ đầu bằng three.js: ribbon trail bám theo một vật đang di chuyển, và hệ thống particle cho tia lấp lánh, tia lửa và pháo hoa. Không dùng thư viện nào ngoài three.js, chỉ có BufferGeometry, vài shader nhỏ và một chút quản lý bộ nhớ cẩn thận. Đây là bản demo hoàn chỉnh để bạn chơi thử trước:
Quả cầu sáng đi theo một đường cong Lissajous cho đến khi bạn di con trỏ lên cảnh, lúc đó nó sẽ đuổi theo bạn. Phía sau nó là một dải ribbon thon dần, đổi màu, một luồng tia lấp lánh, và thỉnh thoảng có tia lửa nặng rơi xuống theo trọng lực. Mỗi cú nhấp tạo ra một vụ nổ 180 particle. Thanh công cụ cho phép bạn bật tắt trail và particle, đổi tốc độ phát, còn bộ đếm cho biết pool particle đang được dùng bao nhiêu.
Ribbon trail
Trail là bản ghi những nơi một vật đã đi qua, được vẽ thành một dải tam giác. Vậy ta có ba việc: nhớ các vị trí gần đây, biến mỗi vị trí thành hai vertex, và nối các vertex đó thành tam giác.
1. Ring buffer lưu vị trí
Mỗi frame ta đẩy vào vị trí, màu và mốc thời gian hiện tại của quả cầu. Dùng mảng rồi gọi unshift vẫn chạy được, nhưng nó xáo trộn bộ nhớ và sinh rác. Ring buffer chỉ ghi đè ô cũ nhất và dịch chỉ số head lên phía trước:
const TRAIL_CAP = 128; // ring buffer capacity (samples)
const TRAIL_DURATION = 1.0; // seconds a sample lives
const TRAIL_HALF_WIDTH = 0.26; // world units at the head
const ringPos = new Float32Array(TRAIL_CAP * 3);
const ringCol = new Float32Array(TRAIL_CAP * 3);
const ringTime = new Float32Array(TRAIL_CAP);
let ringHead = -1; // index of newest sample
let ringCount = 0;
function trailPush(p, color, time) {
ringHead = (ringHead + 1) % TRAIL_CAP;
const i3 = ringHead * 3;
ringPos[i3] = p.x; ringPos[i3 + 1] = p.y; ringPos[i3 + 2] = p.z;
ringCol[i3] = color.r; ringCol[i3 + 1] = color.g; ringCol[i3 + 2] = color.b;
ringTime[ringHead] = time;
ringCount = Math.min(ringCount + 1, TRAIL_CAP);
}
// k = 0 is the newest sample, k = ringCount - 1 the oldest
const ringIndex = k => (ringHead - k + TRAIL_CAP) % TRAIL_CAP;
Các mẫu được gắn mốc thời gian, nên trail luôn hiển thị đúng một giây chuyển động gần nhất bất kể frame rate. Khi quả cầu dừng lại, các mẫu cũ hết hạn và trail co về phía đầu, đúng như bạn mong đợi ở một sao chổi.
2. Geometry chỉ cấp phát một lần
Mesh của trail không bao giờ đổi buffer. Ta cấp phát chỗ cho TRAIL_CAP mẫu, mỗi mẫu hai vertex, và dựng index buffer một lần lúc khởi động. Mỗi đoạn giữa mẫu k và k + 1 là một quad gồm hai tam giác, (a, b, c) và (b, d, c). Attribute aSide là +1 hoặc −1 để fragment shader biết một pixel đang gần mép nào.
const trailGeo = new THREE.BufferGeometry();
const trailPos = new Float32Array(TRAIL_CAP * 2 * 3);
const trailCol = new Float32Array(TRAIL_CAP * 2 * 3);
const trailAlpha = new Float32Array(TRAIL_CAP * 2);
const trailSide = new Float32Array(TRAIL_CAP * 2);
for (let i = 0; i < TRAIL_CAP; i++) { trailSide[i * 2] = 1; trailSide[i * 2 + 1] = -1; }
const trailIdx = new Uint16Array((TRAIL_CAP - 1) * 6);
for (let i = 0; i < TRAIL_CAP - 1; i++) {
const a = i * 2, b = a + 1, c = a + 2, d = a + 3;
trailIdx.set([a, b, c, b, d, c], i * 6); // runs once at startup
}
trailGeo.setIndex(new THREE.BufferAttribute(trailIdx, 1));
const trailPosAttr = new THREE.BufferAttribute(trailPos, 3).setUsage(THREE.DynamicDrawUsage);
trailGeo.setAttribute('position', trailPosAttr);
trailGeo.setAttribute('aColor', trailColAttr); // same pattern
trailGeo.setAttribute('aAlpha', trailAlphaAttr); // same pattern
trailGeo.setAttribute('aSide', new THREE.BufferAttribute(trailSide, 1));
DynamicDrawUsage báo cho WebGL biết ta sẽ ghi đè các buffer này thường xuyên. Mỗi frame ta chỉ điền 2n vertex đầu tiên và vẽ 6(n − 1) index bằng setDrawRange. Phần còn lại của buffer nằm yên không dùng, nên sau khi khởi động không cần cấp phát thêm hay gọi setAttribute nữa.
3. Hướng về camera, thon dần, mờ dần
Để biến một dãy điểm thành ribbon, mỗi mẫu cần một vector bên để dịch hai vertex của nó ra hai phía. Nếu bạn dùng một trục cố định như hướng lên của thế giới, ribbon sẽ bị quay nghiêng thành một đường mỏng rồi biến mất mỗi khi quả cầu di chuyển dọc trục đó. Thay vào đó ta lấy tích có hướng của hướng trail và hướng tới camera. Kết quả vuông góc với cả hai, nên ribbon luôn quay mặt phẳng về phía người xem, kể cả khi quả cầu lao vào hoặc ra xa camera theo dao động trên trục z.
function updateTrail(now) {
// drop samples older than TRAIL_DURATION
while (ringCount > 0 && now - ringTime[ringIndex(ringCount - 1)] > TRAIL_DURATION) ringCount--;
const n = ringCount;
for (let k = 0; k < n; k++) {
readRing(k, _p);
readRing(Math.max(k - 1, 0), _prev);
readRing(Math.min(k + 1, n - 1), _next);
// direction along the trail and a camera-facing side vector
_dir.subVectors(_prev, _next);
_toCam.subVectors(camera.position, _p);
_side.crossVectors(_dir, _toCam);
const len = _side.length();
if (len > 1e-6) { _side.divideScalar(len); _lastSide.copy(_side); }
else _side.copy(_lastSide); // degenerate (orb not moving): reuse last side
// age 0 at the head, 1 at the tail
const ri = ringIndex(k);
const u = Math.min((now - ringTime[ri]) / TRAIL_DURATION, 1);
const width = TRAIL_HALF_WIDTH * Math.pow(1 - u, 0.8); // taper
const alpha = Math.pow(1 - u, 1.6); // fade
const v = k * 2, o = v * 3;
trailPos[o] = _p.x + _side.x * width;
trailPos[o + 1] = _p.y + _side.y * width;
trailPos[o + 2] = _p.z + _side.z * width;
trailPos[o + 3] = _p.x - _side.x * width;
trailPos[o + 4] = _p.y - _side.y * width;
trailPos[o + 5] = _p.z - _side.z * width;
// ...copy ringCol into trailCol for both vertices...
trailAlpha[v] = trailAlpha[v + 1] = alpha;
}
trailGeo.setDrawRange(0, Math.max(n - 1, 0) * 6);
trailPosAttr.needsUpdate = true;
trailColAttr.needsUpdate = true;
trailAlphaAttr.needsUpdate = true;
}
Một vài chi tiết trong đoạn code này gánh phần lớn công việc:
- Sai phân trung tâm. Hướng tại mẫu
klàp[k−1] − p[k+1], cho các góc cua mượt hơn so với sai phân một phía. - Frame suy biến. Khi quả cầu đứng yên, hướng bằng không và tích có hướng cũng bằng không. Chuẩn hóa nó sẽ sinh ra
NaN, nên ta dùng lại vector bên trước đó. - Tuổi điều khiển mọi thứ.
uchạy từ 0 ở đầu đến 1 ở đuôi. Độ rộng co lại theo(1 − u)^0.8còn alpha mờ nhanh hơn theo(1 − u)^1.6, nên đuôi mỏng dần rồi biến mất thay vì kết thúc bằng một mép cứng. - Vector tạm.
_p,_dir,_sidevà các biến khác được tạo một lần ở cấp module. Không có gì trong vòng lặp này cấp phát bộ nhớ.
Material là một ShaderMaterial nhỏ. Fragment shader thêm độ mờ dần mềm theo chiều rộng ribbon nhờ aSide, cộng với một lõi sáng mảnh, giúp dải phẳng trông như một tia sáng:
const trailMat = new THREE.ShaderMaterial({
vertexShader: /* glsl */ `
attribute vec3 aColor;
attribute float aAlpha;
attribute float aSide;
varying vec3 vColor;
varying float vAlpha;
varying float vSide;
void main() {
vColor = aColor; vAlpha = aAlpha; vSide = aSide;
gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
}`,
fragmentShader: /* glsl */ `
varying vec3 vColor;
varying float vAlpha;
varying float vSide;
void main() {
float edge = 1.0 - vSide * vSide; // 1 in the middle, 0 at the edges
float core = pow(edge, 6.0) * 0.7; // bright center line
gl_FragColor = vec4(vColor + core, edge * vAlpha);
}`,
transparent: true,
depthWrite: false,
side: THREE.DoubleSide,
blending: THREE.AdditiveBlending,
});
Hệ thống particle tiết kiệm tài nguyên
Particle dùng THREE.Points: mỗi particle là một vertex, được vẽ thành hình vuông hướng về màn hình, rồi fragment shader biến nó thành một sprite tròn mềm. Mọi particle nằm trong một BufferGeometry với bốn attribute (position, aColor, aSize, aAlpha), nên hàng nghìn tia lấp lánh chỉ tốn một draw call.
Sprite tròn mềm với size attenuation
PointsMaterial có sẵn không thể thay đổi kích thước hay alpha theo từng particle, nên ta tự viết. Vertex shader nhân gl_PointSize theo khoảng cách để kích thước hoạt động như đơn vị thế giới, còn fragment shader dùng gl_PointCoord để vẽ độ mờ dần xuyên tâm với phần lõi nóng ở giữa:
attribute float aSize;
attribute float aAlpha;
attribute vec3 aColor;
uniform float uScale;
varying vec3 vColor;
varying float vAlpha;
void main() {
vColor = aColor;
vAlpha = aAlpha;
vec4 mv = modelViewMatrix * vec4(position, 1.0);
// size is in world units: perspective size attenuation
gl_PointSize = aSize * uScale / -mv.z;
gl_Position = projectionMatrix * mv;
}
// --- fragment shader ---
varying vec3 vColor;
varying float vAlpha;
void main() {
float d = length(gl_PointCoord - 0.5) * 2.0; // 0 center, 1 edge
float glow = smoothstep(1.0, 0.0, d);
glow *= glow; // soft falloff
float core = smoothstep(0.35, 0.0, d); // hot white center
gl_FragColor = vec4(vColor + core * 0.6, glow * vAlpha);
}
uScale đổi đơn vị thế giới sang pixel. Nó bằng chiều cao canvas tính bằng device pixel chia cho 2 · tan(fov / 2), và được tính lại khi đổi kích thước, nên một particle có aSize = 0.2 luôn phủ 0.2 đơn vị thế giới ở mọi độ phân giải hay pixel ratio.
Pool kích thước cố định với swap-remove
Hệ thống particle đơn giản nhất là đẩy object vào một mảng và splice chúng ra khi chết. Trong game, cách đó sinh rác mỗi frame, và đến một lúc garbage collector sẽ dừng lại để dọn, thường đúng giữa lúc đang cao trào. Vì vậy ta cấp phát mọi thứ trước dưới dạng các typed array phẳng, và các particle còn sống luôn chiếm các ô từ 0 đến alive − 1.
const MAX_PARTICLES = 4000;
// GPU-facing attributes
const pPos = new Float32Array(MAX_PARTICLES * 3);
const pCol = new Float32Array(MAX_PARTICLES * 3);
const pSize = new Float32Array(MAX_PARTICLES);
const pAlpha = new Float32Array(MAX_PARTICLES);
// CPU-only simulation state
const pVel = new Float32Array(MAX_PARTICLES * 3);
const pTint = new Float32Array(MAX_PARTICLES * 3);
const pAge = new Float32Array(MAX_PARTICLES);
const pLife = new Float32Array(MAX_PARTICLES);
// ...pBase (size), pGrav, pDrag...
let alive = 0;
function spawn(x, y, z, vx, vy, vz, life, size, color, gravity, drag) {
if (alive >= MAX_PARTICLES) return false; // pool full: drop the request
const i = alive++, i3 = i * 3;
pPos[i3] = x; pPos[i3 + 1] = y; pPos[i3 + 2] = z;
pVel[i3] = vx; pVel[i3 + 1] = vy; pVel[i3 + 2] = vz;
pTint[i3] = color.r; pTint[i3 + 1] = color.g; pTint[i3 + 2] = color.b;
pAge[i] = 0; pLife[i] = life; pBase[i] = size;
pGrav[i] = gravity; pDrag[i] = drag;
return true;
}
// Move the last live particle into slot i (O(1) removal, keeps [0, alive) packed)
function kill(i) {
const last = --alive;
if (i === last) return;
const i3 = i * 3, l3 = last * 3;
for (let k = 0; k < 3; k++) {
pPos[i3 + k] = pPos[l3 + k];
pVel[i3 + k] = pVel[l3 + k];
pTint[i3 + k] = pTint[l3 + k];
}
pAge[i] = pAge[last]; pLife[i] = pLife[last]; pBase[i] = pBase[last];
pGrav[i] = pGrav[last]; pDrag[i] = pDrag[last];
}
Xóa một particle là O(1): chép particle sống cuối cùng vào chỗ trống rồi giảm alive. Thứ tự không quan trọng với particle additive (sẽ nói thêm bên dưới), nên ta không bao giờ phải dịch chuyển gì cả. Khi pool đầy, spawn đơn giản là từ chối. Ở frame đông đúc bạn mất vài tia lấp lánh mà không ai để ý, thay vì phải nới rộng mảng.
Vòng lặp cập nhật
Mỗi frame, từng particle già đi, nhận trọng lực và drag, di chuyển, rồi được tính lại diện mạo từ t = age / life. Hãy để ý continue sau kill(i): ô i giờ chứa một particle khác chưa được cập nhật, nên ta không được tăng chỉ số.
function updateParticles(dt) {
let i = 0;
while (i < alive) {
pAge[i] += dt;
const t = pAge[i] / pLife[i];
if (t >= 1) { kill(i); continue; } // don't advance: slot i now holds a new particle
const i3 = i * 3;
const damp = Math.exp(-pDrag[i] * dt); // frame-rate independent drag
pVel[i3 + 1] += pGrav[i] * dt; // gravity on Y
pVel[i3] *= damp; pVel[i3 + 1] *= damp; pVel[i3 + 2] *= damp;
pPos[i3] += pVel[i3] * dt;
pPos[i3 + 1] += pVel[i3 + 1] * dt;
pPos[i3 + 2] += pVel[i3 + 2] * dt;
// appearance over life
const grow = Math.min(t * 8, 1); // pop in quickly
pSize[i] = pBase[i] * grow * (1 - t); // then shrink
pAlpha[i] = 1 - t * t; // fade out late
const hot = Math.max(1 - t * 3, 0); // starts cream-hot, cools to tint
pCol[i3] = pTint[i3] + (CREAM.r - pTint[i3]) * hot;
pCol[i3 + 1] = pTint[i3 + 1] + (CREAM.g - pTint[i3 + 1]) * hot;
pCol[i3 + 2] = pTint[i3 + 2] + (CREAM.b - pTint[i3 + 2]) * hot;
i++;
}
partGeo.setDrawRange(0, alive);
pPosAttr.needsUpdate = pColAttr.needsUpdate = pSizeAttr.needsUpdate = pAlphaAttr.needsUpdate = true;
}
Drag dùng Math.exp(-drag * dt) thay vì 1 - drag * dt, nên hoạt động giống nhau ở 30 fps và 144 fps. Các đường cong diện mạo được cố ý giữ đơn giản. Particle hiện ra nhanh trong một phần tám đầu đời, co lại tuyến tính, giữ alpha đến gần cuối, và bắt đầu bằng màu trắng kem rồi nguội dần về màu gốc. Mẹo cuối cùng này khiến particle mới sinh trông nóng rực và particle già trông như tàn than.
Emitter: luồng, tia lửa và vụ nổ
Emitter chỉ là một hàm gọi spawn với các khoảng ngẫu nhiên hợp lý. Demo có ba loại:
- Liên tục dọc theo trail. Một tốc độ tính bằng particle mỗi giây, kèm phần carry lẻ để 180/s ở 144 fps vẫn ra đúng số lượng. Vị trí spawn được rải ngẫu nhiên giữa vị trí frame trước và frame này, nên quả cầu di chuyển nhanh để lại một đường đều thay vì từng cục.
- Tia lửa. Thỉnh thoảng có vài particle nhỏ, nhanh, màu xoài với trọng lực mạnh, để thêm chút đa dạng.
- Vụ nổ. Khi nhấp hoặc chạm: một tia chớp lớn sống ngắn cộng 180 particle bay theo hướng ngẫu nhiên, có màu nằm giữa hai màu ngẫu nhiên trong bảng màu, và bị trọng lực kéo xuống như pháo hoa.
let emitCarry = 0;
function emitAlongTrail(dt, from, to, vel, baseColor, rate) {
emitCarry += rate * dt;
const n = Math.floor(emitCarry);
emitCarry -= n;
for (let k = 0; k < n; k++) {
const f = Math.random(); // spread spawns between last and current position
randomDir(_dir).multiplyScalar(rand(0.1, 0.5));
_c.copy(baseColor);
if (Math.random() < 0.3) _c.lerp(PALETTE[(Math.random() * PALETTE.length) | 0], 0.6);
spawn(
from.x + (to.x - from.x) * f + rand(-0.06, 0.06),
from.y + (to.y - from.y) * f + rand(-0.06, 0.06),
from.z + (to.z - from.z) * f,
_dir.x - vel.x * 0.12, _dir.y - vel.y * 0.12, _dir.z - vel.z * 0.12,
rand(0.5, 1.2), rand(0.06, 0.16), _c, -0.8, 1.2,
);
}
}
function burst(x, y, z) {
const a = PALETTE[(Math.random() * PALETTE.length) | 0];
const b = PALETTE[(Math.random() * PALETTE.length) | 0];
spawn(x, y, z, 0, 0, 0, 0.25, 2.2, CREAM, 0, 0); // one bright flash
for (let k = 0; k < 180; k++) {
randomDir(_dir).multiplyScalar(rand(2.5, 5.5));
_c2.lerpColors(a, b, Math.random());
spawn(x, y, z, _dir.x, _dir.y + 1.2, _dir.z, rand(1.0, 1.8), rand(0.14, 0.3), _c2, -4.5, 1.4);
}
}
Trừ đi một ít vận tốc của quả cầu (vel.x * 0.12) khiến các tia lấp lánh trôi ngược lại so với chuyển động, tạo cảm giác tốc độ. Các object _c, _c2 và _dir là giá trị tạm được dùng lại. Gọi new THREE.Color() cho mỗi particle sẽ phá hỏng toàn bộ công sức ta bỏ ra để xây pool.
Additive glow, depth và sắp xếp
Cả hai material đều dùng blending: THREE.AdditiveBlending và depthWrite: false, và chính hai thiết lập này tạo nên hiệu ứng phát sáng:
- Additive blending cộng màu của mỗi fragment vào những gì đã có sẵn. Chỗ các particle chồng lên nhau sẽ sáng hơn và dần tiến về màu trắng, đúng như cách ánh sáng hoạt động và là lý do lõi của vụ nổ bừng sáng mà không cần post-processing. Hiệu ứng đẹp nhất trên nền tối, đó là lý do demo được đặt vào ban đêm.
- Phép cộng có tính giao hoán, nên thứ tự vẽ không quan trọng. Particle alpha-blend thông thường phải được sắp xếp từ xa đến gần mỗi frame, nếu không sẽ trông sai. Particle additive có thể vẽ theo bất kỳ thứ tự nào, nhờ vậy ta swap-remove thoải mái.
depthWrite: falsengăn mỗi sprite ghi hình vuông của nó vào depth buffer. Nếu không, sprite vẽ trước sẽ che mất phần rìa mềm của các sprite phía sau và bạn sẽ thấy những ô vuông tối bị cắt. Depth test vẫn bật, nên hình khối đặc ở phía trước vẫn che được particle.
Điểm cần lưu ý: additive blending chỉ có thể làm sáng thêm. Khói, bụi trên nền sáng hay bất cứ thứ gì cần làm tối cảnh đều cần blending thường, và khi đó bạn quay lại chuyện phải sắp xếp (hoặc chấp nhận thỉnh thoảng có artifact). Nhiều game dùng cả hai: additive cho lửa, phép thuật và tia lửa, còn alpha có sắp xếp cho khói.
Frame time và hiệu năng
Vài thói quen giúp hiệu ứng kiểu này nhẹ và ổn định:
renderer.setPixelRatio(Math.min(window.devicePixelRatio || 1, 2)); // cap DPR at 2
function frame() {
rafId = requestAnimationFrame(frame);
const dt = Math.min(clock.getDelta(), 1 / 30); // clamp: no giant steps after a hitch
// ...steer orb, push trail, emit, update, render...
}
// pause when the tab is hidden
document.addEventListener('visibilitychange', () => {
if (document.hidden) { cancelAnimationFrame(rafId); rafId = 0; }
else if (!rafId) { clock.getDelta(); frame(); }
});
- Giới hạn delta time. Nếu tab bị đứng nửa giây,
dtkhông giới hạn sẽ khiến mọi particle bay vọt qua trong một bước khổng lồ. Giới hạn ở 1/30 giây khiến một cú giật chỉ trông như chậm đi chốc lát. - Tạm dừng khi bị ẩn. Trình duyệt đã tự giảm tốc tab nền, nhưng dừng hẳn vòng lặp khi có
visibilitychangetiết kiệm pin hoàn toàn, và reset clock khi quay lại tránh frame đầu tiên quá lớn. - Giới hạn pixel ratio. Điện thoại báo DPR từ 3 trở lên. Tăng từ 2 lên 3 làm số pixel mà fragment shader phải tô nhiều hơn gấp đôi, và với nhiều sprite additive chồng lên nhau, fill rate thường là thứ cạn đầu tiên.
- Dự trù số lượng. Chi phí của particle chủ yếu nằm ở overdraw chứ không phải số vertex: vài trăm sprite mềm lớn có thể tốn hơn hàng nghìn sprite nhỏ. Hãy giữ sprite nhỏ, vòng đời ngắn, và chọn pool cùng tốc độ phát nhỏ hơn trên mobile.
- Giảm tần suất cập nhật UI. Bộ đếm particle trong demo cập nhật bốn lần mỗi giây, không phải mỗi frame. Chạm vào DOM cũng không miễn phí.
- Tắt frustum culling cho các object này (
frustumCulled = false). Bounds của chúng đổi mỗi frame, và một bounding sphere cũ có thể cull cả trail dù nó rõ ràng đang hiện trên màn hình.
Một chi tiết khi nhúng: canvas dùng touch-action: pan-y và không bao giờ gọi preventDefault trên sự kiện wheel, nên khi demo nằm trong bài viết này bạn vẫn có thể cuộn qua nó trên điện thoại.
Bước tiếp theo
Mọi thứ ở đây chỉ là các mảng thuần và vài shader, nên rất dễ mở rộng. Bạn có thể chuyển phần mô phỏng particle vào vertex shader (truyền thời điểm spawn và vận tốc ban đầu, rồi tính vị trí từ tuổi), thêm texture atlas cho các hình ngôi sao hay cánh hoa, hoặc gắn trail vào mọi viên đạn trong game của bạn. Dù thêm gì, hãy giữ nguyên các quy tắc: cấp phát một lần, tái sử dụng mọi thứ, và để phép cộng lo phần phát sáng.

Comments
Loading comments…