เป็นเวลาหลายปีที่นักพัฒนาเว็บต้องเลือกสถาปัตยกรรมที่ยากเมื่อสร้างแอปพลิเคชันภาพที่ซับซ้อนและมีการโต้ตอบสูงบนเว็บ คุณควรใช้ DOM เพื่อฟีเจอร์เชิงความหมายที่หลากหลายหรือแสดงผลไปยังองค์ประกอบ <canvas> โดยตรงเพื่อประสิทธิภาพกราฟิกระดับต่ำ
ด้วย HTML-in-Canvas API เวอร์ชันทดลองใหม่ ซึ่งพร้อมให้ใช้งานแล้วในช่วงทดลองใช้จากต้นทาง คุณไม่จำเป็นต้องเลือก API นี้ช่วยให้คุณวาดเนื้อหา DOM ลงใน Canvas 2 มิติหรือพื้นผิว WebGL/WebGPU ได้โดยตรง ขณะเดียวกันก็ยังคงทำให้ UI โต้ตอบได้ เข้าถึงได้ และเชื่อมต่อกับฟีเจอร์เบราว์เซอร์ที่คุณชื่นชอบ การรวม HTML เข้ากับการประมวลผลกราฟิกระดับต่ำจะช่วยให้คุณสร้างประสบการณ์ที่ก่อนหน้านี้เป็นไปไม่ได้
DOM เทียบกับ Canvas
หากต้องการทำความเข้าใจประสิทธิภาพของ API ใหม่นี้ คุณควรดูจุดแข็งที่เกี่ยวข้องของทั้ง DOM และ Canvas
DOM เป็นองค์ประกอบหลักของ UI บนเว็บ โดยมีโซลูชันเลย์เอาต์ข้อความที่พร้อมใช้งานทันที ซึ่งใช้เนื้อหาที่เข้าใจตามความหมายเพื่อสร้างอินเทอร์เฟซที่สมบูรณ์ ซึ่งช่วยให้ผู้ใช้ดำเนินการทั่วไปในหน้าเว็บได้อย่างราบรื่น เช่น การไฮไลต์ข้อความเพื่อคัดลอก หรือการคลิกขวาที่รูปภาพเพื่อบันทึก นอกจากนี้ DOM ยังผสานรวมกับฟีเจอร์ที่จำเป็นของเบราว์เซอร์ด้วย เช่น เครื่องมือช่วยเหลือพิเศษ, การแปล, การค้นหาในหน้าเว็บ, โหมดการอ่าน, ส่วนขยาย, โหมดมืด, การซูมเบราว์เซอร์ และการป้อนข้อความอัตโนมัติ
ในทางกลับกัน Canvas (และ WebGL/WebGPU) ช่วยให้เข้าถึงระดับต่ำเพื่อขับเคลื่อนตารางกริดของพิกเซลสำหรับกราฟิก 2 มิติและ 3 มิติขั้นสูงได้ เกมและเว็บแอปที่ซับซ้อน (เช่น Google เอกสารหรือ Figma) ต้องใช้สิทธิ์เข้าถึงระดับต่ำที่มีประสิทธิภาพนี้ เนื่องจาก Canvas เป็นตารางกริดของพิกเซลโดยพื้นฐาน ฟีเจอร์ที่รองรับ เช่น ข้อความที่ปรับเปลี่ยนตามอุปกรณ์ จึงเคยต้องใช้ตรรกะ UI ที่กำหนดเองที่ซับซ้อน ซึ่งทำให้ขนาดแพ็กเกจเพิ่มขึ้นอย่างมาก ที่สำคัญคือฟีเจอร์เบราว์เซอร์ที่มีประสิทธิภาพทั้งหมดที่ผสานรวมเข้ากับ DOM จะหยุดทำงานโดยสิ้นเชิงเมื่อ UI ติดอยู่ในตารางกริดพิกเซลของ Canvas แบบคงที่
ข้อดีของการนำ DOM มาใช้กับ Canvas
HTML-in-Canvas API เป็นสะพานเชื่อมที่ช่วยให้คุณได้รับประโยชน์จากทั้ง 2 อย่าง การวาง HTML ไว้ภายในองค์ประกอบ <canvas> และซิงค์การเปลี่ยนรูปแบบจะช่วยให้มั่นใจได้ว่าเนื้อหาจะยังคงโต้ตอบได้อย่างสมบูรณ์ และการผสานรวมเบราว์เซอร์ทั้งหมดจะทำงานโดยอัตโนมัติ
สิ่งที่คุณจะได้รับจากการอนุญาตให้ DOM จัดการ UI ภายในองค์ประกอบ <canvas> มีดังนี้
- เลย์เอาต์และการจัดรูปแบบข้อความ: เลย์เอาต์และการจัดรูปแบบข้อความที่เรียบง่าย รวมถึงข้อความหลายบรรทัดหรือข้อความแบบ 2 ทิศทางที่มีการใช้สไตล์ CSS
- การควบคุมแบบฟอร์ม: การควบคุมแบบฟอร์มที่สื่อความหมายและใช้งานง่ายขึ้นพร้อมตัวเลือกการปรับแต่งที่หลากหลาย
- การเลือกข้อความ คัดลอก/วาง และคลิกขวา: ผู้ใช้สามารถไฮไลต์ข้อความภายในฉาก 3 มิติ หรือคลิกขวาที่เมนูตามบริบทได้โดยตรง
- การช่วยเหลือพิเศษ: เนื้อหาที่แสดงผลภายใน Canvas จะแสดงต่อแผนผังการช่วยเหลือพิเศษ ระบบการช่วยเหลือพิเศษสามารถแยกวิเคราะห์ UI ได้เหมือนกับที่แยกวิเคราะห์ HTML ปกติ และแสดง UI ต่อระบบต่างๆ เช่น โปรแกรมอ่านหน้าจอ
- ค้นหาในหน้า: ผู้ใช้สามารถใช้ฟีเจอร์ค้นหาในหน้า (Ctrl/Cmd+F) เพื่อค้นหาข้อความ และเบราว์เซอร์จะไฮไลต์ข้อความนั้นโดยตรงภายในพื้นผิว WebGL
- ความสามารถในการจัดทำดัชนีและการเชื่อมต่อกับ AI Agent: Web Crawler และ AI Agent สามารถจัดทำดัชนีและอ่านข้อความที่แสดงผลในฉาก 2 มิติและ 3 มิติได้อย่างราบรื่น
- การผสานรวมส่วนขยาย: ส่วนขยายเบราว์เซอร์จะทำงานโดยค่าเริ่มต้น ตัวอย่างเช่น ส่วนขยายการแทนที่ข้อความจะอัปเดตข้อความที่แสดงผลบนเมช 3 มิติโดยอัตโนมัติ
- การผสานรวมเครื่องมือสำหรับนักพัฒนาเว็บ: คุณสามารถตรวจสอบเนื้อหา Canvas รวมถึงองค์ประกอบ UI ของ WebGL/WebGPU ได้โดยตรงในเครื่องมือสำหรับนักพัฒนาเว็บใน Chrome ปรับแต่งสไตล์ CSS ในเครื่องมือตรวจสอบ แล้วดูการอัปเดตพื้นผิว 3 มิติทันที
กรณีการใช้งานระดับสูง
API นี้จะปลดล็อกศักยภาพอันน่าทึ่งในโดเมนต่างๆ ดังนี้
- แอปพลิเคชันขนาดใหญ่ที่ใช้ Canvas: ตอนนี้เว็บแอปขนาดใหญ่สามารถแสดงผลคอมโพเนนต์ UI ของแอปพลิเคชันที่ซับซ้อนในพื้นที่ทำงานที่ใช้ Canvas ได้โดยตรง ซึ่งจะช่วยปรับปรุงการช่วยเหลือพิเศษและลดขนาดของแพ็กเกจ
- ฉากและเกม 3 มิติ: เว็บไซต์การตลาด, ประสบการณ์ WebXR ที่สมจริง และเกมบนเว็บสามารถวาง UI ของเว็บที่โต้ตอบได้อย่างเต็มรูปแบบลงในฉาก 3 มิติได้แล้ว เช่น หนังสือ 3 มิติที่ใช้ข้อความ DOM จริง หรือเทอร์มินัลในเกมที่รองรับการคัดลอกและวางในตัว
วิธีใช้ API
การใช้ API จะเกิดขึ้นใน 3 ระยะ ได้แก่ การตั้งค่า Canvas, การแสดงผลใน Canvas และการอัปเดตการเปลี่ยนรูปแบบ CSS เพื่อให้เบราว์เซอร์ทราบตำแหน่งที่องค์ประกอบอยู่บนหน้าจอ
ข้อกำหนดเบื้องต้น
HTML-in-Canvas API อยู่ในช่วงทดลองใช้จากต้นทางใน Chrome 148 ถึง 150 หากต้องการทดสอบในเว็บไซต์ ให้ใช้ Chrome Canary 149 ขึ้นไปโดยเปิดใช้แฟล็ก chrome://flags/#canvas-draw-element หากต้องการเปิดใช้ API สำหรับผู้ใช้รายอื่น ให้ลงทะเบียนช่วงทดลองใช้จากต้นทาง
ขั้นตอนที่ 1: การตั้งค่า Canvas พื้นฐาน
ก่อนอื่น ให้เพิ่มแอตทริบิวต์ layoutsubtree ลงในแท็ก <canvas> วิธีนี้จะช่วยให้เบราว์เซอร์ทราบถึงเนื้อหาที่ฝังอยู่ภายใน Canvas, เตรียมเนื้อหาให้พร้อมแสดงภายใน Canvas และแสดงเนื้อหาต่อต้นไม้การช่วยเหลือพิเศษ
<canvas id="canvas" style="width: 200px; height: 200px;" layoutsubtree>
<div id="form_element">
<label for="name">Name:</label> <input id="name" type="text">
</div>
</canvas>
ปรับขนาดตารางกริดของ Canvas
โปรดตรวจสอบว่าได้ปรับขนาดตารางกริดของ Canvas ให้ตรงกับค่าตัวคูณมาตราส่วนของอุปกรณ์เพื่อหลีกเลี่ยงไม่ให้เนื้อหาที่แสดงผลเบลอ
const observer = new ResizeObserver(([entry]) => {
const dpc = entry.devicePixelContentBoxSize;
canvas.width = dpc ? dpc[0].inlineSize : Math.round(entry.contentRect.width * window.devicePixelRatio);
canvas.height = dpc ? dpc[0].blockSize : Math.round(entry.contentRect.height * window.devicePixelRatio);
});
const supportsDevicePixelContentBox =
typeof ResizeObserverEntry !== 'undefined' &&
'devicePixelContentBoxSize' in ResizeObserverEntry.prototype;
const options = supportsDevicePixelContentBox ? { box: 'device-pixel-content-box' } : {};
observer.observe(canvas, options);
ขั้นตอนที่ 2: การแสดงผล
สำหรับบริบท 2 มิติ ให้ใช้เมธอด drawElementImage โดยให้ดำเนินการนี้ภายในเหตุการณ์ paint ซึ่งจะทริกเกอร์ทุกครั้งที่มีการวาดองค์ประกอบใหม่ เช่น ระหว่างการไฮไลต์ข้อความหรือการป้อนข้อมูลของผู้ใช้ คุณต้องอัปเดตการเปลี่ยนรูปแบบ CSS ขององค์ประกอบด้วยค่าที่แสดงผลเพื่อให้การโต้ตอบยังคงทำงานต่อไปได้
const ctx = document.getElementById('canvas').getContext('2d');
const form_element = document.getElementById('form_element');
const canvas = document.getElementById('canvas');
canvas.onpaint = () => {
ctx.reset();
// Draw the form element at x:0, y:0
let transform = ctx.drawElementImage(form_element, 0, 0);
// Use the transform returned later on...
};
แสดงผลด้วย WebGL
สำหรับ WebGL คุณจะใช้ texElementImage2D ซึ่งทำงานคล้ายกับ texImage2D แต่ใช้องค์ประกอบ DOM เป็นแหล่งที่มา
canvas.onpaint = () => {
if (gl.texElementImage2D) {
gl.texElementImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, form_element);
}
};
แสดงผลด้วย WebGPU
WebGPU ใช้วิธี copyElementImageToTexture ในคิวอุปกรณ์ ซึ่งคล้ายกับ copyExternalImageToTexture ดังนี้
canvas.onpaint = () => {
root.device.queue.copyElementImageToTexture(
valueElement,
{ texture: targetTexture }
);
};
ขั้นตอนที่ 3: อัปเดตการเปลี่ยนรูปแบบ CSS
เมื่อแสดงผลองค์ประกอบใน Canvas แล้ว คุณต้องอัปเดตเบราว์เซอร์เกี่ยวกับตำแหน่งขององค์ประกอบ ซึ่งจะช่วยให้มั่นใจได้ว่ามีการซิงค์เชิงพื้นที่ระหว่าง Canvas กับเลย์เอาต์ของ DOM ซึ่งเป็นสิ่งสำคัญเพื่อให้เบราว์เซอร์สามารถจับคู่โซนเหตุการณ์ได้อย่างถูกต้อง เช่น ตำแหน่งที่ผู้ใช้คลิกหรือวางเมาส์เหนือตำแหน่งที่แสดงผลองค์ประกอบ
สำหรับกรณีบริบท 2 มิติ ให้ใช้การเปลี่ยนรูปแบบที่แสดงผลโดยการเรียกใช้การแสดงผลกับ .style.transform property ดังนี้
const ctx = document.getElementById('canvas').getContext('2d');
const form_element = document.getElementById('form_element');
const canvas = document.getElementById('canvas');
canvas.onpaint = () => {
ctx.reset();
// Draw the form element at x:0, y:0
let transform = ctx.drawElementImage(form_element, 0, 0);
// Sync the DOM location with the drawn location
form_element.style.transform = transform.toString();
};
เมื่อใช้ WebGL หรือ WebGPU ตำแหน่งบนหน้าจอขององค์ประกอบจะขึ้นอยู่กับวิธีที่โค้ดตัวปรับเฉดสีใช้พื้นผิวเอาต์พุต และไม่สามารถอนุมานจากบริบทการแสดงผล Canvas ได้ อย่างไรก็ตาม หากโปรแกรม Shader ใช้การฉายภาพมุมมองโมเดลทั่วไปเพื่อวาดพื้นผิว คุณสามารถใช้ฟังก์ชันอำนวยความสะดวกใหม่ element.getElementTransform() เพื่อคำนวณการเปลี่ยนรูปแบบที่ใช้ในลักษณะเดียวกับค่าที่แสดงผลจาก drawElementImage() ได้ คุณต้องดำเนินการต่อไปนี้เพื่ออำนวยความสะดวกในเรื่องนี้
- แปลง MVP Matrix ของ WebGL เป็น DOM Matrix
- ปรับองค์ประกอบ HTML ให้เป็นมาตรฐาน องค์ประกอบ HTML มีขนาดเป็นพิกเซล (เช่น กว้าง 200 พิกเซล) อย่างไรก็ตาม โดยปกติแล้ว WebGL จะถือว่าออบเจ็กต์เป็น "หน่วยสี่เหลี่ยมจัตุรัส" เช่น มีค่าตั้งแต่ 0 ถึง 1 หากไม่ปรับให้เป็นมาตรฐาน ปุ่มขนาด 200 พิกเซลจะดูใหญ่ขึ้น 200 เท่า
- แมปกับวิวพอร์ต Canvas ขั้นตอนนี้คือระยะ "การปรับขนาดใหม่" โดยจะขยายคณิตศาสตร์พื้นที่หน่วยนั้นกลับออกไปเพื่อให้ตรงกับขนาดพิกเซลจริงขององค์ประกอบ
<canvas>บนหน้าจอ นอกจากนี้ยังพลิกแกน Y ด้วย เนื่องจากใน WebGL ค่าบวกจะอยู่ด้านบน แต่ใน CSS ค่าบวกจะอยู่ด้านล่าง - คำนวณการเปลี่ยนรูปแบบสุดท้าย คูณเมทริกซ์ตามลำดับ:
Viewport * MVP * Normalization.การรวมเมทริกซ์เข้าเป็นการเปลี่ยนรูปแบบสุดท้ายจะสร้าง "แผนที่" ที่บอกเบราว์เซอร์อย่างชัดเจนว่าเลเยอร์องค์ประกอบ HTML นั้นควรอยู่ตรงไหนเพื่อให้สอดคล้องกับภาพวาด 3 มิติ - ใช้การเปลี่ยนรูปแบบกับองค์ประกอบ HTML ซึ่งจะย้ายเลเยอร์องค์ประกอบ HTML ไปอยู่ด้านบนของพิกเซลที่แสดงผลโดยตรง ซึ่งจะช่วยให้มั่นใจได้ว่าเมื่อผู้ใช้คลิกปุ่มหรือเลือกข้อความ ผู้ใช้จะกดองค์ประกอบ HTML จริง
if (canvas.getElementTransform) {
// 1. Convert WebGL MVP Matrix to DOM Matrix
const mvpDOM = new DOMMatrix(Array.from(htmlElementMVP));
// 2. Normalize the HTML element (pixels -> 1x1 unit square)
const width = targetHTMLElement.offsetWidth;
const height = targetHTMLElement.offsetHeight;
const cssToUnitSpace = new DOMMatrix()
.scale(1 / width, -1 / height, 1) // Shrink to unit size and flip Y
.translate(-width / 2, -height / 2); // Center the element
// 3. Map to the canvas viewport
const clipToCanvasViewport = new DOMMatrix()
.translate(canvas.width / 2, canvas.height / 2) // Move origin to center
.scale(canvas.width / 2, -canvas.height / 2, 1); // Stretch to canvas dimensions
// 4. Multiply: (Clip -> Pixels) * (MVP) * (pixels -> unit square)
const screenSpaceTransform = clipToCanvasViewport
.multiply(mvpDOM)
.multiply(cssToUnitSpace);
// 5. Apply to the transform
const computedTransform = canvas.getElementTransform(targetHTMLElement, screenSpaceTransform);
if (computedTransform) {
targetHTMLElement.style.transform = computedTransform.toString();
}
}
การรองรับไลบรารีและเฟรมเวิร์ก
ไลบรารียอดนิยมบางรายการได้เปิดตัวการรองรับฟีเจอร์ HTML-in-Canvas แล้ว
Three.js
การอัปเดตเมทริกซ์ด้วยตนเองอาจเป็นเรื่องน่าเบื่อ ซึ่งเป็นเหตุผลที่เฟรมเวิร์กต่างๆ เริ่มนำไปใช้แล้ว Three.js มีการรองรับเวอร์ชันทดลองโดยใช้ THREE.HTMLTexture ใหม่ ดังนี้
const material = new THREE.MeshBasicMaterial();
material.map = new THREE.HTMLTexture(uiElement); // Pass the DOM element
const geometry = new THREE.BoxGeometry(1, 1, 1);
const mesh = new THREE.Mesh(geometry, material);
scene.add(mesh);
PlayCanvas
PlayCanvas ยังรองรับ HTML-in-Canvas โดยใช้ Texture API ด้วย
// Wait for the 'paint' event to set the source
canvas.addEventListener('paint', () => {
htmlTexture.setSource(htmlElement);
}, { once: true });
canvas.requestPaint();
// Keep up to date
canvas.addEventListener('paint', onPaintUpload);
const material = new pc.StandardMaterial();
material.diffuseMap = htmlTexture;
material.update();
การสาธิต
ก่อนลองใช้การสาธิต โปรดตรวจสอบว่าสภาพแวดล้อมของคุณได้รับการกำหนดค่าอย่างเหมาะสม
มีการสาธิตหลายรายการที่ใช้เป็นข้อมูลอ้างอิงสำหรับการใช้ API เราได้เห็นโซลูชันที่สร้างสรรค์จากชุมชนแล้ว ตั้งแต่หนังสือ 3 มิติที่แปลได้ไปจนถึงองค์ประกอบ UI ที่หักเหผ่านตัวปรับเฉดสีแก้ว
- หนังสือ 3 มิติ: หนังสือ 3 มิติที่แสดงผลด้วย WebGL ซึ่งใช้เลย์เอาต์ HTML สำหรับหน้าต่างๆ ผู้ใช้สามารถสลับแบบอักษรด้วย CSS ได้ เนื่องจากเป็นแบบ DOM การแปลในตัวจึงทำงานได้ทันที และ AI Agent สามารถดึงข้อความได้โดยมีความซับซ้อนน้อยลง
- UI แบบ 3 มิติที่มีการโต้ตอบ: แถบเลื่อนเยลลี่ WebGPU ที่หักเหแสงตามโมเดล 3 มิติที่อยู่เบื้องหลัง ขณะที่ยังคงตอบสนองต่อแอตทริบิวต์
<input type="range">step ของ HTML มาตรฐาน - พื้นผิวแบบเคลื่อนไหว: ป้ายโฆษณา 3 มิติแบบไดนามิกที่แสดงผลดินสอ SVG แบบเคลื่อนไหวโดยใช้ DOM ลงในพื้นผิว WebGL โดยตรงโดยไม่ต้องใช้ลูปภาพเคลื่อนไหวที่กำหนดเอง
- Refractive overlays: เลเยอร์ตัวพิมพ์แบบอินเทอร์แอกทีฟที่บิดเบี้ยวด้วยเคอร์เซอร์ 3 มิติที่เคลื่อนไหว แต่ยังคงเลือกและค้นหาได้โดยใช้ฟีเจอร์ค้นหาในหน้าเว็บ
ดูคอลเล็กชันเดโมที่ชุมชนสร้างขึ้น หากต้องการให้เดโม HTML-in-Canvas แสดงในคอลเล็กชันนี้ ให้สร้าง Pull Request เพื่อเพิ่มเดโม
ข้อจำกัด
แม้ว่า API จะมีประสิทธิภาพ แต่ก็มีข้อจำกัดบางประการที่ควรทราบ ดังนี้
- เนื้อหาแบบข้ามต้นทาง: API จะไม่ทำงานกับเนื้อหา iframe แบบข้ามต้นทางเนื่องจากเหตุผลด้านความปลอดภัยและความเป็นส่วนตัว
- การเลื่อนเทรดหลัก: HTML-in-canvas จะวาดด้วย JavaScript ซึ่งหมายความว่าการเลื่อนและภาพเคลื่อนไหวจะอัปเดตแยกต่างหากจาก JavaScript ไม่ได้เหมือนกับที่ทำนอก Canvas นักพัฒนาแอปควรพิจารณาลักษณะด้านประสิทธิภาพของการใส่เนื้อหาที่เลื่อนได้ไว้ใน Canvas เทียบกับการเลื่อน Canvas ทั้งหมดอย่างรอบคอบ
ความคิดเห็น
หากคุณกำลังทดลองใช้ HTML-in-Canvas API เราอยากฟังความคิดเห็นจากคุณ คุณสามารถลงชื่อสมัครใช้ช่วงทดลองใช้จากต้นทางเพื่อเปิดใช้ฟีเจอร์นี้ในเว็บไซต์ขณะที่อยู่ในระยะทดลองเพื่อช่วยเราปรับแต่งการออกแบบ API นอกจากนี้ คุณยังยื่นปัญหาเพื่อแสดงความคิดเห็นได้ด้วย
แหล่งข้อมูล
- การรองรับ HTML-in-Canvas ใน Three.js
- เดโม HTML-in-Canvas ใน Three.js
- การรองรับ HTML-in-Canvas ใน PlayCanvas: เอกสารประกอบสำหรับนักพัฒนาซอฟต์แวร์
- การสาธิต HTML-in-Canvas ใน PlayCanvas
- HTML-in-Canvas: Explainer
- คำแนะนำในการพัฒนาเว็บที่ทันสมัยสำหรับเครื่องมือเขียนโค้ด AI สำหรับ HTML-in-Canvas
- เดโม Chrome.dev สำหรับ HTML-in-Canvas
- คอลเล็กชันเดโม HTML-in-Canvas ที่ยอดเยี่ยมจากชุมชน