Tooling
This commit is contained in:
Rainer Leit
@@ -0,0 +1,270 @@
|
||||
"""Elite_RockyMeadows' kit, as its own demo maps use it: the landscape material and its three layer infos, the
|
||||
sun with the moving cloud shadows, the skybox dome, sky light, height fog and post-process grade. The numbers
|
||||
were read out of the pack's Rocky_Meadows_01 demo map with Scripts/Authoring/dump_level.py.
|
||||
|
||||
Shared by create_world.py and create_region_world.py so the two worlds are dressed by one set of numbers rather
|
||||
than two copies of them. Everything here is editor-side and imports `unreal`; the callers pass in their own
|
||||
`spawn`, because how an actor is created and labelled is theirs, and their manifest, because the distances
|
||||
scale with how big the world is.
|
||||
|
||||
A manifest passed in here needs `side_m`, `sea_level_m` and `sea_level_z_cm`. Both manifests have them.
|
||||
"""
|
||||
import unreal
|
||||
|
||||
PACK = "/Game/Elite_RockyMeadows"
|
||||
# The ground is the project's own now (D-69a), so a world is built from Content/Terrain and not from the pack.
|
||||
# That is not bookkeeping: MI_Ground_RockyMeadows carries the colour corrections in RawContent/Terrain/
|
||||
# ground.json, and the pack's instance it was copied from still tints the meadow layer blue at every distance.
|
||||
# The sky kit below stays in the pack, which is what ground.json's `_comment_not_here` says and why PACK remains.
|
||||
TERRAIN = "/Game/Terrain"
|
||||
LANDSCAPE_MATERIAL = f"{TERRAIN}/Materials/MI_Ground_RockyMeadows"
|
||||
# Paint layer name -> the layer info asset. The names mislead: Base_Layer samples the rock textures,
|
||||
# Layer_02 the grass, Layer_03 the high rock, so the meadow weightmap is the Layer_02 one. The copies keep the
|
||||
# pack's `LayerName` property, which is the half that has to match what the master material blends.
|
||||
LAYER_INFOS = {
|
||||
"Base_Layer": f"{TERRAIN}/Layers/Base_Layer_LayerInfo",
|
||||
"Layer_02": f"{TERRAIN}/Layers/Layer_02_LayerInfo",
|
||||
"Layer_03": f"{TERRAIN}/Layers/Layer_03_LayerInfo",
|
||||
# The biome layers (D-76). Built by Scripts/Authoring/build_ground_material.py, which duplicates a layer
|
||||
# info per layer and renames its LayerName - the property the material blends by, which the asset's own
|
||||
# name only documents. A layer enabled in Region.json with no entry here stops the build with a message
|
||||
# rather than being dropped, because a dropped layer paints the material's first substance everywhere.
|
||||
"Beach": f"{TERRAIN}/Layers/Beach_LayerInfo",
|
||||
"Sand": f"{TERRAIN}/Layers/Sand_LayerInfo",
|
||||
"Ice": f"{TERRAIN}/Layers/Ice_LayerInfo",
|
||||
"Regolith": f"{TERRAIN}/Layers/Regolith_LayerInfo",
|
||||
}
|
||||
SKYBOX_MESH = f"{PACK}/Materials/Skybox/Skybox_Mesh"
|
||||
SKYBOX_MATERIAL = f"{PACK}/Materials/Skybox/M_Skybox_Inst_RockyMeadows"
|
||||
CLOUD_SHADOWS = f"{PACK}/Materials/Light_Material/M_Cloud_Shadows_Inst02"
|
||||
SEA_MESH = "/Engine/BasicShapes/Plane"
|
||||
# The package is WaterMaterial and the material inside it is DefaultWaterMaterial, which is why every spelling
|
||||
# of "WaterMaterial.WaterMaterial" resolved to nothing: does_asset_exist answers on the object name, not the
|
||||
# package's. It is the engine's single-layer water (MSM_SingleLayerWater). Getting this wrong cost a world
|
||||
# whose sea rendered as a flat white shape material out to the horizon, bright enough to read as an ice sheet,
|
||||
# for as long as the failure was only a warning. It is an error now.
|
||||
SEA_MATERIALS = ("/Engine/EngineMaterials/WaterMaterial.DefaultWaterMaterial",
|
||||
"/Engine/EngineMaterials/WaterMaterial.WaterMaterial")
|
||||
|
||||
# What the sea actually wears. The engine's single-layer water is a whole-planet sheet here rather than a lake:
|
||||
# it reads at every scale as something it is not, and until a real water body replaces it, a plane pretending
|
||||
# to be the ocean is worth less than a plane that is honestly a placeholder. `SEA_GREY` is the switch - set it
|
||||
# False and the water material above comes back, unchanged and still the first thing tried.
|
||||
SEA_GREY = True
|
||||
SEA_MATERIAL = "/Game/World/M_Sea_Proto"
|
||||
# 0.18 linear is the classic mid-grey card: dark enough that two thirds of the world does not blow the auto
|
||||
# exposure the way the white shape material did, light enough to read as a surface rather than a hole.
|
||||
SEA_GREY_COLOR = (0.18, 0.185, 0.19)
|
||||
SEA_GREY_ROUGHNESS = 0.6
|
||||
|
||||
# Distances are scaled up where the demo's 8 km scene would otherwise cut the effect short on a bigger world.
|
||||
PACK_SUN = {
|
||||
"rotation": unreal.Rotator(roll=-51.273, pitch=-31.342, yaw=36.413), # keyword arguments: positional order is roll, pitch, yaw
|
||||
"intensity": 9.2368,
|
||||
"light_color": unreal.Color(r=223, g=245, b=255, a=255),
|
||||
"light_function_scale": unreal.Vector(1024.0, 1024.0, 1024.0),
|
||||
"light_function_fade_distance": 200000.0, # the pack's: cloud shadows within 2 km of the camera
|
||||
# Past the fade distance the light function is replaced by this flat factor, and the engine's default is
|
||||
# 0.5 - half sun over everything further away than 2 km, which on a world tens of kilometres across is
|
||||
# almost all of it. That one number was most of why the world came out dark, and stretching the fade
|
||||
# distance to cover the world instead only traded the darkness for a mottle: the cloud texture is tens of
|
||||
# metres across, so from a kilometre up it stops reading as cloud and becomes the dirty streaking over
|
||||
# every slope. The engine's own note says this should be the average brightness of the light function's
|
||||
# emissive, and M_Cloud_Shadows is white with dark blobs in it, not mid grey. Measured on four tiles: the
|
||||
# pack's distances with 1.0 here are as bright as deleting the light function outright, and keep the
|
||||
# clouds where they were designed to be seen.
|
||||
"disabled_brightness": 1.0,
|
||||
"dynamic_shadow_distance_movable_light": 200000.0,
|
||||
"cascade_distribution_exponent": 3.0,
|
||||
"light_source_angle": 0.5357,
|
||||
"shadow_bias": 0.5,
|
||||
}
|
||||
PACK_SKY_LIGHT = {"intensity": 1.5, "lower_hemisphere_color": unreal.LinearColor(0.0, 0.0, 0.0, 1.0), "sky_distance_threshold": 150000.0}
|
||||
# The demo map these numbers came from is about 8 km across. Fog density is per unit of distance, so the same
|
||||
# number over a bigger world is proportionally more fog: on a 30.6 km world it was opaque, and a capture
|
||||
# looking straight down from 25 km saw nothing but white. `scale_fog` divides the density by how much bigger
|
||||
# the world is than the demo, and raises the height falloff to the engine's own 0.2 so the fog thins with
|
||||
# altitude instead of reaching to the top of the sky.
|
||||
PACK_DEMO_SIDE_M = 8000.0
|
||||
PACK_FOG = {
|
||||
"fog_density": 0.027143,
|
||||
"fog_height_falloff": 0.039076,
|
||||
"fog_inscattering_luminance": unreal.LinearColor(0.238715, 0.329426, 0.458333, 1.0),
|
||||
"directional_inscattering_luminance": unreal.LinearColor(0.25, 0.20832, 0.154948, 1.0),
|
||||
"directional_inscattering_exponent": 4.0,
|
||||
"directional_inscattering_start_distance": 10000.0,
|
||||
}
|
||||
PACK_POST_PROCESS = { # FPostProcessSettings field -> value; the override flag of each is set alongside
|
||||
"auto_exposure_min_brightness": 1.0,
|
||||
"auto_exposure_max_brightness": 1.0,
|
||||
"auto_exposure_bias": 0.263034,
|
||||
"color_saturation": unreal.Vector4(1.0, 1.0, 1.0, 1.25),
|
||||
}
|
||||
|
||||
|
||||
def load_or_raise(asset_path):
|
||||
asset = unreal.load_asset(asset_path)
|
||||
if not asset:
|
||||
raise RuntimeError(f"{asset_path} not found; is the pack in Content/?")
|
||||
return asset
|
||||
|
||||
|
||||
def set_properties(target, values):
|
||||
for name, value in values.items():
|
||||
target.set_editor_property(name, value)
|
||||
|
||||
|
||||
def keep_always_loaded(actor):
|
||||
"""World partition streams actors by their bounds; the sky dome and the sea are the whole world and must
|
||||
not stream at all."""
|
||||
try:
|
||||
actor.set_editor_property("is_spatially_loaded", False)
|
||||
except Exception as error:
|
||||
unreal.log_warning(f"{actor.get_actor_label()}: could not clear is_spatially_loaded ({error}); it will stream by bounds")
|
||||
|
||||
|
||||
def weightmap_entries(weight_path, layer_names=None):
|
||||
"""The three paint layers as the landscape library wants them. `weight_path(layer_name)` returns the file
|
||||
for that layer, which is the one thing that differs between a single world and a tile of one."""
|
||||
entries = []
|
||||
for layer_name in (LAYER_INFOS if layer_names is None else layer_names):
|
||||
asset_path = LAYER_INFOS.get(layer_name)
|
||||
if asset_path is None:
|
||||
# A paint layer was enabled in Region.json before it had a substance. Said here rather than
|
||||
# further down, where the landscape library would drop the layer with a warning and the ground
|
||||
# would come out as the material's first layer everywhere (D-74, phase 2).
|
||||
raise RuntimeError(
|
||||
f"paint layer {layer_name!r} has no layer info in rocky_meadows.LAYER_INFOS. Add the "
|
||||
f"substance to RawContent/Terrain/ground.json, run collect_terrain_assets.py, and give it "
|
||||
f"a layer the landscape material blends, or set its `enabled` false in Region.json.")
|
||||
entry = unreal.LandscapeAuthoringWeightmap()
|
||||
entry.set_editor_property("layer_info", load_or_raise(asset_path))
|
||||
entry.set_editor_property("file", weight_path(layer_name))
|
||||
entries.append(entry)
|
||||
return entries
|
||||
|
||||
|
||||
def scale_fog(manifest):
|
||||
"""The pack's fog numbers, thinned for how big this world is. Returns a copy; PACK_FOG is left as read."""
|
||||
fog = dict(PACK_FOG)
|
||||
ratio = PACK_DEMO_SIDE_M / max(manifest.side_m, 1.0)
|
||||
fog["fog_density"] = round(PACK_FOG["fog_density"] * ratio, 6)
|
||||
fog["fog_height_falloff"] = 0.2
|
||||
unreal.log(f"fog density {PACK_FOG['fog_density']:g} -> {fog['fog_density']:g} "
|
||||
f"({manifest.side_m / 1000:.2f} km world against the pack's {PACK_DEMO_SIDE_M / 1000:g} km demo)")
|
||||
return fog
|
||||
|
||||
|
||||
def dress(spawn, manifest):
|
||||
"""The pack's sky, sun, fog and grade, so the level reads like its demo maps."""
|
||||
sun = spawn(unreal.DirectionalLight, "World_Sun", unreal.Vector(0, 0, 50000), PACK_SUN["rotation"])
|
||||
light = sun.light_component
|
||||
light.set_editor_property("mobility", unreal.ComponentMobility.MOVABLE)
|
||||
set_properties(light, {k: v for k, v in PACK_SUN.items() if k != "rotation"})
|
||||
light.set_editor_property("light_function_material", load_or_raise(CLOUD_SHADOWS))
|
||||
|
||||
sky_light = spawn(unreal.SkyLight, "World_SkyLight", unreal.Vector(0, 0, 50000))
|
||||
sky_light.light_component.set_editor_property("mobility", unreal.ComponentMobility.MOVABLE)
|
||||
set_properties(sky_light.light_component, PACK_SKY_LIGHT)
|
||||
|
||||
# The pack's skybox is a textured dome mesh, not a sky atmosphere. Scale it so the whole world sits inside
|
||||
# with room to spare, and sink its centre so the dome's equator is below the sea from any shore.
|
||||
mesh = load_or_raise(SKYBOX_MESH)
|
||||
native_radius = max(mesh.get_bounds().sphere_radius, 1.0)
|
||||
radius = manifest.side_m * 100.0 * 1.1
|
||||
skybox = spawn(unreal.StaticMeshActor, "World_Skybox", unreal.Vector(0.0, 0.0, -radius * 0.25))
|
||||
skybox.static_mesh_component.set_editor_property("mobility", unreal.ComponentMobility.MOVABLE)
|
||||
skybox.static_mesh_component.set_static_mesh(mesh)
|
||||
skybox.static_mesh_component.set_material(0, load_or_raise(SKYBOX_MATERIAL))
|
||||
skybox.static_mesh_component.set_editor_property("cast_shadow", False)
|
||||
skybox.static_mesh_component.set_collision_enabled(unreal.CollisionEnabled.NO_COLLISION)
|
||||
skybox.set_actor_scale3d(unreal.Vector(radius / native_radius, radius / native_radius, radius / native_radius))
|
||||
keep_always_loaded(skybox)
|
||||
unreal.log(f"skybox dome radius {radius / 100000:.1f} km (mesh radius {native_radius:g} cm, scale {radius / native_radius:g})")
|
||||
|
||||
fog = spawn(unreal.ExponentialHeightFog, "World_Fog", unreal.Vector(0.0, 0.0, manifest.sea_level_z_cm))
|
||||
set_properties(fog.component, scale_fog(manifest))
|
||||
|
||||
post = spawn(unreal.PostProcessVolume, "World_PostProcess")
|
||||
post.set_editor_property("unbound", True)
|
||||
settings = post.get_editor_property("settings")
|
||||
for field, value in PACK_POST_PROCESS.items():
|
||||
settings.set_editor_property(f"override_{field}", True)
|
||||
settings.set_editor_property(field, value)
|
||||
post.set_editor_property("settings", settings)
|
||||
|
||||
|
||||
def sea_grey_material():
|
||||
"""The placeholder grey, authored here rather than picked out of /Engine.
|
||||
|
||||
Nothing the engine ships is the right grey: `BasicShapeMaterial` is the near-white that once read as an
|
||||
ice sheet out to the horizon, and `WorldGridMaterial` puts a metre grid on a plane seventy kilometres
|
||||
across. Twenty lines of material graph buys an exact value instead, and it is built on demand so a fresh
|
||||
clone needs no extra step - if the asset is there it is used, and it is only ever created once."""
|
||||
existing = unreal.load_asset(SEA_MATERIAL)
|
||||
if existing:
|
||||
return existing
|
||||
package, name = SEA_MATERIAL.rsplit("/", 1)
|
||||
material = unreal.AssetToolsHelpers.get_asset_tools().create_asset(
|
||||
name, package, unreal.Material, unreal.MaterialFactoryNew())
|
||||
if not material:
|
||||
raise RuntimeError(f"could not create {SEA_MATERIAL}")
|
||||
lib = unreal.MaterialEditingLibrary
|
||||
colour = lib.create_material_expression(material, unreal.MaterialExpressionConstant3Vector, -400, 0)
|
||||
colour.set_editor_property("constant", unreal.LinearColor(*SEA_GREY_COLOR, 1.0))
|
||||
lib.connect_material_property(colour, "", unreal.MaterialProperty.MP_BASE_COLOR)
|
||||
roughness = lib.create_material_expression(material, unreal.MaterialExpressionConstant, -400, 160)
|
||||
roughness.set_editor_property("r", SEA_GREY_ROUGHNESS)
|
||||
lib.connect_material_property(roughness, "", unreal.MaterialProperty.MP_ROUGHNESS)
|
||||
lib.recompile_material(material)
|
||||
unreal.EditorAssetLibrary.save_loaded_asset(material)
|
||||
unreal.log(f"created {SEA_MATERIAL}")
|
||||
return material
|
||||
|
||||
|
||||
def sea_material():
|
||||
if SEA_GREY:
|
||||
return sea_grey_material()
|
||||
material = next((asset for asset in (unreal.load_asset(path) for path in SEA_MATERIALS) if asset), None)
|
||||
if material is None:
|
||||
raise RuntimeError(f"none of {SEA_MATERIALS} loaded, so two thirds of this world would be an "
|
||||
f"untextured plane; find what the engine calls its water material before building "
|
||||
f"the level, or set SEA_GREY to use the placeholder deliberately")
|
||||
return material
|
||||
|
||||
|
||||
def ensure_sea(spawn, manifest):
|
||||
"""A flat plane at sea level, at present wearing a placeholder grey: enough to read as *a surface* until a
|
||||
water body replaces it. It keeps collision so a walk off the coast is a walk, not a fall to the sea floor.
|
||||
|
||||
The material is re-applied on every run rather than only on the run that spawns the plane, so changing
|
||||
SEA_GREY and re-running a level's dressing is enough to change the sea. Without that a rerun would find
|
||||
the actor already there by label, leave it alone, and the switch would do nothing on any world that
|
||||
already exists."""
|
||||
mesh = load_or_raise(SEA_MESH)
|
||||
material = sea_material()
|
||||
side = manifest.side_m * 100.0 * 1.5 / 100.0 # the plane is 100 cm; cover the world and the sea beyond its edge
|
||||
sea = spawn(unreal.StaticMeshActor, "World_Sea_Proto", unreal.Vector(0.0, 0.0, manifest.sea_level_z_cm))
|
||||
sea.static_mesh_component.set_static_mesh(mesh)
|
||||
sea.static_mesh_component.set_material(0, material)
|
||||
sea.static_mesh_component.set_editor_property("cast_shadow", False)
|
||||
sea.set_actor_scale3d(unreal.Vector(side, side, 1.0))
|
||||
keep_always_loaded(sea)
|
||||
|
||||
|
||||
def repair_sea(manifest):
|
||||
"""Put the current sea material on a `World_Sea_Proto` that is already in the level.
|
||||
|
||||
`ensure_dressing` spawns the sea only when it is missing, which is right - a rerun must not leave two suns
|
||||
- but it means a material change cannot reach a world that already has one. This is the other half, and it
|
||||
is a separate function because it is the *only* thing a caller may want to do to a finished level."""
|
||||
del manifest # the plane's size and height are already right; only its material is in question
|
||||
material = sea_material()
|
||||
actors = unreal.get_editor_subsystem(unreal.EditorActorSubsystem).get_all_level_actors()
|
||||
seas = [actor for actor in actors if actor.get_actor_label() == "World_Sea_Proto"]
|
||||
for sea in seas:
|
||||
sea.static_mesh_component.set_material(0, material)
|
||||
unreal.log(f"sea material set to {material.get_path_name()}")
|
||||
if not seas:
|
||||
unreal.log_warning("no World_Sea_Proto in the loaded level; nothing to repair")
|
||||
return len(seas)
|
||||
Reference in New Issue
Block a user