Mythic Realm manual

Mythic Realm generates a seeded, endless open world for Unity 6 and URP. This manual covers each part; Getting started sets up a project and the API reference lists what a game calls.

Contents: Components · Building a game on it · Editor tools · Look · Sky, weather and sound · Rivers · Wildlife · Rocks, ore and trees · World styles and distant land · Grass and flowers · Terrain shape · Climate and biomes · Colliders · Quality tiers · Profiles · Saving and generator versions · Baking terrains · Benchmark · Platforms · Player builds · Known limits

Components #

• WorldManager: streams deterministic terrain chunks and GPU-instanced props around a viewer Transform (default Camera.main). It creates no camera, lights, sky or UI and leaves RenderSettings alone. Add it with GameObject > Mythic Realm > Streaming World. API: HeightAt, GroundAt, BiomeAt (they work from the first frame, even in another script's Awake: the world starts before other scripts and makes its generator on first use), SnapViewerToLand, ApplySettings, SettingsApplied. For a game: WorldReady (raised once the area around the viewer has streamed in, and again after settings that change the land) and WhenReady(action); ChunkLoaded, ChunkCollidersReady and ChunkUnloading with a WorldChunk (coordinate and world bounds; every load is followed by exactly one unloading, at the latest when the world is destroyed), for placing enemies, loot or buildings as the world streams and removing them again; FindSpawnPoint(near, out point) (dry, gentle ground clear of trees and rocks, searched outward) and FindSites(bounds, results, maxCount) (such places on a jittered grid, the same every time for the same area). Set Drive Fog And Clip Plane to keep far plane and linear-fog distances matched to the view distance (you still enable fog yourself). Destroying it frees what it made (chunks, distant tiles, their meshes, materials and textures); the meshes, materials and textures every world shares (terrain layers, props, grass, animals) stay so the next world starts at once, and WorldManager.ReleaseSharedCaches() frees them too when the game is done with the world for a while (call it a frame after destroying the last world). It works with Enter Play Mode Options (Play without reloading scripts): every Play starts clean.
• WorldEnvironment: the sky and air for your own scene: it drives a directional light as the sun and moon (the scene's own, or one it makes), sets the procedural sky, ambient light and fog, and adds day and night and weather (WorldAtmosphere), the sound of the world (WorldAmbience) and waterfall spray (WorldWaterfalls), with the demo's post-processing look in a Linear project (demoLook; left out when the scene has a global volume). Put it beside a WorldManager (GameObject > Mythic Realm > World Environment); it uses that world's camera and adds no controls. Removing it removes what it added and puts the scene's skybox back.
• WorldDemoRig: optional ready-to-explore setup (camera, a WorldEnvironment, fly/walk controller, wildlife and mining with their prompts, IMGUI tuning panel; F12 saves a clean screenshot of the view at the screen's size, Shift+F12 at twice it, to WorldManager.ShotDir: the project's Shots folder in the editor, Application.persistentDataPath/Shots in a player). The rig also turns on the animal and mining prompts and the interact key (hud and interactKey on WorldFauna and WorldMining, off when you add those components yourself), so a scene without the rig draws no overlay and binds no key. GameObject > Mythic Realm > Demo Rig. Only the environment changes scene lighting; leave both out to keep your own. Every module (WorldAtmosphere, WorldAmbience, WorldWaterfalls, WorldFauna, WorldMining, PlayerController) also works added by hand: left empty, its world is WorldManager.Instance and its sun the scene's.
• Input: demo controls read WorldInput.Provider. Legacy Input Manager works by default. If the Input System package is installed and enabled, MythicRealm.InputSystem registers its provider automatically; there is no hard dependency on it. Assign your own IWorldInputProvider to override.

Building a game on it #

A game needs three things from Mythic Realm: the world, its sky and air, and a way to know when and where things are. The Integration sample puts them together in one scene; this chapter explains the parts.

The scene. A WorldManager (the world: terrain, water, trees, rocks, grass and the distant land) and a WorldEnvironment (sun and moon, sky, fog, weather, sound and waterfall spray), with your own camera and player. Leave out WorldDemoRig: it is the demo's camera, controller, panel and prompts. Every other module (WorldFauna for wildlife, WorldMining for mining and felling) can be added on its own; left empty, its world is WorldManager.Instance. Their prompts and the E key are off unless you turn on hud and interactKey, so a game draws its own interface and binds its own keys.

Settings. Keep the world's settings in a World Profile asset and assign it to the WorldManager; the same seed and settings make the same world on every machine. Each profile records the generator version it was made with, so a later package update keeps your world as it is (see Saving and generator versions).

Starting. Height and ground queries (HeightAt, GroundAt, BiomeAt, TryGround) work from the first frame, even from another script's Awake. The world raises WorldReady once the area around the viewer has streamed in, with its colliders; WhenReady(action) runs the action then, or at once if the world is already ready. Put the player at FindSpawnPoint(near, out point): dry, gentle ground clear of trees and rocks, searched outward from near.

Collision. The terrain has colliders within colliderDistance chunks of the viewer (2 by default, a chunk being 64 m) and trees and rocks within propColliderDistance (1). Keep gameplay inside that radius, or raise it. If your player can outrun the streaming, hold it on HeightAt where a chunk's collider is not ready yet, as IntegrationPlayer.cs does.

Placing things as the world streams. ChunkLoaded, ChunkCollidersReady and ChunkUnloading pass a WorldChunk (its coordinate and world bounds). Every load is followed by exactly one unloading, at the latest when the world is destroyed, so they pair up for spawning enemies, loot or buildings and removing them again. FindSites(bounds, results, maxCount) lists good places in an area on a jittered grid, the same every time for the same area, so a chunk spawns the same camps or chests whenever it loads.

The player's changes. Trees felled and rocks mined stay gone, and come back from a save with WorldSave (see Saving and generator versions); a few hundred bytes of JSON hold them with the bag, the time and weather and the player's place. The land itself is never saved: it is remade from the seed.

Quality. WorldQuality gives each of Unity's quality levels a drawing tier (view, prop and grass distances, the distant land's reach). Turn on Follow quality level to take it, and call SetQualityLevel from your options menu.

Leaving the world. Destroying the WorldManager frees what it made. The meshes, materials and textures every world shares stay, so the next world starts at once; call WorldManager.ReleaseSharedCaches() a frame after destroying the last world when the game is done with it for a while. Enter Play Mode without a domain reload works: every Play starts clean.

Input. The demo's controls read WorldInput.Provider. Both input systems work without setup; assign your own IWorldInputProvider to drive the demo pieces from your input.

Editor tools #

• WorldManager Inspector: status, warnings, grouped settings; edits apply live in play mode. Select the object to see gizmos: yellow ring = view distance, orange = props drawn, green = terrain colliders, cyan = prop colliders; in play mode each loaded chunk is outlined by state.
• Terrain Generator window (Tools > Mythic Realm > Terrain Generator; the window is titled Mythic Realm): shows the bake footprint in the Scene view (green; pink for "continue"), a size/prop-count summary with warnings, and a progress bar.
• Tools > Mythic Realm > Check Setup: verifies URP, shader references, input for the demo controls and the viewer (a Demo Rig counts: it adds the WorldManager at Play).

Look #

The streamed terrain uses the Mythic Realm/BiomeTerrain shader: the six layer textures live in texture arrays and are blended per pixel from a weight map written for each chunk, so the streamed world looks like the baked one (grass, forest floor, desert, snow, rock, sand and tundra, with a darker seabed). Water is the Mythic Realm/Water shader on a mesh per tile that dips below sea level; the mesh stores the water depth, which drives the colour, opacity and shoreline foam. Lakes lie still (no swell or whitecaps), cold lakes turn glacial turquoise and lakes above the snow line freeze; The surface is drawn in flat low-poly facets with hard colour bands and a hard white shore line (WorldSettings.flatWater, on by default; off gives normal-mapped ripples, soft foam and whitecaps; also in the Inspectors, the demo panel and the terrain window). For a stylized low-poly ground, WorldSettings.facetedGround (off by default; also in the Inspectors and the demo panel) draws each triangle of the ground in one flat shade and each layer in one flat colour with crisp edges between them, the rock in broad beds; it changes only the drawing, and a bake takes it into its ground material. Both shaders need shader model 3.5 (texture arrays); where they are unsupported the package falls back to plain URP Lit terrain and a flat water plane.

No art ships with the package: terrain layer textures (grass, forest floor, desert, snow, rock, sand), the streamed terrain's detail map and every prop texture are generated from tileable noise (ProceduralTextures). Baking writes the layer maps as PNGs to <output>/Layers/v3 and the prop textures to <output>/Props/v3/Textures, so you can edit or replace them; these are shared by every bake into that folder and kept, so a package version that generates them differently writes a new v folder (MythicRealmTerrainBuilder.CacheVersion) and earlier bakes keep theirs. Props: oak, birch, pine, spruce, snow pine, acacia, palm, cactus, tundra shrub, rock, boulder, bush and fallen logs, each with a simplified LOD mesh, chosen by climate (spruce and pine in taiga, birch among the oaks, acacia in savanna, palms on warm beaches and in the tropics, shrubs above the tree line). They are drawn with the Mythic Realm/Prop shader: URP lighting, a gentle wind sway that grows toward the top of the mesh, cloud shadows, and snow that settles on faces that point up.

Sky, weather and sound #

Added by WorldEnvironment (and so by WorldDemoRig). Both are plain components you can also add yourself: they find the scene's world, sun and weather on their own, or take them from Init(world, sun) / Init(world, atmosphere).

• Day and night. timeOfDay (0 to 24, 6 = sunrise) and dayLengthMinutes (0 freezes the time). The sun crosses the sky with orange light at the ends of the day, a dim blue moon takes over at night, and the sky, ambient light and fog follow. About 1400 stars turn through the night and a moon sits opposite the sun.
• Weather. Clear, cloudy, rain and storm (SetWeather), faded in over a few seconds; with autoWeather it changes by itself, with more rain on wet land. Cloud cover dims the sun, greys the sky and fog and shortens the view. Rain turns to snow where the air at the camera is at or below freezing (or force it with precipitation). Storms flash with lightning.
• Clouds. A cloud layer (Mythic Realm/Clouds, cloudHeight, windYaw) drifts on the wind: a few wisps when clear, a solid dark sheet in a storm; lit from the sun, orange at dusk, dark at night. The terrain, grass and props darken under the same clouds, so shadows move across the land.
• Wet and snowy ground. Rain darkens and glosses the terrain and grass; snow settles on level ground, whitens grass and rests on the tops of branches and rocks. It builds while it snows, lies for a long while in freezing air and melts in seconds in warm air. The world reads two shader globals, _OWWet and _OWSnow; set them yourself if you drive the weather another way (WorldAtmosphere.SetGround, groundEffects).
• Sound. No audio files: every sound is synthesised at start (under a second). Rain, rivers and the sea when you are near water, birds by day, crickets on warm nights and thunder after each flash of lightning (delayed by its distance). WorldAmbience.volume and mute; the panel has a slider and a switch. WorldAtmosphere.Lightning (with the distance in metres) is public for your own audio.

Rivers #

Rivers come from rain (flowRivers, on by default). The generator lets rain run off the real ground in 2 km tiles: pits fill, every place passes its water to the lowest way out, and the places that gather enough rain become rivers, so rivers lie in the valleys and tributaries join where valleys join; wetter ground sheds more, so dry land has fewer rivers. A river widens as it gathers rain, meanders on gentle ground, splits into a small delta where a big river meets a low coast, and its bed only ever falls downstream, so water runs downhill to the sea, widening into a mouth at the coast; a big river cuts a valley down into the hills; where the bed drops sharply it falls over a lip as a waterfall with mist and spray at its foot; a stream dropping 10 m or more per 16 m piece down a steep face cascades the whole way, with the same mist at its foot (the spray fades out with distance); a river with nothing upstream begins as a trickle from a damp patch and a small pond (a spring); deep pits stay as lakes standing at the level they would spill over. Switch flowRivers off for the older drainage trees: rivers grown upstream from each coast to meltwater at the snow line or a lake high in the mountains, with deltas. Either way everything is generated from the seed (no simulation state), so any chunk can be built on its own, and the water uses the same shader as the sea, so colour, ripples and shoreline foam match; banks are sand and gravel and the valley is greener than the land around it. Rivers change along their length like real ones: steep, straight and narrow-valleyed near the source, gentle, meandering and with a broad floodplain downstream, splitting into a small delta where a big river meets the sea. The water flows downstream (ripples move with the current, faster on steep reaches, with white water in rapids). Snowfields drain into small lakes in the basins below them. Where a river falls steeply it drops in a waterfall. Rivers freeze out near the poles. Tune riverScale (basin size) and riverWidth, or switch them off with rivers. Baked terrains include river water too.

Wildlife #

Animals roam the world around the viewer and live where it makes sense for them (geese by the water, antelope on open grassland, deer and bears in woods near water, camels in the desert, eagles on high ground), and thirsty ones walk to water to drink (WorldFauna, added by the demo rig; toggle with WorldSettings.wildlife, or per species with SetSpeciesEnabled): rabbit, deer, boar, wolf, bear, antelope, camel, goose and eagle, placed by biome the same way every time. Looking at one and pressing E harvests it (with interactKey on, as the demo rig sets it; a game can call Harvest itself), and each species gives the resources that fit it: meat, fat, bone, fur, hide, feathers and antler, which go into WorldFauna.Bag. ResourceInfo.Uses tells what each is good for in crafting (fat: food, fuel, light, waterproofing; bone: tools, weapons, glue; fur: clothing, bedding; hide: clothing, containers, cordage; feathers: arrows, bedding; antler: tools, weapons). A game calls Harvest(animal) from its own hunting and listens to the Harvested event. Each quadruped moves like itself: Species.gait gives it the wolf's walk, trot and rotary gallop, a rabbit's bound (a hop at every speed) or a camel's pace (the two legs of one side together), rollAmp how far it rocks with each step, and scareBound how long a scared deer bounds before it gallops.

The wolf is drawn from a model the package ships (Runtime/Resources/MythicRealm/WolfModel, made with TRELLIS.2 from Grok pictures; see Third Party Notices.md), recoloured, rigged and animated in code. Turn off WorldFauna.animalModels, or remove the model, and the wolf sculpted in code (SculptedWolf.cs) takes its place on the same skeleton. The other species are built in code. Any four-legged species can be drawn from a model of your own: Tools > Mythic Realm > Import Animal Model takes an OBJ, FBX or Mesh asset (or a GLB when the com.unity.cloud.gltfast package is in your project; glTFast does not read WebP textures, so convert a GLB's textures to PNG first), simplifies it to a few thousand flat facets, samples its texture into one colour per facet, fits the skeleton and saves an AnimalModelAsset under Assets/Resources/MythicRealm/Models; a second import as the doe gives the herd's females their own model.

Rocks, ore and trees #

Rocks come in several shapes and kinds of stone for their country, and some hold ore, the metal showing as a vein through the stone: copper, tin (copper and tin make bronze), silver, gold, platinum and exotic, each rarer than the one before (and only the first three below the mountains). Looking at a rock and pressing E mines it (WorldMining, with interactKey on, as the demo rig sets it; a game can call Hit and HitTree itself): the higher the ore, the more hits and the better the pick it needs (toolTier). A broken rock gives stone and its metal and stays gone. Trees work the same way with an axe (axeTier): the harder the wood (birch, then pine and spruce, then oak, then acacia) the better the axe and the more hits, and a felled tree gives its wood, resin, bark or fibre and leaves a stump. Minerals has the tiers, hardness and loot; WorldSettings.stoneTypes switches the kinds of stone and ore off.

Big outcrops of bedrock stand out of the land: crags set into steep ground, tors on crests and knolls, and spills of boulders at the foot of cliffs and steep rises, in granite, sandstone in the deserts and mesas, or basalt on a volcano. They are drawn like the rock of the ground around them (the same texture and beds, projected in world space), nothing grows inside them, they are solid but cannot be mined, and the distant tiles carry the crags and tors too. outcropDensity (0 to 3) sets how many.

World styles and distant land #

World styles. Five ready-made worlds, one click each: Temperate (the default: green hills and forests, rivers and lakes, snowy peaks, beaches and cliffed coasts), Alpine (great ranges up to 2 km high over broad green valleys and lakes, snow on the heights, pine and spruce up to the tree line; mountainHeight raises such ranges in any world), Archipelago (warm jungle islands in a shallow sea with cliffed headlands), Desert canyons (mesas and buttes stepping up in banded cliffs around oases) and Frozen north (tundra, snowfields and dark taiga by a cold sea). Pick one from World style in the demo panel, Apply world style in the WorldManager inspector or the Terrain Generator window, or from code with WorldPresets.Apply(name, settings). A style sets the terrain and climate settings and keeps the seed and the streaming, drawing and grass settings, so it works with any seed; save the result to a World Profile to keep it.

Beyond the chunks the land goes on to the horizon: coarse tiles drawn with the same ground layers, with their own sea and lakes, out to farDistance (4 km by default, stretched up to twice that in a world of great ranges: WorldSettings.FarReach; farTerrain turns them off). The air between the viewer and the land is drawn as aerial perspective: a haze densest at sea level that thins with height, so far ridges turn blue and pale in layers, with a glow toward the sun and mist in the valleys at dawn and dusk (WorldAtmosphere.haze, valleyMist). Tiles of four by four chunks are used to 1.5 km and tiles of sixteen by sixteen beyond; each leaves a hole where something finer is loaded and sinks a few metres around the chunks, so the chunks always cover it. Out to 1.5 km they carry trees (farTrees): the chunks' rules for biome, slope, tree line, kinds and sizes on a 6 m grid, drawn with the simplified tree meshes and no shadows from where the chunks stop drawing theirs, thinning out beyond 700 m. Crags and tors too, but no small rocks, grass or colliders out there. The tiles are built on worker threads only when the chunks leave a worker free, and cost about 0.1 ms of main thread per frame. With Drive Fog And Clip Plane the fog and far plane reach out to them (WorldManager.VisibleRange).

Grass and flowers #

Near the viewer (90 m by default) the ground is covered in instanced grass tufts and, in moist temperate meadows, patches of wild flowers. Placement is deterministic and runs on worker threads; the tufts are drawn by the Mythic Realm/Grass shader with wind, shadows and a distance fade. Colour and height follow the climate: green meadows, golden savanna and steppe, short olive tundra grass, tall dark jungle grass; nothing grows on snow, sand, rock or hot desert. Tune it with grassDistance, grassDensity and grassWind (ultraGrass draws fuller tufts at about twice the cost), or switch it off with grass. It needs structured buffers in the vertex shader (desktop and console GPUs) and is skipped elsewhere; baked terrains get it too, as a BakedGrass component that draws around the camera (it is not saved in the scene).

Terrain shape #

The land is shaped by fractal noise whose finer octaves are damped where the ground is already steep, the way water-worn mountains look: clean flanks, relief kept on the flats and in the valleys, and ridge and valley lines that wind downhill (a slow warp of the coordinates bends the creases). erosion (0 to 1, default 0.7) sets how much; 0 is plain noise. It is calibrated against the plain noise, so heights, coasts, the snow line and the biomes stay put, and rivers, lakes and waterfalls work on it as before. It costs about 2 microseconds per height sample (0.8 off). Nothing is simulated, so any chunk is still built on its own from the seed. A region baked before this setting existed continues with erosion off.

On top of that, rain has cut gullies down the slopes. gullies (0 to 1, default 1) creases steep ground into channels and sharp spurs that run straight downhill and branch into finer rills, up to about 12 m deep on mountain sides; some hillsides are cut deeply and others only scored, and flat ground, shores, the seabed and lake shores get none. The gullies follow the broad slope of the land (sampled every 8 m), not its small bumps. Rivers and lakes are found on the ground without them, so they stay where they were. They are an erosion-noise filter, not a simulation, so any chunk is still built on its own; they add about 3 microseconds per height sample. A region baked before them continues without.

Some country has landforms of its own (landforms, 0 to 1, default 1). In hot, dry land the ground steps up in level benches and sheer risers 18 to 34 m high, so hills become mesas and buttes with banded cliff faces; the steps wind across the slopes and only ever rise with the ground, so drainage is unchanged. Along about a third of the coasts the land stands up out of the sea in cliffs, on a line that wanders into headlands and coves; elsewhere the coast shelves into beaches as before. Cold or high mountains have broad U-shaped glacial valleys between sharp ridges, often holding long finger lakes, and near the coast the sea runs into them. Now and then a volcano stands on the land: a cone with a crater lake at the top, bare rock on its upper slopes and dark ash below. They cost about 1 microsecond per height sample.

Climate and biomes #

Biomes come from a simple but real-world climate model, not from noise alone:

• Latitude. The world has a north (+Z) and a south. The equator sits at equatorZ and a pole latitudeScale meters away (12 km by default, with the origin at 45 degrees north). Sea-level temperature falls from 28 C at the equator to about 8 C at 45 degrees and -27 C at a pole.
• Altitude. Temperature drops 6.5 C per kilometre of virtual height (peakElevation is how tall the highest peaks count as being, 3.5 km by default; the whole relief, height scale plus great ranges, is stretched to it), so mountains have a snow line and a tree line like on Earth.
• Moisture. A wet equator, dry subtropical belts (deserts), wetter mid-latitudes and dry poles, plus regional noise.

Steep faces (above about 42 degrees) are bare rock. Trees thin out and shrink toward the tree line. temperatureBias warms or cools the whole world.

Colliders #

Runtime chunks within colliderDistance chunks (default 2, circular footprint) of the viewer get a MeshCollider on WorldManager.chunkLayer; farther chunks have none, so keep gameplay inside that radius. Collision data is cooked on worker threads, the collider attached on the main thread when done, and Ready waits for it. Runtime trees and rocks are drawn instanced but are solid within propColliderDistance chunks (default 1): each chunk gets one object with a trunk capsule per tree, a sphere per rock and a mesh collider per outcrop, kept in step with what is drawn. Beyond that radius they can be walked through. The baked Terrain has a TerrainCollider, trunk-sized capsule colliders on the terrain trees and convex colliders on rocks (window toggle "Colliders").

Quality tiers #

WorldQuality holds a drawing tier for each of Unity's default quality levels (Very Low to Ultra): view, prop and grass distances, grass density, how far the distant land reaches and how far its trees are drawn (farTreeDistance, faded out over its last 250 m). Ultra and Very High are the defaults. A WorldManager with Follow quality level on (off by default; the Demo Rig turns it on for the WorldManager it adds, see its own followQualityLevel) takes its level's tier at start and in SetQualityLevel(level), overriding the settings' and the profile's distances; the terrain's shape and the on/off settings (grass, ultra grass, distant land, its trees, wildlife) are never touched, and Save to profile keeps the profile's own distances. Levels named otherwise map by position (the top level is always the full world). The render side (MSAA, HDR, shadow distance and cascades, render scale) stays in your project's URP asset for each level; a good start is one URP asset per level (Very Low: no shadows, no MSAA, render scale 0.75; Low: hard shadows to 80 m; Medium: soft to 140 m, MSAA 2x; High: 200 m with HDR; Very High: 250 m; Ultra: 250 m, MSAA 4x). The demo panel has a row of Quality buttons; in the editor the level goes back when Play stops. The benchmark takes -mythicrealm-benchmark-quality Low (name or index) and the overrides -mythicrealm-benchmark-renderscale, -mythicrealm-benchmark-msaa and -mythicrealm-benchmark-shadowdist, and writes them in its summary.

Profiles #

WorldProfile is a ScriptableObject holding every world setting (seed, noise, biomes, props, streaming). Create one with Assets > Create > Mythic Realm > World Profile and assign it to WorldManager (or WorldDemoRig); it replaces the inline settings at start. The demo panel can "Reset to profile" and "Save to profile". In the Terrain Generator window you can load a profile, save the current values into it, or create a new one. A profile used at runtime must be reachable from the build (assigned on a scene object or placed in a Resources folder).

Saving and generator versions #

The land is never saved: it is remade from the seed and settings. What a player changes is: WorldSave.Capture(world, bag, atmosphere, player) records the trees felled and rocks mined, the bag's contents, the time and weather and where the player stands (each of the last four optional), ToJson() makes it a few hundred bytes of plain JSON, and WorldSave.FromJson(json).Restore(world, bag, atmosphere, player) puts it back, rebuilding the loaded chunks so the stumps and gaps show at once (a CharacterController on the player is switched off for the move). WorldManager.SetEdits with empty arrays starts a new game. Felled trees and mined rocks also stay so when settings change, even the land's shape; a new seed is a new world and starts untouched. Animals harvested are not saved: they come back after respawnMinutes.

Every profile records the generation rules it was made with (WorldSettings.generatorVersion, WorldGenerator.Version when it was created; 11 now). When a later package version changes how land, rivers, biomes or props are made, it keeps the earlier rules for the earlier version, so a game that shipped with a profile keeps its world, and its saves still fit it, after an update; raise the number to take the newer rules (that reshapes the world). This package makes versions 10 and 11 (10 differs only in the faces of the great ranges). The package's tests compare every world style at every version against recorded output, so the rules of a version cannot change unnoticed.

Baking terrains #

Tools > Mythic Realm > Terrain Generator bakes a seeded region (500 m to 4 km) into a real Terrain: biome layers, water plane, terrain trees (Unity tree system, with LODGroup) and rock objects. Same seed and settings give the same land as the runtime world. Assets go to Assets/MythicRealmGenerated; the generated objects are undoable.

By default the bake's ground is drawn the way the streamed world draws it: the chunks' own layer weights (rock beds, scree, snow, held turf, the bare rock under crags) on Mythic Realm/BiomeTerrain meshes over the Terrain, which keeps its heightmap for collision, trees, grass and editing but does not draw it. Trees and rocks change to their simple mesh at 128 m; trees and the big crags and tors are drawn to 1.5 km and the other props and rocks to 320 m, as in the streamed world at its default distances (scaled by the quality level's LOD bias). Sculpting the Terrain switches that region back to the Terrain's own drawing (so the edit shows); turn Ground like the streamed world off to bake for Unity's paint and sculpt tools from the start. Nothing is drawn past the edge of the square.

Continuing a terrain #

Bake a square, sculpt it however you like, then in the window's Continue from an existing terrain section pick that Terrain, a side, and what the land should do at the edge: continue its slope, plateau, rise or fall at an angle, or follow the generator. The new square starts exactly at your edge height and eases back into generated terrain after the hold and ease distances. Only the edge is used (not your interior sculpting), and the new square takes the source's size and resolution and its stored seed and settings (BakedRegion).

Benchmark #

WorldBenchmark measures performance on a fixed fly-through so runs are comparable. In the demo, press Run benchmark in the panel (the panel hides while it runs). From code: WorldBenchmark.Begin(world, new WorldBenchmark.Options { seconds = 30, viewDistances = new[] { 4, 8, 12 } }). From the command line of the editor, or of a player built with the MYTHICREALM_BENCHMARK scripting define (a game built without it ignores these switches): -mythicrealm-benchmark [-mythicrealm-benchmark-seconds 30] [-mythicrealm-benchmark-speed 180] [-mythicrealm-benchmark-views 4,8,12] [-mythicrealm-benchmark-warmup 10] [-mythicrealm-benchmark-out folder]; the player quits when finished. Results go to a Benchmarks folder next to the project (editor) or the executable (player): a per-frame CSV (with a column per profiler marker), a summary CSV with one row per pass, and a worst CSV listing the 10 slowest frames and what each was spent on. Measure in a Development or release build for real numbers; editor numbers include editor overhead. The route flies due north from the start, so what it passes through (forest, tundra, snow) depends on the seed and the settings; each pass logs where it ended, so compare runs only with the same seed, settings and spawn. To see where a slow frame goes, record the Profiler (Window > Analysis > Profiler) and look for the MythicRealm.* markers (MythicRealm.BuildChunk and its MythicRealm.Chunk.* children). In a release player, where those markers read nothing, -mythicrealm-benchmark-hitch times every stage of Unity's player loop with a stopwatch: the frames CSV gets the largest stage of each frame (loop_max_ms, loop_max_seg) and whether the window had focus, and the worst CSV the five largest stages of each slow frame and of the frame after it (loop_top, next_loop_top). -mythicrealm-benchmark-nogc pauses the garbage collector during the passes, to tell a collection's stall from anything else.

Platforms #

The terrain and water shaders need shader model 3.5 (texture arrays); the props' GPU path (draw lists read from structured buffers) needs shader model 4.5 and compute support and falls back to plain instancing without them.

Player builds #

Shaders are referenced from Runtime/Resources/MythicRealmShaders.asset, which also holds instancing-enabled materials for the Lit and prop shaders so the GPU-instancing shader variants are kept. The installed package has it complete and needs nothing. If the asset goes missing (an embedded copy of the package, after changing URP), run Tools > Mythic Realm > Update Shader References. Without the instancing materials, props silently do not draw in a build, and the clouds and prop shader are left out if they are not referenced.

Known limits #

URP only. The terrain shader samples up to seven layers per pixel. Prop colliders are created on the main thread, but measured cost is small (under 2 ms in the worst frame of a 25 s fly-through). Snow frosts trees by face direction, not by branch. The cloud layer is a single sheet without volume, and clouds shade the ground, grass and props but not water. The bake is a single Terrain (max 4 km). On a coarse bake (a few metres per heightmap cell) the drawn ground and the Terrain's collision can differ by a little on steep ground, as they sample slightly different grids; a 4 km bake at 2049 writes a ground asset of a few hundred MB (the project's text serialization).