सालों से, वेब डेवलपर को वेब पर जटिल और इंटरैक्टिव विज़ुअल ऐप्लिकेशन बनाते समय, आर्किटेक्चर से जुड़ा एक मुश्किल फ़ैसला लेना पड़ता था. क्या आपको डीओएम की बेहतर सिमैंटिक सुविधाओं का इस्तेमाल करना चाहिए या लो-लेवल ग्राफ़िक्स परफ़ॉर्मेंस के लिए, सीधे <canvas> एलिमेंट पर रेंडर करना चाहिए?
एक्सपेरिमेंट के तौर पर उपलब्ध नए HTML-in-Canvas API की मदद से, आपको दोनों में से किसी एक को चुनने की ज़रूरत नहीं है. यह एपीआई अब ऑरिजिन ट्रायल के लिए उपलब्ध है. इस एपीआई की मदद से, डीओएम कॉन्टेंट को सीधे 2D कैनवस या WebGL/WebGPU टेक्स्चर में ड्रॉ किया जा सकता है. साथ ही, यूज़र इंटरफ़ेस (यूआई) को इंटरैक्टिव और ऐक्सेस करने लायक बनाए रखा जा सकता है. इसके अलावा, इसे अपने पसंदीदा ब्राउज़र की सुविधाओं से जोड़ा जा सकता है. एचटीएमएल को लो-लेवल ग्राफ़िक्स प्रोसेसिंग के साथ जोड़कर, ऐसे अनुभव बनाए जा सकते हैं जो पहले मुमकिन नहीं थे.
डीओएम बनाम कैनवस
इस नए एपीआई की क्षमता को समझने के लिए, डीओएम और कैनवस, दोनों की खूबियों को देखना ज़रूरी है.
डीओएम, वेब यूज़र इंटरफ़ेस का मुख्य हिस्सा होता है. यह टेक्स्ट लेआउट के लिए पहले से मौजूद समाधान उपलब्ध कराता है. इसके लिए, यह कॉन्टेंट के सिमैंटिक को समझकर बेहतर इंटरफ़ेस बनाता है. इससे उपयोगकर्ता, वेब पेजों पर आसानी से सामान्य कार्रवाइयां कर पाते हैं. जैसे, कॉपी करने के लिए टेक्स्ट को हाइलाइट करना या किसी इमेज को सेव करने के लिए उस पर राइट क्लिक करना. डीओएम, ब्राउज़र की ज़रूरी सुविधाओं के साथ भी इंटिग्रेट होता है: सुलभता टूल, अनुवाद, पेज पर ढूंढें, रीडर मोड, एक्सटेंशन, गहरे रंग वाला मोड, ब्राउज़र ज़ूम, और ऑटोमैटिक भरने की सुविधा.
Canvas (और WebGL/WebGPU) की मदद से, बहुत ऐडवांस 2D और 3D ग्राफ़िक के लिए, पिक्सल के ग्रिड को चलाने के लिए लो-लेवल ऐक्सेस मिलता है. गेम और जटिल वेब ऐप्लिकेशन (जैसे, Google Docs या Figma) को इस बेहतर और लो-लेवल ऐक्सेस की ज़रूरत होती है. कैनवस, मुख्य रूप से पिक्सल का एक ग्रिड होता है. इसलिए, रिस्पॉन्सिव टेक्स्ट जैसी सुविधाओं के लिए, जटिल कस्टम यूज़र इंटरफ़ेस (यूआई) लॉजिक की ज़रूरत होती थी. इससे आपके बंडल का साइज़ काफ़ी बढ़ जाता था. सबसे ज़रूरी बात यह है कि जब यूज़र इंटरफ़ेस (यूआई) को स्टैटिक कैनवस पिक्सल ग्रिड में ट्रैप किया जाता है, तो डीओएम में इंटिग्रेट की गई ब्राउज़र की सभी बेहतरीन सुविधाएं पूरी तरह से काम करना बंद कर देती हैं.
डीओएम को कैनवस पर लाने के फ़ायदे
HTML-in-Canvas API, एक ऐसा ब्रिज है जो आपको दोनों दुनिया का बेहतरीन अनुभव देता है. <canvas> एलिमेंट के अंदर एचटीएमएल डालने और उसके ट्रांसफ़ॉर्म को सिंक करने से, यह पक्का किया जाता है कि कॉन्टेंट पूरी तरह से इंटरैक्टिव बना रहे. साथ ही, सभी ब्राउज़र इंटिग्रेशन अपने-आप काम करें.
<canvas> एलिमेंट के अंदर, डीओएम को यूज़र इंटरफ़ेस (यूआई) मैनेज करने की अनुमति देने पर, आपको ये फ़ायदे मिलते हैं:
- टेक्स्ट लेआउट और फ़ॉर्मैटिंग: टेक्स्ट लेआउट और फ़ॉर्मैटिंग को आसान बनाया गया है. इसमें सीएसएस स्टाइल के साथ कई लाइनों वाला या दोनों दिशाओं में लिखा जाने वाला टेक्स्ट शामिल है.
- फ़ॉर्म कंट्रोल: पसंद के मुताबिक बनाने के कई विकल्पों के साथ, फ़ॉर्म कंट्रोल को आसानी से इस्तेमाल किया जा सकता है.
- टेक्स्ट चुनना, कॉपी/पेस्ट करना, और राइट क्लिक करना: उपयोगकर्ता आपके 3D सीन में टेक्स्ट को हाइलाइट कर सकते हैं या कॉन्टेक्स्ट मेन्यू पर राइट क्लिक कर सकते हैं.
- सुलभता: कैनवस में रेंडर किया गया कॉन्टेंट, सुलभता ट्री में दिखता है. सुलभता सिस्टम, यूज़र इंटरफ़ेस (यूआई) को सामान्य एचटीएमएल की तरह पार्स कर सकते हैं. साथ ही, इसे स्क्रीन रीडर जैसे सिस्टम के लिए उपलब्ध करा सकते हैं.
- पेज में ढूंढें: उपयोगकर्ता, टेक्स्ट खोजने के लिए, पेज में ढूंढें (Ctrl/Cmd+F) सुविधा का इस्तेमाल कर सकते हैं. ब्राउज़र, टेक्स्ट को सीधे आपके WebGL टेक्सचर में हाइलाइट करता है.
- इंडेक्स करने और एआई एजेंट के साथ इंटरफ़ेस करने की सुविधा: वेब क्रॉलर और एआई एजेंट, आपके 2D और 3D सीन में रेंडर किए गए टेक्स्ट को आसानी से इंडेक्स और पढ़ सकते हैं.
- एक्सटेंशन इंटिग्रेशन: ब्राउज़र एक्सटेंशन नेटिव तौर पर काम करते हैं. उदाहरण के लिए, टेक्स्ट बदलने वाला एक्सटेंशन, आपके 3D मेश पर रेंडर किए गए टेक्स्ट को अपने-आप अपडेट कर देता है.
- DevTools इंटिग्रेशन: सीधे Chrome DevTools में, अपने कैनवस कॉन्टेंट की जांच की जा सकती है. इसमें WebGL/WebGPU यूज़र इंटरफ़ेस (यूआई) एलिमेंट भी शामिल हैं. इंस्पेक्टर में जाकर, सीएसएस स्टाइल में बदलाव करें और देखें कि वह 3D टेक्सचर पर तुरंत अपडेट हो जाता है!
इस्तेमाल करने के तरीके
यह एपीआई, कई डोमेन में शानदार सुविधाएं देता है:
- कैनवस पर आधारित बड़े ऐप्लिकेशन: ज़्यादा स्टोरेज वाले वेब ऐप्लिकेशन, अब जटिल ऐप्लिकेशन यूज़र इंटरफ़ेस (यूआई) कॉम्पोनेंट को अपने कैनवस पर आधारित वर्कस्पेस में नेटिव तौर पर रेंडर कर सकते हैं. इससे ऐक्सेस करने की सुविधा बेहतर होती है और बंडल का साइज़ कम होता है.
- 3D सीन और गेम: मार्केटिंग साइटें, WebXR के इमर्सिव अनुभव, और वेब गेम अब 3D सीन में पूरी तरह से इंटरैक्टिव वेब यूज़र इंटरफ़ेस (यूआई) जोड़ सकते हैं. जैसे, असली डीओएम टेक्स्ट का इस्तेमाल करने वाली 3D बुक या गेम में मौजूद टर्मिनल, जो कॉपी और पेस्ट करने की सुविधा के साथ काम करता है.
एपीआई का इस्तेमाल कैसे करें
एपीआई का इस्तेमाल तीन चरणों में किया जाता है: कैनवस सेट अप करना, कैनवस में रेंडर करना, और सीएसएस ट्रांसफ़ॉर्म को अपडेट करना, ताकि ब्राउज़र को पता चल सके कि एलिमेंट स्क्रीन पर कहां मौजूद है.
ज़रूरी शर्तें
HTML-in-Canvas API, Chrome के 148 से 150 वर्शन में ऑरिजिन ट्रायल के तौर पर उपलब्ध है. अपनी साइट पर इसकी जांच करने के लिए, Chrome Canary 149 या इसके बाद के वर्शन का इस्तेमाल करें. साथ ही, chrome://flags/#canvas-draw-element फ़्लैग को चालू करें. अन्य उपयोगकर्ताओं के लिए एपीआई चालू करने के लिए, ऑरिजिन ट्रायल के लिए रजिस्टर करें.
पहला चरण: Canvas का बुनियादी सेटअप
सबसे पहले, अपने <canvas> टैग में layoutsubtree एट्रिब्यूट जोड़ें. इससे ब्राउज़र को कैनवस में मौजूद कॉन्टेंट के बारे में पता चलता है. साथ ही, वह कॉन्टेंट को कैनवस में दिखाने के लिए तैयार करता है और उसे सुलभता ट्री में दिखाता है.
<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>
कैनवस ग्रिड का साइज़ तय करना
रेंडर किए गए कॉन्टेंट को धुंधला होने से बचाने के लिए, कैनवस ग्रिड का साइज़ डिवाइस के स्केल फ़ैक्टर के हिसाब से सेट करें.
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);
दूसरा चरण: रेंडरिंग
2D कॉन्टेक्स्ट के लिए, drawElementImage तरीके का इस्तेमाल करें. ऐसा paint इवेंट के अंदर करें. यह इवेंट तब ट्रिगर होता है, जब एलिमेंट फिर से ड्रॉ होता है. उदाहरण के लिए, टेक्स्ट को हाइलाइट करने या उपयोगकर्ता के इनपुट के दौरान. एलिमेंट के सीएसएस ट्रांसफ़ॉर्म को रिटर्न वैल्यू के साथ अपडेट करना ज़रूरी है, ताकि इंटरैक्टिविटी काम करती रहे.
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 की तरह ही काम करता है. हालांकि, यह डीओएम एलिमेंट को सोर्स के तौर पर लेता है.
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 }
);
};
तीसरा चरण: सीएसएस ट्रांसफ़ॉर्म को अपडेट करना
एलिमेंट को कैनवस में रेंडर करने के बाद, आपको ब्राउज़र को अपडेट करना होगा कि वह कहां मौजूद है. इससे यह पक्का होता है कि कैनवस और डीओएम के लेआउट के बीच स्पेसियल सिंक्रनाइज़ेशन हो. यह ज़रूरी है, ताकि ब्राउज़र, इवेंट ज़ोन को सही तरीके से मैप कर सके. जैसे, उपयोगकर्ता ने कहां क्लिक किया या कर्सर घुमाया और एलिमेंट कहां रेंडर हुआ.
2D कॉन्टेक्स्ट के मामले में, रेंडरिंग कॉल से मिले ट्रांसफ़ॉर्म को .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 की मदद से, स्क्रीन पर किसी एलिमेंट की जगह इस बात पर निर्भर करती है कि शेडर कोड, आउटपुट टेक्सचर का इस्तेमाल कैसे करता है. साथ ही, कैनवस रेंडरिंग कॉन्टेक्स्ट से इसका पता नहीं लगाया जा सकता. हालांकि, अगर आपका शेडर प्रोग्राम, टेक्सचर बनाने के लिए सामान्य मॉडल व्यू प्रोजेक्शन का इस्तेमाल करता है, तो नए सुविधाजनक फ़ंक्शन element.getElementTransform() का इस्तेमाल करके, ऐसा ट्रांसफ़ॉर्मेशन कंप्यूट किया जा सकता है जिसे drawElementImage() से मिलने वाली वैल्यू की तरह ही इस्तेमाल किया जा सकता है. इसके लिए, आपको ये काम करने होंगे:
- WebGL एमवीपी मैट्रिक्स को डीओएम मैट्रिक्स में बदलें.
- एचटीएमएल एलिमेंट को सामान्य बनाएं. एचटीएमएल एलिमेंट का साइज़, पिक्सल में तय किया जाता है. उदाहरण के लिए, 200 पिक्सल चौड़ा. हालांकि, WebGL आम तौर पर ऑब्जेक्ट को "यूनिट स्क्वेयर" के तौर पर मानता है. उदाहरण के लिए, 0 से 1 तक. अगर आपने नॉर्मलाइज़ नहीं किया, तो आपका 200 पिक्सल का बटन 200 गुना बड़ा दिखेगा.
- कैनवस व्यूपोर्ट पर मैप करें. इस चरण को "रीस्केलिंग" फ़ेज़ कहा जाता है. यह उस यूनिट-स्पेस मैथ को वापस स्ट्रेच करता है, ताकि स्क्रीन पर आपके
<canvas>एलिमेंट के असल पिक्सल डाइमेंशन से मैच किया जा सके. यह Y-ऐक्सिस को भी फ़्लिप करता है, क्योंकि WebGL में ऊपर की ओर पॉज़िटिव होता है, लेकिन सीएसएस में नीचे की ओर पॉज़िटिव होता है. - फ़ाइनल ट्रांसफ़ॉर्म का हिसाब लगाएं. मैट्रिक्स को इस क्रम में गुणा करें:
Viewport * MVP * Normalization.उन्हें एक फ़ाइनल ट्रांसफ़ॉर्म में जोड़ने से एक "मैप" बनता है. इससे ब्राउज़र को पता चलता है कि एचटीएमएल एलिमेंट लेयर को कहां रखा जाना चाहिए, ताकि वह 3D ड्रॉइंग के साथ अलाइन हो सके. - एचटीएमएल एलिमेंट पर ट्रांसफ़ॉर्म लागू करें. इससे एचटीएमएल एलिमेंट लेयर, रेंडर किए गए पिक्सल के ठीक ऊपर आ जाती है. इससे यह पक्का होता है कि जब कोई उपयोगकर्ता किसी बटन पर क्लिक करता है या टेक्स्ट चुनता है, तो वह असली एचटीएमएल एलिमेंट पर क्लिक कर रहा हो.
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();
}
}
लाइब्रेरी और फ़्रेमवर्क के लिए सहायता
कुछ लोकप्रिय लाइब्रेरी में, कैनवस में एचटीएमएल की सुविधा पहले से ही उपलब्ध है.
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 के साथ भी काम करता है:
// 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();
डेमो
डेमो आज़माने से पहले, पक्का करें कि आपका एनवायरमेंट सही तरीके से कॉन्फ़िगर किया गया हो.
एपीआई का इस्तेमाल करने के लिए, कई डेमो उपलब्ध हैं. हमें कम्यूनिटी से पहले ही क्रिएटिव सलूशन मिल रहे हैं. इनमें, अनुवाद की जा सकने वाली 3D किताबों से लेकर यूज़र इंटरफ़ेस (यूआई) एलिमेंट तक शामिल हैं. ये एलिमेंट, ग्लास शेडर की मदद से रिफ़्रैक्ट होते हैं:
- 3D बुक: WebGL से रेंडर की गई 3D बुक, जिसके पेजों के लिए एचटीएमएल लेआउट का इस्तेमाल किया जाता है. उपयोगकर्ता, सीएसएस की मदद से फ़ॉन्ट बदल सकते हैं. यह डीओएम पर आधारित है. इसलिए, पहले से मौजूद अनुवाद की सुविधा तुरंत काम करती है. साथ ही, एआई एजेंट आसानी से टेक्स्ट को निकाल सकते हैं.
- इंटरैक्टिव 3D यूज़र इंटरफ़ेस (यूआई): WebGPU जेली स्लाइडर, जो पहले से मौजूद 3D मॉडल के आधार पर रोशनी को रिफ़्रैक्ट करता है. साथ ही, स्टैंडर्ड एचटीएमएल
<input type="range">स्टेप एट्रिब्यूट के हिसाब से काम करता है. - ऐनिमेटेड टेक्सचर: यह एक डाइनैमिक 3D बिलबोर्ड है, जो ऐनिमेटेड एसवीजी पेंसिल को रेंडर करता है. इसके लिए, डीओएम का इस्तेमाल करके सीधे WebGL टेक्सचर में रेंडर किया जाता है. इसमें कस्टम ऐनिमेशन लूप की ज़रूरत नहीं होती.
- रिफ़्रैक्टिव ओवरले: यह एक इंटरैक्टिव टाइपोग्राफ़ी लेयर है, जो मूविंग 3D कर्सर की वजह से डिस्टॉर्ट होती है. हालांकि, इसे पूरी तरह से चुना जा सकता है और 'पेज में ढूंढें' सुविधा का इस्तेमाल करके खोजा जा सकता है.
कम्यूनिटी के बनाए गए डेमो का कलेक्शन देखें. अगर आपको इस कलेक्शन में अपने HTML-in-Canvas डेमो को शामिल करना है, तो उसे जोड़ने के लिए पुल का अनुरोध करें.
सीमाएं
एपीआई काफ़ी असरदार है, लेकिन इसकी कुछ सीमाएं हैं:
- क्रॉस-ऑरिजिन कॉन्टेंट: सुरक्षा और निजता से जुड़ी वजहों से, एपीआई क्रॉस-ऑरिजिन iframe कॉन्टेंट के साथ काम नहीं करता.
- मुख्य थ्रेड स्क्रोलिंग: HTML-in-canvas को JavaScript की मदद से ड्रॉ किया जाता है. इसका मतलब है कि स्क्रोलिंग और ऐनिमेशन, JavaScript से अलग अपडेट नहीं हो सकते. हालांकि, कैनवस के बाहर ऐसा किया जा सकता है. डेवलपर को कैनवस के अंदर स्क्रोल किए जा सकने वाले कॉन्टेंट को डालने और पूरे कैनवस को स्क्रोल करने की सुविधा देने के बीच, परफ़ॉर्मेंस की विशेषताओं पर ध्यान से विचार करना चाहिए.
सुझाव/राय दें या शिकायत करें
अगर आपने HTML-in-Canvas API को आज़माया है, तो हमें अपने अनुभव के बारे में बताएं! अपनी साइट पर इस सुविधा को चालू करने के लिए, ऑरिजिन ट्रायल के लिए साइन अप किया जा सकता है. ऐसा तब किया जा सकता है, जब यह सुविधा एक्सपेरिमेंट के फ़ेज़ में हो. इससे हमें एपीआई डिज़ाइन को बेहतर बनाने में मदद मिलेगी. कोई सुझाव/राय देने या शिकायत करने के लिए, समस्या की शिकायत भी की जा सकती है.
संसाधन
- Three.js में HTML-in-Canvas की सुविधा
- Three.js डेमो में HTML-in-Canvas
- PlayCanvas में HTML-in-Canvas की सुविधा: डेवलपर का दस्तावेज़
- PlayCanvas में HTML-in-Canvas का डेमो
- HTML-in-Canvas: इसके बारे में जानकारी
- HTML-in-Canvas के लिए, एआई कोडिंग टूल के लिए मॉडर्न वेब गाइडेंस
- HTML-in-Canvas के लिए Chrome.dev के डेमो
- कम्यूनिटी की ओर से HTML-in-Canvas के शानदार डेमो का कलेक्शन