WebGL ओवरले व्यू

सैंपल देखें

WebGL ओवरले व्यू की मदद से, सीधे WebGL का इस्तेमाल करके, अपने मैप में कॉन्टेंट जोड़ा जा सकता है, या लोकप्रिय ग्राफ़िक्स लाइब्रेरी, जैसे कि तीन.jss शामिल हैं. 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}) को कॉल किया जाता है उपलब्ध हैं. किसी भी WebGL स्थिति को शुरू करने या बाइंड करने के लिए इसका इस्तेमाल करें, जैसे कि शेडर, GL बफ़र ऑब्जेक्ट वगैरह. onContextRestored() ने WebGLStateOptions लिया जिसमें एक फ़ील्ड होता है:
  • gl, WebGLRenderingContext का एक हैंडल है, जिसका इस्तेमाल बुनियादी मैप में किया जाता है.
• onDraw({gl, transformer}), बुनियादी मैप पर सीन रेंडर करता है. onDraw() के लिए पैरामीटर एक WebGLDrawOptions ऑब्जेक्ट है, जिसमें दो हैं फ़ील्ड:
  • gl, WebGLRenderingContext का एक हैंडल है, जिसका इस्तेमाल बुनियादी मैप में किया जाता है.
  • transformer मैप से बदलने के लिए हेल्पर फ़ंक्शन देता है मॉडल-व्यू-प्रोजेक्शन मैट्रिक्स के निर्देशांकों का इस्तेमाल करके मैप के निर्देशांकों का वर्ल्ड स्पेस, कैमरा स्पेस, और स्क्रीन में अनुवाद करें स्पेस.
• onContextLost() को तब कॉल किया जाता है, जब रेंडरिंग कॉन्टेक्स्ट किसी और यहां आपको पहले से मौजूद जीएल स्टेट को साफ़ करना चाहिए, क्योंकि अब ज़रूरत नहीं है.
• onStateUpdate({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);

जीएल स्टेट रीसेट किया जा रहा है

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

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

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

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

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

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

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

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

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);

उदाहरण

नीचे Three.js का इस्तेमाल करने का आसान उदाहरण दिया गया है, लोकप्रिय, ओपन सोर्स WebGL लाइब्रेरी, का इस्तेमाल कर मैप पर 3D ऑब्जेक्ट रखा जा सकता है. जो उदाहरण आपको दिख रहा है उसे बनाने के लिए, WebGL ओवरले व्यू का इस्तेमाल करने के बारे में सिलसिलेवार तरीके से निर्देश दें जो इस पेज के सबसे ऊपरी हिस्से में है, तो WebGL-Accelerated Map Experience के लिए कोडलैब बनाना.

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);