ब्राउज़र ओपन वर्ल्ड के लिए डायनामिक LOD और स्ट्रीमिंग के साथ लैंडस्केप जेनरेशन

Perlin noise के साथ हाइटमैप प्रोसीजरल टेरेन के लिए डिफ़ॉल्ट शुरुआती पॉइंट हैं। fBm के कुछ octaves लेयर करें, एक कलर ग्रेडिएंट लगाएं, और आपके पास कुछ ऐसा है जो टेरेन जैसा दिखता है। हर ट्यूटोरियल यहीं खत्म होता है। लेकिन असली लैंडस्केप स्टैक किए हुए नॉइज़ जैसे नहीं दिखते। उनमें पानी से कटी हुई नदी घाटियां होती हैं, स्ट्रेस फ्रैक्चर से बनी चट्टानों की सतहें होती हैं, और लाखों सालों के कटाव से बनी गुफाएं और मेहराब होते हैं। उनमें कोरिलेटेड टेक्सचर होते हैं (समतल जमीन पर घास, खड़ी ढलानों पर चट्टान, ट्रीलाइन के ऊपर बर्फ) जो उन्हीं फिजिकल प्रोसेस से उभरते हैं जिन्होंने ज्यामिति को आकार दिया।

यह गाइड बताती है कि नॉइज़ के बाद क्या आता है। फिजिकली ग्राउंडेड जेनरेशन मेथड, वॉल्यूमेट्रिक रिप्रेजेंटेशन जो गुफाओं और ओवरहैंग को संभालते हैं, डिफ्यूज़न-आधारित न्यूरल टेरेन सिंथेसिस, और GPU-ड्रिवन LOD और स्ट्रीमिंग पाइपलाइन जो इन सबको एक ब्राउज़र टैब में 60fps पर रेंडर करने के लिए चाहिए।

यहां सब कुछ हमारी खास बाधा को ध्यान में रखकर बनाया गया है: एक मल्टीप्लेयर ओपन वर्ल्ड जो WebGL 2 / WebGPU में चलता है, नेटवर्क पर स्ट्रीम होता है, और जिसे क्रिएटर एडिट कर सकते हैं।

हाइटमैप क्यों काफी नहीं हैं

एक हाइटमैप हर ग्रिड पॉइंट पर एक हाइट वैल्यू स्टोर करता है। यह एक 2D फंक्शन है: (x, z) दिया जाए, तो y लौटाओ। यह रिप्रेजेंटेशन कॉम्पैक्ट है, GPU-फ्रेंडली है, और रेंडर करने में तेज है। लेकिन इसकी कुछ बुनियादी सीमाएं हैं जो एक क्रिएटर वर्ल्ड के लिए मायने रखती हैं।

कोई गुफा या ओवरहैंग नहीं। एक हाइटमैप ऐसे टेरेन को रिप्रेजेंट नहीं कर सकता जहां एक पॉइंट की दो अलग-अलग हाइट हों। गुफाएं, मेहराब, चट्टानों के ओवरहैंग, सुरंगें और तैरते हुए द्वीप सब असंभव हैं। Minecraft, No Man's Sky और Deep Rock Galactic सभी को इसी कारण वॉल्यूमेट्रिक टेरेन चाहिए।

कोई वर्टिकल फीचर नहीं। हाइटमैप में एक खड़ी चट्टान की सतह लगभग अनंत ढलान होती है, जो भारी टेक्सचर स्ट्रेचिंग और कोलिज़न आर्टिफैक्ट पैदा करती है। असली चट्टानों में horizontal फीचर होते हैं (कगार, दरारें) जिन्हें एक हाइटमैप रिप्रेजेंट नहीं कर सकता।

नॉइज़ नॉइज़ जैसा ही दिखता है। fBm के 8 octaves और domain warping के साथ भी टेरेन में एक बनावटी गुणवत्ता रहती है। इसमें असली भूविज्ञान की दिशात्मक संरचना नहीं होती: रिज लाइन, ड्रेनेज नेटवर्क, sediment deposits, टेक्टोनिक फोल्ड। ये पैटर्न फिजिकल प्रोसेस से उभरते हैं, नॉइज़ फंक्शन से नहीं।

क्रिएटर एडिट सीमित हैं। अगर क्रिएटर सिर्फ हाइट बदल सकते हैं, तो वे सुरंग नहीं खोद सकते, गुफाएं नहीं बना सकते, या भूमिगत जगहें नहीं बना सकते। एक ऐसी दुनिया के लिए जिसे क्रिएटर सचमुच आकार दे सकें, टेरेन रिप्रेजेंटेशन को जोड़ने के साथ-साथ घटाने (subtraction) को भी सपोर्ट करना होगा।

समाधान हाइटमैप को पूरी तरह छोड़ देना नहीं है। टेरेन के 90% हिस्से के लिए जो एक साधारण सतह है, वे अब भी सबसे अच्छा रिप्रेजेंटेशन हैं। समाधान एक हाइब्रिड तरीका है: हाइटमैप बेस टेरेन के साथ वॉल्यूमेट्रिक ओवरले वहां जहां जटिल ज्यामिति चाहिए, असली लैंडफॉर्म के लिए फिजिकली करेक्ट जेनरेशन, और उस विविधता के लिए न्यूरल सिंथेसिस जो नॉइज़ हासिल नहीं कर सकता।

क्विक जवाब: हम असल में क्या बनाएंगे

गहराई में जाने से पहले, यह रहा डिसीजन फ्रेमवर्क। बाकी लेख हर हिस्से को समझाता है।

टेरेन रिप्रेजेंटेशन

एक हाइब्रिड हाइटमैप + SDF सिस्टम इस्तेमाल करें। हाइटमैप पूरी दुनिया को कवर करता है (सस्ता, कॉम्पैक्ट, आजमाया हुआ)। SDF वॉल्यूम सिर्फ वहां मौजूद होते हैं जहां गुफाओं, ओवरहैंग, या क्रिएटर-कार्व्ड फीचर की जरूरत हो (शायद 5-10% chunks)। इससे दुनिया का 90% हिस्सा हाइटमैप कॉस्ट पर रहता है, और जहां जरूरत हो वहां मनचाही ज्यामिति सपोर्ट होती है।

जेनरेशन पाइपलाइन

सर्वर-साइड एक chained प्रोसेस के रूप में चलाएं:

1. Terrain Diffusion (या टेक्स्ट प्रॉम्प्ट के लिए MESA) एक seed से बेस हाइटमैप जेनरेट करता है। यह नॉइज़ की जगह असली एलिवेशन डेटा पर ट्रेन किए गए भूगर्भीय रूप से असली लैंडफॉर्म देता है।
2. एनालिटिकल इरोज़न (stream power law) हाइटमैप को नदी नेटवर्क और रिजलाइन के साथ मिलीसेकंड में रिफाइन करता है।
3. TerraFusion या Geodiffussr हाइटमैप से कोरिलेटेड टेक्सचर जेनरेट करते हैं (या WebGL 2 fallback के लिए प्रोसीजरल slope/altitude नियम इस्तेमाल करें)।
4. Ecosystem सिमुलेशन वनस्पति घनत्व के नक्शे बनाता है।
5. Arenite-स्टाइल इरोज़न चट्टानों की सतहों, मेहराबों और गुफाओं के लिए SDF वॉल्यूम जेनरेट करता है, जहां टेरेन को उनकी जरूरत हो।
6. Chunk बनाएं, कंप्रेस करें, CDN पर अपलोड करें। औसत chunk: 2-8 KB। वॉल्यूमेट्रिक डेटा वाला जटिल chunk: 20-100 KB।

क्रिएटर इस पाइपलाइन के साथ पैरामीटर एडजस्ट करके ("ज्यादा गीला," "ज्यादा पहाड़ी," "गुफाएं जोड़ो"), इरादा स्केच करके, या ब्रश और SDF टूल से सीधे sculpt करके इंटरैक्ट करते हैं।

LOD स्ट्रेटजी

ब्राउज़र क्षमता	हाइटमैप LOD	वॉल्यूमेट्रिक LOD	वनस्पति LOD
WebGPU	compute culling + indirect draw के साथ GPU-ड्रिवन quadtree (CDLOD)	compute marching cubes + Transvoxel के साथ मल्टी-रिज़ॉल्यूशन SDF	indirect draw के साथ ComputeInstanceCulling
WebGL 2	CPU-साइड ring अपडेट के साथ geometry clipmaps	2-3 LOD लेवल पर पहले से जेनरेट की गई और कैश की गई मेश	CPU frustum cull, InstancedMesh

दोनों रास्ते pop-free ट्रांज़िशन के लिए vertex shader में geomorphing इस्तेमाल करते हैं। दोनों दूर की वनस्पति के लिए billboard impostor इस्तेमाल करते हैं। WebGPU रास्ता तेज है (3.5ms टेरेन बजट) लेकिन WebGL 2 रास्ता भी चलने लायक है (6.5ms)।

स्ट्रीमिंग

प्रोग्रेसिव लोडिंग: पहले टेरेन ज्यामिति (<100ms), दूसरे नंबर पर टेक्सचर (<300ms), तीसरे नंबर पर वनस्पति (<1s), चौथे नंबर पर वॉल्यूमेट्रिक डेटा (<3s)। प्लेयर की वेलोसिटी के आधार पर pre-fetch करें। मेमोरी बजट: कुल 256 MB टेरेन।

एडिटिंग

सरफेस sculpting के लिए हाइटमैप ब्रश (raise, lower, smooth, erode)। वॉल्यूमेट्रिक एडिटिंग के लिए SDF प्रिमिटिव (गुफाएं carve करें, मेहराब जोड़ें)। दोनों लोकल पर तुरंत होते हैं, 100-300ms में सर्वर के साथ sync होते हैं, और delta अपडेट के जरिए बाकी प्लेयर तक broadcast होते हैं।

किस क्रम में क्या बनाएं

महीना 1-2: geometry clipmaps के साथ हाइटमैप टेरेन। सिर्फ WebGL 2। CDN से स्ट्रीमिंग। प्रोसीजरल slope/altitude मटेरियल। इससे हर ब्राउज़र में स्क्रीन पर टेरेन आ जाता है। जेनरेशन के लिए नॉइज़ + एनालिटिकल इरोज़न इस्तेमाल करें (Terrain Diffusion रुक सकता है)।

महीना 3-4: वनस्पति और वातावरण। density maps से GPU-instanced घास और पेड़। दिन/रात के चक्र के साथ प्रोसीजरल आसमान। वातावरण की धुंध। Cascaded shadow maps। दुनिया एक जगह जैसी लगने लगती है।

महीना 5-6: क्रिएटर एडिटिंग। हाइटमैप ब्रश टूल। मल्टीप्लेयर टेरेन एडिट के लिए delta-आधारित sync। एक साथ एडिटिंग के लिए spatial locking। यहीं से क्रिएटर दुनिया को आकार देना शुरू करते हैं।

महीना 7-9: वॉल्यूमेट्रिक टेरेन और WebGPU रास्ता। गुफाओं और ओवरहैंग के लिए SDF ओवरले। WebGPU compute में marching cubes। LOD boundaries के लिए Transvoxel। SDF sculpting टूल। इससे पूरा क्रिएशन टूलकिट खुल जाता है।

महीना 10-12: न्यूरल जेनरेशन और पॉलिश। बेस हाइटमैप के लिए Terrain Diffusion या MESA। टेक्सचर के लिए TerraFusion/Geodiffussr। माइक्रो-डिटेल के लिए Phasor noise। anti-repetition के लिए Hex-tiling। Virtual texturing। Laplacian blending। टेरेन प्रोडक्शन क्वालिटी तक पहुंचता है।

इस क्रम का मतलब है कि 2 महीने बाद कुछ खेलने लायक मौजूद होता है, 4 महीने बाद कुछ सुंदर, 6 महीने बाद कुछ एडिट करने लायक, और 12 महीने बाद कुछ अत्याधुनिक।

बाकी लेख हर फैसले के पीछे की रिसर्च है।

हाइटमैप से आगे के टेरेन रिप्रेजेंटेशन

Signed Distance Fields (SDFs)

एक signed distance field 3D स्पेस में हर पॉइंट पर सबसे नज़दीकी सतह तक की दूरी स्टोर करता है। पॉज़िटिव वैल्यू बाहर हैं, नेगेटिव वैल्यू अंदर हैं, और zero-crossing खुद सतह है। SDF मनचाहे 3D आकार रिप्रेजेंट करते हैं, जिनमें गुफाएं, मेहराब और तैरती हुई ज्यामिति शामिल हैं।

एक SDF को मेश के रूप में रेंडर करने के लिए, आप zero-crossing को त्रिभुजों के रूप में निकालने के लिए marching cubes (या इसका एक वैरिएंट) चलाते हैं। मेश रिज़ॉल्यूशन ग्रिड रिज़ॉल्यूशन पर निर्भर करता है: एक 256x256x256 SDF ग्रिड 1-मीटर रिज़ॉल्यूशन पर लगभग एक chunk जितना टेरेन देता है।

ब्राउज़र इम्प्लीमेंटेशन: WebGPU marching cubes compute shaders के जरिए पूरी तरह GPU पर चलता है। Will Usher का webgpu-marching-cubes इम्प्लीमेंटेशन ब्राउज़र में रियल टाइम में एक 256^3 ग्रिड प्रोसेस करता है, और native-स्पीड परफॉर्मेंस हासिल करता है। यह एल्गोरिदम बेहद parallel है (हर cell अलग से प्रोसेस होती है), जो इसे GPU compute के लिए आदर्श बनाता है।

@compute @workgroup_size(4, 4, 4)
fn marchingCubes(@builtin(global_invocation_id) id: vec3<u32>) {
    let sdfValues = sampleSDF(id);
    let caseIndex = classifyCell(sdfValues);
    if (caseIndex == 0u || caseIndex == 255u) { return; }
    let triangles = lookupTriangulation(caseIndex);
    let vertices = interpolateEdges(sdfValues, triangles);
    appendToMeshBuffer(vertices);
}

स्टोरेज कॉस्ट: एक 256^3 SDF 8-bit quantized precision पर uncompressed 16 MB है। लेकिन ज्यादातर वॉल्यूम खाली है (सतह से दूर)। Run-length encoding या sparse octree स्टोरेज आमतौर पर इसे प्रति chunk 100-500 KB तक घटा देता है, जो हाइटमैप टेरेन के बराबर है।

एडिटिंग: SDF टेरेन स्वाभाविक रूप से एडिट करने लायक है। मटेरियल जोड़ना distance field पर एक min() ऑपरेशन है। मटेरियल हटाना (खोदना) एक negated आकार के साथ max() है। आकारों के बीच smooth blending smoothMin() इस्तेमाल करती है। ये ऑपरेशन compute shader में इंटरैक्टिव रेट पर चलते हैं।

Dual Contouring

Marching cubes vertices को ग्रिड edges पर रखता है, जिससे smooth सतहें बनती हैं लेकिन sharp फीचर (चट्टान के किनारे, चट्टान के कोने) खो जाते हैं। Dual contouring हर cell में एक vertex उस पोज़ीशन पर रखता है जो उस cell के अंदर सतह को सबसे अच्छे से दर्शाती है, और इस तरह sharp किनारे और कोने बचाता है।

इस एल्गोरिदम को हर ग्रिड पॉइंट पर distance field वैल्यू और सतह के normals (SDF का gradient) दोनों चाहिए। यह सबसे अच्छी vertex पोज़ीशन ढूंढने के लिए हर cell पर एक छोटी least-squares समस्या हल करता है। नतीजा एक ऐसी मेश है जो smooth टेरेन और sharp चट्टानी फीचर दोनों को पकड़ती है।

Neural Dual Contouring (Chen et al., 2022, arXiv:2202.01999) least-squares solver की जगह एक neural network रखता है जो सबसे अच्छी vertex पोज़ीशन और edge crossings की भविष्यवाणी करता है। यह बेहतर सतह reconstruction सटीकता और फीचर संरक्षण हासिल करता है, खासकर जटिल प्राकृतिक चट्टानी संरचनाओं के लिए।

Transvoxel एल्गोरिदम

वॉल्यूमेट्रिक टेरेन में सबसे कठिन समस्या मेश जेनरेट करना नहीं है। यह LOD ट्रांज़िशन हैं। जब एक हाई-रिज़ॉल्यूशन chunk एक लो-रिज़ॉल्यूशन chunk के बगल में होता है, तो boundary पर मेश आपस में मेल नहीं खातीं, जिससे दिखने वाली दरारें बनती हैं।

Transvoxel एल्गोरिदम, जिसे Eric Lengyel (transvoxel.org) ने डिज़ाइन किया, रिज़ॉल्यूशन के बीच की boundaries पर खास transition cells डालकर इसे हल करता है। ये cells अतिरिक्त त्रिभुजों के साथ रिज़ॉल्यूशन के फर्क को पाटती हैं जो दोनों तरफ से बिल्कुल मेल खाते हैं। यह एल्गोरिदम जटिल boundary समस्या को 73 equivalence classes तक घटा देता है (brute-force तरीके के लगभग 12 लाख मामलों की तुलना में)।

Transvoxel खास तौर पर रियल-टाइम एप्लिकेशन के लिए डिज़ाइन किया गया है जहां voxel डेटा डायनामिक रूप से बदलता है (क्रिएटर एडिट, इरोज़न, mining)। यह patent-free है और इसे शिप हुए गेम में इस्तेमाल किया गया है (Space Engineers, Astroneer)। एडिट करने लायक वॉल्यूमेट्रिक टेरेन वाली ब्राउज़र दुनिया के लिए, Transvoxel ही LOD समाधान है।

हाइब्रिड: हाइटमैप बेस + वॉल्यूमेट्रिक ओवरले

एक ब्राउज़र ओपन वर्ल्ड के लिए व्यावहारिक तरीका एक लेयर्ड सिस्टम है:

लेयर 1: हाइटमैप टेरेन पूरी दुनिया को कवर करता है। यह लहरदार पहाड़ियों, घाटियों और पर्वतों के लिए सस्ता, कॉम्पैक्ट रिप्रेजेंटेशन है। यह प्रति chunk छोटे हाइटमैप patches (हर एक 2-4 KB) के रूप में स्ट्रीम होता है। रेंडरिंग स्थिर GPU कॉस्ट के साथ geometry clipmaps इस्तेमाल करती है।

लेयर 2: वॉल्यूमेट्रिक ओवरले सिर्फ उन chunks में मौजूद होते हैं जहां जटिल ज्यामिति चाहिए। गुफाएं, चट्टानों की सतहें, मेहराब, क्रिएटर-कार्व्ड सुरंगें और भूमिगत जगहें sparse SDF वॉल्यूम के रूप में स्टोर होती हैं। सिर्फ वॉल्यूमेट्रिक डेटा वाले chunks ही SDF स्टोरेज और marching cubes कॉस्ट उठाते हैं।

लेयर 3: क्रिएटर बदलाव बेस लेयर के ऊपर SDF एडिट के रूप में स्टोर होते हैं। एक क्रिएटर जो सुरंग खोदता है, सुरंग का SDF आकार स्टोर करता है। रेंडरिंग सिस्टम हाइटमैप सतह को वॉल्यूमेट्रिक subtractions और additions के साथ मिलाकर अंतिम मेश बनाता है।

इस हाइब्रिड में समतल टेरेन की कीमत लगभग शून्य है (बस हाइटमैप), और यह सिर्फ वहीं स्केल करता है जहां जटिलता मौजूद हो। एक आम दुनिया में, शायद 5-10% chunks को वॉल्यूमेट्रिक डेटा की जरूरत होती है।

फिजिकली करेक्ट टेरेन जेनरेशन

नॉइज़ रैंडम टेरेन बनाता है। फिजिक्स असली टेरेन बनाता है। फर्क साफ दिखता है: नॉइज़ टेरेन में कोई संरचना नहीं होती (यह हर जगह रैंडम रूप से उबड़-खाबड़ है), जबकि फिजिकल टेरेन में नदी नेटवर्क, रिज लाइन, alluvial fans और cliff bands होते हैं जो इरोज़न और टेक्टोनिक्स से उभरते हैं।

Hydraulic इरोज़न: नींव

Sebastian Lague का hydraulic इरोज़न इम्प्लीमेंटेशन एक्शन में। सिमुलेटेड बारिश की बूंदें ढलान पर बहती हैं, स्पीड और ढलान के आधार पर मटेरियल काटती हैं, और वेलोसिटी गिरने पर sediment जमा करती हैं, और समतल नॉइज़ को नदी घाटियों, रिजलाइन और alluvial fans में बदल देती हैं।

पानी ढलान पर बहता है, sediment उठाता है, और धीमा होने पर उसे जमा कर देता है। यह एकमात्र प्रोसेस, लाखों वर्चुअल सालों तक सिमुलेट किया जाए, तो बेरंग नॉइज़ को पहचाने जाने लायक भूगर्भीय फीचर वाले टेरेन में बदल देता है।

particle-आधारित तरीका हाइटमैप पर सिमुलेटेड बारिश की बूंदें गिराता है। हर बूंद ढलान पर बहती है (gradient का पीछा करते हुए), स्पीड और ढलान के आधार पर मटेरियल काटती है, घुले हुए भार के रूप में sediment ले जाती है, और वेलोसिटी घटने या क्षमता पार होने पर sediment जमा करती है। 200,000-500,000 particles के बाद टेरेन में बनते हैं:

• नदी घाटियां जो अधिकतम पानी के बहाव के रास्ते पर चलती हैं
• रिज लाइन जो drainage basins को अलग करती हैं
• Alluvial fans जहां खड़ी घाटियां समतल मैदानों में खुलती हैं
• V-आकार की घाटियां पहाड़ी टेरेन में, और U-आकार की हिमनद टेरेन में

GPU इम्प्लीमेंटेशन: particle सिमुलेशन parallelizable है। हर particle स्वतंत्र है (अनुमान particle-particle इंटरैक्शन को नजरअंदाज करता है, जो इरोज़न के लिए ठीक है)। एक WebGPU compute shader 60fps पर हर फ्रेम 10,000 particles प्रोसेस करता है, और 200,000 particles करीब 3 सेकंड के रियल टाइम में पूरे करता है।

Sebastian Lague का ओपन-सोर्स इम्प्लीमेंटेशन (GitHub) मानक शुरुआती पॉइंट है। यह C# में एक ही थ्रेड पर चलता है और एक 1024x1024 हाइटमैप को कुछ सेकंड में प्रोसेस करता है। GPU वर्ज़न 50-100x तेज है।

Thermal इरोज़न

पानी ही एकमात्र इरोज़न बल नहीं है। तापमान में बदलाव से चट्टान में दरार पड़ती है और वह टूटती है (thermal weathering)। जब दो टेरेन पॉइंट के बीच की ढलान किसी मटेरियल के angle of repose से ज्यादा हो जाती है, तो मटेरियल ऊंचे पॉइंट से नीचे वाले पॉइंट पर गिरता है। इससे बनते हैं:

• Talus slopes चट्टानों के आधार पर (गिरी हुई चट्टान के ढेर)
• Softened रिज लाइन समय के साथ
• मटेरियल पर निर्भर प्रोफाइल (कठोर चट्टान खड़ी ढलानें बनाए रखती है, नरम मिट्टी ढलकर हल्के कोण बनाती है)

Thermal इरोज़न hydraulic इरोज़न से सरल है। यह एक local ऑपरेशन है: हर cell के लिए, पड़ोसियों के साथ हाइट के फर्क की तुलना करें। अगर ढलान threshold से ज्यादा हो, तो मटेरियल नीचे की ओर ले जाएं। यह हर iteration पर एक ही compute shader पास के रूप में चलता है और 50-100 iterations में converge हो जाता है।

hydraulic और thermal इरोज़न को मिलाने से ऐसा टेरेन बनता है जो दोनों में से किसी एक की तुलना में नाटकीय रूप से ज्यादा प्राकृतिक दिखता है। पानी घाटियां काटता है, thermal इरोज़न उनके बीच की रिज को नरम करता है और घाटी के फर्श को मलबे से भरता है।

Stream Power Law: एनालिटिकल इरोज़न

हाल की रिसर्च particle-आधारित सिमुलेशन का एक विकल्प देती है। stream power law (एक भू-आकृति विज्ञान समीकरण जो इरोज़न रेट को drainage area और ढलान से जोड़ता है) को iteratively सिमुलेट करने के बजाय analytically हल किया जा सकता है।

Cordonnier et al. (2024, HAL) एनालिटिकल stream power law को landslide और hillslope diffusion प्रोसेस के साथ मिलाते हैं। नतीजा एक ऐसा टेरेन जेनरेशन है जो फिजिकली ग्राउंडेड है लेकिन एक टेम्पोरल सिमुलेशन के बजाय एक गणितीय फंक्शन के रूप में चलता है। आप एक नॉइज़-आधारित हाइटमैप और पैरामीटर (बारिश की दर, चट्टान की कठोरता, टेक्टोनिक uplift दर) डालते हैं और मिलीसेकंड में एक eroded टेरेन पाते हैं।

यह एनालिटिकल तरीका एक ब्राउज़र दुनिया के लिए आदर्श है क्योंकि यह टेरेन जेनरेशन के दौरान सर्वर-साइड एक बार चलता है, iteratively नहीं। पैरामीटर क्रिएटर ट्यून कर सकते हैं ("इस इलाके को ज्यादा पहाड़ी बनाओ" uplift दर एडजस्ट करता है, "इसे ज्यादा गीला करो" बारिश बढ़ाता है और घाटियों को गहरा करता है)।

Arenite: मल्टी-फिजिक्स इरोज़न (SIGGRAPH 2025)

Arenite stress, wind इरोज़न, fluvial इरोज़न और particle deposition को सिमुलेट करके लेयर्ड चट्टान से मेहराब, hoodoos और buttes जेनरेट करता है। सर्वर-साइड जेनरेशन SDF वॉल्यूम देता है जो सीधे एक marching cubes पाइपलाइन में जाता है।

Arenite (Project page) एक फिजिक्स-आधारित sandstone सिमुलेटर है जो साधारण शुरुआती परिस्थितियों से मेहराब, alcoves, hoodoos और buttes जेनरेट करता है। यूज़र erodability मैप पेंट करते हैं (नरम चट्टान बनाम कठोर चट्टान की लेयर) और वनस्पति, फिर सिस्टम सिमुलेट करता है:

• Stress distribution चट्टान के स्तंभ से होकर
• Wind इरोज़न जो खुले हुए नरम मटेरियल को प्राथमिकता से हटाता है
• Fluvial इरोज़न पानी के बहाव से
• Particle deposition जो नई संरचनाएं बनाता है

GPU इम्प्लीमेंटेशन एक डेस्कटॉप GPU पर जटिल संरचनाओं के लिए 5 मिनट से कम में चलता है। हालांकि यह रियल-टाइम ब्राउज़र इस्तेमाल के लिए बहुत धीमा है, यह सर्वर-साइड जेनरेशन के लिए काफी तेज है। एक क्रिएटर नरम/कठोर चट्टान की लेयर के साथ एक चट्टान की सतह तय कर सकता है और मिनटों में एक असली मेहराब संरचना पा सकता है।

आउटपुट एक 3D voxel field है, जो सीधे हमारी SDF/marching cubes पाइपलाइन में फिट हो जाता है।

रिप्रेजेंटेशन के पार Flexible इरोज़न

IRIT-STORM का 2024 का एक पेपर ("Flexible Terrain Erosion," Springer) एक व्यावहारिक समस्या हल करता है: ज्यादातर इरोज़न मेथड सिर्फ heightfields पर काम करते हैं। अगर आपका टेरेन voxels, SDFs, या लेयर्ड मटेरियल इस्तेमाल करता है, तो आपको हर एक के लिए अलग इरोज़न कोड चाहिए।

flexible इरोज़न मेथड इरोज़न को दो स्वतंत्र प्रोसेस में बांटता है: टेरेन alteration (सतह से मटेरियल हटाना) और material transport (बुनियादी फिजिक्स से चलने वाले particles के साथ sediment ले जाना)। हर particle का size, density, restitution और sediment क्षमता configurable होती है। एक वैकल्पिक vector field असली fluid dynamics के लिए particle की गति को नियंत्रित करता है।

क्योंकि particles एक unified material alteration इंटरफेस के जरिए टेरेन से इंटरैक्ट करते हैं, वही सिमुलेशन heightfields, voxel grids, implicit surfaces और लेयर्ड मटेरियल stacks पर काम करता है। हमारे हाइब्रिड टेरेन (हाइटमैप बेस + SDF ओवरले) के लिए, इसका मतलब है कि एक इरोज़न सिस्टम दोनों रिप्रेजेंटेशन संभालता है। particle सिमुलेशन GPU पर parallel चलता है।

River Networks और Drainage Basins

इरोज़न नदियां काटता है, लेकिन भरोसेमंद river networks जेनरेट करने के लिए सिर्फ पानी को ढलान पर बहाना काफी नहीं है। दो तरीके बेहतर नतीजे देते हैं:

Drainage-first जेनरेशन (Amit Patel, Red Blob Games, Project) एलिवेशन देने से पहले river network बनाता है। एक graph से शुरू करें (Voronoi या triangle mesh)। edges को रिज (कोई बहाव नहीं), entries (पानी अंदर आता है), या outlets (पानी बाहर जाता है) के रूप में वर्गीकृत करें। इससे असली drainage hierarchies बनती हैं जहां नदियां छोटी सहायक नदियों से मिलकर बड़ी जलधाराओं में बदलती हैं, और अलग-अलग नदी प्रकारों के लिए Rosgen classification system का पालन करती हैं (समतल टेरेन में braided channels, पर्वतों में संकरी घाटियां)।

Flow accumulation ट्रैक करता है कि हर टेरेन cell से कितना पानी गुजरता है। सिमुलेटेड बारिश को समान रूप से गिराएं, उसे ढलान पर बहाएं, और हर cell के visits गिनें। ज्यादा accumulation वाली cells नदी के channels हैं। मध्यम accumulation वाली cells मौसमी धाराएं हैं। accumulation मैप इरोज़न की तीव्रता (ज्यादा पानी = ज्यादा इरोज़न) और वनस्पति वितरण (नदी के किनारे ज्यादा गीले होते हैं, अलग पौधों की प्रजातियों को सहारा देते हैं) को भी चलाता है।

एक क्रिएटर दुनिया के लिए, river network टेरेन बनाते वक्त सर्वर-साइड जेनरेट होता है और प्रति chunk एक 2D flow direction मैप और एक water accumulation मैप के रूप में स्टोर होता है। ब्राउज़र क्लाइंट इन मैप का इस्तेमाल पानी की सतह रेंडर करने (नदी के channels में सही हाइट पर समतल plane) और वनस्पति वितरण चलाने (पानी के पास हरियाली ज्यादा) के लिए करता है।

Coastal और Shoreline जेनरेशन

समुद्र तट वे जगह हैं जहां टेरेन पानी से मिलता है, और इनमें खास फीचर होते हैं जो मानक इरोज़न नहीं बनाता: समुद्री चट्टानें, beach deposits, tidal flats, sea stacks और wave-cut platforms।

NEWTS1.0 (2024, MIT) दो इरोज़न तंत्रों का इस्तेमाल करके चट्टानी समुद्र तट के विकास को मॉडल करता है: uniform retreat (स्थिर इरोज़न दर) और wave-driven इरोज़न (fetch distance और incident wave angle के फंक्शन के रूप में इरोज़न दर)। यह मॉडल हजारों सिमुलेटेड सालों तक चलता है और headlands, खाड़ियां, sea stacks और मेहराब बनाता है जो असली coastal भू-आकृति विज्ञान से मेल खाते हैं।

एक ब्राउज़र दुनिया के लिए, coastal फीचर दुनिया बनाते वक्त पहले से जेनरेट होंगे। पैरामीटर (प्रमुख wave direction, तट के साथ चट्टान की कठोरता में बदलाव) क्रिएटर को उनके समुद्र तट का चरित्र नियंत्रित करने देते हैं। एक "Norwegian fjord" सेटिंग खड़ी किनारों वाली inlets बनाती है। एक "tropical atoll" सेटिंग lagoons के साथ नीची रेतीली तटरेखाएं बनाती है।

Cave और Underground जेनरेशन

गुफाओं को पूरी तरह वॉल्यूमेट्रिक टेरेन (SDFs या voxels) चाहिए क्योंकि हाइटमैप बंद जगहों को रिप्रेजेंट नहीं कर सकते। जेनरेशन के तरीके:

3D noise thresholding सबसे सरल मेथड है। हर voxel पर 3D Perlin या simplex noise sample करें। threshold से नीचे की वैल्यू ठोस हैं, ऊपर की खाली। threshold और noise पैरामीटर एडजस्ट करके सुरंग का व्यास, connectivity और chamber size नियंत्रित करें। इससे organic, कीड़े जैसी गुफा प्रणालियां बनती हैं जो Minecraft की याद दिलाती हैं।

PLUME (Procedural Layer Underground Modeling Engine) (2024, arXiv:2508.20926) लेयर्ड प्रोसीजरल नियमों का इस्तेमाल करके असली गुफा और lava tube वातावरण जेनरेट करता है। मूल रूप से अंतरिक्ष अन्वेषण रिसर्च के लिए बनाया गया (मंगल के lava tubes को सिमुलेट करते हुए), यह stalactites, columns और chamber systems के साथ भूगर्भीय रूप से संभव भूमिगत संरचनाएं बनाता है।

metaball carving के साथ L-system सुरंगें एक L-system grammar का इस्तेमाल करके टेरेन से होकर शाखाओं वाले सुरंग रास्ते उगाती हैं, फिर metaball implicit surfaces का इस्तेमाल करके असल सुरंग ज्यामिति carve करती हैं। metaballs smooth, गोल गुफा की दीवारें बनाते हैं। अलग-अलग पैरामीटर के साथ कई passes प्राथमिक रास्ते, साइड chambers और संकरी जोड़ने वाली सुरंगें बनाते हैं।

एक क्रिएटर दुनिया के लिए, cave जेनरेशन SDF ओवरले सिस्टम से जुड़ती है। बेस टेरेन एक हाइटमैप है (कोई गुफा नहीं)। जब किसी chunk को गुफाएं चाहिए (या तो प्रोसीजरल जेनरेशन से या क्रिएटर डिज़ाइन से), तो एक SDF वॉल्यूम जेनरेट होता है जो बेस टेरेन से cave ज्यामिति घटाता है। marching cubes पाइपलाइन मिली हुई सतह रेंडर करती है।

वनस्पति एक फिजिकल प्रोसेस के रूप में

गेम में वनस्पति आमतौर पर प्रोसीजरल रूप से ऐसे नियमों के साथ रखी जाती है जैसे "2000m से नीचे घास, 1500m से नीचे पेड़, 3000m से ऊपर बर्फ।" यह तेज है लेकिन एकसमान, गैर-असली वितरण बनाता है।

फिजिकली ग्राउंडेड वनस्पति सिमुलेशन हर पौधे को संसाधनों (रोशनी, पानी, मिट्टी के पोषक तत्व) के लिए प्रतिस्पर्धा करते हुए मॉडल करता है। सिमुलेशन:

1. बीज टेरेन पर बिखेरे जाते हैं
2. हर पौधा उपलब्ध संसाधनों के आधार पर बढ़ता है (पानी hydraulic इरोज़न सिमुलेशन से बहता है, धूप ढलान और aspect पर निर्भर करती है, मिट्टी की गहराई इरोज़न इतिहास पर निर्भर करती है)
3. पौधे प्रतिस्पर्धा करते हैं: पेड़ घास को छाया में डाल देते हैं, घना canopy नए seedlings को रोकता है
4. सिमुलेटेड समय के साथ, biomes स्वाभाविक रूप से उभरते हैं: पानी वाली घाटियों में जंगल, हवादार रिज पर विरल वनस्पति, जहां पानी जमा होता है वहां wetlands

Deussen et al. का ecosystem सिमुलेशन (Paper) ऐसे जंगल वितरण बनाता है जो असली पारिस्थितिक पैटर्न से मेल खाते हैं। सिमुलेशन एक 2D ग्रिड पर चलता है (प्रति टेरेन chunk एक cell) और density maps और species assignments बनाता है जिन्हें रेंडरिंग सिस्टम GPU instanced वनस्पति प्लेसमेंट के लिए इस्तेमाल करता है।

एक ब्राउज़र दुनिया के लिए, वनस्पति सिमुलेशन दुनिया जेनरेशन के दौरान एक बार चलता है (सर्वर-साइड)। आउटपुट प्रति chunk density maps का एक सेट है: tree density, grass density, flower density, rock debris density। ब्राउज़र क्लाइंट इन मैप को GPU instancing के साथ इस्तेमाल करके runtime पर वनस्पति बिखेरता है।

Diffusion-आधारित टेरेन सिंथेसिस

यहीं फील्ड सबसे तेजी से आगे बढ़ रहा है। Diffusion models (वही टेक्नोलॉजी जो images के लिए Stable Diffusion के पीछे है) टेरेन जेनरेशन पर लागू की जा रही है, और नतीजे नॉइज़-आधारित मेथड से काफी ज्यादा असली हैं।

Terrain Diffusion: Perlin Noise का उत्तराधिकारी

Terrain Diffusion Minecraft के अंदर चलते हुए, रियल टाइम में अनंत seed-consistent टेरेन स्ट्रीम करते हुए। असली दुनिया के एलिवेशन डेटा पर ट्रेन किया गया, यह ऐसे लैंडस्केप बनाता है जिनकी भूगर्भीय संरचना नॉइज़ फंक्शन मैच नहीं कर सकते।

Terrain Diffusion (Goslin, 2025, arXiv:2512.08309, Project page) 1985 में Perlin noise के बाद से प्रोसीजरल टेरेन जेनरेशन में सबसे बड़ी प्रगति है। इस काम को बाद में SIGGRAPH 2026 में स्वीकार किया गया, और canonical arXiv शीर्षक अब "InfiniteDiffusion: Bridging Learned Fidelity and Procedural Utility for Open-World Terrain Generation" है। InfiniteDiffusion एल्गोरिदम और Terrain Diffusion फ्रेमवर्क एक ही पेपर के दो हिस्से हैं।

मुख्य नवाचार InfiniteDiffusion है, एक एल्गोरिदम जो unbounded domains के लिए diffusion sampling को नए सिरे से तैयार करता है। पारंपरिक diffusion models fixed-size आउटपुट बनाते हैं (जैसे एक 512x512 हाइटमैप)। InfiniteDiffusion अनंत विस्तार का टेरेन बनाता है, साथ में:

• Seed consistency: एक ही seed हमेशा वही टेरेन बनाता है, Perlin noise की तरह
• Constant-time random access: आप पड़ोसी इलाके पहले जेनरेट किए बिना किसी भी पॉइंट पर हाइट query कर सकते हैं
• कोई boundary artifacts नहीं: बिना दिखने वाले seams या repetition के अनंत जेनरेशन

सिस्टम diffusion models का एक hierarchical stack इस्तेमाल करता है। सबसे ऊपरी स्तर ग्रहीय-पैमाने के फीचर पकड़ता है (महाद्वीप, पर्वत श्रृंखलाएं)। हर अगला स्तर बारीक डिटेल जोड़ता है (अलग-अलग चोटियां, घाटियां, छोटे पैमाने का खुरदरापन)। एक compact Laplacian encoding समुद्र तल से हिमालय की चोटियों तक की विशाल dynamic range में आउटपुट को स्थिर करता है।

परफॉर्मेंस: जेनरेशन रियल-टाइम अन्वेषण के साथ कदम मिलाकर चलता है। पेपर रिपोर्ट करता है कि orbital velocity (करीब 7,700 m/s) के सैद्धांतिक चरम पर भी, टेरेन सिंथेसिस एक consumer GPU पर traversal से 9x तेज चलता है। प्रोजेक्ट में एक Minecraft integration शामिल है जो रियल-टाइम टेरेन सिंथेसिस दिखाता है।

यह हमारे लिए क्यों मायने रखता है: Terrain Diffusion असली दुनिया के एलिवेशन डेटा (पृथ्वी की असल भू-आकृति) पर ट्रेन किए गए लैंडस्केप बनाता है। आउटपुट में river networks, पर्वत श्रृंखलाएं, coastal फीचर और plateau संरचनाएं हैं जो training data से उभरती हैं, हाथ से ट्यून किए गए noise पैरामीटर से नहीं। एक क्रिएटर कह सकता है "Scottish Highlands जैसा टेरेन जेनरेट करो" और diffusion model कुछ सही भूगर्भीय चरित्र वाला बनाएगा।

मॉडल दुनिया जेनरेशन के दौरान सर्वर-साइड चलता है। आउटपुट एक मानक हाइटमैप है जो किसी भी अन्य टेरेन डेटा की तरह ब्राउज़र तक स्ट्रीम होता है। जेनरेशन मेथड क्लाइंट के लिए अदृश्य है।

TerraFusion: संयुक्त ज्यामिति और टेक्सचर

TerraFusion एक हाथ से बने स्केच से हाइटमैप और टेक्सचर एक साथ जेनरेट करता है। ज्यामिति और मटेरियल के बीच का सहसंबंध बेक्ड-इन है, नदी के तल रेतीले निकलते हैं, चट्टान की सतहें चट्टानी, समतल जमीन घास वाली, बिना किसी मैन्युअल splat painting के।

TerraFusion (2025, arXiv:2505.04050) हाइटमैप और टेरेन टेक्सचर को संयुक्त रूप से जेनरेट करके आगे जाता है। मुख्य अंतर्दृष्टि: टेरेन ज्यामिति और सतह का रूप कोरिलेटेड हैं (नदी के तल रेतीले होते हैं, चट्टान की सतहें चट्टानी, समतल इलाके घास वाले)। इन्हें अलग-अलग जेनरेट करने से बेमेल पैदा होता है।

TerraFusion हाइटमैप और टेक्सचर के लिए अलग VAEs के साथ एक latent diffusion model इस्तेमाल करता है, जो उनके joint distribution को मॉडल करने के लिए ट्रेन किया गया है। सिस्टम सपोर्ट करता है:

• Unconditional जेनरेशन: मैचिंग टेक्सचर के साथ रैंडम संभव टेरेन
• Sketch-conditioned जेनरेशन: एक क्रिएटर एक मोटा नक्शा बनाता है (यहां घाटियां, वहां रिज, इस किनारे चट्टानें) और मॉडल विस्तृत ज्यामिति और टेक्सचर जेनरेट करता है जो स्केच से मेल खाते हैं

एक क्रिएटर दुनिया के लिए, यह असरदार है। एक क्रिएटर अपने plot का सामान्य layout स्केच करता है, और सिस्टम उचित सतह मटेरियल के साथ भूगर्भीय रूप से संभव टेरेन भर देता है। कोई हाइटमैप painting नहीं, कोई texture splatting नहीं, कोई मैन्युअल material assignment नहीं।

MESA: Text-to-Terrain

MESA टेक्स्ट प्रॉम्प्ट से जोड़ीदार satellite images और DEMs देता है। Copernicus global dataset पर ट्रेन किया गया, यह हर पैमाने और जलवायु क्षेत्र पर असली टेरेन को समझता है, fjords, steppes, खेती की जमीन, alpine रिज।

MESA (2025, arXiv:2504.07210, CVPR 2025 Workshop) टेक्स्ट विवरण से टेरेन जेनरेट करता है। यह Copernicus प्रोग्राम के global remote sensing data पर ट्रेन किया गया है, इसलिए इसे हर तरह के स्थलीय लैंडस्केप का अनुभव है।

"steep granite walls वाला एक fjord जो एक चट्टानी समुद्र तट में खुलता है" जैसा एक प्रॉम्प्ट उचित भूगर्भीय संरचना के साथ एक हाइटमैप बनाता है। "हल्की पहाड़ियों और चौड़ी नदी घाटी वाली लहरदार खेती की जमीन" कुछ बिल्कुल अलग बनाता है।

MESA, Major TOM Core-DEM extension dataset पेश करता है, जो globally satellite imagery को digital elevation models के साथ जोड़ता है। यह training data मॉडल को यह समझ देता है कि असली टेरेन हर पैमाने पर और हर जलवायु क्षेत्र में कैसा दिखता है।

Geodiffussr: Text-Guided Terrain Texturing

Geodiffussr एक हाइटमैप और एक टेक्स्ट प्रॉम्प्ट लेता है और ऐसे सतह टेक्सचर जेनरेट करता है जो एलिवेशन का सम्मान करते हैं। बर्फ सिर्फ संभव ऊंचाइयों के ऊपर दिखती है, ऊंचाई के साथ वनस्पति पतली होती है, पानी गड्ढों में बैठता है। ज्यामिति वैसी ही रहती है।

Geodiffussr (2025, arXiv:2511.23029) एक मौजूदा हाइटमैप लेता है और एलिवेशन डेटा का सम्मान करते हुए टेक्स्ट विवरण से निर्देशित टेक्सचर जेनरेट करता है। "Autumn forest" मध्यम ढलानों पर नारंगी और सुनहरे पत्ते बनाता है और खड़ी सतहों पर खुली चट्टान। "Tropical coast" नीची जमीन पर palm वनस्पति बनाता है और समुद्र तल पर coral रेत।

सिस्टम multi-scale content aggregation इस्तेमाल करता है ताकि texture assignments एलिवेशन का सम्मान करें: बर्फ सिर्फ एक फिजिकली संभव ऊंचाई के ऊपर दिखती है, पानी के फीचर गड्ढों में बैठते हैं, ऊंचाई के साथ वनस्पति पतली होती है।

एक क्रिएटर दुनिया के लिए, इसका मतलब है कि टेरेन टेक्सचर को ज्यामिति बदले बिना एक टेक्स्ट प्रॉम्प्ट से फिर जेनरेट किया जा सकता है। एक क्रिएटर अपना मनचाहा टेरेन sculpt करता है, फिर mood का वर्णन करता है ("dark volcanic wasteland" या "lush temperate forest") और सिस्टम उचित सतह मटेरियल जेनरेट करता है।

ब्राउज़र टेरेन के लिए Dynamic LOD

बड़े टेरेन को हर जगह full resolution पर रेंडर करना एक ब्राउज़र में असंभव है। 1-मीटर रिज़ॉल्यूशन पर एक 4 km x 4 km दुनिया अकेले टेरेन की 1.6 करोड़ vertices है। Dynamic LOD इसे दुनिया के size की परवाह किए बिना एक स्थिर, संभालने लायक vertex count तक घटा देता है।

Geometry Clipmaps

geometry clipmaps की मूल SIGGRAPH 2004 प्रस्तुति। आधे होते रिज़ॉल्यूशन पर टेरेन के concentric rings दुनिया के size की परवाह किए बिना vertex count स्थिर रखते हैं, और आज भी ज्यादातर ब्राउज़र टेरेन LOD की नींव हैं।

Geometry clipmaps (Losasso और Hoppe, SIGGRAPH 2004, Paper) हाइटमैप टेरेन LOD के लिए gold standard बने हुए हैं। आइडिया: टेरेन को कैमरा पर केंद्रित concentric चौकोर rings के एक सेट के रूप में रेंडर करें। हर ring पिछले से दोगुने क्षेत्र का होता है लेकिन आधे रिज़ॉल्यूशन पर।

कैमरा के पास (सबसे अंदरूनी ring): full resolution, 1-मीटर ग्रिड spacing। एक ring बाहर: 2-मीटर spacing, 4x क्षेत्र को कवर करते हुए। अगला ring: 4-मीटर spacing, 16x क्षेत्र को कवर करते हुए। और ऐसे ही 6-8 स्तरों तक, जब तक सबसे बाहरी ring पूरी दृश्य दूरी को कवर न कर ले।

कुल vertex count स्थिर है: लगभग N^2 * levels, जहां N vertices में ring की चौड़ाई है। N=256 और 8 levels के साथ, यह कुल करीब 500K vertices है। यह वैसा ही रेंडर होता है चाहे दुनिया 1 km चौड़ी हो या 100 km।

ब्राउज़र इम्प्लीमेंटेशन: Geometry clipmaps WebGL 2 में काम करते हैं क्योंकि उन्हें सिर्फ मानक vertex buffer अपडेट चाहिए (कोई compute shaders नहीं)। जैसे कैमरा चलता है, CPU हर ring के लिए हाइटमैप डेटा को उचित रिज़ॉल्यूशन पर टेरेन sample करके अपडेट करता है। vertex shader एक texture से हाइट वैल्यू पढ़ता है और समतल ग्रिड को displace करता है।

Morphing: LOD स्तरों के बीच का ट्रांज़िशन नासमझी से संभाला जाए तो दिखने वाला "popping" बनाता है। Geomorphing (नीचे अपने सेक्शन में बताया गया) एक ट्रांज़िशन zone पर vertex shader में स्तरों के बीच vertex पोज़ीशन blend करता है, और बिना अतिरिक्त draw call कॉस्ट के smooth, pop-free ट्रांज़िशन बनाता है।

CDLOD: Quadtree-Adaptive Clipmaps

CDLOD (Strugar, 2014, Paper) fixed concentric rings के बजाय एक quadtree इस्तेमाल करके geometry clipmaps में सुधार करता है। quadtree टेरेन के मुताबिक ढलता है: समतल इलाके मोटे nodes इस्तेमाल करते हैं, जबकि हाई डिटेल वाले इलाके (चट्टानें, रिज) बारीक subdivision पाते हैं।

यह एक क्रिएटर दुनिया के लिए मायने रखता है क्योंकि अलग-अलग chunks की जटिलता अलग होती है। एक समतल घास का मैदान न्यूनतम रिज़ॉल्यूशन चाहता है। चट्टानों और गुफाओं वाला एक पहाड़ी इलाका अधिकतम डिटेल चाहता है। CDLOD रिज़ॉल्यूशन वहां allocate करता है जहां यह मायने रखता है।

CPU-साइड quadtree traversal हल्का है (कुछ सौ nodes) और तय करता है कि किस रिज़ॉल्यूशन पर कौन से टेरेन patches draw करने हैं। GPU हर patch को per-patch LOD uniforms के साथ एक instanced ग्रिड के रूप में रेंडर करता है।

Concurrent Binary Trees: Planetary-Scale Tessellation

ग्रहीय-पैमाने के टेरेन के लिए CBT adaptive tessellation: त्रिभुज कैमरा के पास subdivide होते हैं और दूरी में merge होते हैं, पूरी तरह GPU पर। console hardware पर 0.2ms से कम।

Concurrent Binary Trees (CBT) adaptive टेरेन tessellation के लिए एक GPU-फ्रेंडली डेटा संरचना है, जिसे Benyoub और Dupuy (Intel, HPG 2024, Paper, GitHub) ने पेश किया।

मुख्य आइडिया: टेरेन को एक binary tree के रूप में दर्शाएं जहां हर node एक त्रिभुज है। Adaptive subdivision कैमरा के पास वाले त्रिभुजों को split करता है और दूर वाले त्रिभुजों को merge करता है। binary tree पूरी तरह GPU memory में एक 1D array (एक binary heap) के रूप में रहता है, और subdivision/merge ऑपरेशन compute shaders के रूप में चलते हैं।

2024 का पेपर CBT को चौकोर हाइटमैप domains से बढ़ाकर मनचाहे polygon meshes तक ले जाता है। इसका मतलब है आप एक sphere को tessellate कर सकते हैं (ग्रहीय रेंडरिंग के लिए) या एक मनचाहा बेस मेश (गैर-आयताकार सीमाओं वाली गेम दुनिया के लिए)। मुख्य सुधार: implicit encoding के बजाय CBT को एक memory pool manager के रूप में इस्तेमाल करना बहुत ज्यादा subdivision स्तरों की अनुमति देता है।

परफॉर्मेंस: console-स्तर hardware पर 0.2ms से कम में ग्रहीय-पैमाने का टेरेन tessellation। एल्गोरिदम processor count के साथ linearly स्केल करता है। WebGPU के लिए, यह एक ब्राउज़र में planet-scale टेरेन रेंडरिंग का एक रास्ता देता है, हालांकि इम्प्लीमेंटेशन की जटिलता ज्यादा है।

WebGPU के साथ GPU-Driven LOD

WebGPU एक पूरी तरह GPU-ड्रिवन टेरेन पाइपलाइन को सक्षम करता है जो LOD फैसलों में CPU की भागीदारी खत्म कर देती है:

1. Compute pass 1: Frustum और occlusion culling। एक compute shader हर टेरेन patch के bounding box को view frustum और एक occlusion buffer (पिछले फ्रेम का depth buffer, downsampled) के खिलाफ टेस्ट करता है। अदृश्य patches पूरी तरह हटा दिए जाते हैं।

2. Compute pass 2: LOD selection। दिखने वाले patches के लिए, screen-space size compute करें और उचित LOD स्तर चुनें। LOD स्तर और patch ID को एक indirect draw buffer में लिखें।

3. Compute pass 3: Mesh generation (वॉल्यूमेट्रिक टेरेन के लिए)। SDF डेटा वाले chunks के लिए, चुने हुए LOD रिज़ॉल्यूशन पर मेश जेनरेट करने के लिए marching cubes चलाएं।

4. Indirect draw। एक ही drawIndexedIndirect() कॉल सभी टेरेन patches रेंडर करता है। GPU सब कुछ तय करता है: क्या draw करना है, किस रिज़ॉल्यूशन पर, किस क्रम में।

इस पाइपलाइन की दुनिया के size या जटिलता की परवाह किए बिना स्थिर CPU कॉस्ट है (compute shaders dispatch करना और indirect draw call)। GPU हर patch के फैसले संभालता है।

@compute @workgroup_size(64)
fn lodSelection(@builtin(global_invocation_id) id: vec3<u32>) {
    let patchIdx = id.x;
    let bounds = patchBounds[patchIdx];

    if (!frustumTest(bounds, viewProjection)) { return; }
    if (occlusionTest(bounds, depthPyramid) == OCCLUDED) { return; }

    let screenSize = projectedSize(bounds, viewProjection, screenDimensions);
    let lod = clamp(u32(log2(maxScreenSize / screenSize)), 0u, MAX_LOD);

    let drawIdx = atomicAdd(&drawCount, 1u);
    drawArgs[drawIdx] = DrawArgs(patchIdx, lod, indexCount[lod], indexOffset[lod]);
}

Geomorphing: Pop-Free LOD ट्रांज़िशन

टेरेन LOD में सबसे बड़ा विज़ुअल artifact popping है: जब एक patch LOD स्तर बदलता है तो vertices अचानक नई पोज़ीशन पर कूद जाती हैं। Geomorphing एक ट्रांज़िशन zone पर LOD स्तरों के बीच vertex पोज़ीशन को smoothly interpolate करके इसे खत्म करता है।

इम्प्लीमेंटेशन पूरी तरह vertex shader में रहता है। हर vertex अपनी current-LOD पोज़ीशन और अपनी next-coarser-LOD पोज़ीशन दोनों स्टोर करता है। जैसे कैमरा दूरी ट्रांज़िशन threshold पार करती है, एक morph factor दोनों के बीच blend करता है:

float morphFactor = smoothstep(lodNear, lodFar, distanceToCamera);
float morphedHeight = mix(fineLodHeight, coarseLodHeight, morphFactor);
gl_Position = viewProjection * vec4(worldPos.x, morphedHeight, worldPos.z, 1.0);

Hoppe का geometry clipmap पेपर (GPU Gems 2, Chapter 2) clipmap rings के लिए पूरा इम्प्लीमेंटेशन बताता है। morph zone हर ring का बाहरी 20% है। इस zone के अंदर, vertices smoothly अगले ring के रिज़ॉल्यूशन की ओर converge करती हैं। विज़ुअल असर: टेरेन ज्यामिति detail स्तरों के बीच snap होने के बजाय "पिघलती" है। आम कैमरा स्पीड पर, ट्रांज़िशन अदृश्य होता है।

Image-space blending (Scherzer et al., Paper) एक विकल्प है जो दो LOD स्तरों की रेंडर की गई images को screen space में blend करता है। यह ज्यादा चरम LOD फर्क (जैसे mesh-to-billboard ट्रांज़िशन) संभालता है लेकिन ट्रांज़िशन zone के लिए एक अतिरिक्त render pass की कीमत लेता है।

GPU-Driven Vegetation Culling

वनस्पति (पेड़, घास, चट्टानें) अक्सर एक ओपन वर्ल्ड में draw calls का सबसे बड़ा स्रोत होती है। एक नासमझ तरीका हर फ्रेम हर वनस्पति instance draw करता है। GPU-ड्रिवन culling, जो अब Three.js में WebGPU के जरिए उपलब्ध है, अदृश्य instances को rasterizer तक पहुंचने से पहले खत्म कर देता है।

Three.js का ComputeInstanceCulling (Docs) instanced meshes के लिए frustum और LOD culling देता है, और बड़े instance counts के लिए 10-100x परफॉर्मेंस फायदा देता है। पाइपलाइन:

1. एक compute shader सभी instance bounding spheres पढ़ता है
2. हर एक को कैमरा frustum के खिलाफ टेस्ट करता है (6-plane test)
3. distance-आधारित LOD लगाता है: एक threshold से परे के instances कम detail पर स्विच करते हैं या पूरी तरह cull हो जाते हैं
4. बचे हुए instances एक buffer में compact होते हैं और drawIndirect के जरिए draw होते हैं

CPU per-instance शून्य काम करता है। शुरुआती setup के बाद, instance count की परवाह किए बिना कॉस्ट प्रति वनस्पति प्रकार एक compute dispatch और एक indirect draw call है।

घनी वनस्पति के लिए, Three.js का IndirectBatchedMesh (Docs) कई ज्यामिति प्रकारों (पेड़, झाड़ियां, चट्टानें) को एक ही buffer में पैक करता है और उन्हें multi-draw indirect के साथ draw करता है। एक chunk की सारी वनस्पति के लिए एक draw call।

हमारे वनस्पति सिस्टम के density-map-आधारित scattering के साथ मिलाकर, इसका मतलब है: density मैप एक compute shader में 50,000 घास के तिनकों की पोज़ीशन बनाता है, culling pass उन 70% को खत्म करता है जो off-screen हैं या बहुत दूर, और एक indirect draw call बचे हुए 15,000 तिनके रेंडर करता है। कुल CPU कॉस्ट: नगण्य।

वॉल्यूमेट्रिक टेरेन के लिए LOD

वॉल्यूमेट्रिक टेरेन (SDF + marching cubes) को अपने ही LOD सिस्टम की जरूरत है क्योंकि मेश जेनरेट होती है, पहले से authored नहीं। तरीका:

Multi-resolution SDF storage। SDF को एक mipmap जैसी hierarchy में कई रिज़ॉल्यूशन पर स्टोर करें। Level 0 full resolution है (1-मीटर voxels)। Level 1, 2-मीटर voxels है (8x कम डेटा)। Level 2, 4-मीटर voxels है। हर स्तर पर, SDF न्यूनतम absolute distance लेकर downsample होता है।

LOD-selected marching cubes। चाहे गए LOD से मेल खाते SDF स्तर पर marching cubes चलाएं। पास के chunks level 0 इस्तेमाल करते हैं। दूर के chunks level 2 या 3 इस्तेमाल करते हैं। Transvoxel एल्गोरिदम अलग-अलग स्तरों के बीच की boundary संभालता है।

Caching। जेनरेट की गई meshes तब तक कैश रहती हैं जब तक SDF न बदले (क्रिएटर एडिट) या LOD स्तर न बदले (कैमरा काफी हिला)। स्थिर टेरेन के लिए, मेश एक बार जेनरेट होकर फिर इस्तेमाल होती है।

टेरेन के लिए Streaming आर्किटेक्चर

Chunk डेटा फॉर्मेट

हर टेरेन chunk (64x64 मीटर) एक compact binary package के रूप में स्ट्रीम होता है:

ChunkPacket {
  header: {
    chunkX: i16, chunkZ: i16,
    version: u32,
    flags: u8  // hasHeightmap | hasVolumetric | hasVegetation
  }
  heightmap: {
    resolution: u8,      // 65x65 for full, 33x33 for half, 17x17 for quarter
    quantizedHeights: u16[resolution * resolution],  // delta-encoded, zlib compressed
    splatMap: u8[4 * resolution * resolution]         // RGBA blend weights, LZ4 compressed
  }
  volumetric?: {         // only present if flags.hasVolumetric
    sdfResolution: u8,   // typically 32 or 64
    sparseOctree: bytes  // run-length encoded sparse SDF
  }
  vegetation?: {         // only present if flags.hasVegetation
    treeDensityMap: u8[16 * 16],    // 4m resolution density grid
    grassDensityMap: u8[32 * 32],   // 2m resolution density grid
    rockDensityMap: u8[16 * 16]
  }
  creatorObjects: {
    count: u16,
    objects: PlacedObject[]   // assetId + transform + properties, ~40 bytes each
  }
}

आम size:

• सिर्फ हाइटमैप वाला chunk (समतल टेरेन): 2-4 KB compressed
• हाइटमैप + वनस्पति: 4-8 KB
• हाइटमैप + वॉल्यूमेट्रिक + वनस्पति (जटिल chunk): 20-100 KB
• 5x5 full-detail neighborhood: कुल 50-500 KB

Progressive Chunk लोडिंग

Chunks दूरी, गति की दिशा और डेटा प्रकार के आधार पर प्राथमिकता क्रम में लोड होते हैं:

Priority 1 (तुरंत, <100ms): उन chunks के लिए हाइटमैप ज्यामिति जिनमें प्लेयर घुसने वाला है। टेरेन की सतह पहले दिखती है। सबसे कम रिज़ॉल्यूशन (प्रति chunk 17x17) पर भी, जमीन मौजूद रहती है।

Priority 2 (तेज, <300ms): Splat maps और टेरेन टेक्सचर। जमीन को रंग मिलता है।

Priority 3 (streaming, <1s): Full-resolution हाइटमैप upgrade। वनस्पति density maps। GPU instancing पेड़ और घास बनाता है।

Priority 4 (background, <3s): गुफाओं/ओवरहैंग वाले chunks के लिए वॉल्यूमेट्रिक SDF डेटा। marching cubes एक Web Worker में मेश जेनरेट करता है, buffer को main thread में transfer करता है।

Priority 5 (lazy, <10s): क्रिएटर-रखे ऑब्जेक्ट। संरचनाओं के लिए हाई-रिज़ॉल्यूशन टेक्सचर। फूल, छोटी चट्टानें, मलबा जैसे डिटेल ऑब्जेक्ट।

Predictive Pre-fetching

प्लेयर के एक chunk में घुसने का इंतजार न करें। वेलोसिटी के आधार पर अनुमान लगाएं कि वे कहां जा रहे हैं और पहले से लोड करें:

• चलने की स्पीड (5 km/h): 2 chunks आगे pre-fetch करें (128m)। आम broadband latency पर, यह 200-400ms का lead time है।
• दौड़ना/सवारी (15 km/h): 4 chunks आगे pre-fetch करें। load ring वेलोसिटी की दिशा के साथ shift होता है।
• उड़ना/fast travel: ट्रांज़िशन के दौरान रेंडरिंग रोकें। destination chunks को सर्वोच्च प्राथमिकता पर स्ट्रीम करें। जब पहले फ्रेम के लिए काफी डेटा मौजूद हो तो रेंडरिंग फिर शुरू करें।

pre-fetch सिस्टम ट्रैक करता है कि कौन से chunks cache में हैं, कौन से in-flight हैं (अनुरोध किए गए लेकिन अभी नहीं पहुंचे), और कौन से चाहिए। एक priority queue लंबित अनुरोधों को तात्कालिकता से sort करती है। जिन chunks से प्लेयर दूर जा चुका है, उनके अनुरोध रद्द करें।

Memory बजट और Eviction

एक ब्राउज़र टैब को डेस्कटॉप पर 2-4 GB मिलता है। टेरेन सिस्टम को इसके एक हिस्से के अंदर रहना होगा (बाकी रेंडरिंग, फिजिक्स, networking और JavaScript heap के लिए है)।

टारगेट बजट: सभी टेरेन डेटा के लिए 256 MB।

हमारे आम chunk sizes पर:

• Full-detail cached chunks: ~100 (10x10 neighborhood) हर एक 5-100 KB पर = raw डेटा के लिए 5-10 MB
• GPU टेरेन ज्यामिति: ~50 MB (दिखने वाले टेरेन के लिए vertex buffers, index buffers)
• टेरेन टेक्सचर: ~100 MB (KTX2 compressed, atlas-packed)
• वनस्पति instance buffers: ~50 MB (GPU instancing के लिए positions, rotations, scales)
• SDF वॉल्यूम और cached marching cubes meshes: ~50 MB

दृश्य range से परे के chunks पहले GPU memory से evict होते हैं (टेक्सचर, vertex buffers), फिर CPU cache से। raw हाइटमैप डेटा सबसे आखिर में जाता है क्योंकि इसे रखना सबसे सस्ता है और प्लेयर के पलटने पर इसका होना सबसे जरूरी।

Biome ट्रांज़िशन और Anti-Tiling

Smooth Biome सीमाएं

असली लैंडस्केप में biomes के बीच कड़े किनारे नहीं होते। एक जंगल किसी रेखा पर रुककर रेगिस्तान नहीं बन जाता। एक gradient होता है: घना जंगल पतला होकर बिखरे पेड़ों में बदलता है, फिर scrubland, फिर विरल रेगिस्तानी वनस्पति। इसे सही करना दुनिया को tiled के बजाय निरंतर महसूस कराता है।

AutoBiomes (Kötter et al., Paper) प्रोसीजरल टेरेन जेनरेशन को सरलीकृत जलवायु सिमुलेशन के साथ मिलाता है। तापमान, आर्द्रता और एलिवेशन हर पॉइंट पर biome प्रकार तय करते हैं। biomes के बीच, material weights और वनस्पति घनत्व एक ट्रांज़िशन zone (आमतौर पर 50-100 मीटर चौड़ा) पर interpolate होते हैं। ट्रांज़िशन की चौड़ाई biome जोड़ी के हिसाब से अलग होती है: forest-to-grassland चौड़ा और क्रमिक है, cliff-to-water संकरा और अचानक।

एक क्रिएटर दुनिया के लिए, biome assignment एक मोटे ग्रिड पर चलता है (प्रति 16x16 मीटर क्षेत्र एक biome sample)। टेरेन shader मौजूदा fragment और उसके पड़ोसियों के लिए biome वैल्यू पढ़ता है, ट्रांज़िशन zone में material weights interpolate करता है, और तदनुसार टेक्सचर blend करता है। वनस्पति scattering वही interpolated घनत्व वैल्यू इस्तेमाल करती है, इसलिए जंगल के किनारे पर tree density धीरे-धीरे fade होती है।

क्रिएटर नियंत्रण: क्रिएटर को अपने plots पर biome overrides पेंट करने दें। सिस्टम टेरेन गुणों से डिफ़ॉल्ट biomes जेनरेट करता है, लेकिन क्रिएटर उन्हें override कर सकते हैं। किसी नीची जगह पर "swamp" पेंट करें और मटेरियल गंदले पानी, काई और मरे हुए पेड़ों में बदल जाता है। biome paint मैप biome IDs का एक per-chunk 16x16 ग्रिड (256 bytes) है जो प्रोसीजरल assignment को override करता है।

Hex-Tiling: Texture Repetition खत्म करना

टेरेन रेंडरिंग में सबसे आम विज़ुअल artifact texture repetition है। एक 100-मीटर घास के मैदान पर tiled एक 1-मीटर घास texture दिखने वाले grid पैटर्न बनाती है। दो तकनीकें इसे ठीक करती हैं:

Hex-tiling (Mikkelsen, Demo) चौकोर tiling grid की जगह एक hexagonal grid रखती है। हर hexagonal tile texture को एक रैंडम offset और rotation पर sample करती है। seams छिपाने के लिए hexagonal सीमाओं को blend किया जाता है। नतीजा एक ऐसी सतह है जो tiled के बजाय एकसमान रूप से रैंडम दिखती है। कॉस्ट: प्रति fragment लगभग 3 अतिरिक्त texture samples। यह तकनीक production गेम में व्यापक रूप से इस्तेमाल होती है और किसी भी fragment shader में चलती है।

Stochastic texture filtering (Pharr et al., NVIDIA, 2024, Paper) shading से पहले के बजाय बाद में filtering लगाती है, stochastic sampling इस्तेमाल करते हुए। stochastic sampling से error न्यूनतम है और spatiotemporal denoising से अच्छे से संभाला जाता है। यह ज्यादा सटीक filtered नतीजे देता है और compressed/sparse टेक्सचर के साथ काम करता है। टेरेन के लिए, यह tiling artifacts और वे filtering artifacts दोनों खत्म करता है जो hex-tiling कभी-कभी ट्रांज़िशन पर पैदा कर सकती है।

एक ब्राउज़र दुनिया के लिए, hex-tiling व्यावहारिक विकल्प है (यह किसी भी shader में काम करती है)। Stochastic filtering को ज्यादा infrastructure चाहिए लेकिन अगर temporal denoising उपलब्ध हो (जो TAA के साथ एक WebGPU रास्ते में होगा) तो यह बेहतर नतीजे देती है।

टेरेन Material सिस्टम

Triplanar Mapping

मानक UV-mapped टेक्सचर खड़ी ढलानों पर भयानक रूप से खिंच जाते हैं क्योंकि UV coordinates compress होते हैं। Triplanar mapping टेक्सचर को तीनों axes (X, Y, Z) पर project करता है और सतह के normal के आधार पर blend करता है:

vec3 blending = abs(normal);
blending = normalize(max(blending, 0.00001));
blending /= (blending.x + blending.y + blending.z);

vec4 xaxis = texture(material, worldPos.yz * scale);
vec4 yaxis = texture(material, worldPos.xz * scale);
vec4 zaxis = texture(material, worldPos.xy * scale);

vec4 color = xaxis * blending.x + yaxis * blending.y + zaxis * blending.z;

चट्टान की सतहों को X या Z projection मिलता है (कोई stretching नहीं)। समतल जमीन को Y projection मिलता है। blending smooth और automatic है। कोई UV unwrapping जरूरी नहीं।

Babylon.js में एक built-in TriPlanar Material है। Three.js को एक custom shader चाहिए, लेकिन इम्प्लीमेंटेशन करीब 30 लाइन GLSL है।

PBR टेरेन के लिए, triplanar mapping को सभी channels पर लगाएं: albedo, normal, roughness और ambient occlusion। वही blending weights हर channel पर लागू होते हैं।

Slope और Altitude-आधारित Material Assignment

हाथ से splat maps पेंट करने के बजाय, टेरेन गुणों के आधार पर मटेरियल प्रोसीजरल रूप से assign करें:

float slope = acos(dot(normal, vec3(0, 1, 0)));
float altitude = worldPos.y;

float grassWeight = smoothstep(0.3, 0.0, slope) * smoothstep(2000.0, 1500.0, altitude);
float rockWeight = smoothstep(0.2, 0.5, slope);
float snowWeight = smoothstep(2500.0, 3000.0, altitude) * smoothstep(0.4, 0.1, slope);
float sandWeight = smoothstep(5.0, 0.0, altitude) * smoothstep(0.15, 0.0, slope);

नीची ऊंचाई पर समतल जमीन को घास मिलती है। खड़ी ढलानों को चट्टान। ऊंची ऊंचाई को बर्फ (लेकिन सिर्फ उन सतहों पर जो बर्फ जमा होने के लिए काफी समतल हों)। समुद्र तल के पास रेत। ट्रांज़िशन smooth और फिजिकली प्रेरित हैं।

एक क्रिएटर दुनिया के लिए, altitude thresholds और blend zones को प्रति chunk paintable पैरामीटर के रूप में expose करें। क्रिएटर treeline को ऊपर या नीचे ले जा सकते हैं, बर्फ की कवरेज बढ़ा सकते हैं, या अपने plot के लिए material नियम एडजस्ट करके एक घास वाली पहाड़ी को रेतीले रेगिस्तान में बदल सकते हैं।

GPU-Friendly Laplacian Texture Blending

मानक texture blending (लेयर के बीच linear interpolation) या तो दिखने वाले seams पैदा करती है या धुले-धुले, low-contrast नतीजे। Laplacian pyramid blending इसे हल करती है लेकिन पारंपरिक रूप से महंगी precomputation चाहती है।

Wronski (NVIDIA, 2025, JCGT) एक GPU-friendly वैरिएंट पेश करते हैं जो रियल-टाइम shaders में बिना precomputation और बिना अतिरिक्त memory के काम करता है। यह तकनीक मानक mipmap chain को Laplacian pyramid के एक अनुमान के रूप में इस्तेमाल करती है: texture को मौजूदा mip level और एक मोटे level दोनों पर sample करें, अंतर (Laplacian) compute करें, और हर लेयर से Laplacian योगदान blend करें।

नतीजा sharp local फीचर (अलग-अलग घास के तिनके, चट्टान की दरारें) बचाता है जबकि बड़े पैमाने पर smoothly blend करता है। कॉस्ट प्रति fragment कुछ अतिरिक्त texture taps है। ऐसे टेरेन के लिए जहां आप प्रति pixel 4+ material layers blend कर रहे हैं, यह linear blending से काफी बेहतर नतीजे देती है, खासकर घास, चट्टान और रेत के बीच के ट्रांज़िशन पर।

Erosion Detail के लिए Phasor Noise

मानक टेरेन अक्सर पास से देखने पर समतल दिखता है क्योंकि इरोज़न सिमुलेशन हाइटमैप रिज़ॉल्यूशन (1-मीटर ग्रिड) पर चलता है। असली टेरेन में सेंटीमीटर पैमाने पर बारीक इरोज़न पैटर्न (rills, gullies, weathering cracks) होते हैं।

Grenier et al. (2024, CGF) रियल टाइम में टेरेन माइक्रो-डिटेल जोड़ने के लिए phasor noise इस्तेमाल करते हैं। Phasor noise एक stochastic phase field को periodic functions में फीड करके structured पैटर्न synthesize करता है। टेरेन पर लागू, यह spatially varying इरोज़न पैटर्न बनाता है जो:

• संकरे rills को scales के पार बड़े gullies में cascade करते हैं
• टेरेन ढलान के साथ अपने आप align होते हैं (इरोज़न पैटर्न fall line का पीछा करते हैं)
• 32x तक amplification हासिल करते हैं (हाइटमैप रिज़ॉल्यूशन के 32x पर detail जोड़ते हुए)
• पूरी तरह एक fragment shader में इंटरैक्टिव frame rates पर चलते हैं

एक ब्राउज़र दुनिया के लिए, phasor noise टेरेन shader में एक detail layer के रूप में चलता है। हाइटमैप बड़े पैमाने का आकार देता है। Phasor noise fragment shader में ज्यामिति की जटिलता बढ़ाए बिना भरोसेमंद माइक्रो-इरोज़न जोड़ता है। पैरामीटर (pattern frequency, amplitude, orientation) प्रति biome अलग हो सकते हैं: खुली चट्टान पर गहरे rills, रेत के टीलों पर हल्की लहरें, सूखी मिट्टी पर खुरदरी छाल जैसी texture।

टेरेन के लिए Virtual Texturing

बड़े पैमाने पर, टेरेन texture atlas बेढंगा हो जाता है। 1 texel प्रति सेंटीमीटर पर एक 4 km x 4 km दुनिया को 400,000 x 400,000 pixel texture चाहिए। साफ तौर पर असंभव।

Virtual texturing (इसे megatexture भी कहते हैं, id Software के Rage से) टेरेन texture को एक paged structure के रूप में मानकर इसे हल करता है। पूरी texture वैचारिक रूप से मौजूद है लेकिन सिर्फ स्क्रीन पर दिखने वाली tiles GPU memory में लोड होती हैं।

पाइपलाइन:

1. Feedback pass: टेरेन को एक shader के साथ रेंडर करें जो आउटपुट करता है कि हर pixel को कौन सी texture tile चाहिए (tile ID और mip level)। इसे CPU में वापस पढ़ें (या एक compute shader से प्रोसेस करें)।
2. Tile loading: अनुरोधित tiles को CDN से लोड करें या splat मैप डेटा से प्रोसीजरल रूप से जेनरेट करें।
3. Indirection texture: एक छोटी texture virtual tile coordinates को एक texture atlas में physical tile coordinates पर map करती है।
4. Render pass: टेरेन shader सही physical tile ढूंढने के लिए indirection texture देखता है, फिर atlas से material texture sample करता है।

WebGPU के compute shaders feedback analysis और page table management पूरी तरह GPU पर संभाल सकते हैं। CPU सिर्फ tile I/O मैनेज करता है।

नतीजा: texture memory विस्फोट के बिना किसी भी रिज़ॉल्यूशन पर unique texturing वाला टेरेन। कैमरा से दूर की tiles low resolution पर लोड होती हैं। पास की tiles high resolution पर लोड होती हैं। कुल memory उपयोग एक fixed बजट के अंदर रहता है (आमतौर पर 128-256 MB texture atlas)।

Dynamic टेरेन इफेक्ट

Puddles और Wetness

बारिश सिर्फ गिरती नहीं। यह जमा होती है। गड्ढों में, यह puddles बनाती है। सतहों पर, यह एक गीली चमक बनाती है। खड़ी ढलानों पर, यह बह जाती है। इसे सिमुलेट करना मौसम को टेरेन से जुड़ा हुआ महसूस कराता है, न कि पूरी तरह विज़ुअल overlay।

shader-आधारित तरीका fluid dynamics सिमुलेट नहीं करता। यह यह तय करने के लिए टेरेन हाइटमैप इस्तेमाल करता है कि पानी कहां जमा होता है:

float concavity = heightCenter * 4.0 - heightLeft - heightRight - heightUp - heightDown;
float puddleDepth = max(0.0, concavity * rainIntensity - evaporationRate * timeSinceRain);
float wetness = smoothstep(0.0, 0.02, puddleDepth);

vec3 wetColor = baseColor * 0.7;
float wetRoughness = baseRoughness * 0.3;
vec3 finalColor = mix(baseColor, wetColor, wetness);
float finalRoughness = mix(baseRoughness, wetRoughness, wetness);

Concave इलाके (हाइटमैप का negative Laplacian) पानी इकट्ठा करते हैं। concavity जितनी गहरी, puddle उतना बड़ा। गीली सतहें गहरी होती हैं और ज्यादा reflective बनती हैं (कम roughness)। बारिश रुकने के बाद असर समय के साथ fade होता है।

पूरे puddle reflections के लिए, puddle सतह पर एक planar reflection pass जोड़ें। या screen-space reflections (SSR) इस्तेमाल करें जो सस्ते हैं और Three.js और Babylon.js दोनों के post-processing stacks में पहले से उपलब्ध हैं।

Puddle सतहों पर बारिश की बूंदें एक feedback texture में एक साधारण 2D wave equation इस्तेमाल करती हैं (Saurel, 2026, Blog)। हर बारिश की बूंद एक ripple बनाती है जो बाहर की ओर फैलती है और घटती है। wave texture puddle normal map को modulate करती है, और 60fps पर भरोसेमंद ripple पैटर्न बनाती है।

Footprints और Terrain Deformation

जब एक प्लेयर नरम टेरेन (रेत, बर्फ, मिट्टी) पर चलता है, footprints फिजिकल मौजूदगी का एहसास बढ़ाते हैं। तकनीक: प्रति chunk एक छोटी deformation texture (64x64 pixels = 4 KB) रखें जो हाइट offsets स्टोर करती है। जब एक कैरेक्टर नरम टेरेन पर कदम रखता है, deformation texture में एक footprint आकार stamp करें।

टेरेन vertex shader deformation texture पढ़ता है और हाइट से offset घटाता है। टेरेन fragment shader footprint इलाके को गहरा करता है (दबी हुई मिट्टी गहरी होती है) और roughness बढ़ाता है (अस्त-व्यस्त सतह)।

Footprints deformation texture को धीरे-धीरे शून्य करके समय के साथ fade होते हैं (बर्फ भर जाती है, बारिश मिट्टी के निशान धो देती है)। fade दर मौसम पर निर्भर करती है: बारिश में तेज, सूखे में धीमी।

एक मल्टीप्लेयर दुनिया के लिए, footprint डेटा ephemeral और local है। हर क्लाइंट दिखने वाले प्लेयर के लिए footprints जेनरेट करता है। deformation texture को clients के बीच sync करने की जरूरत नहीं (हर कोई अपने version के transient footprints देखता है)। यह हर कदम broadcast करने की networking कॉस्ट से बचाता है।

Procedural Sky और Day/Night Cycle

आसमान किसी भी ओपन वर्ल्ड में सबसे बड़ी दिखने वाली सतह है। यह पूरे टेरेन का mood तय करता है।

Three.js में एक complete sky system है जिसमें procedural sun/moon, day/night cycle, बादल, तारे और lens flares शामिल हैं। built-in Three.js Sky example (जो WebGPU में भी उपलब्ध है) Preetham का एनालिटिकल sky model लागू करता है।

ज्यादा फिजिकली सटीक नतीजों के लिए, webgpu-sky-atmosphere Hillaire के atmosphere model को एक WebGPU post-process के रूप में लागू करता है। यह multiple scattering phase functions सपोर्ट करता है और first principles से सही aerial perspective (दूर का टेरेन ज्यादा धुंधला दिखता है), sun/sunset रंग, और sky gradients बनाता है।

TerrainView7 precomputed atmospheric scattering के साथ WebGPU में full-scale planet rendering दिखाता है, और साबित करता है कि फिजिकली सटीक atmosphere rendering एक ब्राउज़र में चलती है।

एक क्रिएटर दुनिया के लिए, sky पैरामीटर (sun position, बादल कवरेज, धुंध density) सभी clients में सर्वर की world clock से synchronize होते हैं। sky shader हर client पर local चलता है, और सभी प्लेयर में एकसमान lighting बनाता है।

टेरेन Lighting: Indirect Illumination

सीधी धूप shadow maps से संभाली जाती है। लेकिन छाया में टेरेन का रंग और चमक (ambient/indirect light) विज़ुअल क्वालिटी के लिए उतना ही जरूरी है। पूरी तरह काली छायाएं गलत दिखती हैं। छायाओं को sky रंग से tint होना चाहिए (साफ दिन पर नीली, बादल वाले दिन पर ग्रे)।

एक ब्राउज़र दुनिया के लिए, व्यावहारिक तरीका:

Screen-space indirect lighting visibility bitmask के साथ (Jimenez et al., 2023, Paper) प्रति pixel 32 directional visibility sectors ट्रैक करके मानक SSAO में सुधार करता है। यह सिर्फ यह नहीं पकड़ता कि एक पॉइंट कितना occluded है, बल्कि occlusion की दिशा भी। पतली सतहें सही ढंग से दूसरी तरफ से रोशनी आने देती हैं। नतीजा एक ऐसा indirect illumination है जो global illumination infrastructure के बिना पास की ज्यामिति पर प्रतिक्रिया करता है।

कॉस्ट SSAO के बराबर है (1-2ms)। विज़ुअल सुधार बड़ा है: canyons में टेरेन canyon की दीवारों से bounce light उठाता है। ओवरहैंग के नीचे ground reflection से रोशन होते हैं। यह असर sky shader के atmospheric scattering के साथ मिलकर फिजिकली प्रेरित ambient lighting बनाता है।

टेरेन Physics Integration

Rapier Heightfield Colliders

Rapier का WASM physics engine टेरेन के लिए optimized native heightfield colliders देता है। एक टेरेन collider बनाना सीधा है:

const heights = new Float32Array(65 * 65);
// Fill with heightmap data...
const groundCollider = RAPIER.ColliderDesc.heightfield(
  64, 64, heights, new RAPIER.Vector3(64.0, 100.0, 64.0)
);
world.createCollider(groundCollider);

heightfield collider कुशल broadphase queries के लिए structured grid इस्तेमाल करता है। एक heightfield के खिलाफ raycasting एक triangle mesh के O(n) के बजाय O(log n) है। एक 65x65 chunk के लिए, collision queries microseconds में हल होती हैं।

वॉल्यूमेट्रिक टेरेन (SDF ओवरले) वाले chunks के लिए, marching cubes आउटपुट से एक triangle mesh जेनरेट करें और एक trimesh collider इस्तेमाल करें। यह heightfield collider से ज्यादा महंगा है लेकिन मनचाही ज्यामिति संभालता है। सिर्फ प्लेयर के सबसे नज़दीकी 3-5 chunks के लिए trimesh colliders जेनरेट करें। दूर के chunks को physics नहीं चाहिए।

परफॉर्मेंस: एक 65x65 chunk के लिए Rapier का heightfield collider character controller queries के लिए प्रति physics step लगभग 0.1ms जोड़ता है। heightfield colliders वाले 5 active chunks: 0.5ms। एक वॉल्यूमेट्रिक chunk के लिए एक trimesh collider: 0.2-0.5ms। कुल टेरेन physics बजट: 1ms से कम, पूरी दुनिया के लिए 2-3ms physics बजट के अंदर अच्छे से।

Terrain-Aware Character Controller

character controller को टेरेन गुणों पर प्रतिक्रिया देनी होगी:

• Slope limiting: कैरेक्टर 45 डिग्री तक की ढलानों पर चल सकता है। ज्यादा खड़ी ढलानें फिसलन पैदा करती हैं। यह कैरेक्टर की पोज़ीशन पर टेरेन normal इस्तेमाल करता है (हाइटमैप gradient से सस्ते में compute होता है)।
• Surface material response: चट्टान पर चलना रेत या मिट्टी पर चलने से अलग footstep आवाज और movement speed पैदा करता है। टेरेन का splat मैप किसी भी पॉइंट पर सतह का मटेरियल देता है।
• Step climbing: कैरेक्टर 0.5 मीटर तक के कगारों पर चढ़ सकता है। Rapier का KinematicCharacterController इसे configurable step height के साथ अपने आप संभालता है।

ब्राउज़र में Interactive Terrain Editing

एक क्रिएटर दुनिया के लिए, टेरेन सिर्फ जेनरेट नहीं होता। इसे प्लेयर sculpt, modify और reshape करते हैं। editing टूल को responsive (तुरंत विज़ुअल feedback) और networked (बाकी प्लेयर सेकंडों में बदलाव देखें) होना चाहिए।

WebGPU SDF Editor

Reinder Nijhoff का WebGPU SDF Editor दिखाता है कि full-featured SDF modeling आज ब्राउज़र में काम करती है। editor सपोर्ट करता है:

• छह primitive आकार (sphere, box, cone, cylinder, capsule, torus) position, rotation और scale के साथ
• Boolean ऑपरेशन (union, subtraction, intersection) smooth blending और configurable blend radii के साथ
• Hierarchical scene graphs groups और nested ऑपरेशन के साथ
• Real-time rendering कई GPU compute shader stages, 16,384 grid cells में octree-आधारित space partitioning, और marching cubes या surface nets के जरिए surface extraction इस्तेमाल करते हुए
• Temporal anti-aliasing और ambient occlusion shadow maps के जरिए

हर primitive एक ही GPU buffer में 28 floats (112 bytes) के रूप में स्टोर होता है। यह compact रिप्रेजेंटेशन मतलब है कि एक जटिल टेरेन एडिट (दर्जनों SDF primitives जो एक गुफा प्रवेश, एक मेहराब, या एक carved चट्टान की सतह तय करते हैं) 5 KB से कम का होता है और बाकी प्लेयर के साथ तुरंत sync होता है।

एक क्रिएटर दुनिया के लिए, SDF editing workflow ऐसा दिखता है:

1. क्रिएटर एक sculpting टूल चुनता है (sphere जोड़ो, box घटाओ, smooth blend)
2. SDF primitive रखने और साइज़ करने के लिए दुनिया में click/drag करता है
3. क्लाइंट तुरंत local मेश अपडेट करने के लिए modified SDF पर marching cubes चलाता है (<16ms में feedback)
4. SDF एडिट (primitive type + transform + blend mode, ~100 bytes) सर्वर को भेजा जाता है
5. सर्वर एडिट validate करता है (क्रिएटर के plot के अंदर, protected इलाकों से intersect नहीं करता) और पास के प्लेयर को broadcast करता है
6. बाकी प्लेयर के clients SDF एडिट लागू करते हैं और अपनी local मेश फिर जेनरेट करते हैं

एक एडिट के बाकी लोगों को दिखने का कुल round-trip: नेटवर्क latency के हिसाब से 100-300ms। क्रिएटर अपना एडिट तुरंत देखता है क्योंकि यह सर्वर पुष्टि से पहले local लागू होता है।

Brush-Based Heightmap Editing

हाइटमैप लेयर के लिए (टेरेन का 90% जिसे वॉल्यूमेट्रिक फीचर नहीं चाहिए), एक सरल editing model काम करता है। क्रिएटर एक ब्रश से हाइट बदलाव पेंट करता है:

• Raise/lower: falloff के साथ एक radius में हाइट जोड़ें या घटाएं
• Smooth: एक radius में हाइट औसत करें, sharp फीचर हटाते हुए
• Flatten: एक radius में सभी हाइट को एक target वैल्यू पर सेट करें
• Erosion brush: ब्रश radius में local hydraulic इरोज़न के कुछ steps लगाएं

हाइटमैप एडिट एक delta है: हाइट बदलाव का एक छोटा patch जो बेस टेरेन के ऊपर overlay होता है। delta patch छोटा है (16-bit हाइट offsets का एक 32x32 ग्रिड = 2 KB) और बाकी प्लेयर के साथ एक ही message के रूप में sync होता है। प्रति chunk कई delta patches जमा होते हैं और समय-समय पर सर्वर-साइड chunk के persistent हाइटमैप में merge होते हैं।

Collaborative Editing बाधाएं

जब कई क्रिएटर एक ही chunk एक साथ एडिट करते हैं, सिस्टम को नियम चाहिए:

• Spatial locking: एक दिए गए 8x8 मीटर sub-region को एक बार में सिर्फ एक क्रिएटर एडिट कर सकता है। lock तब हासिल होता है जब क्रिएटर एक edit stroke शुरू करता है और तब छूटता है जब वे ब्रश उठाते हैं। 10 सेकंड की निष्क्रियता के बाद locks timeout हो जाते हैं।
• Non-overlapping edits: अगर दो क्रिएटर एक ही chunk के अलग हिस्से एडिट करते हैं, दोनों एडिट बिना टकराव के लागू होते हैं (वे अलग हाइटमैप cells या SDF regions बदलते हैं)।
• Overlapping edits: अगर दो क्रिएटर एक ही जगह एडिट करते हैं, सर्वर एडिट को आगमन क्रम में serialize करता है। reconciliation के बाद दोनों clients वही अंतिम नतीजा देखते हैं।

यह placed objects के लिए इस्तेमाल किए जाने वाले पूरे CRDT तरीके से सरल है क्योंकि टेरेन एडिट एक निरंतर field (हाइट, SDF distances) पर additive ऑपरेशन हैं, न कि अलग object state।

WebGPU में Nanite-Style Virtual Geometry

Unreal Engine 5 का Nanite build time पर एक cluster DAG (directed acyclic graph) बनाकर और runtime पर screen-space error के आधार पर per-cluster सही LOD चुनकर अरबों त्रिभुज रेंडर करता है। पूरी पाइपलाइन GPU पर चलती है। इस तरीके को WebGPU में port किया गया है।

Nanite WebGPU

Nanite WebGPU Chrome में एक पूरा scene रेंडर करते हुए, meshlet LOD, WGSL compute shaders में software rasterization, और per-meshlet frustum और occlusion culling इस्तेमाल करते हुए। कोई native plugin नहीं, शुद्ध WebGPU।

Nanite WebGPU by Scthe (1.1k+ GitHub stars) Nanite के core आर्किटेक्चर का एक पूरा ब्राउज़र इम्प्लीमेंटेशन है:

• Meshlet LOD hierarchy meshoptimizer के cluster generation का इस्तेमाल करके offline बनाई गई
• Software rasterizer WGSL compute shaders में लागू (WebGPU की उन बाधाओं के अंदर काम करते हुए जहां hardware rasterization per-cluster draws कुशलता से नहीं कर सकती)
• Per-instance और per-meshlet culling frustum और occlusion tests इस्तेमाल करते हुए
• Billboard impostors बेहद दूर के objects के लिए
• Texture और per-vertex normal सपोर्ट

पाइपलाइन: meshes को ~128 त्रिभुजों के clusters में बांटा जाता है। पड़ोसी clusters को group किया जाता है, और हर group को simplify किया जाता है (meshoptimizer इस्तेमाल करते हुए) जबकि shared boundaries बचाई जाती हैं। यह तब तक recurse करता है जब तक पूरी मेश एक ही cluster में collapse न हो जाए। runtime पर, एक compute shader DAG पर चलता है और per-group सबसे मोटा cluster चुनता है जो मौजूदा screen resolution पर 1 pixel से कम error पैदा करता है।

THREE-Nanite एक उभरता हुआ Three.js इम्प्लीमेंटेशन है जो integrated graphics hardware पर 20-40fps हासिल करता है जबकि लाखों त्रिभुज संभालता है। यह दिखाता है कि Nanite-style rendering low-end ब्राउज़र hardware पर भी चलने लायक है।

meshoptimizer: LOD पाइपलाइन की नींव

meshoptimizer (Arseny Kapoulkine द्वारा) ज्यादातर ब्राउज़र-compatible LOD पाइपलाइन के पीछे की library है। Version 1.0 (2025) देता है:

• Mesh simplification error metrics के साथ (आकार कितना बदला, LOD selection के लिए इस्तेमाल)
• Cluster generation Nanite-style meshlet hierarchies के लिए
• Vertex cache optimization GPU-friendly triangle ordering के लिए
• Overdraw optimization pixel shader कॉस्ट घटाने के लिए
• Vertex quantization और compression छोटे downloads के लिए

meshoptimizer 1.0 (दिसंबर 2025 में रिलीज़) एक नया single-header clusterlod.h शिप करता है जो Nanite-style continuous LOD सीधे लागू करता है। यह clusters की एक hierarchy बनाता है जो क्रमिक रूप से group और simplify होती हैं, जो as-is या एक custom पाइपलाइन के लिए reference के रूप में इस्तेमाल हो सकती है। यह वही cluster-DAG primitive है जो टेरेन पाइपलाइन को SDF/marching-cubes मेश LOD के लिए चाहिए।

हमारी टेरेन पाइपलाइन के लिए, meshoptimizer SDF टेरेन के marching cubes आउटपुट को LOD hierarchies वाली optimized, clustered meshes में प्रोसेस करता है। offline processing सर्वर-साइड चलती है। ब्राउज़र pre-clustered meshes पाता है और runtime पर GPU-ड्रिवन LOD selection करता है।

LOD generation के लिए meshoptimizer और runtime selection के लिए WebGPU compute का मेल ब्राउज़र टेरेन को Nanite जैसा ही architectural पैटर्न देता है, web बाधाओं के लिए ढाला हुआ।

Terrain-Aware Level Design

टेरेन सिर्फ एक सतह नहीं है जिस पर चलना हो। इसका आकार प्लेयर की गति को निर्देशित करता है, ध्यान directs करता है, और अन्वेषण का भावनात्मक rhythm बनाता है। सबसे अच्छी ओपन वर्ल्ड टेरेन को एक डिज़ाइन टूल के रूप में इस्तेमाल करती हैं।

Sightlines और Landmarks

Level Design Book का wayfinding chapter बताता है कि कैसे टेरेन एलिवेशन नियंत्रित करता है कि प्लेयर क्या देखते हैं और कहां जाते हैं। एक रिज उसके पीछे की चीज़ छिपाती है, और जिज्ञासा पैदा करती है। एक घाटी गति को अपने सबसे नीचे पॉइंट की ओर funnel करती है। दूर से दिखने वाला एक ऊंचा landmark (टावर, पर्वत शिखर, असामान्य पेड़) प्लेयर को चलने के लिए एक लक्ष्य देता है।

एक क्रिएटर दुनिया के लिए, इसका मतलब है कि टेरेन जेनरेशन को प्राकृतिक wayfinding फीचर बनाने चाहिए। रिज लाइन को sightlines तोड़नी चाहिए, और "reveal moments" बनाने चाहिए जब एक प्लेयर एक पहाड़ी की चोटी पर पहुंचता है और एक नया इलाका देखता है। घाटियों को दिलचस्प जगहों की ओर converge करना चाहिए। ऊंचे पॉइंट वहां मौजूद होने चाहिए जहां क्रिएटर दूर से दिखने वाले landmarks रख सकें।

Curiosity-Driven Exploration

Purdue University से रिसर्च (Paper) चार spatial exploration triggers पहचानती है:

1. चरम पॉइंट तक पहुंचना (सबसे ऊंची चोटी, सबसे दूर का किनारा, सबसे गहरी गुफा)। टेरेन में साफ चरम होने चाहिए जो वहां पहुंचने पर इनाम दें।
2. विज़ुअल बाधाएं हल करना (उस चट्टान के पीछे क्या है? उस गुफा के अंदर?)। ऐसा टेरेन जो दृश्य रोकता है, छिपी चीज़ ढूंढने के लिए गति को प्रेरित करता है।
3. जगह से बाहर के objects (जंगल में एक संरचना, अंधेरे में एक रोशनी)। प्राकृतिक टेरेन के खिलाफ क्रिएटर-रखे objects एक contrast बनाते हैं जो ध्यान खींचता है।
4. Spatial connections समझना (यह घाटी उस तट से कैसे जुड़ती है?)। ऐसा टेरेन जो पठनीय भूगोल बनाता है, map-reading और route-planning को प्रोत्साहित करता है।

PlotMap: AI-Assisted POI Placement

PlotMap (arXiv:2309.15242) narrative requirements (इस quest को एक नदी के पास एक गांव चाहिए, उस quest को एक पहाड़ी की चोटी पर एक खंडहर चाहिए) लेकर और spatial constraints संतुष्ट करने वाली टेरेन जगहें ढूंढकर point-of-interest layout को automate करता है। एक क्रिएटर दुनिया के लिए, एक समान सिस्टम टेरेन गुणों के आधार पर सुझा सकता है कि संरचनाएं कहां रखें: "इस पहाड़ी की चोटी पर एक watchtower के लिए अच्छी sightlines हैं," "यह सुरक्षित घाटी एक गांव के लिए उपयुक्त होगी।"

बहता हुआ पानी और Waterfalls

नदियां और waterfalls ऐसे टेरेन फीचर हैं जो विज़ुअल आकर्षण को ambient sound और gameplay affordance (पानी एक बाधा, एक संसाधन, या एक रास्ते के रूप में) के साथ मिलाते हैं।

River Rendering

ओपन वर्ल्ड में नदियां आमतौर पर textured strips के रूप में रेंडर होती हैं जो टेरेन सतह का पीछा करती हैं। strip मेश river spline (control points के रूप में स्टोर) से जेनरेट होती है और टेरेन हाइटमैप पर project होती है। river shader लगाता है:

• Flow-aligned UVs जो नदी की दिशा में scroll करते हैं, बहते पानी का रूप बनाते हुए
• किनारों पर Foam जहां नदी bank से मिलती है (depth-आधारित, shoreline foam जैसा)
• Speed variation channel की चौड़ाई के आधार पर (संकरे हिस्से तेज बहते हैं, चौड़े हिस्से धीमे)
• depth-आधारित रंग के साथ Transparency (उथला साफ है, गहरा गहरे रंग का)

एक ब्राउज़र दुनिया के लिए, river डेटा compact है: एक spline (प्रति river segment 20-50 control points, ~400 bytes) और चौड़ाई और flow speed पैरामीटर। क्लाइंट spline को अपनी टेरेन सतह पर project करके river मेश local जेनरेट करता है।

Waterfall Rendering

जहां एक नदी एक चट्टान की सतह से गिरती है, एक waterfall particle system समतल river सतह की जगह लेता है। रियल-टाइम water simulation रिसर्च से hybrid तरीका (EG): वे regions जो एक height field से रिप्रेजेंट नहीं हो सकते (waterfalls, splashes) spray, splash और foam particles में बदल जाते हैं जो fluid simulation के साथ mass और momentum exchange करते हैं।

एक ब्राउज़र दुनिया के लिए, waterfalls सरल हैं: पता लगाएं कि river spline कहां एक टेरेन height discontinuity पार करती है, उस पॉइंट पर downward velocity के साथ एक particle system spawn करें, और आधार पर एक foam splash जोड़ें। particles scrolling alpha textures वाले GPU-instanced quads हैं। प्रति waterfall 500 particles, एक draw call। गिरते पानी की आवाज distance attenuation के साथ Web Audio API इस्तेमाल करती है।

दूर के टेरेन फीचर के लिए Impostors

पेड़, चट्टानें, इमारतें और बाकी टेरेन फीचर दूरी पर छोटे हो जाते हैं। उन्हें पूरी 3D meshes के रूप में रेंडर करना GPU cycles बर्बाद करता है। Impostors दूर के objects की जगह pre-rendered समतल images रखते हैं जो कैमरा की ओर face करती हैं।

Octahedral Impostor Atlases

एक octahedral impostor एक 3D object के रूप को कई देखने के कोणों से पकड़ता है और उन्हें एक texture atlas में स्टोर करता है। runtime पर, shader मौजूदा view direction के आधार पर atlas sample करता है, और दो सबसे नज़दीकी पकड़े गए कोणों के बीच interpolate करता है।

एक hemi-octahedral atlas (सिर्फ ऊपरी hemisphere से views, क्योंकि आप शायद ही पेड़ों को नीचे से देखते हैं) उसी texture size के साथ एक पूरे octahedral atlas की दोगुनी angular resolution देता है। Unity का impostor system रिपोर्ट करता है कि 1,600 tree instances को असली meshes (हर एक 140K त्रिभुज) से impostors में स्विच करने पर frame time 111ms से गिरकर 5.78ms हो जाता है।

एक ब्राउज़र दुनिया के लिए, impostor पाइपलाइन:

1. सर्वर-साइड: हर asset को 16-32 देखने के कोणों से रेंडर करें, color, normal और depth पकड़ते हुए
2. एक atlas texture में पैक करें (प्रति asset एक atlas, ~256x256 pixels, KTX2 के रूप में <100 KB)
3. runtime पर: impostor distance (आमतौर पर 100-200m) से परे के instances atlas sample करते हुए billboards के रूप में रेंडर होते हैं
4. स्विच छिपाने के लिए एक 20m ट्रांज़िशन zone पर मेश और impostor के बीच crossfade करें

Billboard Splatting (BBSplat)

Billboard Splatting (2024, arXiv:2411.08508) learnable textured planar primitives इस्तेमाल करके इसे आगे ले जाता है। pre-rendered views के बजाय, BBSplat किसी भी कोण से 3D object को सबसे अच्छे से दर्शाने के लिए billboard positions और textures को optimize करता है। यह 3D Gaussian Splatting की तुलना में 17x तक compression हासिल करता है जबकि view-dependent रूप बनाए रखता है। एक ब्राउज़र दुनिया में दूर के टेरेन फीचर के लिए, BBSplat angular coverage सुधारते हुए per-asset impostor storage घटा सकता है।

Professional टेरेन टूल और वे क्या सिखाते हैं

शून्य से एक टेरेन पाइपलाइन बनाने से पहले, यह समझने लायक है कि professional offline टूल क्या करते हैं। ये टूल दशकों की टेरेन जेनरेशन रिसर्च को production workflows में distill करते हैं।

Gaea (QuadSpinner) GPU-accelerated है और बदलावों पर लगभग तुरंत feedback देता है। यह प्रति साइड 2 मिलियन pixels तक tiled builds, automatic LOD mesh export, और एक node-आधारित graph सपोर्ट करता है जहां हर node एक फिजिकल प्रोसेस है (इरोज़न, sedimentation, uplift, thermal weathering)। Gaea के इरोज़न nodes ऐसा टेरेन बनाते हैं जो हाथ से sculpt किया हुआ दिखता है क्योंकि वे generic noise के बजाय खास फिजिकल प्रोसेस मॉडल करते हैं। मुख्य अंतर्दृष्टि: Gaea एक ही इरोज़न एल्गोरिदम इस्तेमाल नहीं करता। यह fluvial इरोज़न (नदी carving), thermal इरोज़न (चट्टान crumbling), coastal इरोज़न (wave action), और wind इरोज़न (रेत के टीले बनना) के लिए अलग nodes देता है। उन्हें एक graph में मिलाने से एक खास जलवायु के भूगर्भीय चरित्र वाला टेरेन बनता है।

World Machine टेरेन macro-structure पर ध्यान देते हुए एक समान graph तरीका लेता है। इसका "layout generator" आर्टिस्ट को टेरेन फीचर का मोटा आकार स्केच करने देता है (यहां पर्वत, वहां घाटी, इस किनारे तटरेखा) और सिस्टम फिजिकली संभव detail भर देता है। यह बिल्कुल वही क्रिएटर workflow है जो हम चाहते हैं: इरादा स्केच करो, भूविज्ञान पाओ।

World Creator editing के दौरान real-time preview और built-in river generation के साथ खुद को अलग करता है, जो टेरेन का विश्लेषण करती है और drainage analysis के आधार पर अपने आप flow paths calculate करती है।

इन टूल से हम क्या लेते हैं: फिजिकल प्रोसेस को मिलाने का node-graph तरीका किसी भी एक एल्गोरिदम से ज्यादा असरदार है। हमारी सर्वर-साइड जेनरेशन पाइपलाइन को chaining सपोर्ट करनी चाहिए: noise base > tectonic uplift > hydraulic इरोज़न > thermal weathering > coastal इरोज़न > वनस्पति। क्रिएटर हर stage पर पैरामीटर नियंत्रित करते हैं। पाइपलाइन सर्वर-साइड सेकंडों में चलती है और हाइटमैप, splat maps और वनस्पति density maps बनाती है।

SoilMachine: Open-Source Geomorphology

SoilMachine एक ही लेयर्ड टेरेन मॉडल में hydraulic, thermal और wind इरोज़न को couple करता है। multi-layer डेटा संरचना ऐसे फीचर सपोर्ट करती है जो हाइटमैप रिप्रेजेंट नहीं कर सकते: गुफाएं, ओवरहैंग, buttes और groundwater distributions।

SoilMachine एक open-source modular geomorphology सिमुलेटर है जो कई इरोज़न सिस्टम (hydraulic, thermal, wind) को sediment transport और deposition के साथ couple करता है। GPU compute के साथ C++ में बना, यह multi-process इरोज़न तरीके का एक reference इम्प्लीमेंटेशन देता है जो professional टूल इस्तेमाल करते हैं।

संबंधित soillib (C++20, MIT license) अंतर्निहित geomorphology simulation primitives को एक reusable library के रूप में देता है। और hydro-gen OpenGL compute shaders में real-time पैरामीटर adjustment के साथ grid-आधारित (shallow water) और particle-आधारित (raindrop) hydraulic इरोज़न दोनों लागू करता है।

ये open-source टूल हमारी सर्वर-साइड जेनरेशन पाइपलाइन के लिए ढाले जा सकते हैं। compute shader इम्प्लीमेंटेशन सीधे WebGPU में translate होते हैं अगर हम कभी real-time क्रिएटर feedback के लिए ब्राउज़र में इरोज़न चलाना चाहें।

Multi-Layer Terrain Materials

असली टेरेन एक ही सतह नहीं है। यह लेयर है: नीचे bedrock, ऊपर मिट्टी, सतहों पर जमा होती बर्फ या रेत। Dynamic layering मौसमों, मौसम और क्रिएटर actions के साथ टेरेन का विज़ुअल चरित्र बदलती है।

Layered Heightfield Representation

एक ही हाइटमैप के बजाय, प्रति grid cell कई height layers इस्तेमाल करें:

Cell {
  bedrock_height: f16,    // permanent rock surface
  soil_height: f16,       // accumulated soil/sediment above bedrock
  snow_height: f16,       // dynamic snow accumulation
  water_height: f16       // standing water depth
}

कुल: प्रति cell 8 bytes (एक ही हाइटमैप के लिए 2 bytes बनाम)। एक 65x65 chunk के लिए, यह compression से पहले 34 KB है। फिर भी compact।

विज़ुअल सतह bedrock + soil + snow है। टेरेन shader सभी layers पढ़ता है और तदनुसार मटेरियल blend करता है: जहां मिट्टी पतली है, चट्टान दिखती है। जहां बर्फ जमा है, सतह सफेद है। जहां पानी बैठा है, आपको puddles या झीलें मिलती हैं।

Dynamic Accumulation

बर्फबारी के दौरान बर्फ समतल, ऊपर की ओर मुंह वाली सतहों पर जमा होती है। accumulation दर सतह के normal (खड़ी ढलानें बर्फ नहीं रोकतीं), तापमान (altitude-निर्भर), और shelter (ओवरहैंग के नीचे के इलाके साफ रहते हैं) पर निर्भर करती है। एक compute shader pass प्रति weather tick (हर कुछ सेकंड) snow layer अपडेट करता है।

रेत accumulation wind-driven deposition के साथ इसी तरह काम करती है। हवा खुली सतहों से particles ले जाती है और बाधाओं के पीछे और सुरक्षित इलाकों में जमा करती है।

एक क्रिएटर दुनिया के लिए, dynamic accumulation मतलब है कि टेरेन अलग मौसम में अलग दिखता है। एक बर्फानी तूफान के दौरान बर्फ दुनिया को ढक लेती है और साफ मौसम में पिघल जाती है। बारिश गड्ढों को पानी से भरती है। यह दुनिया को क्रिएटर के कुछ किए बिना responsive महसूस कराता है।

Multi-Layered इरोज़न

2024 का पेपर "3D Real-Time Hydraulic Erosion Simulation using Multi-Layered Heightmaps" (EG) इरोज़न को layers के पार काम करने के लिए बढ़ाता है। पानी bedrock से तेज मिट्टी को erode करता है। Sediment एक नई soil layer के रूप में जमा होता है। सिमुलेशन layer integrity बनाए रखता है (bedrock मिट्टी के नीचे रहता है) जबकि ओवरहैंग (जहां bedrock नीचे eroded मिट्टी के ऊपर लटकता है) जैसे जटिल फीचर सक्षम करता है।

परफॉर्मेंस: 2048x2048 रिज़ॉल्यूशन पर एक RTX 3070 पर प्रति simulation step लगभग 6ms। यह सर्वर-साइड जेनरेशन के लिए काफी तेज है लेकिन per-frame ब्राउज़र simulation के लिए बहुत धीमा। लेयर्ड रिप्रेजेंटेशन स्थिर टेरेन जेनरेशन के लिए काम करता है, और dynamic snow/water accumulation एक सस्ते per-frame shader के रूप में चलता है।

घास, चट्टान और Detail Rendering

लैंडस्केप को टेरेन ज्यामिति और टेक्सचर से ज्यादा चाहिए। इसे ऐसे घास के तिनके चाहिए जो हवा में लहराएं, ढलानों पर बिखरी चट्टानें, और फूल, कंकड़ और गिरी हुई टहनियों जैसे छोटे detail जो पास से देखने पर प्राकृतिक लगें।

GPU-Instanced घास

GPU instancing के साथ एक ही draw call में दस लाख घास के तिनके रेंडर किए गए। वही तकनीक Three.js और WebGPU में काम करती है: per-instance transforms, vertex-shader wind animation, और टेरेन डेटा से तिनके बिखेरने के लिए एक density map।

ब्राउज़र-आधारित घास rendering Three.js में अच्छी तरह आजमाई हुई है और GPU instancing के जरिए काम करती है। al-ro के grass demo से तरीका InstancedBufferGeometry इस्तेमाल करके एक ही draw call के साथ 100,000 घास के तिनके रेंडर करता है।

हर घास का तिनका एक साधारण quad (4-8 त्रिभुज) है। per-instance attributes position, height, bend direction, color variation और wind phase तय करते हैं। vertex shader:

1. per-instance transform पढ़ता है
2. world position और time से keyed sine waves इस्तेमाल करके wind animation लगाता है
3. wind strength के आधार पर तिनके को मोड़ता है (टिप पर ज्यादा bend, आधार पर कोई नहीं)
4. color gradient लगाता है (subsurface scattering के लिए आधार पर गहरा, टिप पर हल्का)

Codrops का fluffy grass tutorial (2025, Tutorial) एक shell texturing तरीका दिखाता है: ground plane को बढ़ते offsets पर कई बार रेंडर करें, हर layer घनी घास के आयतन का रूप बनाने के लिए एक noise texture sample करते हुए। यह बहुत घनी कवरेज के लिए अलग-अलग blade instancing से सस्ता है लेकिन पास से कम असली।

एक क्रिएटर दुनिया के लिए, घास घनत्व प्रति chunk वनस्पति density map से आता है। GPU render time पर density map से blade positions बिखेरता है। कोई per-blade डेटा स्टोर या स्ट्रीम नहीं होता। density map प्रति chunk एक 32x32 ग्रिड (1 KB) है, और GPU इससे हजारों blade instances जेनरेट करता है।

Procedural Rock और Cliff Detail

चट्टान की सतहों और चट्टानी टेरेन को geometric detail चाहिए जो बेस हाइटमैप या SDF reasonable रिज़ॉल्यूशन पर नहीं दे सकते। दो तरीके एक-दूसरे के पूरक हैं:

GPU mesh shader resurfacing (Raad et al., Eurographics 2025, Paper) render time पर एक मोटे control mesh से procedural ज्यामिति जेनरेट करता है। mesh shader एक बेस टेरेन सतह पढ़ता है और detail ज्यामिति को memory में स्टोर किए बिना displacement, दरारें और protrusions जोड़ता है। यह VRAM उपयोग घटाता है और dynamic LOD सक्षम करता है।

Instanced rock scattering GPU instancing इस्तेमाल करके खड़ी ढलानों और चट्टान के किनारों पर pre-made rock meshes रखता है। एक compute shader टेरेन normal और slope पढ़ता है, और जहां slope एक threshold से ज्यादा हो वहां rock instances बिखेरता है। हर instance एक छोटी मेश (200-500 त्रिभुज) है random rotation और scale के साथ। 10,000 बिखरी चट्टानें instancing के साथ नगण्य rendering कॉस्ट जोड़ती हैं।

सड़कें और रास्ते

क्रिएटर-रखी सड़कों, trails और रास्तों को टेरेन के मुताबिक conform करना और सतह मटेरियल बदलना (घास को मिट्टी या पत्थर से बदलना) चाहिए।

हर बड़े game engine द्वारा इस्तेमाल किया जाने वाला तरीका: रास्ते को एक spline (control points की एक श्रृंखला) के रूप में तय करें। spline को टेरेन सतह पर project करें। एक strip मेश जेनरेट करें जो spline का पीछा करती है और टेरेन से थोड़ा ऊपर बैठती है। strip पर एक road texture लगाएं। टेरेन shader में, एक projected texture या decal इस्तेमाल करके spline की चौड़ाई के अंदर टेरेन मटेरियल को road मटेरियल की ओर blend करें।

एक ब्राउज़र दुनिया के लिए, एक क्रिएटर टेरेन पर एक रास्ता बनाता है। क्लाइंट control points जेनरेट करता है और उन्हें सर्वर को भेजता है (कुछ दर्जन vec3 वैल्यू)। सर्वर spline स्टोर करता है। सभी clients spline को अपनी टेरेन मेश पर project करके road strip local रेंडर करते हैं। road डेटा छोटा है (path spline points, शायद 200 bytes) लेकिन विज़ुअल असर बड़ा है: क्रिएटर builds को जोड़ने वाले रास्ते दुनिया को बसी हुई महसूस कराते हैं।

टेरेन के लिए Shadows

टेरेन shadows readability (टेरेन का आकार समझना) और वातावरण (दिन के समय का mood) के लिए जरूरी हैं। एक ओपन वर्ल्ड में, सूरज पूरे दृश्य टेरेन पर छायाएं डालता है।

Cascaded Shadow Maps (CSM)

CSM view frustum को 3-4 distance ranges (cascades) में बांटता है। हर cascade सूरज के नज़रिए से एक shadow map को अपनी दूरी के लिए उचित रिज़ॉल्यूशन पर रेंडर करता है। पास का cascade: high resolution (पेड़ों और इमारतों के नीचे विस्तृत छायाएं)। दूर का cascade: low resolution (व्यापक पर्वत छायाएं)।

Three.js और Babylon.js दोनों CSM सपोर्ट करते हैं। टेरेन के लिए मुख्य optimization: shadow map में सिर्फ टेरेन रेंडर करें, अलग-अलग घास के तिनके या छोटे detail नहीं। घास टेरेन के shadow map का इस्तेमाल करके self-shadow करती है, अपने खुद के का नहीं।

परफॉर्मेंस बजट: हर एक 1024x1024 पर 3-4 shadow cascades। टेरेन को shadow maps में रेंडर करने की कॉस्ट 0.5-1ms (टेरेन ज्यामिति पहले से GPU memory में है)। टेरेन shader में 4 cascades sample करना 0.2-0.3ms जोड़ता है।

हाइटमैप से Terrain Self-Shadowing

बहुत बड़े टेरेन के लिए जहां CSM महंगा हो जाता है, एक horizon map pre-compute करें: हर टेरेन cell के लिए, 8 compass दिशाओं में अधिकतम elevation angle स्टोर करें। render time पर, यह तय करने के लिए कि एक पॉइंट छाया में है या नहीं, sun angle की horizon map से तुलना करें। Skyrim दूर के टेरेन (CSM range से परे) के लिए टेरेन self-shadows ऐसे ही संभालता है।

horizon map हाइटमैप से सर्वर-साइड compute होता है (कुछ सेकंड की processing) और एक 128x128 per-chunk texture (16 KB compressed) के रूप में स्ट्रीम होता है। विज़ुअल असर बड़ा है: पर्वत घाटियां चरम view distances पर भी असली रूप से गहरी होती हैं।

Streaming के लिए टेरेन डेटा Compression

एक ब्राउज़र दुनिया के लिए नेटवर्क bottleneck है। टेरेन डेटा में बचाया गया हर byte एक तेज load time है।

हाइटमैप Compression

Raw 16-bit हाइटमैप अच्छे से compress होते हैं क्योंकि आस-पास की cells की वैल्यू समान होती हैं। पाइपलाइन:

1. Delta encoding: हर cell और उसकी predicted वैल्यू (पड़ोसियों का औसत) के बीच का अंतर स्टोर करें। Delta वैल्यू छोटी हैं, शून्य के पास clustering करती हैं।
2. Quantization: दूर के chunks के लिए, precision को 16-bit से 12-bit या 8-bit तक घटाएं। 500 मीटर दूर, 8-bit height precision (100m height range पर 0.4m resolution) 16-bit से अलग नहीं दिखती।
3. Entropy coding: delta-encoded stream पर zlib या brotli compression लगाएं। आम compression ratio: 4-8x।

नतीजा: एक 65x65 chunk 16-bit पर 8.4 KB raw से 1-2 KB compressed हो जाता है। 8-bit घटी precision पर: 0.5-1 KB।

Progressive हाइटमैप Streaming

टेरेन को पहले low resolution पर भेजें, फिर refine करें। एक 17x17 हाइटमैप (4m cell spacing वाले 64m chunk के लिए न्यूनतम) 578 bytes raw है, 200 bytes से कम compressed। टेरेन तुरंत दिखता है। फिर 33x33 refinement स्ट्रीम करें (odd-row/column samples जोड़ता है)। फिर 65x65 full resolution। हर स्तर पिछला डेटा बदले बिना detail जोड़ता है।

यह geometry clipmap LOD rings से map होता है: दूर का टेरेन low-resolution version (17x17) इस्तेमाल करता है, mid-range medium (33x33) इस्तेमाल करता है, पास full (65x65) इस्तेमाल करता है। streaming प्राथमिकता rendering LOD से मेल खाती है।

SDF Volume Compression

Sparse SDF वॉल्यूम नाटकीय रूप से compress होते हैं क्योंकि ज्यादातर voxels सतह से दूर हैं (खाली जगह)। विकल्प:

Run-length encoding: समान वैल्यू (खाली voxels) के runs encode करें। आम SDF वॉल्यूम 95%+ खाली होते हैं, इसलिए RLE 10-50x compression हासिल करता है।

Sparse octree: सिर्फ वे octree nodes स्टोर करें जिनमें surface-crossing voxels हों। खाली जगह के कोई nodes नहीं। एक ही cave tunnel वाले एक 64^3 SDF वॉल्यूम में शायद सिर्फ 2,000-5,000 occupied nodes हों (कुल 262,144 voxels बनाम), हर एक 1-2 bytes के रूप में स्टोर।

Entropy-driven progressive compression (2024, HAL) 3D spatial डेटा पर entropy-optimized planes और adaptive quantization के साथ space को recursively partition करके लागू होता है। यह rate-distortion trade-offs के लिए optimized refinements का एक stream बनाता है, जो खासकर नेटवर्क streaming के low bitrates पर फायदेमंद है।

इसे एक साथ रखना: ब्राउज़र टेरेन पाइपलाइन

इस लेख के ऊपर का strategic overview क्विक decision framework और phased build plan देता है। यह सेक्शन सर्वर-साइड जेनरेशन पाइपलाइन और ब्राउज़र rendering पाइपलाइन दोनों के लिए पूरी technical detail देता है।

Generation Pipeline (Server-Side)

जेनरेशन पाइपलाइन फिजिकल प्रोसेस के एक directed graph के रूप में चलती है, जो Gaea और World Machine के node-graph तरीके से प्रेरित है। हर stage पिछली stage का आउटपुट लेकर उसे refine करती है। क्रिएटर हर stage पर पैरामीटर नियंत्रित करते हैं।

Stage	Input	Process	Output	Time
1. Base terrain	Seed or text prompt	Terrain Diffusion / MESA / noise + fBm	16-bit heightmap	1-5s
2. Erosion	Heightmap	Analytical stream power + thermal erosion	Eroded heightmap, flow accumulation map, sediment map	0.5-2s
3. Rivers	Eroded heightmap, flow map	Drainage network extraction, channel carving	River splines, water level map	0.5s
4. Coast	Heightmap near sea level	NEWTS-style wave erosion	Coastline features (cliffs, beaches, stacks)	1-3s
5. Volumetric	Heightmap + creator intent	Arenite erosion / cave generation / SDF sculpts	Sparse SDF volumes for affected chunks	1-60s
6. Materials	Heightmap + erosion maps	TerraFusion / Geodiffussr / procedural rules	Splat maps, terrain textures	1-5s
7. Vegetation	Heightmap + flow map + materials	Ecosystem competition simulation	Density maps per biome per chunk	1-3s
8. Horizon maps	Final heightmap	8-direction max elevation angle	Self-shadow texture per chunk	2-5s
9. Chunking	All outputs	Slice, delta-encode, compress, hash	Chunk packages on CDN	5-10s
Total				15-90s

एक नई 4x4 km दुनिया 15-90 सेकंड में जेनरेट होती है। क्रिएटर एडिट (sculpting, पैरामीटर बदलाव) सिर्फ प्रभावित chunks के लिए प्रभावित stages फिर चलाते हैं, आमतौर पर 5 सेकंड से कम में पूरे होते हैं।

Rendering Pipeline (Browser)

Step	WebGPU path	WebGL 2 fallback	Frame budget
1. Streaming	Priority queue, predictive pre-fetch	Same	N/A (async)
2. Heightmap terrain	GPU-driven CDLOD quadtree, compute culling, indirect draw	Geometry clipmaps, CPU ring updates	0.5-1ms
3. Volumetric mesh	Compute marching cubes + Transvoxel	Pre-generated meshes from Web Worker, 2-3 cached LODs	0.5-2ms
4. LOD transitions	Geomorphing in vertex shader	Same	Included above
5. Materials	Triplanar PBR + Laplacian blending + phasor noise detail + virtual texturing	Triplanar PBR + linear blending + pre-baked splat maps	1-1.5ms
6. Vegetation	ComputeInstanceCulling + IndirectBatchedMesh, hex-tiled ground cover	CPU frustum cull + InstancedMesh	1-1.5ms
7. Water	Flow-aligned river strips, depth-based shoreline foam	Same (simpler reflections)	0.5ms
8. Shadows	3-4 cascade CSM + horizon map self-shadows	2 cascade CSM	0.5-1ms
9. Atmosphere	Hillaire sky model + volumetric fog + weather particles	Preetham sky + distance fog	0.5ms
10. Dynamic effects	Puddle accumulation, footprint deformation, snow/rain	Puddle accumulation, rain particles	0.3ms
Total terrain			3.5-6.5ms

60fps (प्रति फ्रेम 16.6ms) पर, टेरेन सिस्टम WebGPU पर frame बजट का 21% और WebGL 2 पर 39% इस्तेमाल करता है। बाकी player avatars, क्रिएटर objects, UI, networking और post-processing के लिए उपलब्ध है।

यह एक ब्राउज़र में क्यों काम करता है

पूरी पाइपलाइन तीन ब्राउज़र बाधाओं के इर्द-गिर्द डिज़ाइन की गई है:

Memory (अधिकतम 2-4 GB): 256 MB टेरेन बजट फिट होता है क्योंकि हाइटमैप chunks हर एक 2-8 KB हैं (delta-encoded), SDF वॉल्यूम sparse हैं (प्रति वॉल्यूमेट्रिक chunk 100-500 KB), वनस्पति runtime पर 1 KB density maps से जेनरेट होती है, और टेक्सचर KTX2 compression इस्तेमाल करते हैं (प्रति 1024x1024 150 KB)। किसी भी वक्त, ब्राउज़र में दिखने वाली दुनिया कुल 50-200 MB होती है।

कोई disk access नहीं: सब कुछ नेटवर्क पर स्ट्रीम होता है। Progressive loading मतलब प्लेयर <100ms में टेरेन देखता है (low-res हाइटमैप), <300ms में textured टेरेन, और <3s में full detail। वेलोसिटी के आधार पर pre-fetching सामान्य अन्वेषण के दौरान load times छिपाती है।

GPU बहुत अलग होते हैं: WebGPU रास्ता high-end डेस्कटॉप संभालता है। WebGL 2 fallback बाकी सब संभालता है, mobile सहित। वही chunk डेटा दोनों रास्ते चलाता है। फर्क rendering तकनीक का है, डेटा फॉर्मेट का नहीं। WebGL 2 चलाने वाला एक Chromebook वही दुनिया देखता है जो WebGPU चलाने वाला एक RTX 4090, बस कम detail और छोटी view distance पर।

Research Papers

Terrain Representation और Mesh Generation

"Marching Cubes: A High Resolution 3D Surface Construction Algorithm" -- Lorensen और Cline (SIGGRAPH 1987)। DOI। वॉल्यूमेट्रिक डेटा से triangle meshes निकालने का foundational एल्गोरिदम। 38 साल बाद भी सबसे ज्यादा इस्तेमाल किया जाने वाला isosurface extraction मेथड। GPU-parallel इम्प्लीमेंटेशन WebGPU compute shaders में रियल टाइम में चलते हैं।

"Dual Contouring of Hermite Data" -- Ju, Losasso, Schaefer, Warren (SIGGRAPH 2002)। DOI। ऐसी meshes बनाता है जो sharp फीचर (चट्टान के किनारे, चट्टान के कोने) बचाती हैं जिन्हें marching cubes गोल कर देता है। distance वैल्यू के अलावा surface normals चाहिए।

"Neural Dual Contouring" -- Chen et al. (2022)। arXiv:2202.01999। dual contouring में least-squares vertex placement की जगह एक learned predictor रखता है। जटिल प्राकृतिक फीचर के लिए बेहतर सतह क्वालिटी।

"The Transvoxel Algorithm" -- Lengyel (2009, 2024 में अपडेट)। transvoxel.org। voxel टेरेन के लिए seamless LOD ट्रांज़िशन। 73 transition cell types इस्तेमाल करके रिज़ॉल्यूशन boundaries पर दरारें खत्म करता है। Patent-free, रियल-टाइम एप्लिकेशन के लिए डिज़ाइन किया गया।

Terrain LOD और Rendering

"Geometry Clipmaps: Terrain Rendering Using Nested Regular Grids" -- Losasso और Hoppe (SIGGRAPH 2004)। Paper। concentric LOD rings के साथ constant-cost टेरेन rendering। इंटरैक्टिव rates पर 40 GB टेरेन संभालता है। ज्यादातर ब्राउज़र टेरेन renderers की नींव।

"CDLOD: Hybrid LOD for Terrain Rendering" -- Strugar (2014)। Paper। geometry clipmaps पर quadtree-adaptive सुधार। सिर्फ दूरी के बजाय टेरेन जटिलता के आधार पर रिज़ॉल्यूशन allocate करता है।

"GPU-Driven Rendering Pipelines" -- Ubisoft (SIGGRAPH 2015), Wihlidal और Hoppe। GPU-ड्रिवन तरीके को औपचारिक रूप दिया जहां compute shaders culling, LOD selection, और draw call generation संभालते हैं। हमारी WebGPU टेरेन पाइपलाइन के लिए architectural पैटर्न।

Physical Terrain Generation

"Physically-Based Analytical Erosion for Fast Terrain Generation" -- Cordonnier et al. (2024)। HAL। एनालिटिकल stream power law इरोज़न जो iterative simulation से बचता है। मिलीसेकंड में फिजिकली संभव टेरेन बनाता है।

"Fast Hydraulic Erosion Simulation and Visualization on GPU" -- Mei, Decaudin, Hu (2007)। HAL। shallow-water simulation इस्तेमाल करते हुए GPU-parallel hydraulic इरोज़न। ज्यादातर game engine इरोज़न इम्प्लीमेंटेशन का आधार।

"Arenite: A Physics-Based Sandstone Simulator" -- SIGGRAPH 2025। Project। stress और इरोज़न simulation से मेहराब, hoodoos और alcoves जेनरेट करता मल्टी-फिजिक्स इरोज़न। डेस्कटॉप GPUs पर 5 मिनट से कम में चलता है।

"Efficient Debris-flow Simulation for Steep Terrain Erosion" -- Purdue CGVLAB (2024)। Paper। असली पर्वत टेरेन फीचर बनाता GPU-accelerated debris flow और steep-slope इरोज़न।

"Flexible Terrain Erosion" -- IRIT-STORM (2024)। Springer। particle-आधारित इरोज़न जो एक unified इंटरफेस के साथ heightfields, voxel grids, implicit surfaces और लेयर्ड मटेरियल के पार काम करता है। हाइब्रिड टेरेन रिप्रेजेंटेशन के लिए एक इरोज़न सिस्टम सक्षम करता है।

Terrain Detail और Texturing

"GPU-Friendly Laplacian Texture Blending" -- Wronski (NVIDIA, 2025)। JCGT। बिना precomputation के टेरेन मटेरियल के लिए रियल-टाइम Laplacian pyramid blending। seam artifacts खत्म करते हुए sharp फीचर बचाता है। प्रति fragment कुछ अतिरिक्त texture taps।

"Real-time Terrain Enhancement with Controlled Procedural Patterns" -- Grenier et al. (2024)। CGF। हाइटमैप रिज़ॉल्यूशन के 32x तक phasor noise-आधारित माइक्रो-इरोज़न detail। Slope-aligned पैटर्न पूरी तरह एक fragment shader में चलते हैं।

Adaptive Tessellation

"Concurrent Binary Trees for Large-Scale Game Components" -- Benyoub और Dupuy (Intel, HPG 2024)। Paper। adaptive टेरेन tessellation के लिए GPU-friendly binary tree डेटा संरचना। 0.2ms से कम में ग्रहीय-पैमाने की ज्यामिति रेंडर करती है। चौकोर domains से मनचाहे polygon meshes तक बढ़ाई गई।

Cave और Underground Generation

"PLUME: Procedural Layer Underground Modeling Engine" -- 2024। arXiv:2508.20926। लेयर्ड प्रोसीजरल नियमों का इस्तेमाल करके असली गुफा और lava tube वातावरण जेनरेट करने के लिए open-source फ्रेमवर्क। मूल रूप से अंतरिक्ष अन्वेषण रोबोटिक्स के लिए बना।

Neural Terrain Synthesis

"InfiniteDiffusion: Bridging Learned Fidelity and Procedural Utility for Open-World Terrain Generation" -- Goslin (2025, SIGGRAPH 2026)। arXiv:2512.08309। Laplacian encoding के साथ hierarchical diffusion models इस्तेमाल करते हुए अनंत, seed-consistent टेरेन जेनरेशन। consumer GPUs पर baseline से 9x तेज।

"TerraFusion: Joint Generation of Terrain Geometry and Texture" -- 2025। arXiv:2505.04050। sketch conditioning के साथ एक साथ हाइटमैप और texture synthesis के लिए latent diffusion।

"MESA: Text-Driven Terrain Generation" -- CVPR 2025 Workshop। arXiv:2504.07210। Copernicus remote sensing training data इस्तेमाल करते हुए text-to-terrain।

"Geodiffussr: Generative Terrain Texturing with Elevation Fidelity" -- 2025। arXiv:2511.23029। flow-matching इस्तेमाल करते हुए एलिवेशन डेटा का सम्मान करती text-guided टेरेन texture generation।

"Sketch2Terrain: AI-Driven Real-Time Terrain Sketch Mapping" -- 2025। Project। augmented reality में sketch-to-terrain। मैन्युअल mapping पर 38% efficiency सुधार।

Vegetation और Ecosystem Simulation

"GPU-Based Real-Time Procedural Distribution of Vegetation on Large-Scale Virtual Terrains" -- SBGames 2018। Paper। GPU पर biotic/abiotic factors इस्तेमाल करते हुए quadtree-आधारित वनस्पति scattering।

"Procedural Generation and Rendering of Forests" -- 2022। Paper। असली जंगल वितरण के लिए ecosystem competition simulation के साथ मिलाई गई L-system tree generation।

"Real-Time Procedural Generation with GPU Work Graphs" -- AMD GPUOpen 2024। Paper। 4ms से कम में 79K+ वनस्पति instances जेनरेट करते GPU work graphs।

Browser GPU Technology

"GSWT Renderer" -- SIGGRAPH Asia 2025। GitHub। dynamic LOD और streaming के साथ अनंत 3D टेरेन के लिए Gaussian Splatting Wang Tiles इस्तेमाल करता WebGPU + Rust/Wasm renderer।

"GPU Compute in the Browser at the Speed of Native: WebGPU Marching Cubes" -- Usher (2024)। Blog। दिखाता है कि WebGPU compute parallel mesh generation एल्गोरिदम के लिए native-speed परफॉर्मेंस हासिल करता है।

Voxel Rendering और Large-Scale Scenes

"Aokana: A GPU-Driven Voxel Rendering Framework for Open World Games" -- 2025। arXiv:2505.02017। दसियों अरब voxels वाले scenes के लिए LOD और streaming के साथ Sparse Voxel DAG। पिछले state-of-the-art से 9x memory कमी और 4.8x तेज rendering। game engines के साथ integration के लिए डिज़ाइन किया गया।

Procedural Geometry और Resurfacing

"Real-time Procedural Resurfacing using GPU Mesh Shaders" -- Raad et al. (Eurographics 2025)। Paper। mesh shaders इस्तेमाल करते हुए render time पर मोटे control meshes से विस्तृत geometric सतहें जेनरेट करता है। memory में high-resolution ज्यामिति स्टोर किए बिना dynamic LOD सक्षम करता है।

Terrain Shadows

"Optimizing Terrain Shadows" -- AMD GPUOpen। Blog। बड़े पैमाने के टेरेन के लिए व्यावहारिक CSM optimization। cascade splitting, GPU-efficient shadow map rendering, और terrain-specific optimizations कवर करता है।

Virtual Geometry और Mesh Optimization

"Nanite WebGPU" -- Scthe (2024)। GitHub, Demo। UE5 Nanite आर्किटेक्चर का पूरा ब्राउज़र इम्प्लीमेंटेशन: meshlet LOD hierarchy, WGSL में software rasterizer, per-meshlet culling, billboard impostors।

"Billions of Triangles in Minutes" -- Kapoulkine (2025)। Blog। hierarchical clustered LOD generation के लिए Meshoptimizer v1.0। विशाल meshes को Nanite-style cluster DAGs में कुशलता से प्रोसेस करता है।

"Billboard Splatting (BBSplat)" -- 2024। arXiv:2411.08508। novel view synthesis के लिए learnable textured planar primitives जो 3D Gaussian Splatting बनाम 17x compression हासिल करते हैं।

Terrain Lighting और Global Illumination

"Global Illumination in Once Human" -- GDC 2025। Session। 16km ओपन वर्ल्ड के लिए hybrid GI: neural network compressed probes (69:1 ratio), ML-आधारित indoor/outdoor leak resolution, dynamic probe reactions।

"GI with AMD FidelityFX Brixelizer" -- GDC 2024। Paper। screen-space probes के साथ compute-आधारित sparse distance field cascades। कोई hardware ray-tracing जरूरी नहीं।

"Radiance Cascades" -- 2024। Blog। temporal accumulation के बिना cascaded radiance structures इस्तेमाल करती noiseless रियल-टाइम global illumination।

Level Design और Exploration

"PlotMap: Automated Layout Design for Building Game Worlds" -- 2023। arXiv:2309.15242। टेरेन पर narrative spatial constraints संतुष्ट करती AI-assisted POI placement।

"Spatial Exploration Triggers" -- Purdue University (FDG 2022)। Paper। चार डिज़ाइन पैटर्न जो प्लेयर अन्वेषण चलाते हैं: चरम पॉइंट, विज़ुअल बाधाएं, जगह से बाहर के objects, spatial connections।

Data Compression और Streaming

"Entropy-driven Progressive Compression of 3D Point Clouds" -- SGP 2024। Paper। adaptive quantization के साथ recursive space partitioning इस्तेमाल करती rate-distortion optimized progressive compression। variable-bandwidth नेटवर्क streaming के लिए उपयुक्त refinement streams बनाती है।

Interactive Editing

"WebGPU SDF Editor" -- Nijhoff (2026)। Project। real-time marching cubes, boolean ऑपरेशन, smooth blending, और octree space partitioning के साथ ब्राउज़र में full-featured SDF modeling। प्रति primitive 112 bytes।

River और Coastal Generation

"Procedural River Drainage Basins" -- Patel (Red Blob Games)। Project। Voronoi/triangle mesh edge classification इस्तेमाल करती drainage-first river generation। टेरेन एलिवेशन देने से पहले river hierarchies बनाती है।

"NEWTS1.0: Numerical Model of Coastal Erosion by Waves and Transgressive Scarps" -- MIT (2024)। Paper। uniform retreat और wave-driven इरोज़न इस्तेमाल करता सरलीकृत coastal इरोज़न मॉडल। असली भू-आकृति विज्ञान से मेल खाते headlands, खाड़ियां, sea stacks और मेहराब बनाता है।

आगे पढ़ें

• Browser 3D Open World Tech ब्राउज़र में एक मल्टीप्लेयर क्रिएटर दुनिया के लिए पूरा आर्किटेक्चर कवर करता है
• Web Games Tech Stack in 2026 WebGL, WebGPU और WebAssembly की बुनियादी बातें कवर करता है
• Three.js + USDC Tech Report ब्राउज़र में 3D assets लोड करने पर
• Frontier Open-Source Gen AI Models AI generation पाइपलाइन के लिए
• WebGPU getting started — GPU-ड्रिवन टेरेन के लिए compute shaders
• Web Workers for game logic — टेरेन generation को Workers पर offload करना
• Game physics libraries — टेरेन interaction और heightfield colliders के लिए physics
• Where to Find Free Game Assets — टेरेन rendering के लिए texture और material स्रोत