Engine

एक लाइन में#

ब्राउज़र में एक पूरा गेम इंजन: कोई सीन बनाएँ, उसे व्यवहार दें, play दबाएँ, और उसे वेब पर या किसी नेटिव डेस्कटॉप और मोबाइल बाइनरी के रूप में एक्सपोर्ट करें।

यह aukimi का, काफ़ी बड़े फ़ासले से, सबसे बड़ा स्टूडियो है। यह पेज इसे उसी तरह मैप करता है जैसे इंटरफ़ेस करता है, यानी हर पैनल जिस drawer में रहता है उसके हिसाब से, न कि फ़ीचर को वर्णानुक्रम में सूचीबद्ध करके।

ले-आउट#

चार पैनल बटन#

ये सब एक जैसा व्यवहार नहीं करते, और कुछ ढूँढने से पहले यह फ़र्क़ जानना ज़रूरी है:

Systems और Tools जान-बूझकर एक ही slot साझा करते हैं; इन्हें अगल-बगल रखा गया है ताकि यह दिखे कि वे ऐसा करते हैं।

Systems#

इंजन के अपने subsystems: वे चीज़ें जो किसी सीन के पास होती हैं, न कि वे जिनसे आप बनाते हैं।

Rendering#

toolbar पर मौजूद FX Master स्विच पूरी post पाइपलाइन को एक क्लिक में ऑन-ऑफ़ कर देता है: यह देखने का सबसे तेज़ तरीक़ा कि इसकी क़ीमत आपको क्या चुकानी पड़ रही है। अलग-अलग: bloom, depth of field, SSR, SSAO, GTAO, SSGI, temporal AA, FXAA, motion blur, volumetric fog, contact shadows, colour grading, film grain, chromatic aberration, vignette और tonemapping, साथ ही Nanite-जैसी geometry और Hi-Z occlusion।

Look Presets ऊपर की सारी चीज़ों के पूरे configurations हैं। Render Style register बदलता है, फ़ोटोग्राफ़िक की जगह stylised। Shader Lab वहाँ है जहाँ आप अपना ख़ुद का लिखते हैं। Mesh LOD और Post Process Volumes वे दो हैं जो किसी बड़े सीन पर अपनी क़ीमत ख़ुद वसूल लेते हैं: हर mesh का अपना level-of-detail, और सिर्फ़ किसी volume के अंदर लगने वाली post-processing।

रेंडरर Babylon.js है। यह WebGL पर शुरू होता है और जब ब्राउज़र में WebGPU हो तो ख़ुद उस पर स्विच हो जाता है, और वह नाकाम हो तो अपने-आप वापस चला जाता है।

Gameplay systems#

Physics दोनों को कवर करता है, 3D solver (Havok) और 2D वाला। AI & Navigation navmesh और उस पर मौजूद agents है। Gameplay Zones व्यवहार जुड़े हुए trigger volumes हैं। Multiplayer room सीन को एक Colyseus सर्वर से जोड़ता है (नीचे देखें)।

World systems#

Level Streaming खिलाड़ी के हिलने पर level के हिस्सों को लोड और अनलोड करता है। Baking लाइटिंग को पहले से गणना कर लेता है; Light Probes अंतरिक्ष के बिंदुओं पर indirect लाइट और रिफ्लेक्शन कैप्चर करते हैं। Decals बिना geometry जोड़े सतहों पर डीटेल प्रोजेक्ट करते हैं।

Tools#

वे चीज़ें जिनसे आप बनाते हैं।

World generators#

Terrain, water, sky और चार कंटेंट generators, trees, plants, rocks और kitbash टुकड़े। इनका नीचे अपना एक अलग हिस्सा है।

Gameplay authoring#

Inventory, Data tables (Tools → Data) और Dialogue Trees वे तीन एडिटर हैं जो किसी गेम को ऐसा कंटेंट देने देते हैं जो कोड में नहीं रहता, नीचे विस्तार से।

Animation#

एंटिटी एनिमेशन के लिए Timeline, shots के लिए Cinematic Sequencer, और framing के लिए Camera Tools। देखें Animation और कैमरा।

World एडिटर#

Tools → World के तहत सात पैनल। ये किसी सीन को भरने का तेज़ तरीक़ा हैं, और यही वजह है कि किसी level को मॉडलिंग सेशन से शुरू नहीं करना पड़ता।

Terrain#

कोई सीन कई terrains रख सकता है; हर एक Terrains सूची में एक पंक्ति है और तीन रिज़ॉल्यूशन में से किसी एक पर बनाया जाता है, 128² (तेज़), 256² (संतुलित) या 512² (डीटेल वाला)।

पैनल में दस मोड हैं, और उनमें एक बात साझा है: Masks में पेंट किया गया mask इन सभी को सीमित करता है।

Sculpt। Raise 1, Lower 2, Smooth 3, Flatten 4, Pinch 5, Inflate 6, Noise 7, Sharpen 8, Stamp 9, Terrace 0, Erode E, Fill F, Clone C (source सेट करने के लिए Alt-click), Blur B, Ramp R, साथ ही दो water टूल: River एक रास्ता ड्रॉ करता है, Lake किसी बिंदु पर भर देता है।

ब्रश की अपनी dynamics हैं: pressure curve, lazy mouse, falloff, symmetry, pattern, और size व strength दोनों पर jitter। Stamp छह shapes रखता है: crater, mountain peak, plateau, river valley, dome, noise hill। Erosion दो रूपों में आता है: E ब्रश local है, जबकि Adjustments पूरे terrain पर hydraulic, thermal और wind erosion चलाता है।

Paint। आठ लेयर, क्योंकि दो RGBA splatmaps हर एक चार चैनल रखते हैं। मटेरियल लाइब्रेरी कैटेगरी के हिसाब से सजी है, grass, dirt, forest, rocks, roads and surfaces, cliffs, sand, snow, volcanic, wetland, fantasy, और आपकी अपनी, और हर लेयर UV scale, displacement, एक detail map, और surface relief (bump strength और parallax depth) रखती है। Break texture tiling (cell bombing) वह सेटिंग है जो किसी दोहराए गए ज़मीन के टेक्सचर को grid जैसा दिखने से रोकती है।

Generate noise से बनाता है, फिर Generate Textures height और slope के हिसाब से मटेरियल असाइन करता है, उत्तर/दक्षिण shade variation के साथ और जहाँ पानी है वहाँ sand या pebble शोरलाइन के साथ। Real World सार्वजनिक NASA/USGS elevation tiles इम्पोर्ट करता है: कोई landmark चुनें या coordinates टाइप करें, ज़ूम चुनें, और पैनल वह elevation रेंज बताता है जो यह वापस लाया।

Sketch अंदर आने का दूसरा रास्ता है। किसी 2D मैप पर ridge और valley स्ट्रोक ड्रॉ करें, तीन तक असली source landscapes चुनें, और terrain को sketch से मेल खाने के लिए synthesise किया जाता है, चाहें तो पहले से मौजूद चीज़ में blend कर दिया जाता है, और उसी पास में auto-textured और eroded भी।

Masks को ब्रश से पेंट किया जाता है और फिर पूरे तौर पर एडिट किया जाता है: clear, invert, blur, grow, shrink। smart masks terrain से ही एक निकालते हैं, height से, slope से, layer से या cavity से।

Paths। control points रखने के लिए क्लिक करें और एक smooth curve उनके बीच से गुज़रता है; उन्हें हिलाने के लिए amber points खींचें, curve मोड़ने के लिए cyan handles। Bake Path इसके नीचे की ज़मीन को समतल करता है, टेक्सचर पेंट करता है और embankments उठाता है।

Vegetation के दो हिस्से हैं। ब्रश हाथ से instances रखता और हटाता है; scatter rules उन्हें condition, layer weights, seed, min/max scale, और हर asset जिस height और slope band को स्वीकार करता है, उसके हिसाब से रखते हैं। Grass और फूल एक कॉन्फ़िगर की जा सकने वाली draw distance के बाद धुँधले हो जाते हैं, और Export to Scene instances को सीन ऑब्जेक्ट में बदल देता है।

Biomes ऊपर की सारी चीज़ों का one-click वर्ज़न है: कोई biome चुनें, मनचाही categories टिक करें (soil, trees, plants and grass, flowers, पानी के पास algae, rocks), एक density सेट करें, और Apply Biome ज़मीन को पेंट करता है और सब कुछ बिखेर देता है, यह बताते हुए कि इसने हर एक के कितने instances रखे। Tree age variety हर जगह एक ही पेड़ छापने के बजाय saplings से लेकर ancients तक मिलाती है, और ground blend (RVT) हर rock base को उसके नीचे के terrain रंग में मिला देता है।

SDF एक अलग रेंडरर है, कोई अलग टूल नहीं: terrain को एक distance field से raymarch किया जाता है, octaves, lacunarity और persistence से आकार, grass/rock/snow से टेक्सचर, एक snow line और एक slope threshold के साथ, और अपनी soft shadows, ambient occlusion और fog।

बड़े terrains का एक LOD system होता है, जिसमें skirt geometry (जो levels के बीच के गैप बंद करती है), smooth level transitions, frustum culling और एक stats overlay शामिल हैं। Heightmaps 16-bit PNG, 8-bit PNG या RAW 16-bit के रूप में इम्पोर्ट-एक्सपोर्ट होते हैं; splatmaps एक RGBA PNG या हर लेयर की अपनी फ़ाइल के रूप में; और पूरा terrain, या सिर्फ़ उसकी सेटिंग्स, एक प्रीसेट के रूप में।

Sky Studio#

वातावरण। चार आकाश टाइप, solid, gradient, HDRI, और Rayleigh और Mie scattering, Mie absorption, ozone, ground albedo, turbidity, planet radius और atmosphere thickness वाला एक physical atmosphere।

सब कुछ time of day पर टिका है, जो अपने-आप चक्र में चल सकता है: सूरज elevation, azimuth और intensity से, अपनी shadow intensity के साथ; चाँद phase से; तारे twinkle के साथ; और एक aurora। Volumetric clouds में thickness, erosion, noise scale और curl distortion होते हैं, और absorption, scatter, ambient और एक powder term के ज़रिए लाइट; cirrus और Belt of Venus अलग हैं। Aerial perspective वह धुंध है जो दूरी के साथ गाढ़ी होती है और दूर की geometry को क्षितिज में धुँधला कर देती है, यही वह सेटिंग है जो किसी लैंडस्केप को बड़ा दिखाती है।

शुरू करने के लिए दस प्रीसेट: clear day, dawn, sunset, dusk, night, overcast, stormy, desert, arctic और space।

Water#

दो टैब: खुले समुद्र के लिए Ocean (FFT), बाक़ी हर चीज़ के लिए Shore & lakes।

⚠️ Water Terrain एडिटर में बनाया जाता है: river और lake टूल, या Show Water से, और यहाँ ट्यून किया जाता है। बिना water वाले किसी सीन पर यह पैनल खोलने से आपको ऐसी सेटिंग्स मिलती हैं जिन्हें लगाने के लिए कुछ है ही नहीं।

Shore water में colour, opacity, wave strength और speed, choppiness, foam width और Fresnel होते हैं, साथ ही screen-space reflections और refraction blur। इसके नीचे ख़ुद WGSL shader है: अपनी scroll directions और speed वाली दो normal scales, foam threshold और softness, refraction strength और index of refraction, और पानी के अंदर की लाइट, absorption, turbidity, scattering और translucency।

Tree Generator#

दो मोड, Tree और Trunk। कोई पेड़ deciduous या evergreen होता है, sapling से ancient तक की एक उम्र रखता है, और living, dead, snag या fallen log हो सकता है। सब कुछ seeded है, इसलिए Randomize seed उसी चरित्र के साथ एक अलग पेड़ पाने का सबसे तेज़ तरीक़ा है।

आकार हर branch level के हिसाब से है: children, length, radius, taper, gnarliness, twist, sections, segments, angle और start height, साथ ही natural variation, phototropism और gravitropism: वे दो जो किसी पेड़ को लाइट की ओर झुकाते हैं और अपने ही वज़न के नीचे लटकाते हैं, और अपनी strength वाला एक global force। आधार में root flare (lobes और height) और buttress है।

पत्तियाँ billboards हैं, single या double sided, count, size, angle, variance, clump, curl, droop, sheen और rounded normals के साथ। Bark छह styles में आती है: ridged, aspen, pine, birch, smooth, palm, relief, moss, एक नम आधार, sun bleach, canopy ambient occlusion और एक autumn turn के साथ। चार seasons पूरा लुक एक साथ बदल देते हैं।

Forest एक साथ कई बिखेरता है: count, spread radius, scale variance, और एक age mix (single, natural, young, old, even)। Add age progression पाँचों जीवन-अवस्थाओं को एक पंक्ति में रखता है, जो उन्हें अगल-बगल परखने का सबसे तेज़ तरीक़ा है। कोई पेड़ एक सीन एंटिटी के रूप में या GLB के रूप में निकलता है, और किसी भी सेटिंग को प्रीसेट के रूप में सेव किया जा सकता है।

Plant Generator#

पाँच तरह, flower, cluster, herb, fern, grass, जो एक stem (count, height, thickness, curve, colour) और leaves (count, size, width, angle) साझा करते हैं। Ferns leaflet pairs, leaflet sweep और frond arch जोड़ते हैं; grass blade count और arch जोड़ता है।

इनमें से किसी पर भी flower वैकल्पिक है: petals, petal rows, length, width, curl, tip sharpness, bloom, centre size, और तीन रंग, petal, petal tip और centre, साथ ही यह तय करने के लिए translucency और roughness कि लाइट पत्ती से होकर कैसे गुज़रे। सीन में एक जोड़ें, कई बिखेरें, या GLB एक्सपोर्ट करें।

Rock Generator#

तीन तरह, rock, stone, cliff, तीन styles में: realistic, toon, या outline वाला low poly।

Shape किसी sphere पर noise है: scale, strength, octaves, persistence, warp और एक ridged विकल्प, साथ ही अपनी frequency वाला strata और angular पत्थर के लिए depth व sharpness वाले facet cuts। Radius, detail, flatten, shape variance और एक flat bottom silhouette तय करते हैं, और चार erosion प्रीसेट, fresh, weathered, natural, eroded, इन सभी को एक साथ हिला देते हैं।

सतह पर colour variation, mineral veins, lichen और moss, tiling व strength वाला एक detail texture, triplanar blending और parallax relief होते हैं। यह डिफ़ॉल्ट रूप से एक बंडल किया गया Stone मटेरियल इस्तेमाल करता है; इसे override करने के लिए Matter से Engine को कोई मटेरियल भेजें।

Kitbash, Sculpt जैसी ही library#

Kitbash Sculpt के साथ साझा है: यह पैनल और Sculpt का Edit Forge एक ही library पढ़ते हैं। वहाँ बनाया गया कोई piece यहाँ रखा जाता है, और यहाँ रखा गया कोई piece वापस उसमें सेव किया जा सकता है।

सीन जो स्टोर करता है वह है part और उसके dimensions, उसके vertices नहीं, यही वजह है कि कोई kitbashed इमारत फ़ाइल में लगभग कुछ भी क़ीमत नहीं रखती और बाद में अपने source से अपडेट की जा सकती है।

catalogue से कोई piece arm करें और हर left click उसे रख देता है। तीन snapping मोड तय करते हैं कि यह कहाँ उतरेगा: on terrain (pieces अपने नीचे की ज़मीन की ऊँचाई फ़ॉलो करते हैं), on water (build plane पानी के लेवल पर बैठता है), और snap to sockets, किसी रखे गए piece पर एक connection point पर निशाना साधें और नया piece उससे मिलने के लिए घूम जाता है। कोई chain अपने खुले सिरे से बढ़ती है, भरे हुए sockets उम्मीदवारों से बाहर हो जाते हैं, और हर click अपना ख़ुद का undo चरण है। Ctrl/Cmd selection के लिए और Alt rotation के लिए आरक्षित रहता है। Collections अपना source और version रखते हैं, ताकि original बदलने पर किसी instance को अपडेट किया जा सके।

बाक़ी एडिटर#

World एडिटर किसी सीन को भरते हैं; ये वाले उसे एक इंटरफ़ेस, एक मैप, उसकी कंटेंट टेबल और यह जाँचने के औज़ार देते हैं कि इसकी क़ीमत क्या है।

HUD एडिटर#

Tools → Editors → UI। छह टैब, Templates, Elements, Layers, Preview, Style और Script, एक ऐसे preview पर जो तीन device साइज़ के बीच बदलता है: desktop 960×540, tablet 768×432, mobile 375×667।

Elements तीन groups में आते हैं (Display, Data, Input) और nest होते हैं: panel और flex children रखते हैं, इसलिए Layers टैब एक flat लिस्ट नहीं बल्कि एक असली tree है। History पचास चरण गहरी है।

⚠️ Style टैब CSS-जैसा है, और यह फ़र्क़ मायने रखता है। HUD कैनवस पर Babylon के GUI से ड्रॉ किया जाता है, और असली CSS वहाँ तक नहीं पहुँचती। यहाँ आप जो नियम लिखते हैं वे GUI properties पर मैप होते हैं; selectors एक element के लिए #name, किसी तरह के लिए .type (.text, .panel) और हर चीज़ के लिए * हैं।

Script टैब इसे बनाने का दूसरा तरीक़ा है: ui.* API, createText, createPanel, createProgress, createButton, इसे चलाने के दो तरीक़ों के साथ। Build Layout इसे design-time पर execute करता है और आपको हाथ से हिलाने के लिए असली elements छोड़ देता है; Run Live इसे गेम में चलाता है।

बाहर की ओर दो कनेक्शन: HUD आर्टवर्क Inkwell या Vectra में खुलती है और कॉपी होने के बजाय वापस लिंक हो जाती है, और किसी Vectra दस्तावेज़ को HUD elements के रूप में इम्पोर्ट किया जा सकता है। minimap element अपनी अलग चीज़ है, range, grid, और player, enemies, allies, items और objectives के लिए markers के साथ।

Tilemap एडिटर#

ग्यारह टूल, brush, eraser, fill, rectangle, select, eyedropper, stamp, autotile, prop, zone और path, चार map projections पर: orthogonal, isometric, staggered isometric और hexagonal।

Autotiling चार templates के साथ आता है, और हर नाम में मौजूद नंबर उन tiles की गिनती है जिनकी यह उम्मीद करता है: Blob 47 (पूरा corner और edge), Wang 16 (edge-based), Simple 4 (NSEW), और RPG Maker A2 (48 tiles, वहाँ बनाए गए maps के साथ compatible)।

ख़ुद tiles के ऊपर दो लेयर बैठती हैं। Zones gameplay मतलब पेंट करते हैं: buildable, water, forest, road, farm, residential, commercial, blocked, और props category के हिसाब से ऑब्जेक्ट रखते हैं: trees, rocks, buildings, vegetation, water, paths। Maps ब्राउज़र के अपने डेटाबेस में रहते हैं, इसलिए कोई असेव्ड map भी reload में बचा रहता है।

Inventory, data tables और dialogue#

वे तीन एडिटर जो किसी गेम को ऐसा कंटेंट देने देते हैं जो कोड में नहीं रहता।

Inventory एक catalogue एडिट करता है और उसे सीन पर लगाता है। किसी item में actions होते हैं, और एक action एक trigger है: use, equip, unequip, साथ ही आठ types में से एक: message, heal, damage, grant, remove, event, toast, scene। पैनल की अपनी तीन layouts हैं (grid, list, compact), तीन appearance प्रीसेट (graphite, midnight, warm), और चार visual slots, background, slot, equipment, tooltip, जो ठीक तरह से redraw के लिए किसी और मॉड्यूल में खुलते हैं।

Data tables typed हैं: कोई column text, number, bool या ref होता है। CSV अंदर जाता है और बाहर आता है। हर एडिट pure functions से गुज़रता है, यही वह चीज़ है जो export की लिखी टेबल को बिल्ड की पढ़ी टेबल जैसा ही बनाए रखती है।

Dialogue trees ऐसे nodes हैं जिनका एक speaker और एक line होती है। कोई node या तो एक next पर जारी रहता है, या choices में बँट जाता है, हर एक की अपनी text और अपनी destination, branch टॉगल ही एडिटर का इकलौता structural फ़ैसला है।

Animation और कैमरा#

Cinematic Sequencer एक duration और एक loop flag के साथ sequences बनाता है, हर एंटिटी का एक track, और playhead पर कैप्चर की गई keyframes, Add Key आपसे टाइप करवाने के बजाय एंटिटी का मौजूदा मान लेता है। नीचे का graph editor समय को progress के मुक़ाबले दिखाता है, easing के लिए गोल handles के साथ: ढलान ही गति है। Shots की अपनी अवधि होती है, और letterbox के लिए एक Cinemascope framing (1.422:1) उपलब्ध है।

Camera Tools FOV, position, target, mode और speed को कवर करता है, साथ ही उन viewpoints के लिए bookmarks जिन पर आप बार-बार लौटते हैं, और camera layers।

Audio#

Audio Manager audio events, tracks और channels व categories वाला एक mixer रखता है। हर source के effects एक low-pass, एक high-pass और एक reverb send हैं; एक random मोड कई clips के बीच चुनता है ताकि कोई दोहराई गई आवाज़ loop जैसी न लगे। Scrubbing playhead खींचते समय audio बजाता है।

Profiler#

एक frame counter नहीं, एक frame breakdown: camera render, mesh evaluation, particles, sprites और shader compilation, हर एक real या estimated के तौर पर चिह्नित, ताकि किसी measurement से आया नंबर कभी किसी model से आए नंबर के लिए ग़लत न समझा जाए। इसके साथ counters: meshes और active meshes, lights, cameras, physics bodies।

Recording स्पष्ट रूप से शुरू की जाती है, और यह किसी समझे जाने वाले graph के बजाय एक Issues सूची पर ख़त्म होती है: low FPS, high draw calls, high triangles, high memory, आपके तय किए target frame rate के मुक़ाबले।

सीन बनाना#

Entities#

कोई नया सीन एक Main Camera, एक Directional Light, एक Skybox और एक Ground Plane के साथ आता है।

आप क्या जोड़ सकते हैं: Empty, Cube, Sphere, Cylinder, Plane, Light, Camera, Script, Mesh, साथ ही दो परिवार जो पहले से जुड़े हुए आते हैं:

• Characters: Third-Person, First-Person (FPS), Top-Down, Platformer, Basic।
• Props: Pickup (heal) और Hazard (damage)।

Scene graph सर्च करता है, टाइप से फ़िल्टर करता है, और जोड़ता, duplicate या delete करता है; एंटिटी nest होती हैं, और reparenting एक खींचने का काम है। Placement में snapping और ज़मीन को तेज़ी से भरने के लिए एक scatter brush होता है।

Inspector#

Transform (position, rotation, scale), एक Enabled स्विच, और एंटिटी के components: यहाँ जोड़े, कॉन्फ़िगर और हटाए जाते हैं, नीचे Add Script के साथ। कई एंटिटी चुनें और इंस्पेक्टर batch एडिटिंग पर स्विच हो जाता है, ताकि एक फ़ील्ड का बदलाव उन सभी पर लागू हो जाए।

Console#

सिर्फ़ एक log नहीं। यह level के हिसाब से फ़िल्टर करता है (all, logs, info, warning, error), किसी मैसेज को वापस उस एंटिटी से जोड़ता है जिसने उसे पैदा किया, और एक expression prompt रखता है: कोई expression टाइप करें, Enter उसे live सीन पर चलाता है, ऐरो कुंजियाँ history में घूमती हैं।

इसे व्यवहार देना#

तीन रास्ते, और वे साथ-साथ मौजूद हैं।

Scripts#

lifecycle hooks के साथ JavaScript, और अपना एक अलग संदर्भ:

function start() {}                     // once, when the entity starts
function update(dt) {}                  // every frame
function fixedUpdate(dt) {}             // fixed timestep, for physics
function onCollisionEnter(other) {}     // first frame of contact
function onCollisionStay(other) {}      // every frame while touching
function onCollisionExit(other) {}      // contact just ended
function onTriggerEnter(other) {}       // entered a trigger volume
function onTriggerExit(other) {}
function onMessage(msg, data, senderId) {}   // entity-to-entity messaging
function onAnimationEvent(name, data) {}
function onDestroy() {}

Collisions और triggers 2D और 3D दोनों में fire होते हैं, और हर पक्ष को अपना contact normal मिलता है: other.contact.normal दूसरी एंटिटी से इस एंटिटी की ओर इशारा करता है। यही वह चीज़ है जो किसी स्क्रिप्ट को "मैं इस पर उतरा" और "यह मुझ पर उतरा" में फ़र्क़ बताने देती है: कोई platformer stomp other.contact.normal.y > 0.5 पढ़ता है।

Script एडिटर#

F2, या किसी एंटिटी पर Add Script। tabs वाला एक Monaco एडिटर, एक साथ कई scripts खुली, हर एक प्रोजेक्ट फ़ाइल के बजाय ब्राउज़र के अपने डेटाबेस में रखी जाती है, इसलिए कोई असेव्ड buffer reload में बच जाता है।

पाँच dialects, एक प्रोग्राम। भाषा स्विच JavaScript, BASIC, Python, C# और Rust देता है। यह जो दिखता है वह नहीं करता: JavaScript ही असली सच्चाई है, और बाक़ी चार stored JS से transpile की गई views हैं। Python से Rust पर स्विच करना Python को ट्रांसलेट नहीं करता, यह उस JS पर वापस जाता है जिससे Python जनरेट हुई थी और उसे ट्रांसलेट करता है। Multi-hop translation ही वह चीज़ है जो किसी प्रोग्राम को बिगाड़ देती है, और एडिटर ऐसा करने से मना कर देता है।

पाँच categories में तेरह templates, हर एक अपनी कठिनाई के हिसाब से लेबल किए गए:

character-controller प्रीसेट और game-starter props (pickup, hazard) उसी सूची में दिखते हैं, जो किसी इम्पोर्ट किए गए character पर एक काम करने वाला controller डालने का व्यावहारिक तरीक़ा है।

चलाना और debug करना। F5 चलाता है, F9 एक breakpoint सेट करता है। Debugger किसी लाइन पर रुकता है, एक फ़्रेम आगे बढ़ता है, और watch expressions के ज़रिए live मान बताता है। Script Lab बिना किसी एंटिटी जोड़े कोई प्रोग्राम चलाता है, किसी ऑब्जेक्ट पर एक component के बजाय API के लिए एक scratchpad।

कोड के साथ: एक API reference, खुली फ़ाइल के लिए एक symbol list, और favourites व recents वाली एक snippet library। Ctrl+S सेव करता है, Ctrl+F ढूँढता है, Ctrl+H बदलता है, और एडिटर आठ themes के साथ आता है।

Blueprints और behaviours#

एक visual graph, तैयार behaviours की एक library, और behaviour stack के ऊपर layered एक state machine।

Graph बाईस groups में 267 nodes रखता है, Math, Scene, Entity, Animation, Flow Control, String, Events, Physics, UI, Array, Vector, Transform, Debug, Input, Utility, Game, Boolean, Camera, Tween, Variables, Audio और 2D व 3D परिवार। तीन ख़ासियतें इन्हें अलग करती हैं, और graph यहीं से बना है: 17 event nodes execution शुरू करते हैं, 117 pure nodes बिना किसी side-effect और बिना execution pin के एक मान गणना करते हैं, और 9 latent nodes बाद में ख़त्म होते हैं: यही वे हैं जो बिना अपनी कोई state machine बनाए किसी delay या tween को expressible बनाते हैं।

चार टूल: select V, pan H, comment C, reroute R, एक ऐसे कैनवस पर जो एक minimap के साथ 0.1× से 3× तक ज़ूम करता है। Variables छह टाइप में आते हैं, boolean, integer, float, string, vector3 और object। हर node का विवरण उसके tooltip पर है, जो इतनी बड़ी library के ख़ुद को समझाने की इकलौती जगह है।

State machine#

अपना ख़ुद का पैनल, और जान-बूझकर Animator वाला नहीं: Animator की conditions हर केस के लिए हाथ से लिखे UI वाला एक flat enum हैं, जबकि ये structured हैं और world की बात करती हैं।

सात conditions, और हर एक सीन के बारे में एक सवाल है: sees (range में कोई tagged target, वैकल्पिक रूप से किसी angle के अंदर और line of sight में), lost (N सेकंड तक कोई target नहीं), किसी threshold के मुक़ाबले distance, health, message received, timer (मौजूदा state में बिताया गया समय), और flag (shared blackboard पर एक मान)। दो combinators, and और or, दोनों सूचीबद्ध हैं भले ही or पहले से implicitly मौजूद था, एक ही state में दो transitions एक or हैं, पर "यह मुझे देखता है AND मेरी health अब भी बची है" का कोई रूप ही नहीं था।

⚠️ Health की तुलना maximum के एक अंश के रूप में होती है, कभी किसी absolute संख्या के रूप में नहीं। "30 HP से कम" वाला threshold किसी re-balancing पास में टिकता नहीं; "0.3 से कम" टिकता है।

किसी state में घुसते या छोड़ते समय, चार effects: कोई मैसेज send करें, कोई blackboard key set करें, कोई animation clip play करें, या कोई named effect fire करें। इनमें से कोई भी कुछ हिलाता नहीं, movement behaviours के पास रहता है, और मशीन तय करती है कि कौन सा behaviour सक्रिय है।

कोई transition * से शुरू हो सकता है, यानी कोई भी state। Validator पहली समस्या पर रुकने के बजाय समस्याओं की पूरी सूची लौटाता है, इसलिए आधी लिखी मशीन भी बनी रहती है और आपको सब कुछ ग़लत एक साथ दिख जाता है। Node positions डेटा का हिस्सा हैं: कोई ऐसा graph जिसका layout सीन के बाहर रहता है, अगले इंसान के लिए जब वह इसे खोलता है तो फेरबदल होकर वापस आता है।

BASIC#

TXT व्यूपोर्ट मोड बंडल किए गए demo प्रोग्राम वाला एक classic-BASIC environment है, और इस भाषा का अपना एक अलग संदर्भ है। यहाँ यह एक असली भाषा है, कोई खिलौना नहीं: multi-file modules (#INCLUDE), typed numerics (signed और unsigned 8/16/32/64-bit, float32 और float64), nested records, SELF के साथ object methods, references (REF/BYREF), structured TRY/CATCH/FINALLY, conditional compilation, coroutines, typed handles, और storage buffers व raw WGSL के साथ WebGPU compute।

OPTION EXPLICIT opt-in है; classic implicit variables डिफ़ॉल्ट बने रहते हैं ताकि इम्पोर्ट किए प्रोग्राम भी चलते रहें।

चलाना और शिप करना#

Play#

Play, Pause, Stop। रुकने पर, एक banner बताता है कि सेशन ने क्या बदला, ताकि play-mode का कोई एडिट कभी चुपचाप न रखा जाए और न चुपचाप खोया जाए। सेशन को किसी bug report में रिकॉर्ड और replay किया जा सकता है, और scenario bookmarks किसी playtest को level के बीच से शुरू करने देते हैं।

Build#

Build एक गेम टाइप लेता है (सीन से पहचाना गया, या हाथ से सेट: sidescroller/platformer, first/third person, text-based) और एक target।

• Web: WebGL fallback वाला WebGPU, वैकल्पिक WebXR (VR/AR), minification, एक FPS काउंटर, और एक embed assets विकल्प जो एक अकेली फ़ाइल बनाता है।
• Desktop और mobile: नेटिव बिल्ड। सीन को डेटा के रूप में एक्सपोर्ट किया जाता है (scene.glb + scene.json) और एक जनरेट किए गए Bevy (Rust) प्रोजेक्ट के ज़रिए कंपाइल किया जाता है; स्क्रिप्ट वहाँ एक embedded QuickJS रनटाइम पर बिना बदलाव के चलती हैं।

Compression हर axis के हिसाब से कॉन्फ़िगर की जा सकती है, algorithm, textures, meshes, एक quality प्रीसेट के साथ जो इन्हें आपस में बाँधता है। Builds को उनके साइज़ (original बनाम compressed) के साथ एक history में रखा जाता है और बाद में दोबारा डाउनलोड किया जा सकता है।

कोई नेटिव बिल्ड सिर्फ़ वही रखता है जिसे एक्सपोर्ट करना exporter को आता है। glTF custom shaders, thin instances, procedural sky या post-processing नहीं पकड़ता, इसलिए कोई भी runtime सिस्टम जिसे Bevy साइड पर पोर्ट नहीं किया गया, किसी desktop या mobile बिल्ड में ग़ायब रहेगा जबकि वेब पर बिल्कुल सही दिखेगा। किसी नेटिव बिल्ड पर भरोसा करने से पहले उसे जाँच लें।

Multiplayer#

Multiplayer room पैनल किसी सीन को एक Colyseus गेम सर्वर से जोड़ता है। बिना किसी अकाउंट और बिना किसी कॉन्फ़िगरेशन के एक मुफ़्त शेयर्ड टेस्ट सर्वर उपलब्ध है; किसी प्रोजेक्ट को उसका अपना सर्वर भी दिया जा सकता है। room एक share code से कीड होता है जिसे आप अपने पास रख सकते हैं या बाँट सकते हैं।

यह क्या पढ़ता और लिखता है#

दूसरे स्टूडियो को काम भेजना#

स्वीकार करता है Sculpt, Retopo और Pigment से mesh, Render से पूरे सीन, पिक्सेल आर्ट, एनिमेशन, Matter से PBR मटेरियल सेट, 2D rigs, वीडियो प्रोजेक्ट, इमेज, वेक्टर आर्ट, और Vectra objects।

बनाता है 2D rigs।

कोई Vectra स्क्रीन मॉकअप ढाँचे के रूप में पहुँचता है, तस्वीर के रूप में नहीं। यह एक HUD hierarchy बन जाता है जिसे Engine ले-आउट और स्क्रिप्ट कर सकता है: यही फ़र्क़ है किसी ऐसे डिज़ाइन में जिसे आप वायर कर सकते हैं और उसके किसी स्क्रीनशॉट में।

Shortcuts#

Cmd/Ctrl + K palette से Engine के अपने कमांड तक पहुँचता है, ग्लोबल कमांड के साथ-साथ। Engine के पास अपनी सेटिंग्स में एक समर्पित, सर्च की जा सकने वाली keyboard-shortcut पैनल भी है; इसमें shortcuts पेज पर समाने से कहीं ज़्यादा है।

सीमाएँ और आम अड़चनें#

• कोई ख़ाली व्यूपोर्ट आमतौर पर ब्राउज़र की वजह से होता है, सीन की वजह से नहीं। Engine को WebGL 2 चाहिए; जाँच लें कि hardware acceleration ऑन है।
• Systems और Tools एक ही drawer साझा करते हैं। अगर कोई पैनल "ग़ायब" हो गया लगे, तो वह शायद दूसरे में है।
• कंसोल देखने की सबसे पहली जगह है, आख़िरी नहीं: यह errors को उस एंटिटी से जोड़ता है जिसने उन्हें पैदा किया।
• play मोड में जोड़ा गया कोई component रुकने पर बच न पाए, हो सकता है। रुकने पर दिखने वाला banner पढ़ लें।
• 2D और 3D के बीच अपने solver में Physics अलग है, भले ही स्क्रिप्ट callbacks एक जैसे हों। 2D में एक resting contact 2 mm की skin से पहचाना जाता है, क्योंकि detection चलने से पहले solver penetration को ठीक शून्य पर ले आता है।