WebGL ओवरले व्यू

सैंपल देखें

WebGL ओवरले व्यू की मदद से, अपने मैप में सीधे WebGL या Three.js जैसी लोकप्रिय ग्राफ़िक लाइब्रेरी का इस्तेमाल करके कॉन्टेंट जोड़ा जा सकता है. WebGL ओवरले व्यू, उसी WebGL रेंडरिंग कॉन्टेक्स्ट को सीधे ऐक्सेस करता है जिसका इस्तेमाल Google Maps Platform, वेक्टर बेसमैप को रेंडर करने के लिए करता है. शेयर किए गए रेंडरिंग कॉन्टेक्स्ट का इस्तेमाल करने से कई फ़ायदे मिलते हैं. जैसे, इमारत की 3D ज्यामिति के साथ डेप्थ ऑक्लूज़न (गहराई में छिपी हुई चीज़ें) और बेसमैप रेंडरिंग के साथ 2D/3D कॉन्टेंट सिंक करने की सुविधा. WebGL ओवरले व्यू की मदद से रेंडर किए गए ऑब्जेक्ट को, अक्षांश/देशांतर निर्देशांक से भी जोड़ा जा सकता है. इससे, मैप को खींचने, ज़ूम करने, पैन करने या झुकाने पर, वे ऑब्जेक्ट भी अपने-आप चलने लगते हैं.

ज़रूरी शर्तें

WebGL ओवरले व्यू का इस्तेमाल करने के लिए, आपको वेक्टर मैप चालू करके मैप आईडी का इस्तेमाल करके मैप लोड करना होगा. हमारा सुझाव है कि मैप आईडी बनाते समय, झुकाने और घुमाने की सुविधा चालू करें, ताकि 3D कैमरे को पूरी तरह से कंट्रोल किया जा सके. ज़्यादा जानकारी के लिए खास जानकारी देखें.

WebGL ओवरले व्यू जोड़ना

अपने मैप में ओवरले जोड़ने के लिए, google.maps.WebGLOverlayView लागू करें. इसके बाद, setMap का इस्तेमाल करके, उसे अपने मैप इंस्टेंस में पास करें:

// Create a map instance.
const map = new google.maps.Map(mapDiv, mapOptions);

// Create a WebGL Overlay View instance.
const webglOverlayView = new google.maps.WebGLOverlayView();

// Add the overlay to the map.
webglOverlayView.setMap(map);

लाइफ़साइकल हुक

WebGL ओवरले व्यू, हुक का एक सेट उपलब्ध कराता है. इन हुक को वेक्टर बेसमैप के WebGL रेंडरिंग कॉन्टेक्स्ट के लाइफ़साइकल में अलग-अलग समय पर कॉल किया जाता है. लाइफ़साइकल हुक की मदद से, ओवरले में रेंडर की जाने वाली चीज़ों को सेटअप, ड्रॉ, और हटाया जा सकता है.

• ओवरले बनाने पर, onAdd() को कॉल किया जाता है. ओवरले खींचने से पहले, इंटरमीडिएट डेटा स्ट्रक्चर को फ़ेच करने या बनाने के लिए इसका इस्तेमाल करें. इन डेटा स्ट्रक्चर को WebGL रेंडरिंग कॉन्टेक्स्ट के तुरंत ऐक्सेस की ज़रूरत नहीं होती.
• रेंडरिंग कॉन्टेक्स्ट उपलब्ध होने के बाद, onContextRestored({gl}) को कॉल किया जाता है. इसका इस्तेमाल, किसी भी वेबजीएल स्टेट को शुरू करने या बांधने के लिए किया जाता है. जैसे, शेडर, GL स्मृति ऑब्जेक्ट वगैरह. onContextRestored(), WebGLStateOptions का एक उदाहरण लेता है, जिसमें एक फ़ील्ड होता है:
  • gl, बेसमैप में इस्तेमाल किए गए WebGLRenderingContext का हैंडल है.
• onDraw({gl, transformer}), बेसमैप पर सीन को रेंडर करता है. onDraw() के पैरामीटर एक WebGLDrawOptions ऑब्जेक्ट होते हैं, जिसमें दो फ़ील्ड होते हैं:
  • gl, बेसमैप में इस्तेमाल किए गए WebGLRenderingContext का हैंडल है.
  • transformer, मैप निर्देशांकों को मॉडल-व्यू-प्रोजेक्शन मैट्रिक में बदलने के लिए हेल्पर फ़ंक्शन उपलब्ध कराता है. इनका इस्तेमाल, मैप निर्देशांकों को वर्ल्ड स्पेस, कैमरा स्पेस, और स्क्रीन स्पेस में बदलने के लिए किया जा सकता है.
• onContextLost() को तब कॉल किया जाता है, जब किसी भी वजह से रेंडरिंग कॉन्टेक्स्ट खो जाता है. साथ ही, आपको पहले से मौजूद किसी भी GL स्टेटस को साफ़ करना चाहिए, क्योंकि अब इसकी ज़रूरत नहीं है.
• onStateUpdate({gl}), रेंडर लूप के बाहर GL स्टेटस को अपडेट करता है. साथ ही, requestStateUpdate को कॉल करने पर इसे ट्रिगर किया जाता है. यह एक ऐसा WebGLStateOptions इंस्टेंस लेता है जिसमें एक फ़ील्ड होता है:
  • gl, बेसमैप में इस्तेमाल किए गए WebGLRenderingContext का हैंडल है.
• onRemove() को तब कॉल किया जाता है, जब WebGLOverlayView.setMap(null) की मदद से ओवरले को मैप से हटाया जाता है. साथ ही, आपको सभी इंटरमीडिएट ऑब्जेक्ट हटाने चाहिए.

उदाहरण के लिए, यहां सभी लाइफ़साइकल हुक को बुनियादी तौर पर लागू करने का तरीका बताया गया है:

const webglOverlayView = new google.maps.WebGLOverlayView();

webglOverlayView.onAdd = () => {
  // Do setup that does not require access to rendering context.
}

webglOverlayView.onContextRestored = ({gl}) => {
  // Do setup that requires access to rendering context before onDraw call.
}

webglOverlayView.onStateUpdate = ({gl}) => {
  // Do GL state setup or updates outside of the render loop.
}

webglOverlayView.onDraw = ({gl, transformer}) => {
  // Render objects.
}

webglOverlayView.onContextLost = () => {
  // Clean up pre-existing GL state.
}

webglOverlayView.onRemove = () => {
  // Remove all intermediate objects.
}

webglOverlayView.setMap(map);

GL स्टेटस रीसेट करना

WebGL ओवरले व्यू, बेसमैप के WebGL रेंडरिंग कॉन्टेक्स्ट को दिखाता है. इसलिए, ऑब्जेक्ट रेंडर करने के बाद, GL स्टेटस को उसकी मूल स्थिति पर रीसेट करना बेहद ज़रूरी है. जीएल स्टेटस को रीसेट न करने पर, जीएल स्टेटस में विरोध हो सकता है. इसकी वजह से, मैप और आपके बताए गए किसी भी ऑब्जेक्ट, दोनों को रेंडर नहीं किया जा सकेगा.

आम तौर पर, GL स्टेटस को रीसेट करने की प्रोसेस, onDraw() हुक में मैनेज की जाती है. उदाहरण के लिए, Three.js एक हेल्पर फ़ंक्शन उपलब्ध कराता है, जो GL स्टेटस में हुए किसी भी बदलाव को मिटा देता है:

webglOverlayView.onDraw = ({gl, transformer}) => {
  // Specify an object to render.
  renderer.render(scene, camera);
  renderer.resetState();
}

अगर मैप या आपके ऑब्जेक्ट रेंडर नहीं होते हैं, तो हो सकता है कि GL की स्थिति को रीसेट न किया गया हो.

कोऑर्डिनेट ट्रांसफ़ॉर्मेशन

वेक्टर मैप पर किसी ऑब्जेक्ट की स्थिति बताने के लिए, अक्षांश और देशांतर के निर्देशांक के साथ-साथ ऊंचाई की जानकारी दी जाती है. हालांकि, 3D ग्राफ़िक को वर्ल्ड स्पेस, कैमरा स्पेस या स्क्रीन स्पेस में दिखाया जाता है. मैप के निर्देशांकों को आम तौर पर इस्तेमाल होने वाले इन स्पेस में बदलना आसान बनाने के लिए, WebGL ओवरले व्यू में onDraw() हुक में coordinateTransformer.fromLatLngAltitude(latLngAltitude, rotationArr, scalarArr) हेल्पर फ़ंक्शन दिया गया है. यह इन निर्देशांकों को लेता है और Float64Array दिखाता है:

• latLngAltitude: अक्षांश/देशांतर/ऊंचाई के निर्देशांक, LatLngAltitude या LatLngAltitudeLiteral के तौर पर.
• rotationArr: डिग्री में बताए गए यूलर रोटेशन ऐंगल के Float32Array.
• scalarArr: कार्डिनल ऐक्सिस पर लागू करने के लिए स्केलर की Float32Array वैल्यू.

उदाहरण के लिए, Three.js में कैमरा प्रोजेक्शन मैट्रिक बनाने के लिए, यहां fromLatLngAltitude() का इस्तेमाल किया गया है:

const camera = new THREE.PerspectiveCamera();
const matrix = coordinateTransformer.fromLatLngAltitude({
    lat: mapOptions.center.lat,
    lng: mapOptions.center.lng,
    altitude: 120,
});
camera.projectionMatrix = new THREE.Matrix4().fromArray(matrix);

उदाहरण

यहां मैप पर 3D ऑब्जेक्ट डालने के लिए, लोकप्रिय और ओपन सोर्स WebGL लाइब्रेरी Three.js का इस्तेमाल करने का एक आसान उदाहरण दिया गया है. इस पेज पर सबसे ऊपर दिख रहे उदाहरण को बनाने के लिए, WebGL ओवरले व्यू का इस्तेमाल करने के बारे में पूरी जानकारी पाने के लिए, WebGL की मदद से बेहतर मैप अनुभव देने वाले ऐप्लिकेशन बनाने का कोडलैब आज़माएं.

const webglOverlayView = new google.maps.WebGLOverlayView();
let scene, renderer, camera, loader;

webglOverlayView.onAdd = () => {
  // Set up the Three.js scene.
  scene = new THREE.Scene();
  camera = new THREE.PerspectiveCamera();
  const ambientLight = new THREE.AmbientLight( 0xffffff, 0.75 ); // Soft white light.
  scene.add(ambientLight);

  // Load the 3D model with GLTF Loader from Three.js.
  loader = new GLTFLoader();
  loader.load("pin.gltf");
}

webglOverlayView.onContextRestored = ({gl}) => {
  // Create the Three.js renderer, using the
  // maps's WebGL rendering context.
  renderer = new THREE.WebGLRenderer({
    canvas: gl.canvas,
    context: gl,
    ...gl.getContextAttributes(),
  });
  renderer.autoClear = false;
}

webglOverlayView.onDraw = ({gl, transformer}) => {
  // Update camera matrix to ensure the model is georeferenced correctly on the map.
  const matrix = transformer.fromLatLngAltitude({
      lat: mapOptions.center.lat,
      lng: mapOptions.center.lng,
      altitude: 120,
  });
camera.projectionMatrix = new THREE.Matrix4().fromArray(matrix);

  // Request a redraw and render the scene.
  webglOverlayView.requestRedraw();
  renderer.render(scene, camera);

  // Always reset the GL state.
  renderer.resetState();
}

// Add the overlay to the map.
webglOverlayView.setMap(map);