Seit Jahren müssen Webentwickler bei der Erstellung komplexer, hochgradig interaktiver visueller Anwendungen im Web eine schwierige architektonische Entscheidung treffen: Sollten Sie das DOM wegen seiner umfangreichen semantischen Funktionen nutzen oder direkt im <canvas>-Element rendern, um eine Low-Level-Grafikleistung zu erzielen?
Mit der neuen experimentellen HTML-in-Canvas API, die jetzt als Ursprungstest verfügbar ist, müssen Sie sich nicht entscheiden. Mit dieser API können Sie DOM-Inhalte direkt in ein 2D-Canvas oder eine WebGL-/WebGPU-Textur zeichnen. Die Benutzeroberfläche bleibt dabei interaktiv, barrierefrei und mit Ihren bevorzugten Browserfunktionen verbunden. Durch die Kombination von HTML mit Low-Level-Grafikverarbeitung können Sie Erlebnisse schaffen, die bisher unmöglich waren.
DOM im Vergleich zu Canvas
Um die Leistungsfähigkeit dieser neuen API zu verstehen, ist es hilfreich, sich die relativen Stärken des DOM und des Canvas anzusehen.
Das DOM ist die Grundlage der Web-UI. Sie bietet sofort einsatzbereite Lösungen für das Textlayout und verwendet semantisch verstandene Inhalte, um umfangreiche Oberflächen zu erstellen. So können Nutzer gängige Vorgänge auf Webseiten nahtlos ausführen – Dinge, die wir oft als selbstverständlich ansehen, wie das Markieren von Text zum Kopieren oder das Rechtsklicken auf ein Bild, um es zu speichern. Das DOM ist auch in wichtige Browserfunktionen eingebunden: Bedienungshilfen, Übersetzung, Suche auf der Seite, Lesemodus, Erweiterungen, dunkler Modus, Browserzoom und Autofill.
Canvas (und WebGL/WebGPU) hingegen ermöglicht den Low-Level-Zugriff auf ein Pixelraster für hochkomplexe 2D- und 3D-Grafiken. Spiele und komplexe Web-Apps wie Google Docs oder Figma benötigen diesen leistungsstarken Low-Level-Zugriff. Da das Canvas im Grunde ein Pixelraster ist, waren für Funktionen wie responsiven Text früher komplexe benutzerdefinierte UI-Logik erforderlich, was die Bundle-Größe drastisch erhöht hat. Entscheidend ist, dass alle leistungsstarken Browserfunktionen, die in das DOM integriert sind, vollständig ausfallen, wenn die Benutzeroberfläche in einem statischen Canvas-Pixelraster gefangen ist.
Vorteile der Übertragung des DOM auf Canvas
Die HTML-in-Canvas API ist die Brücke, die das Beste aus beiden Welten vereint. Wenn du HTML im <canvas>-Element platzierst und die Transformation synchronisierst, bleibt der Inhalt vollständig interaktiv und alle Browserintegrationen funktionieren automatisch.
Wenn Sie die Benutzeroberfläche innerhalb eines <canvas>-Elements vom DOM verwalten lassen, bietet das folgende Vorteile:
- Textlayout und -formatierung: Vereinfachtes Textlayout und -formatierung, einschließlich mehrzeiligem oder bidirektionalem Text mit angewendeten CSS-Stilen.
- Formularsteuerelemente: Ausdrucksstarke und benutzerfreundlichere Formularsteuerelemente mit umfangreichen Anpassungsoptionen.
- Textauswahl, Kopieren/Einfügen und Rechtsklick: Nutzer können Text in Ihren 3D-Szenen markieren oder Kontextmenüs per Rechtsklick aufrufen.
- Barrierefreiheit: Inhalte, die im Canvas gerendert werden, sind für die Baumansicht für Barrierefreiheit zugänglich. Bedienungshilfen können die Benutzeroberfläche wie normales HTML parsen und für Systeme wie Screenreader verfügbar machen.
- In-Page-Suche: Nutzer können mit der In-Page-Suche (Strg/Cmd + F) nach Text suchen. Der Browser hebt ihn dann direkt in Ihren WebGL-Texturen hervor.
- Indexierbarkeit und Schnittstelle für KI-Agenten: Web-Crawler und KI-Agenten können den in Ihren 2D- und 3D-Szenen gerenderten Text nahtlos indexieren und lesen.
- Einbindung von Erweiterungen: Browsererweiterungen funktionieren nativ. Eine Textersetzungserweiterung aktualisiert beispielsweise automatisch den Text, der auf Ihren 3D-Meshes gerendert wird.
- Integration in die Entwicklertools: Sie können den Inhalt Ihres Canvas, einschließlich WebGL-/WebGPU-UI-Elementen, direkt in den Chrome-Entwicklertools prüfen. Passen Sie einen CSS-Stil im Inspektor an und sehen Sie sich die sofortige Aktualisierung auf der 3D-Textur an.
Allgemeine Anwendungsfälle
Diese API bietet unglaubliches Potenzial in mehreren Bereichen:
- Große Canvas-basierte Anwendungen: Komplexe UI-Komponenten von umfangreichen Webanwendungen können jetzt nativ in ihren Canvas-basierten Arbeitsbereichen gerendert werden. Das verbessert die Barrierefreiheit und reduziert die Bundle-Größe.
- 3D-Szenen und Onlinespiele: Auf Marketing-Websites, in immersiven WebXR-Inhalten und in Onlinespielen kann jetzt eine vollständig interaktive Web-UI in 3D-Szenen platziert werden, z. B. ein 3D-Buch mit echtem DOM-Text oder ein Terminal im Spiel, das Kopieren und Einfügen nativ unterstützt.
Verwendung der API
Die Verwendung der API erfolgt in drei Phasen: Canvas einrichten, im Canvas rendern und die CSS-Transformation aktualisieren, damit der Browser weiß, wo sich das Element auf dem Bildschirm befindet.
Vorbereitung
Die HTML-in-Canvas API befindet sich in Chrome 148 bis 150 im Ursprungstest. Wenn Sie die Funktion auf Ihrer Website testen möchten, verwenden Sie Chrome Canary 149 oder höher mit aktiviertem Flag chrome://flags/#canvas-draw-element. Wenn Sie die API für andere Nutzer aktivieren möchten, registrieren Sie sich für den Ursprungstest.
Schritt 1: Canvas einrichten
Fügen Sie zuerst das Attribut layoutsubtree zu Ihrem <canvas>-Tag hinzu. Dadurch wird der Browser auf die im Canvas verschachtelten Inhalte aufmerksam gemacht, bereitet sie für die Anzeige im Canvas vor und macht sie für Barrierefreiheitsbäume zugänglich.
<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>
Größe des Canvas-Rasters festlegen
Damit die gerenderten Inhalte nicht unscharf sind, muss das Canvas-Raster an den Skalierungsfaktor des Geräts angepasst werden.
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);
Schritt 2: Rendering
Verwenden Sie für einen 2D-Kontext die Methode drawElementImage. Führen Sie dies im Ereignis paint aus, das immer dann ausgelöst wird, wenn das Element neu gezeichnet wird, z. B. beim Hervorheben von Text oder bei Nutzereingaben. Es ist wichtig, die CSS-Transformation des Elements mit dem Rückgabewert zu aktualisieren, damit die Interaktivität weiterhin funktioniert.
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...
};
Mit WebGL rendern
Für WebGL verwenden Sie texElementImage2D. Sie funktioniert ähnlich wie texImage2D, verwendet aber das DOM-Element als Quelle.
canvas.onpaint = () => {
if (gl.texElementImage2D) {
gl.texElementImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, form_element);
}
};
Mit WebGPU rendern
WebGPU verwendet die Methode copyElementImageToTexture in der Gerätewarteschlange, analog zu copyExternalImageToTexture:
canvas.onpaint = () => {
root.device.queue.copyElementImageToTexture(
valueElement,
{ texture: targetTexture }
);
};
Schritt 3: CSS-Transformation aktualisieren
Nachdem Sie das Element auf dem Canvas gerendert haben, müssen Sie den Browser darüber informieren, wo es sich befindet. So wird eine räumliche Synchronisierung zwischen dem Canvas und dem DOM-Layout gewährleistet. Das ist wichtig, damit der Browser die Ereigniszone, also die Stelle, an der der Nutzer klickt oder den Mauszeiger bewegt, korrekt dem Ort zuordnen kann, an dem das Element gerendert wird.
Wenden Sie im Fall des 2D-Kontexts die vom Rendering-Aufruf zurückgegebene Transformation auf das .style.transform property an:
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();
};
Bei WebGL oder WebGPU hängt die Position eines Elements auf dem Bildschirm davon ab, wie die Ausgabetextur vom Shader-Code verwendet wird. Sie kann nicht aus dem Canvas-Renderingkontext abgeleitet werden. Wenn Ihr Shader-Programm jedoch eine typische Modellansichtsprojektion zum Zeichnen der Textur verwendet, können Sie die neue Komfortfunktion element.getElementTransform() verwenden, um eine Transformation zu berechnen, die auf dieselbe Weise wie der Rückgabewert von drawElementImage() verwendet werden kann. Gehen Sie dazu so vor:
- WebGL-MVP-Matrix in DOM-Matrix konvertieren
- Normalisieren Sie das HTML-Element. Die Größe von HTML-Elementen wird in Pixeln angegeben (z. B. 200 px breit). WebGL behandelt Objekte jedoch normalerweise als „Einheitsquadrate“, z. B. im Bereich von 0 bis 1. Wenn Sie die Werte nicht normalisieren, wird die 200 Pixel große Schaltfläche 200-mal größer dargestellt.
- Auf den Darstellungsbereich des Canvas zuordnen: Dieser Schritt ist die „Rescaling“-Phase, also die Neuskalierung. Diese Werte werden dann wieder auf die tatsächlichen Pixelabmessungen des
<canvas>-Elements auf dem Bildschirm hochgerechnet. Außerdem wird die Y-Achse umgekehrt, da in WebGL „oben“ positiv ist, in CSS jedoch „unten“. - Berechnen Sie die endgültige Transformation. Multiplizieren Sie die Matrizen in der Reihenfolge:
Viewport * MVP * Normalization.Wenn Sie sie zu einer endgültigen Transformation kombinieren, erhalten Sie eine „Karte“, die dem Browser genau mitteilt, wo sich die HTML-Elementebene befinden soll, damit sie mit der 3D-Zeichnung übereinstimmt. - Wenden Sie die Transformation auf das HTML-Element an. Dadurch wird die HTML-Elementebene direkt über den gerenderten Pixeln platziert. So wird sichergestellt, dass ein Nutzer, der auf eine Schaltfläche klickt oder Text auswählt, das echte HTML-Element trifft.
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();
}
}
Unterstützung für Bibliotheken und Frameworks
Einige der beliebten Bibliotheken unterstützen die HTML-in-Canvas-Funktion bereits.
Three.js
Das manuelle Aktualisieren von Matrizen kann mühsam sein. Deshalb werden bereits Frameworks eingesetzt. Three.js bietet experimentelle Unterstützung mit dem neuen 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 unterstützt auch HTML-in-Canvas über die Textur-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();
Demos
Bevor Sie die Demos ausprobieren, müssen Sie Ihre Umgebung richtig konfigurieren.
Es gibt mehrere Demos, die als Referenz für die Verwendung der API dienen. Wir sehen bereits kreative Lösungen aus der Community, von übersetzbaren 3D-Büchern bis hin zu UI-Elementen, die durch Glasshader gebrochen werden:
- Das 3D-Buch: Ein mit WebGL gerendertes 3D-Buch, dessen Seiten ein HTML-Layout verwenden. Nutzer können Schriftarten mit CSS austauschen. Da die integrierte Übersetzung DOM-basiert ist, funktioniert sie sofort und KI-Agenten können den Text mit weniger Aufwand extrahieren.
- Interaktive 3D-Benutzeroberflächen: Ein WebGPU-Schieberegler, der Licht basierend auf einem zugrunde liegenden 3D-Modell bricht und gleichzeitig auf standardmäßige HTML-
<input type="range">-Schrittattribute reagiert. - Animierte Texturen: Ein dynamisches 3D-Billboard, das einen animierten SVG-Stift mithilfe des DOM direkt in eine WebGL-Textur rendert, ohne dass eine benutzerdefinierte Animationsschleife erforderlich ist.
- Refraktive Overlays: Eine interaktive Typografieebene, die durch einen sich bewegenden 3D-Cursor verzerrt wird, aber vollständig auswählbar und über die In-Page-Suche durchsuchbar ist.
Sehen Sie sich die Sammlung von Demos an, die von der Community erstellt wurden. Wenn Sie möchten, dass Ihre HTML-in-Canvas-Demo in dieser Sammlung aufgeführt wird, erstellen Sie eine Pull-Anfrage, um sie hinzuzufügen.
Beschränkungen
Die API ist zwar leistungsstark, hat aber einige bewusste Einschränkungen:
- Ursprungsübergreifende Inhalte: Aus Sicherheits- und Datenschutzgründen funktioniert die API nicht mit ursprungsübergreifenden iFrame-Inhalten.
- Scrollen im Hauptthread: HTML-in-Canvas wird mit JavaScript gezeichnet. Das bedeutet, dass Scrollen und Animationen nicht unabhängig von JavaScript aktualisiert werden können, wie es außerhalb von Canvas möglich ist. Entwickler sollten die Leistungsmerkmale von scrollbaren Inhalten innerhalb des Canvas im Vergleich zum Scrollen des gesamten Canvas sorgfältig abwägen.
Feedback
Wenn Sie mit der HTML-in-Canvas API experimentieren, würden wir uns über Ihr Feedback freuen. Sie können sich für den Ursprungstest registrieren, um die Funktion während der Testphase auf Ihrer Website zu aktivieren und uns bei der Gestaltung des API-Designs zu unterstützen. Sie können auch ein Problem melden, um Feedback zu geben.
Ressourcen
- HTML-in-Canvas-Unterstützung in Three.js
- HTML-in-Canvas in Three.js-Demo
- HTML-in-Canvas-Unterstützung in PlayCanvas: Entwicklerdokumentation
- HTML-in-Canvas in PlayCanvas-Demo
- HTML-in-Canvas: Erläuterung
- Modern Web Guidance für KI-Coding-Tools für HTML-in-Canvas
- Chrome.dev-Demos für HTML-in-Canvas
- Tolle Sammlung von HTML-in-Canvas-Demos der Community