Admin/Cinderwild
1
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects Releases 10 Wiki Activity
Files
db4a6592360c65e0d1fb12f6465b11cc8cdf1f27
Cinderwild/scripts/world/terrain.gd

584 lines
22 KiB
GDScript
Raw Blame History

extends Node3D
## Terrain generator.
##
## One heightmap chunk built from deterministic noise: a walkable valley of
## rolling hills with a lake, enclosed by a ring of steep mountains that opens on
## one side to a sheer sea cliff. The whole chunk is an island: its edge sinks
## into ocean so the end of the mesh is never visible.
##
## The rim is the world boundary: mountain slopes are too steep to walk up
## (> floor_max_angle), and an invisible wall stands partway up them, or just
## inside the cliff edge on the sea side, so nobody can climb out or fall off. Chunk
## streaming and biomes come in later milestones (docs/ARCHITECTURE.md §4).
##
## Heights are computed once into a grid that feeds the render mesh, the
## collision shape and `sample_height()`, so props and the player sit exactly on
## the visible surface.
##
## Collision is a HeightMapShape3D. Do NOT swap it for a concave trimesh: those
## are one-sided and the player fell straight through them from above.
signal ready_built ## emitted once the mesh + collision exist
@export var size: int = 320 ## chunk is size x size metres
@export var resolution: int = 256 ## grid cells per side
@export var height_scale: float = 9.0 ## rolling-hill amplitude in the valley
@export var noise_seed: int = 1337
@export_group("Boundary")
@export var play_radius: float = 100.0 ## where the mountain rim starts rising
@export var rim_width: float = 30.0 ## horizontal run of the rim's steep face
@export var mountain_height: float = 58.0
@export var rim_warp: float = 16.0 ## how irregular the rim's outline is
@export_range(0.2, 0.9) var wall_frac: float = 0.45 ## invisible wall, as a fraction up the rim
@export_group("Sea cliff")
@export var sea_angle_deg: float = -75.0 ## direction of the coast (atan2(z, x); -90 = straight -Z)
@export var sea_half_width_deg: float = 38.0 ## full-sea arc either side of sea_angle
@export var sea_fade_deg: float = 22.0 ## headland transition back to mountains
@export var sea_level: float = -24.0
@export var cliff_top: float = 0.5 ## height the coast rises/falls to at the edge
@export var cliff_offset: float = 4.0 ## cliff edge, in rim distance past play_radius
@export var cliff_drop_width: float = 6.0 ## horizontal run of the drop (smaller = sheerer)
@export_group("Water & snow")
@export var water_level: float = -2.6
@export var lake_center: Vector2 = Vector2(14.0, -46.0)
@export var lake_radius: float = 24.0
@export var snow_height: float = 40.0
@export_group("Colours")
@export var grass_lush: Color = Color(0.25, 0.40, 0.15)
@export var grass_dry: Color = Color(0.42, 0.49, 0.21)
var built: bool = false
var min_height: float = 0.0
var max_height: float = 0.0
var step: float = 1.0
var half: float = 0.0
var material: ShaderMaterial
var noise_tex: NoiseTexture2D ## shared by every world shader (see common.gdshaderinc)
var normal_tex: NoiseTexture2D ## detail normal map for ground and water
var _noise: FastNoiseLite
var _detail: FastNoiseLite
var _ridge: FastNoiseLite
var _warp: FastNoiseLite
var _wall_ring: Array[Vector3] = []
var _heights := PackedFloat32Array()
var _normals := PackedVector3Array()
func _ready() -> void:
# On a server, its seed; in a saved world, that world's seed; otherwise
# keep the exported default.
var net := get_node_or_null("/root/Net")
var saves := get_node_or_null("/root/Saves")
if net != null and net.state == "connected" and net.world_info.has("seed"):
noise_seed = int(net.world_info.seed)
worldlet_id = String(net.world_info.get("worldlet", worldlet_id))
elif saves != null and saves.has_world():
noise_seed = saves.world_seed()
# (worlds from before worldlets have none: they're the Valley)
worldlet_id = String(saves.read_meta(saves.current_id).get("worldlet", "valley"))
var why := use_worldlet(worldlet_id)
if not why.is_empty():
push_error("[terrain] %s: using the Valley" % why)
use_worldlet("valley")
_build()
# --- height function --------------------------------------------------------
func _ensure_noise() -> void:
if _noise != null:
return
_noise = FastNoiseLite.new()
_noise.seed = noise_seed
_noise.noise_type = FastNoiseLite.TYPE_PERLIN
_noise.frequency = 0.012
_noise.fractal_octaves = 4
_detail = FastNoiseLite.new()
_detail.seed = noise_seed + 1
_detail.noise_type = FastNoiseLite.TYPE_SIMPLEX_SMOOTH
_detail.frequency = 0.06
_detail.fractal_octaves = 2
_ridge = FastNoiseLite.new()
_ridge.seed = noise_seed + 2
_ridge.noise_type = FastNoiseLite.TYPE_SIMPLEX_SMOOTH
_ridge.frequency = 0.022
_ridge.fractal_octaves = 4
_warp = FastNoiseLite.new()
_warp.seed = noise_seed + 3
_warp.noise_type = FastNoiseLite.TYPE_SIMPLEX_SMOOTH
_warp.frequency = 0.03
## Radial offset that makes the rim wobble instead of being a perfect circle.
## Sampled around a circle, so it depends only on the angle from the centre.
func _rim_offset(x: float, z: float) -> float:
var ang := atan2(z, x)
return _warp.get_noise_2d(cos(ang) * 50.0, sin(ang) * 50.0) * rim_warp
## "Rim distance": distance from the centre plus the wobble. The rim starts at
## play_radius and the invisible wall stands at _wall_d() in this same measure.
func _rim_d(x: float, z: float) -> float:
return sqrt(x * x + z * z) + _rim_offset(x, z)
func _wall_d() -> float:
return play_radius + rim_width * wall_frac
func _cliff_d() -> float:
return play_radius + cliff_offset
## 1 on the open-sea side of the rim, 0 where the mountains are, smooth between
## (the headlands). Depends only on the angle from the centre.
func _sea_w(x: float, z: float) -> float:
var diff := absf(wrapf(atan2(z, x) - deg_to_rad(sea_angle_deg), -PI, PI))
return 1.0 - smoothstep(deg_to_rad(sea_half_width_deg), deg_to_rad(sea_half_width_deg + sea_fade_deg), diff)
## Boundary threshold in rim distance: partway up the mountains, or just
## inside the cliff edge on the sea side.
func _wall_threshold(x: float, z: float) -> float:
return lerpf(_wall_d(), _cliff_d() - 1.0, _sea_w(x, z))
# --- worldlets (docs/WORLDLETS_DESIGN.md, W0) ---------------------------------------
# A worldlet's terrain is a list of building blocks applied in order
# (data/worldlets/<id>.json "terrain"). Each block takes the ground so far and
# returns it changed; "hills" starts it. A worldlet can only combine these.
const BLOCKS := ["hills", "rim", "sea_cliff", "lake", "ocean_edge"]
var worldlet_id := "valley"
var worldlet: Dictionary = {} ## the definition, as loaded
var _blocks: Array = [] ## its terrain blocks, in order
var _valley := 0.0 ## the hills before anything else (the sea cliff eases from it)
var _detail_k := 1.4
## The definition of worldlet `id` (data/worldlets/<id>.json), or {} if none.
static func load_worldlet(id: String) -> Dictionary:
var p := "res://data/worldlets/%s.json" % id
if not FileAccess.file_exists(p):
return {}
var d: Variant = JSON.parse_string(FileAccess.get_file_as_string(p))
return d if d is Dictionary else {}
## Every worldlet there is: [{id, name, description}].
static func worldlets() -> Array:
var out: Array = []
for f in DirAccess.get_files_at("res://data/worldlets"):
if f.ends_with(".json"):
var d := load_worldlet(f.get_basename())
if not d.is_empty():
out.append({"id": String(d.id), "name": String(d.get("name", d.id)), "description": String(d.get("description", ""))})
return out
## Takes on worldlet `id`: its size and every block's numbers. Returns ""
## on success, else what's wrong (an unknown worldlet or block keeps the old
## settings, so the game still has an island).
func use_worldlet(id: String) -> String:
var d := load_worldlet(id)
if d.is_empty():
return "no worldlet '%s'" % id
for b in d.get("terrain", []):
if not (b is Dictionary) or not String(b.get("type", "")) in BLOCKS:
return "worldlet '%s': unknown terrain block %s" % [id, str(b)]
worldlet_id = id
worldlet = d
size = int(d.get("size", size))
resolution = int(d.get("resolution", resolution))
_blocks = d.get("terrain", [])
for b in _blocks:
match String(b.type):
"hills":
height_scale = float(b.get("height_scale", height_scale))
_detail_k = float(b.get("detail", _detail_k))
"rim":
play_radius = float(b.get("play_radius", play_radius))
rim_width = float(b.get("rim_width", rim_width))
mountain_height = float(b.get("mountain_height", mountain_height))
rim_warp = float(b.get("rim_warp", rim_warp))
wall_frac = float(b.get("wall_frac", wall_frac))
"sea_cliff":
sea_angle_deg = float(b.get("angle_deg", sea_angle_deg))
sea_half_width_deg = float(b.get("half_width_deg", sea_half_width_deg))
sea_fade_deg = float(b.get("fade_deg", sea_fade_deg))
sea_level = float(b.get("sea_level", sea_level))
cliff_top = float(b.get("cliff_top", cliff_top))
cliff_offset = float(b.get("cliff_offset", cliff_offset))
cliff_drop_width = float(b.get("drop_width", cliff_drop_width))
"lake":
var c: Array = b.get("center", [lake_center.x, lake_center.y])
lake_center = Vector2(float(c[0]), float(c[1]))
lake_radius = float(b.get("radius", lake_radius))
water_level = float(b.get("water_level", water_level))
snow_height = float(d.get("climate", {}).get("snowline", snow_height))
return ""
func _has_block(t: String) -> bool:
for b in _blocks:
if String(b.type) == t:
return true
return false
func _height_fn(x: float, z: float) -> float:
_ensure_noise()
if _blocks.is_empty():
use_worldlet(worldlet_id)
var land := 0.0
for b in _blocks:
match String(b.type):
"hills":
land = _blk_hills(x, z)
"rim":
land = _blk_rim(x, z, land)
"sea_cliff":
land = _blk_sea_cliff(x, z, land)
"lake":
land = _blk_lake(x, z, land)
"ocean_edge":
land = _blk_ocean_edge(x, z, land)
return land
## Rolling hills: the ground everything else is built on.
func _blk_hills(x: float, z: float) -> float:
var valley := _noise.get_noise_2d(x, z) * height_scale
valley += _detail.get_noise_2d(x, z) * _detail_k
_valley = valley
return valley
## The mountain rim: rises from play_radius, stepped into ledges.
func _blk_rim(x: float, z: float, land: float) -> float:
var valley := _valley
var d := _rim_d(x, z)
var t := smoothstep(play_radius, play_radius + rim_width, d)
if t > 0.0:
var ridge := 1.0 - absf(_ridge.get_noise_2d(x, z))
var m := pow(t, 1.4) * mountain_height * (0.65 + 0.55 * ridge)
m += maxf(d - (play_radius + rim_width), 0.0) * 0.35 * (0.5 + ridge)
# Stepped ledges so the faces read as layered cliffs, not smooth ramps.
var band := 6.0
var stepped := floorf(m / band) * band + smoothstep(0.35, 0.65, fposmod(m, band) / band) * band
m = lerpf(m, stepped, 0.45 * t)
land = valley * (1.0 - t * 0.6) + m
return land
## The sea side of the rim: the valley eases to a cliff top, then drops sheer.
func _blk_sea_cliff(x: float, z: float, land: float) -> float:
var valley := _valley
var d := _rim_d(x, z)
# Sea side: the valley eases to a cliff top, then drops sheer to the seabed.
# The edge sits 1 m past the invisible wall at every angle, including the
# headlands where the wall moves outward. (With the edge fixed at _cliff_d(),
# the headlands dropped away INSIDE the wall: pits you could fall into, with
# lake water hanging over them. tests/test_terrain_edges.gd guards this.)
var sw := _sea_w(x, z)
if sw > 0.0:
var edge := _wall_threshold(x, z) + 1.0
var top := cliff_top + _detail.get_noise_2d(x * 0.5, z * 0.5) * 1.5
var coast := lerpf(valley, top, smoothstep(play_radius - 45.0, edge, d))
var seabed := sea_level - 7.0 - minf(maxf(d - edge, 0.0), 60.0) * 0.08 + _detail.get_noise_2d(x, z) * 2.0
coast = lerpf(coast, seabed, smoothstep(edge, edge + cliff_drop_width, d))
land = lerpf(land, coast, sw)
return land
## A lake basin: the ground blends down to a bed below the waterline.
func _blk_lake(x: float, z: float, land: float) -> float:
var ld := Vector2(x - lake_center.x, z - lake_center.y).length()
ld += _detail.get_noise_2d(x * 0.5, z * 0.5) * 5.0
return lerpf(land, water_level - 3.2, smoothstep(lake_radius, lake_radius * 0.35, ld))
## Ocean all round the chunk edge, so the world is an island and the edge of
## the mesh is always hidden under deep water.
func _blk_ocean_edge(x: float, z: float, land: float) -> float:
var e := smoothstep(size * 0.5 - 28.0, size * 0.5 - 4.0, sqrt(x * x + z * z))
return lerpf(land, sea_level - 10.0 + _detail.get_noise_2d(x, z) * 2.0, e)
# --- build ------------------------------------------------------------------
func _build() -> void:
_ensure_noise()
step = float(size) / float(resolution)
half = size * 0.5
var n := resolution + 1
_heights.resize(n * n)
min_height = INF
max_height = -INF
for iz in range(n):
for ix in range(n):
var hv := _height_fn(ix * step - half, iz * step - half)
_heights[iz * n + ix] = hv
min_height = minf(min_height, hv)
max_height = maxf(max_height, hv)
_normals.resize(n * n)
for iz in range(n):
for ix in range(n):
var hl := _heights[iz * n + maxi(ix - 1, 0)]
var hr := _heights[iz * n + mini(ix + 1, resolution)]
var hd := _heights[maxi(iz - 1, 0) * n + ix]
var hu := _heights[mini(iz + 1, resolution) * n + ix]
_normals[iz * n + ix] = Vector3(hl - hr, 2.0 * step, hd - hu).normalized()
_make_textures()
_build_mesh(n)
_build_collision(n)
_build_boundary()
_build_water()
built = true
ready_built.emit()
func _make_textures() -> void:
var fn := FastNoiseLite.new()
fn.seed = noise_seed + 10
fn.noise_type = FastNoiseLite.TYPE_SIMPLEX_SMOOTH
fn.frequency = 0.008
fn.fractal_octaves = 5
noise_tex = NoiseTexture2D.new()
noise_tex.width = 512
noise_tex.height = 512
noise_tex.seamless = true
noise_tex.noise = fn
var fn2 := FastNoiseLite.new()
fn2.seed = noise_seed + 11
fn2.noise_type = FastNoiseLite.TYPE_SIMPLEX_SMOOTH
fn2.frequency = 0.02
fn2.fractal_octaves = 4
normal_tex = NoiseTexture2D.new()
normal_tex.width = 512
normal_tex.height = 512
normal_tex.seamless = true
normal_tex.as_normal_map = true
normal_tex.bump_strength = 6.0
normal_tex.noise = fn2
func _build_mesh(n: int) -> void:
var verts := PackedVector3Array()
var uvs := PackedVector2Array()
verts.resize(n * n)
uvs.resize(n * n)
for iz in range(n):
for ix in range(n):
var i := iz * n + ix
verts[i] = Vector3(ix * step - half, _heights[i], iz * step - half)
uvs[i] = Vector2(float(ix) / resolution, float(iz) / resolution)
var idx := PackedInt32Array()
idx.resize(resolution * resolution * 6)
var k := 0
for iz in range(resolution):
for ix in range(resolution):
var i00 := iz * n + ix
var i10 := i00 + 1
var i01 := i00 + n
var i11 := i01 + 1
# Winding chosen so the top face is the front face in Godot.
idx[k] = i00; idx[k + 1] = i11; idx[k + 2] = i01
idx[k + 3] = i00; idx[k + 4] = i10; idx[k + 5] = i11
k += 6
var arrays := []
arrays.resize(Mesh.ARRAY_MAX)
arrays[Mesh.ARRAY_VERTEX] = verts
arrays[Mesh.ARRAY_NORMAL] = _normals
arrays[Mesh.ARRAY_TEX_UV] = uvs
arrays[Mesh.ARRAY_INDEX] = idx
var mesh := ArrayMesh.new()
mesh.add_surface_from_arrays(Mesh.PRIMITIVE_TRIANGLES, arrays)
material = ShaderMaterial.new()
material.shader = preload("res://shaders/terrain.gdshader")
material.set_shader_parameter("noise_tex", noise_tex)
material.set_shader_parameter("normal_tex", normal_tex)
material.set_shader_parameter("water_level", water_level)
material.set_shader_parameter("snow_height", snow_height)
material.set_shader_parameter("grass_lush", grass_lush)
material.set_shader_parameter("grass_dry", grass_dry)
var mi := MeshInstance3D.new()
mi.name = "TerrainMesh"
mi.mesh = mesh
mi.material_override = material
add_child(mi)
func _build_collision(n: int) -> void:
var hm := HeightMapShape3D.new()
hm.map_width = n
hm.map_depth = n
hm.map_data = _heights
var body := StaticBody3D.new()
body.name = "TerrainBody"
add_child(body)
var col := CollisionShape3D.new()
col.shape = hm
body.add_child(col)
# HeightMapShape3D samples are 1 unit apart; scale to match the mesh.
body.scale = Vector3(step, 1.0, step)
## Invisible wall ringing the valley partway up the mountain slopes, plus four
## world-boundary planes at the chunk edges as a last line of defence.
func _build_boundary() -> void:
var body := StaticBody3D.new()
body.name = "Boundary"
add_child(body)
var segs := 128
var pts: Array[Vector3] = []
for i in range(segs):
var ang := TAU * i / segs
var dir := Vector3(cos(ang), 0.0, sin(ang))
# Solve for the radius whose rim distance equals the wall threshold.
var r := _wall_threshold(dir.x, dir.z) - _rim_offset(dir.x, dir.z)
pts.append(dir * r)
_wall_ring = pts
for i in range(segs):
var a := pts[i]
var b := pts[(i + 1) % segs]
var mid := (a + b) * 0.5
var length := a.distance_to(b) + 0.6
var box := BoxShape3D.new()
box.size = Vector3(length, 400.0, 1.5)
var cs := CollisionShape3D.new()
cs.shape = box
var along := (b - a).normalized()
var seg_basis := Basis(along, Vector3.UP, along.cross(Vector3.UP))
cs.transform = Transform3D(seg_basis, Vector3(mid.x, 100.0, mid.z))
body.add_child(cs)
var planes := [
Plane(Vector3.RIGHT, -half), Plane(Vector3.LEFT, -half),
Plane(Vector3.BACK, -half), Plane(Vector3.FORWARD, -half),
]
for p: Plane in planes:
var wb := WorldBoundaryShape3D.new()
wb.plane = p
var cs := CollisionShape3D.new()
cs.shape = wb
body.add_child(cs)
## Two water bodies: inland water (lake and ponds) as a disc clipped to the
## boundary ring, so it can't hang in the air past the sea cliff; and an ocean
## plane out to the horizon at sea level.
func _build_water() -> void:
var verts := PackedVector3Array([Vector3.ZERO])
for p in _wall_ring:
verts.append(p)
var count := verts.size()
var normals := PackedVector3Array()
var tangents := PackedFloat32Array()
var uvs := PackedVector2Array()
for v in verts:
normals.append(Vector3.UP)
tangents.append_array([1.0, 0.0, 0.0, 1.0])
uvs.append(Vector2(v.x, v.z) / size + Vector2(0.5, 0.5))
var idx := PackedInt32Array()
for i in range(1, count):
idx.append_array([0, i, i % (count - 1) + 1])
var arrays := []
arrays.resize(Mesh.ARRAY_MAX)
arrays[Mesh.ARRAY_VERTEX] = verts
arrays[Mesh.ARRAY_NORMAL] = normals
arrays[Mesh.ARRAY_TANGENT] = tangents
arrays[Mesh.ARRAY_TEX_UV] = uvs
arrays[Mesh.ARRAY_INDEX] = idx
var disc := ArrayMesh.new()
disc.add_surface_from_arrays(Mesh.PRIMITIVE_TRIANGLES, arrays)
_add_water("Water", disc, water_level, {})
var ocean := PlaneMesh.new()
ocean.size = Vector2(8000.0, 8000.0)
_add_water("Ocean", ocean, sea_level, {
"shallow_col": Color(0.16, 0.44, 0.50),
"deep_col": Color(0.02, 0.10, 0.20),
"clarity": 6.0,
})
func _add_water(label: String, mesh: Mesh, y: float, params: Dictionary) -> void:
var mat := ShaderMaterial.new()
mat.shader = preload("res://shaders/water.gdshader")
mat.set_shader_parameter("noise_tex", noise_tex)
mat.set_shader_parameter("normal_tex", normal_tex)
for k in params:
mat.set_shader_parameter(k, params[k])
var mi := MeshInstance3D.new()
mi.name = label
mi.mesh = mesh
mi.material_override = mat
mi.cast_shadow = GeometryInstance3D.SHADOW_CASTING_SETTING_OFF
mi.position = Vector3(0.0, y, 0.0)
add_child(mi)
# --- queries ----------------------------------------------------------------
func in_bounds(x: float, z: float) -> bool:
return absf(x) < half - step and absf(z) < half - step
## True inside the walkable valley. A positive margin shrinks the area, a
## negative one extends it past the invisible wall.
func inside_boundary(x: float, z: float, margin: float = 0.0) -> bool:
_ensure_noise()
return _rim_d(x, z) < _wall_threshold(x, z) - margin
## How strongly (x, z) lies on the sea side of the rim (0..1).
func sea_weight(x: float, z: float) -> float:
_ensure_noise()
return _sea_w(x, z)
## Point on the coast along `angle_deg` (atan2(z, x) convention), at rim
## distance `past_edge` beyond the cliff edge (negative = inland of it).
func coast_point(angle_deg: float, past_edge: float) -> Vector2:
_ensure_noise()
var dir := Vector2(cos(deg_to_rad(angle_deg)), sin(deg_to_rad(angle_deg)))
var r := _cliff_d() + past_edge - _rim_offset(dir.x, dir.y)
return dir * r
## Surface height at (x, z), interpolated on the same triangles as the mesh.
func sample_height(x: float, z: float) -> float:
if _heights.is_empty():
return _height_fn(x, z)
var n := resolution + 1
var gx := clampf((x + half) / step, 0.0, resolution - 0.0001)
var gz := clampf((z + half) / step, 0.0, resolution - 0.0001)
var ix := int(gx)
var iz := int(gz)
var fx := gx - ix
var fz := gz - iz
var h00 := _heights[iz * n + ix]
var h10 := _heights[iz * n + ix + 1]
var h01 := _heights[(iz + 1) * n + ix]
var h11 := _heights[(iz + 1) * n + ix + 1]
if fx > fz:
return h00 + (h10 - h00) * fx + (h11 - h10) * fz
return h00 + (h11 - h01) * fx + (h01 - h00) * fz
## Smoothed surface normal at (x, z).
func sample_normal(x: float, z: float) -> Vector3:
if _normals.is_empty():
return Vector3.UP
var n := resolution + 1
var gx := clampf((x + half) / step, 0.0, resolution - 0.0001)
var gz := clampf((z + half) / step, 0.0, resolution - 0.0001)
var ix := int(gx)
var iz := int(gz)
var fx := gx - ix
var fz := gz - iz
var a := _normals[iz * n + ix].lerp(_normals[iz * n + ix + 1], fx)
var b := _normals[(iz + 1) * n + ix].lerp(_normals[(iz + 1) * n + ix + 1], fx)
return a.lerp(b, fz).normalized()
## Nearest dry, gentle spot to `near` (spiral search), for spawning.
func find_spawn(near: Vector2) -> Vector3:
for ring in range(0, 30):
var r := ring * 2.0
var count := maxi(1, ring * 6)
for i in range(count):
var ang := TAU * i / count
var x := near.x + cos(ang) * r
var z := near.y + sin(ang) * r
var h := sample_height(x, z)
if h > water_level + 1.2 and sample_normal(x, z).y > 0.93 and inside_boundary(x, z, 15.0):
return Vector3(x, h, z)
return Vector3(near.x, sample_height(near.x, near.y), near.y)
Reference in New Issue View Git Blame Copy Permalink