CenaForge: primeira versão pública

Gerador de vídeos narrativos (Godot + FFmpeg), painel Next.js, serviço de voz,
Clipador de lives e Publicador para YouTube, TikTok e Instagram.

Inclui a leitura das visualizações dos posts para o Dashboard e o botão
"Publicar no <rede>" nos cartões das publicações.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-17 16:35:09 -03:00
co-authored by Claude Opus 5.5
commit 84f30bbc2d
484 changed files with 74826 additions and 0 deletions
+12
View File
@@ -0,0 +1,12 @@
extends "res://kits/person.gd"
## Mantém o kit e suas roupas; flexão das poses voltada para a frente local (-Z).
func _pose_values(action: String, t: float) -> Dictionary:
var values: Dictionary = super._pose_values(action, t)
if action in ["sit", "kneel", "exhausted"]:
for key in ["hip_l", "hip_r", "knee_l", "knee_r", "spine", "chest", "shoulder_l", "shoulder_r", "elbow_l", "elbow_r"]:
var angle: Vector3 = values[key]
angle.x *= -1.0
values[key] = angle
return values
+28
View File
@@ -0,0 +1,28 @@
extends RefCounted
## Elenco e barcos da reconstituição dos náufragos (opções de res://kits/person.gd e boat.gd).
## Elenilson: regata cinza e bermuda escura (convenção visual do roteiro, igual em todo o vídeo).
## Os companheiros usam cores discretas e diferentes entre si, nenhuma cinza.
const LOOKS := {
"elenilson": {"shirt": "#8f9297", "pants": "#24272c", "skin": "#b27a54", "hair": "#17110d",
"shoes": "#3b2a1f", "height": 1.74, "sleeveless": true, "shorts": true},
"ivan": {"shirt": "#3c5272", "pants": "#4b4236", "skin": "#8a5838", "hair": "#120d0a",
"shoes": "#2a2420", "height": 1.70},
"manoel": {"shirt": "#7b3d34", "pants": "#3c4047", "skin": "#c69772", "hair": "#55534f",
"shoes": "#2a2420", "height": 1.67},
"iranildo": {"shirt": "#5c6a48", "pants": "#6d685b", "skin": "#a26a47", "hair": "#1e1611",
"shoes": "#2a2420", "height": 1.78, "shorts": true},
# Os outros dois homens do pesqueiro (aparecem só no naufrágio).
"crew_a": {"shirt": "#9c5a30", "pants": "#2c2c2c", "skin": "#b98560", "hair": "#1a1410", "height": 1.72},
"crew_b": {"shirt": "#2f3b31", "pants": "#3a352f", "skin": "#94603f", "hair": "#120d0a", "height": 1.69},
# Equipe de mergulho da lancha (roupa de neoprene).
"diver_a": {"shirt": "#17191d", "pants": "#17191d", "skin": "#c08a64", "hair": "#2a1d14",
"shoes": "#101114", "height": 1.76},
"diver_b": {"shirt": "#1d2a3a", "pants": "#17191d", "skin": "#9c6b48", "hair": "#120d0a",
"shoes": "#101114", "height": 1.73},
}
## Pesqueiro de madeira pintado (azul e vermelho, cabine creme), sem nome no casco.
const FISHING_BOAT := {"hull": "#2d5b86", "stripe": "#b5382b", "cabin": "#e6dfcc", "lights": true}
## Lancha de mergulho civil: branca com faixa laranja.
const DIVE_BOAT := {"hull": "#f3f2ee", "stripe": "#e2701c", "cabin": "#f7f6f2", "lights": false}
+153
View File
@@ -0,0 +1,153 @@
{
"id": "castaways",
"kind": "doc3d",
"label": "Náufragos no costão",
"description": "Reconstituição estilizada: quatro pescadores, pesqueiro e lancha civil na ilha. Chegada, naufrágio, nado, espera, resgate, embarque e partida. Elenilson mantém regata cinza e bermuda escura; roupas e gestos são ilustrativos.",
"keywords": [
"náufrago",
"pescador",
"pesqueiro",
"costão",
"lancha",
"resgate",
"nadando",
"Elenilson",
"apoia a mão",
"ergue o corpo",
"joelhos",
"recuperando o fôlego",
"companheiros",
"convés",
"casco",
"silhuetas próximas",
"sentado observa",
"se levanta",
"acena",
"mergulhador",
"subida assistida",
"acomodados",
"sentado em silêncio",
"repousa",
"costão à noite",
"passagem de noite",
"indica a espera",
"ainda a bordo",
"costão que se distancia"
],
"params": [
{
"name": "moment",
"label": "Momento",
"type": "select",
"default": "arrival",
"options": [
{
"value": "arrival",
"label": "Chegada às rochas",
"keywords": [
"apoia a mão",
"ergue o corpo",
"joelhos",
"recuperando o fôlego",
"perfil estilizado"
]
},
{
"value": "sinking",
"label": "Pesqueiro naufragando",
"keywords": [
"acidente",
"pesqueiro",
"convés",
"inclinação",
"cobrindo o casco",
"anoitecendo"
]
},
{
"value": "swimming",
"label": "Travessia a nado",
"keywords": [
"mar escuro",
"nadando",
"silhuetas próximas",
"travessia condensada",
"mãos buscando"
]
},
{
"value": "waiting",
"label": "Espera no costão",
"keywords": [
"costão à noite",
"sentado observa",
"repousa",
"passagem de noite",
"indica a espera"
]
},
{
"value": "rescue",
"label": "Acenos e aproximação",
"keywords": [
"se levanta",
"acena",
"mergulhadores aproximando",
"homens ainda pequenos",
"costão de dia"
]
},
{
"value": "boarding",
"label": "Nado e subida à lancha",
"keywords": [
"entra na água",
"nada até a equipe",
"subida assistida",
"acomodados a bordo",
"ombro de um mergulhador"
]
},
{
"value": "departure",
"label": "Partida com os sobreviventes",
"keywords": [
"afastando-se",
"sentado em silêncio",
"ainda a bordo",
"se distancia",
"costão que se distancia"
]
}
]
},
{
"name": "camera",
"label": "Distância da câmera",
"type": "select",
"default": "medium",
"options": [
{
"value": "medium",
"label": "Média"
},
{
"value": "close",
"label": "Próxima"
},
{
"value": "wide",
"label": "Aberta"
}
]
},
{
"name": "variant",
"label": "Variação de ângulo",
"type": "number",
"default": 0
}
],
"createdBy": "Codex (continuação da cena CenaForge)",
"createdAt": "2026-11-17"
}
+38
View File
@@ -0,0 +1,38 @@
extends "res://library/island/template.gd"
## Ilha reutilizada com uma pequena laje de costão para encenação, sem precisão topográfica.
## A malha e ground_at compartilham as mesmas alturas; a ilha original não é modificada.
var _stage_enabled := false
var _stage_center := Vector3.ZERO
var _stage_sea := Vector3.FORWARD
func prepare_coast(center: Vector3, sea: Vector3) -> void:
_stage_center = center
_stage_sea = sea
_stage_enabled = true
var terrain := get_node("Terrain")
remove_child(terrain)
terrain.free()
_build_terrain()
var material: StandardMaterial3D = get_node("Terrain").material_override
material.albedo_color = Color("#777b80")
func height_at(x: float, z: float) -> float:
var original := super.height_at(x, z)
if not _stage_enabled:
return original
var offset := Vector3(x - _stage_center.x, 0, z - _stage_center.z)
var blend := 1.0 - smoothstep(4.2, 8.0, offset.length())
var shelf := _stage_center.y - 3.5 * smoothstep(0.6, 5.5, offset.dot(_stage_sea))
return lerpf(original, shelf, blend)
func _terrain_color(h: float, slope: float, x: float, z: float) -> Color:
var original := super._terrain_color(h, slope, x, z)
if not _stage_enabled:
return original
var blend := 1.0 - smoothstep(5.0, 9.0, Vector2(x - _stage_center.x, z - _stage_center.z).length())
var grain := _noise_detail.get_noise_2d(x * 2.0, z * 2.0) * 0.5 + 0.5
return original.lerp(Color("#41464b").lerp(Color("#686b68"), grain), blend)
+81
View File
@@ -0,0 +1,81 @@
extends Node
## Céu, sol (ou lua), névoa e cor do mar por hora do dia, com mistura entre duas horas
## (a espera no costão passa da noite para o dia). Usa o ShaderMaterial do mar da ilha.
##
## const SkyRig := preload("res://library/castaways/sky.gd")
## var sky := SkyRig.new(); add_child(sky)
## sky.build(island.ocean_material(), direção_horizontal_do_sol)
## sky.set_preset("dawn") # "dawn" | "day" | "dusk" | "night"
## sky.blend_presets("night", "dawn", k)
const PRESETS := {
"dawn": {"top": Color("#2f4a7a"), "horizon": Color("#f2b07a"), "ground_h": Color("#d39466"), "ground_b": Color("#1b2434"),
"sun": Color("#ffc58f"), "energy": 1.35, "elev": 9.0, "ambient": 0.45, "exposure": 1.05,
"deep": Color("#0e2438"), "shallow": Color("#2d5d64"), "tint": Color("#f0b07c"), "fog": Color("#e7b089")},
"day": {"top": Color("#2d6fb3"), "horizon": Color("#b9d7ec"), "ground_h": Color("#9cc3d9"), "ground_b": Color("#1d3d55"),
"sun": Color("#fff4e2"), "energy": 1.7, "elev": 50.0, "ambient": 0.48, "exposure": 1.0,
"deep": Color("#04213a"), "shallow": Color("#0a6b75"), "tint": Color("#73a0c2"), "fog": Color("#b9d7ec")},
"dusk": {"top": Color("#232c57"), "horizon": Color("#e48a55"), "ground_h": Color("#b06a45"), "ground_b": Color("#141a2c"),
"sun": Color("#ff9f68"), "energy": 1.1, "elev": 5.0, "ambient": 0.34, "exposure": 1.1,
"deep": Color("#0a1a2b"), "shallow": Color("#1b4a52"), "tint": Color("#e9945e"), "fog": Color("#c98060")},
"night": {"top": Color("#040814"), "horizon": Color("#1b2a47"), "ground_h": Color("#121c30"), "ground_b": Color("#02040a"),
"sun": Color("#a9bcff"), "energy": 0.9, "elev": 35.0, "ambient": 0.7, "exposure": 1.35,
"deep": Color("#12324f"), "shallow": Color("#1b475b"), "tint": Color("#577baa"), "fog": Color("#243653")},
}
var _sky_mat: ProceduralSkyMaterial
var _env: Environment
var _sun: DirectionalLight3D
var _ocean: ShaderMaterial
var _dir := Vector3.FORWARD
func build(ocean: ShaderMaterial, sun_dir: Vector3) -> void:
_ocean = ocean
_dir = Vector3(sun_dir.x, 0, sun_dir.z).normalized()
_sky_mat = ProceduralSkyMaterial.new()
_sky_mat.sun_angle_max = 12.0
var sky := Sky.new()
sky.sky_material = _sky_mat
_env = Environment.new()
_env.background_mode = Environment.BG_SKY
_env.sky = sky
_env.ambient_light_source = Environment.AMBIENT_SOURCE_COLOR
_env.ambient_light_color = Color("#a5b8d0")
_env.tonemap_mode = Environment.TONE_MAPPER_ACES
_env.fog_enabled = true
_env.fog_density = 0.0011
_env.fog_sky_affect = 0.12
var we := WorldEnvironment.new()
we.environment = _env
add_child(we)
_sun = DirectionalLight3D.new()
_sun.shadow_enabled = true
_sun.directional_shadow_max_distance = 70.0
add_child(_sun)
func set_preset(preset: String) -> void:
blend_presets(preset, preset, 0.0)
func blend_presets(a_name: String, b_name: String, k: float) -> void:
var a: Dictionary = PRESETS[a_name]
var b: Dictionary = PRESETS[b_name]
var c := func(key: String) -> Color: return (a[key] as Color).lerp(b[key], k)
var f := func(key: String) -> float: return lerpf(float(a[key]), float(b[key]), k)
_sky_mat.sky_top_color = c.call("top")
_sky_mat.sky_horizon_color = c.call("horizon")
_sky_mat.ground_horizon_color = c.call("ground_h")
_sky_mat.ground_bottom_color = c.call("ground_b")
_env.ambient_light_energy = f.call("ambient")
_env.tonemap_exposure = f.call("exposure")
_env.fog_light_color = c.call("fog")
_sun.light_color = c.call("sun")
_sun.light_energy = f.call("energy")
var elev := deg_to_rad(f.call("elev"))
var to_sun := Vector3(_dir.x * cos(elev), sin(elev), _dir.z * cos(elev))
_sun.basis = Basis.looking_at(-to_sun, Vector3.UP)
_ocean.set_shader_parameter("deep_color", c.call("deep"))
_ocean.set_shader_parameter("shallow_color", c.call("shallow"))
_ocean.set_shader_parameter("sky_tint", c.call("tint"))
+661
View File
@@ -0,0 +1,661 @@
extends Node3D
## Cena 3D do documentário: os náufragos da Ilha das Cobras (reconstituição do caso de 2019).
## Elenilson (regata cinza, bermuda escura) e três companheiros, do naufrágio do pesqueiro ao
## resgate pela lancha de mergulho, no costão da ilha da biblioteca (res://library/island).
## Tudo depende só de (params, t): poses e barcos animados por tempo, sem física nem relógio.
##
## Modelo "castaways": params
## moment: "arrival" | "sinking" | "swimming" | "waiting" | "rescue" | "boarding" | "departure"
## camera: "medium" (padrão) | "close" (mais perto do Elenilson) | "wide" (mais aberto)
## variant: inteiro; muda o ângulo da câmera (lado, altura e ponto de vista)
##
## Tom sóbrio: sem cobra, sem helicóptero, sem navio militar; a lancha do resgate é civil.
const Island := preload("res://library/castaways/shore.gd")
const Person := preload("res://library/castaways/actor.gd")
const Boat := preload("res://kits/boat.gd")
const Cast := preload("res://library/castaways/cast.gd")
const SkyRig := preload("res://library/castaways/sky.gd")
const MOMENTS := ["arrival", "sinking", "swimming", "waiting", "rescue", "boarding", "departure"]
const ZOOM := {"medium": 1.12, "close": 1.0, "wide": 1.3}
var _p: Dictionary
var _dur = 1.0
var _moment = "arrival"
var _variant = 0
var _zoom = 1.0
var _island: Node3D
var _sky: Node
var _camera: Camera3D
var _people = {} # id → Person (Elenilson = "elenilson")
var _boat: Node3D # pesqueiro (sinking) ou lancha de mergulho (rescue, boarding, departure)
var _seats: Array = [] # pedras de apoio sob quem está sentado no costão
var _rock_mat: StandardMaterial3D
# Costão escolhido: c = onde o grupo fica; sea = direção do mar; tan = ao longo da costa.
var _c = Vector3.ZERO
var _sea = Vector3.FORWARD
var _tan = Vector3.RIGHT
var _spots = {} # id → Vector3 (posição no costão, y = chão)
var _last_cam = Vector3.ZERO
var _support_points: Dictionary = {}
func setup(cfg: Dictionary, viewport_size: Vector2) -> void:
_p = cfg.params
_dur = maxf(float(cfg.video.duration), 0.1)
_moment = str(_p.get("moment", "arrival"))
if not (_moment in MOMENTS):
_moment = "arrival"
_variant = posmod(int(_p.get("variant", 0)), 6)
_zoom = float(ZOOM.get(str(_p.get("camera", "medium")), 1.0))
_island = Island.new()
_island.name = "Island"
add_child(_island)
_island.setup({"params": {"embedded": true, "environment": false, "lighthouse": false, "sea_detail": true, "time": "day"}, "video": cfg.video}, viewport_size)
_island.set_sea_state(1.7 if _moment == "sinking" else (1.0 if _moment == "swimming" else 0.7))
_rock_mat = StandardMaterial3D.new()
_rock_mat.albedo_color = Color("#57534d")
_rock_mat.roughness = 1.0
_find_coast()
_island.prepare_coast(_c, _sea)
for id in _spots:
_spots[id] = _ground(_spots[id])
_clear_stage()
_sky = SkyRig.new()
add_child(_sky)
_sky.build(_island.ocean_material(), _sun_dir())
match _moment:
"sinking":
_sky.set_preset("dusk")
"swimming":
_sky.set_preset("night")
"arrival":
_sky.set_preset("dawn")
"waiting":
_sky.set_preset("night")
_:
_sky.set_preset("day")
_build_cast()
_camera = Camera3D.new()
_camera.fov = 52.0
_camera.near = 0.08
_camera.far = 9000.0
_camera.keep_aspect = Camera3D.KEEP_HEIGHT
add_child(_camera)
_camera.current = true
func apply(t: float) -> void:
_island.apply(t)
var p = clampf(t / _dur, 0.0, 1.0)
match _moment:
"sinking":
_do_sinking(t, p)
"swimming":
_do_swimming(t, p)
"waiting":
_do_waiting(t, p)
"rescue":
_do_rescue(t, p)
"boarding":
_do_boarding(t, p)
"departure":
_do_departure(t, p)
_:
_do_arrival(t, p)
if _moment in ["arrival", "waiting", "rescue"]:
for id in ["elenilson", "ivan", "manoel", "iranildo"]:
_fit_ground(_people[id], _moment == "arrival" and id == "elenilson")
var shot: Array = _compose_shot(t, p)
_place_camera(shot[0], shot[1], shot[2], t)
func state_signature() -> String:
var e: Node3D = _people.elenilson
var ep = e.global_position if e.is_inside_tree() else e.position
return "%.3f,%.3f,%.3f|%.3f,%.3f,%.3f" % [_last_cam.x, _last_cam.y, _last_cam.z, ep.x, ep.y, ep.z]
# ------------------------------------------------------------------ costão e elenco
## Procura, na costa da ilha, um trecho de pedra baixo, pouco inclinado, perto da água e
## longe das pedras grandes (determinístico: o terreno vem de sementes fixas).
func _find_coast() -> void:
var best = INF
for side in [1.0, -1.0]:
for xi in range(-54, 55, 2):
var x = float(xi)
var z = 0.0
while z < 70.0 and _island.ground_at(x, z * side) > 1.1:
z += 0.25
if z >= 70.0:
continue
var n: Vector3 = _island.ground_normal(x, z * side)
var sea = Vector2(n.x, n.z)
if sea.length() < 0.05:
continue
sea = sea.normalized()
var c = Vector2(x, z * side) - sea * 1.4
var hmin = INF
var hmax = -INF
for k in 16:
var a = TAU * k / 16.0
for r in [1.0, 2.0, 2.8]:
var h: float = _island.ground_at(c.x + cos(a) * r, c.y + sin(a) * r)
hmin = minf(hmin, h)
hmax = maxf(hmax, h)
var water = 0.0
while water < 10.0 and _island.ground_at(c.x + sea.x * water, c.y + sea.y * water) > -0.5:
water += 0.25
var clear = INF
for rk in _island.rock_list():
clear = minf(clear, Vector2(rk[0].x, rk[0].z).distance_to(c) - float(rk[1]))
var score: float = (hmax - hmin) + water * 0.12 + maxf(0.0, 3.0 - clear) * 0.6
if score < best:
best = score
_c = Vector3(c.x, _island.ground_at(c.x, c.y), c.y)
_sea = Vector3(sea.x, 0, sea.y)
_tan = Vector3(-_sea.z, 0, _sea.x)
print("CASTAWAYS costao c=(%.2f, %.2f, %.2f) mar=(%.2f, %.2f) nota=%.2f" % [_c.x, _c.y, _c.z, _sea.x, _sea.z, best])
# Lugares do grupo no costão (Elenilson mais perto do mar).
_spots = {
"elenilson": _ground(_c + _sea * 0.2),
"ivan": _ground(_c + _tan * 1.7 - _sea * 0.5),
"manoel": _ground(_c - _tan * 1.8 - _sea * 0.4),
"iranildo": _ground(_c + _tan * 0.5 - _sea * 1.7),
}
## Abre somente a área de atuação nesta instância da ilha; a biblioteca original fica intacta.
func _clear_stage() -> void:
for node_name in ["Forest", "Rocks"]:
var node: MultiMeshInstance3D = _island.get_node(node_name)
var mm: MultiMesh = node.multimesh
for i in mm.instance_count:
var tr: Transform3D = mm.get_instance_transform(i)
var delta_pos: Vector3 = (tr.origin - _c) * Vector3(1, 0, 1)
var corridor: bool = node_name == "Rocks" and delta_pos.dot(_sea) > -4.0 and absf(delta_pos.dot(_tan)) < 12.0
var camera_clear: bool = node_name == "Forest" and _moment == "rescue" and delta_pos.dot(_sea) > -40.0 and absf(delta_pos.dot(_tan)) < 8.0
if delta_pos.length() < 10.0 or corridor or camera_clear:
tr.origin.y -= 80.0
mm.set_instance_transform(i, tr)
func _ground(v: Vector3) -> Vector3:
return Vector3(v.x, _island.ground_at(v.x, v.z), v.z)
## Vértices reais das peças: apoio sobre o terreno depois de aplicar a pose articulada.
func _cache_support(person: Node3D) -> void:
var parts: Array = []
for mesh in person.find_children("*", "MeshInstance3D", true, false):
var vertices: PackedVector3Array = mesh.mesh.surface_get_arrays(0)[Mesh.ARRAY_VERTEX]
parts.append([mesh, vertices])
_support_points[person.name] = parts
func _fit_ground(person: Node3D, only_raise: bool = false) -> void:
var lift: float = -INF
for part in _support_points[person.name]:
var tr: Transform3D = part[0].global_transform
for v in part[1]:
var point: Vector3 = tr * v
lift = maxf(lift, _island.ground_at(point.x, point.z) - point.y)
person.position.y += (maxf(lift, 0.0) if only_raise else lift) + 0.012
func _sun_dir() -> Vector3:
match _moment:
"sinking":
return (_sea * 0.75 - _tan * 0.65).normalized()
"swimming":
return (-_sea * 0.6 + _tan * 0.8).normalized()
"arrival", "waiting":
return (_sea * 0.8 + _tan * 0.6).normalized()
_:
return (_sea * 0.45 + _tan * 0.9).normalized()
func _build_cast() -> void:
var ids = ["elenilson", "ivan", "manoel", "iranildo"]
if _moment == "sinking":
ids += ["crew_a", "crew_b"] # o pesqueiro saiu com seis homens
for id in ids:
var person = Person.new()
person.name = id
person.build(Cast.LOOKS[id])
_people[id] = person
_cache_support(person)
match _moment:
"sinking":
_boat = _make_boat(Cast.FISHING_BOAT)
for id in ids:
_boat.deck().add_child(_people[id])
"swimming", "arrival", "waiting":
for id in ids:
add_child(_people[id])
_:
_boat = _make_boat(Cast.DIVE_BOAT)
_add_benches()
for id in ["diver_a", "diver_b"]:
var diver = Person.new()
diver.name = id
diver.build(Cast.LOOKS[id])
_people[id] = diver
_boat.deck().add_child(diver)
for id in ids:
add_child(_people[id])
if _moment in ["arrival", "waiting", "rescue"]:
for id in ["elenilson", "iranildo"]:
_seats.append(_seat_rock())
func _make_boat(look: Dictionary) -> Node3D:
var boat = Boat.new()
boat.name = "Boat"
boat.build(look)
add_child(boat)
return boat
## Bancos na popa da lancha (os quatro vão sentados).
func _add_benches() -> void:
var wood = StandardMaterial3D.new()
wood.albedo_color = Color("#e4e1da")
for sx in [-1.0, 1.0]:
var mesh = BoxMesh.new()
mesh.size = Vector3(0.42, 0.3, 2.3)
var mi = MeshInstance3D.new()
mi.mesh = mesh
mi.material_override = wood
mi.position = Vector3(sx * 0.84, Boat.DECK_Y + 0.15, 2.15)
_boat.deck().add_child(mi)
func _seat_rock() -> MeshInstance3D:
var mesh = SphereMesh.new()
mesh.radius = 0.34
mesh.height = 0.46
mesh.radial_segments = 8
mesh.rings = 4
var mi = MeshInstance3D.new()
mi.mesh = mesh
mi.material_override = _rock_mat
mi.visible = false
add_child(mi)
return mi
# ------------------------------------------------------------------ apoio das poses
## Põe a pessoa no chão do costão: pés em pos (y = chão desenhado), olhando para facing;
## align (0–1) inclina o corpo junto com a pedra (deitado = 1).
func _on_ground(person: Node3D, pos: Vector3, facing: Vector3, align := 0.0, lift := 0.0) -> void:
var yaw = atan2(-facing.x, -facing.z)
var n: Vector3 = _island.ground_normal(pos.x, pos.z)
var up = Vector3.UP.lerp(n, align).normalized()
var tilt = Quaternion(Vector3.UP, up) if up.distance_to(Vector3.UP) > 0.0001 else Quaternion.IDENTITY
person.basis = Basis(tilt) * Basis(Vector3.UP, yaw)
person.position = Vector3(pos.x, _island.ground_at(pos.x, pos.z) + lift, pos.z)
## Sentado numa pedra do costão, olhando para facing (pés à frente, quadril sobre a pedra).
func _sit_on_rock(person: Node3D, seat: MeshInstance3D, pos: Vector3, facing: Vector3) -> void:
var f = facing.normalized()
var feet = _island.ground_at(pos.x + f.x * 0.42, pos.z + f.z * 0.42)
var under = _island.ground_at(pos.x, pos.z)
var y = maxf(feet, under - 0.3)
person.basis = Basis(Vector3.UP, atan2(-f.x, -f.z))
person.position = Vector3(pos.x, y, pos.z)
seat.visible = true
seat.position = Vector3(pos.x, y + 0.3 - 0.21, pos.z) - f * 0.04
## Deitado de costas ao longo da costa; a altura acompanha o ponto mais alto sob o corpo.
func _lie_on_ground(person: Node3D, pos: Vector3, along: Vector3) -> void:
var a = along.normalized()
var top = -INF
for k in [-0.2, 0.3, 0.8, 1.3]:
top = maxf(top, _island.ground_at(pos.x + a.x * k, pos.z + a.z * k))
var n: Vector3 = _island.ground_normal(pos.x + a.x * 0.5, pos.z + a.z * 0.5)
var tilt = Quaternion(Vector3.UP, n.lerp(Vector3.UP, 0.4).normalized())
# A cabeça fica em +Z da pessoa: olhar para -along põe a cabeça em +along.
person.basis = Basis(tilt) * Basis(Vector3.UP, atan2(a.x, a.z))
person.position = Vector3(pos.x, top + 0.04, pos.z)
## Respiração visível (peito e costas), somada à pose.
func _breathe(person: Node3D, t: float, amount: float) -> void:
person.joints.chest.rotation.x += sin(t * 2.6) * amount
person.joints.spine.rotation.x += sin(t * 2.6 + 0.4) * amount * 0.6
## Vira a cabeça (e um pouco o tronco) na direção de um ponto do mundo.
func _look_head(person: Node3D, target: Vector3, amount := 1.0) -> void:
var head: Node3D = person.joints.neck
var local = person.global_transform.basis.inverse() * (target - head.global_position)
var yaw = clampf(atan2(-local.x, -local.z), -1.4, 1.4) * amount
person.joints.spine.rotation.y += yaw * 0.35
person.joints.neck.rotation.y += yaw * 0.65
func _seg(p: float, a: float, b: float) -> float:
var q = clampf((p - a) / (b - a), 0.0, 1.0)
return q * q * (3.0 - 2.0 * q)
## Barco na água: acompanha a altura e a inclinação das ondas em (x, z), proa para heading.
func _boat_on_sea(pos: Vector3, heading: Vector3, t: float, rock := 0.6) -> void:
var h = heading.normalized()
var right = Vector3(-h.z, 0, h.x)
var bow: float = _island.sea_height(pos.x + h.x * 3.5, pos.z + h.z * 3.5, t)
var stern: float = _island.sea_height(pos.x - h.x * 3.5, pos.z - h.z * 3.5, t)
var sr: float = _island.sea_height(pos.x + right.x * 1.2, pos.z + right.z * 1.2, t)
var sl: float = _island.sea_height(pos.x - right.x * 1.2, pos.z - right.z * 1.2, t)
_boat.position = Vector3(pos.x, (bow + stern + sr + sl) * 0.25, pos.z)
_boat.rotation = Vector3(atan2(bow - stern, 7.0) * 0.8, atan2(-h.x, -h.z), atan2(sr - sl, 2.4) * 0.8)
_boat.float_on(t, rock)
## Ponto do convés (coordenadas do barco) no mundo, já com o balanço deste quadro.
func _on_boat(local: Vector3) -> Vector3:
return _boat.deck().global_transform * local
## Nadador na superfície (corpo meio submerso), indo para heading.
func _swim_at(person: Node3D, pos: Vector3, heading: Vector3, t: float, phase: float) -> void:
var h = heading.normalized()
person.basis = Basis(Vector3.UP, atan2(-h.x, -h.z))
person.position = Vector3(pos.x, _island.sea_height(pos.x, pos.z, t) - 0.06, pos.z)
person.pose("swim", t * 0.85 + phase)
# ------------------------------------------------------------------ momentos
# Cada momento posiciona o elenco no instante t (p = t / duração).
func _do_arrival(t: float, p: float) -> void:
var e: Node3D = _people.elenilson
var land = _spots.elenilson
var water = land + _sea * 0.4
while water.distance_to(land) < 4.0 and _island.ground_at(water.x, water.z) > -0.55:
water += _sea * 0.25
# 0–35%: nadando os últimos metros; 35–60%: apoia as mãos e sobe; depois, de joelhos.
var k_up = _seg(p, 0.3, 0.62)
var pos = water.lerp(land, _seg(p, 0.0, 0.6))
var swim_y: float = _island.sea_height(pos.x, pos.z, t) - 0.06
var y = lerpf(swim_y, _island.ground_at(land.x, land.z), k_up)
y = maxf(y, _island.ground_at(pos.x, pos.z) - 0.35 * (1.0 - k_up))
_on_ground(e, pos, -_sea, 0.8 * k_up)
e.position.y = y
e.blend("swim", "kneel", lerpf(t * 0.8, 0.3, k_up), k_up)
_breathe(e, t, 0.07 * k_up)
e.joints.neck.rotation.x += 0.25 * k_up # cabeça baixa, recuperando o fôlego
_place_group_resting(t, false)
## Os três companheiros descansando no costão (arrival e waiting).
func _place_group_resting(t: float, night: bool) -> void:
var ivan: Node3D = _people.ivan
var manoel: Node3D = _people.manoel
var iran: Node3D = _people.iranildo
if night:
_lie_on_ground(ivan, _spots.ivan, _tan)
ivan.pose("lie", t)
else:
_on_ground(ivan, _spots.ivan, _sea.rotated(Vector3.UP, 0.4), 0.8)
ivan.pose("kneel", t + 1.3)
_breathe(ivan, t + 0.7, 0.06)
ivan.joints.neck.rotation.x += 0.35
_lie_on_ground(manoel, _spots.manoel, -_tan)
manoel.pose("lie", t + 0.9)
_sit_on_rock(iran, _seats[1], _spots.iranildo, _sea.rotated(Vector3.UP, -0.3))
iran.pose("sit", t + 2.1)
if night:
iran.joints.neck.rotation.x += 0.45 # cochilando sentado
func _do_waiting(t: float, p: float) -> void:
# Noite → amanhecer → dia: o tempo da espera passando.
_sky.blend_presets("night", "dawn", _seg(p, 0.4, 0.75))
if p > 0.75:
_sky.blend_presets("dawn", "day", _seg(p, 0.75, 1.0))
var e: Node3D = _people.elenilson
_sit_on_rock(e, _seats[0], _spots.elenilson, _sea)
e.pose("sit", t)
# Vigiando o horizonte: a cabeça varre o mar devagar.
var scan = sin(p * PI * 1.6 + 0.3) * 0.5
_look_head(e, _spots.elenilson + _sea.rotated(Vector3.UP, scan) * 200.0 + Vector3(0, 1.0, 0))
_place_group_resting(t, true)
func _do_sinking(t: float, p: float) -> void:
var center = _c + _sea * 70.0
var k_sink = _seg(p, 0.3, 1.0)
_boat.sink(k_sink * 0.95)
_boat_on_sea(center, _tan, t, 1.6 + k_sink * 0.6)
# Homens no convés, se segurando enquanto o barco aderna (coordenadas do barco).
var places = {
"elenilson": [Vector3(-0.55, Boat.DECK_Y, 1.5), 0.0],
"ivan": [Vector3(0.45, Boat.DECK_Y, 1.9), 1.1],
"manoel": [Vector3(-0.35, Boat.DECK_Y, 2.8), 2.3],
"iranildo": [Vector3(0.55, Boat.DECK_Y, 3.0), 0.6],
"crew_a": [Vector3(0.0, Boat.DECK_Y, 1.0), 1.7],
"crew_b": [Vector3(-0.2, Boat.DECK_Y, -2.2), 2.9],
}
for id in places.keys():
var person: Node3D = _people[id]
person.position = places[id][0]
# Olhando para o lado que afunda (bombordo, -X do barco).
person.rotation = Vector3(0, PI / 2.0 + float(places[id][1]) * 0.25 - 0.3, 0)
person.blend("idle", "exhausted", t + float(places[id][1]), 0.35 + 0.5 * k_sink)
func _do_swimming(t: float, p: float) -> void:
# Mar escuro: os quatro nadam para a ilha (que aparece ao longe), Elenilson à frente.
var heading = -_sea
var start = _c + _sea * 46.0
var e_pos = start + heading * (4.0 * p)
var formation = {
"elenilson": [Vector3.ZERO, 0.0],
"ivan": [_tan * 2.1 + _sea * 1.6, 1.3],
"manoel": [-_tan * 1.9 + _sea * 2.7, 2.4],
"iranildo": [_tan * 0.7 + _sea * 4.3, 0.7],
}
for id in formation.keys():
var drift = _tan * sin(t * 0.4 + float(formation[id][1])) * 0.25
_swim_at(_people[id], e_pos + formation[id][0] + drift, heading, t, float(formation[id][1]))
func _do_rescue(t: float, p: float) -> void:
# Lancha de mergulho chegando do mar; o grupo no costão acenando.
var d0 = _c + _sea * 32.0 + _tan * 1.5
var d1 = _c + _sea * 18.0 + _tan * 1.0
var k_boat = 1.0 - pow(1.0 - p, 1.6) # desacelerando
var bpos = d0.lerp(d1, k_boat)
_boat_on_sea(bpos, (d1 - d0), t, 0.5)
_place_divers_rescue(t)
var e: Node3D = _people.elenilson
# Elenilson se levanta (0–30%) e acena com o grupo.
var k_up = _seg(p, 0.05, 0.3)
var standing_spot: Vector3 = _ground(_spots.elenilson + _sea * 0.65)
var seat: MeshInstance3D = _seats[0]
if k_up < 1.0:
_sit_on_rock(e, seat, _spots.elenilson, _sea)
e.position = e.position.lerp(standing_spot, k_up)
e.blend("sit", "idle", t, k_up)
else:
_on_ground(e, standing_spot, _sea)
e.blend("idle", "wave", t, _seg(p, 0.3, 0.42))
seat.visible = true
_seats[1].visible = false
var waves = {"ivan": [0.08, 0.5], "manoel": [0.16, 1.7], "iranildo": [0.24, 2.6]}
for id in waves.keys():
var person: Node3D = _people[id]
var spot: Vector3 = _spots[id]
_on_ground(person, spot, (bpos - spot) * Vector3(1, 0, 1))
person.blend("idle", "wave", t + float(waves[id][1]), _seg(p, float(waves[id][0]), float(waves[id][0]) + 0.15))
func _place_divers_rescue(t: float) -> void:
var a: Node3D = _people.diver_a
a.position = Vector3(0.3, Boat.DECK_Y, -2.2)
a.rotation = Vector3.ZERO
a.pose("wave", t + 0.4)
var b: Node3D = _people.diver_b
b.position = Vector3(-0.4, Boat.DECK_Y, 1.4)
b.rotation = Vector3(0, -0.3, 0)
b.pose("idle", t)
func _do_boarding(t: float, p: float) -> void:
var center: Vector3 = _c + _sea * 16.0
_boat_on_sea(center, _sea, t, 0.25)
var diver: Node3D = _people.diver_a
diver.position = Vector3(0.0, Boat.DECK_Y, 3.15)
diver.rotation = Vector3(0, PI, 0)
diver.pose("kneel", t)
diver.joints.shoulder_l.rotation.x = 1.3
diver.joints.elbow_l.rotation.x = 0.2
var helm: Node3D = _people.diver_b
helm.position = Vector3(-0.45, Boat.DECK_Y, 1.1)
helm.rotation = Vector3(0, PI, 0)
helm.pose("idle", t)
_sit_on_boat(_people.ivan, -1.0, 1.7, t)
_sit_on_boat(_people.manoel, 1.0, 1.7, t + 1.2)
_board_person(_people.elenilson, t, p, 0.0, -1.0)
_board_person(_people.iranildo, t, p, 0.22, 1.0)
## A subida é primeiro vertical, depois sobre a popa, mantendo o corpo fora do casco.
## Os dois últimos chegam em sequência; todos terminam sentados antes do fim da tomada.
func _board_person(person: Node3D, t: float, p: float, delay: float, side: float) -> void:
var q: float = clampf((p - delay) / 0.72, 0.0, 1.0)
var shore: Vector3 = _c + _sea * 7.0 + _tan * side * 0.5
var stern: Vector3 = _on_boat(Vector3(side * 0.2, 0, 5.25))
var swim_pos: Vector3 = shore.lerp(stern, _seg(q, 0.0, 0.45))
var up: float = _seg(q, 0.45, 0.68)
var aboard: float = _seg(q, 0.68, 0.84)
var seat: Vector3 = _on_boat(Vector3(side * 0.86, Boat.DECK_Y + 0.02, 2.9))
var edge: Vector3 = _on_boat(Vector3(side * 0.2, Boat.DECK_Y + 0.12, 5.25))
var pos: Vector3 = swim_pos.lerp(edge, up).lerp(seat, aboard)
var water_y: float = _island.sea_height(swim_pos.x, swim_pos.z, t) - 0.06
pos.y = lerpf(water_y, edge.y, up)
pos.y = lerpf(pos.y, seat.y, aboard)
person.position = pos
var boat_basis: Basis = _boat.deck().global_basis.orthonormalized()
person.basis = boat_basis * Basis(Vector3.UP, side * PI / 2.0 * aboard)
if q < 0.68:
person.blend("swim", "kneel", lerpf(t * 0.85, 0.3, up), up)
else:
person.blend("kneel", "sit", t, aboard)
## Sentado num banco da lancha (lado sx = -1 bombordo, 1 boreste), virado para o meio.
func _sit_on_boat(person: Node3D, sx: float, z: float, t: float) -> void:
if person.get_parent() != _boat.deck():
person.get_parent().remove_child(person)
_boat.deck().add_child(person)
person.position = Vector3(sx * 0.86, Boat.DECK_Y, z)
person.rotation = Vector3(0, PI / 2.0 * sx, 0)
person.pose("sit", t)
func _do_departure(t: float, p: float) -> void:
# A lancha se afasta da ilha; os quatro sentados, Elenilson olhando o costão.
var start = _c + _sea * 16.0
var center = start + _sea * (16.0 * p)
_boat_on_sea(center, _sea, t, 0.55)
var helm: Node3D = _people.diver_b
helm.position = Vector3(0.45, Boat.DECK_Y, 0.95)
helm.rotation = Vector3(0, 0.15, 0)
helm.pose("idle", t)
var diver: Node3D = _people.diver_a
diver.position = Vector3(-0.5, Boat.DECK_Y, 0.95)
diver.rotation = Vector3(0, -0.2, 0)
diver.pose("idle", t + 2.0)
_sit_on_boat(_people.elenilson, -1.0, 2.9, t)
_sit_on_boat(_people.ivan, -1.0, 1.75, t + 0.8)
_sit_on_boat(_people.manoel, 1.0, 2.9, t + 1.6)
_sit_on_boat(_people.iranildo, 1.0, 1.75, t + 2.4)
for id in ["ivan", "manoel", "iranildo"]:
(_people[id] as Node3D).joints.neck.rotation.x += 0.35 # cabeças baixas, em silêncio
var e: Node3D = _people.elenilson
_look_head(e, _c + Vector3(0, 2.0, 0))
## Composição vertical centralizada no elenco.
func _compose_shot(_t: float, p: float) -> Array:
var e: Node3D = _people.elenilson
var k: float = _seg(p, 0.0, 1.0)
var angle: float = [0.0, -0.38, 0.42][posmod(_variant, 3)]
var target: Vector3
var offset: Vector3
match _moment:
"arrival":
target = (e.position + Vector3(0, 0.5, 0)).lerp(_c + Vector3(0, 0.7, 0), k)
offset = (_sea * lerpf(6.0, 11.5, k) + _tan * 2.0).rotated(Vector3.UP, angle) + Vector3(0, lerpf(2.0, 4.0, k), 0)
"waiting":
target = _c + Vector3(0, 0.65, 0)
offset = (_sea * 9.8 + _tan * lerpf(3.0, 2.2, k)).rotated(Vector3.UP, angle) + Vector3(0, 3.3, 0)
"swimming":
target = e.position + _sea * 1.2 + Vector3(0, 0.1, 0)
offset = (-_sea * 9.5 + _tan * 3.5).rotated(Vector3.UP, angle) + Vector3(0, 3.8 + 0.3 * k, 0)
"rescue":
target = _c + _sea * 4.0 + Vector3(0, 0.8, 0)
offset = (-_sea * 15.0 + _tan * 0.6).rotated(Vector3.UP, angle * 0.12) + Vector3(0, 7.5, 0)
"boarding":
target = _on_boat(Vector3(0, 0.8, 2.8))
offset = _boat.basis * Vector3(13.0 if _variant % 2 == 0 else -13.0, 7.0 + float(_variant % 3), 10.0)
"departure":
target = _on_boat(Vector3(0, 1.2, 1.8))
offset = _boat.basis * Vector3(6.0 if _variant % 2 == 0 else -6.0, 7.0 + float(_variant % 3) * 0.6, -11.0 - k * 2.0)
_:
target = _boat.position + Vector3(0, 0.8 - _seg(p, 0.3, 1.0) * 0.8, 0)
offset = (_sea * 22.0 + _tan * 3.0).rotated(Vector3.UP, angle) + Vector3(0, 4.0 + float(_variant % 3), 0)
return [target + offset, target, target]
func _place_camera(pos: Vector3, target: Vector3, _focus: Vector3, t: float) -> void:
var direction: Vector3 = (pos - target).normalized()
var view_basis: Basis = Basis.looking_at(-direction, Vector3.UP)
var required: float = pos.distance_to(target)
# Enquadra as peças articuladas em x=8–92%, y=18–72%, inclusive durante a subida.
for id in ["elenilson", "ivan", "manoel", "iranildo"]:
for part in _support_points[id]:
var mesh: MeshInstance3D = part[0]
var bounds: AABB = mesh.mesh.get_aabb()
for corner in 8:
required = maxf(required, _required_distance(mesh.global_transform * bounds.get_endpoint(corner), target, view_basis))
if _boat and _moment != "rescue":
for x in [-1.4, 1.4]:
for y in [-0.7, 4.1]:
for z in [-4.1, 4.1]:
required = maxf(required, _required_distance(_on_boat(Vector3(x, y, z)), target, view_basis))
var cam: Vector3 = target + direction * required * _zoom
# Nunca dentro da pedra nem da água.
cam.y = maxf(cam.y, _island.ground_at(cam.x, cam.z) + 0.4)
cam.y = maxf(cam.y, _island.sea_height(cam.x, cam.z, t) + 0.3)
_camera.position = cam
_camera.look_at(target, Vector3.UP)
_island.set_sea_focus(cam.x, cam.z)
_last_cam = cam
func _required_distance(point: Vector3, target: Vector3, view_basis: Basis) -> float:
var local: Vector3 = view_basis.inverse() * (point - target)
var tangent: float = tan(deg_to_rad(_camera.fov * 0.5))
var horizontal: float = absf(local.x) / (tangent * (9.0 / 16.0) * 0.84)
var vertical: float = maxf(local.y / (tangent * 0.64), -local.y / (tangent * 0.44))
return local.z + maxf(horizontal, vertical)
+64
View File
@@ -0,0 +1,64 @@
extends SceneTree
## Verificação local: Godot --headless --path godot --script res://library/castaways/verify.gd
## Compara todos os nós articulados ao buscar tempos em ordens diferentes.
const Scene := preload("res://library/castaways/template.gd")
func _initialize() -> void:
call_deferred("_run")
func _snapshot(node: Node) -> String:
var parts: PackedStringArray = []
if node is Node3D:
parts.append(str(node.transform))
for child in node.get_children():
parts.append(_snapshot(child))
return "|".join(parts)
func _run() -> void:
var checks := 0
for moment in Scene.MOMENTS:
for variant in 3:
var scene := Scene.new()
root.add_child(scene)
scene.setup({"params": {"moment": moment, "variant": variant}, "video": {"duration": 5.0}}, Vector2(540, 960))
for t in [0.0, 0.7, 2.5, 4.95]:
scene.apply(t)
var before := _snapshot(scene)
scene.apply(4.99)
scene.apply(0.0)
scene.apply(t)
if before != _snapshot(scene):
printerr("FALHA determinismo %s variant=%d t=%.2f" % [moment, variant, t])
quit(1)
return
if moment in ["arrival", "waiting", "rescue"] and (moment != "arrival" or t > 0.6):
for id in ["elenilson", "ivan", "manoel", "iranildo"]:
var clearance := INF
for part in scene._support_points[id]:
for vertex in part[1]:
var point: Vector3 = part[0].global_transform * vertex
clearance = minf(clearance, point.y - scene._island.ground_at(point.x, point.z))
if clearance < -0.002 or clearance > 0.03:
printerr("FALHA apoio %s %s: %.4f m" % [moment, id, clearance])
quit(1)
return
checks += 1
var previous := Vector3.ZERO
var largest_step := 0.0
for frame in 150:
scene.apply(float(frame) / 30.0)
var current: Vector3 = scene._people.elenilson.global_position
if frame > 0:
largest_step = maxf(largest_step, current.distance_to(previous))
previous = current
if largest_step > 0.4:
printerr("FALHA continuidade %s variant=%d: %.3f m/quadro" % [moment, variant, largest_step])
quit(1)
return
scene.free()
print("CASTAWAYS_OK %d estados: determinismo por busca temporal e apoio dos personagens" % checks)
quit(0)
+112
View File
@@ -0,0 +1,112 @@
{
"id": "island",
"kind": "doc3d",
"label": "Ilha costeira",
"description": "Ilha alongada com mata densa, costão de pedra e farol listrado num mar animado. Sobrevoo, chegada pelo mar, perto do farol ou rasante; de dia, entardecer ou noite. Outras cenas podem usá-la como cenário (params embedded: true, environment: false, sea_detail: true; métodos ground_at(x, z), sea_height(x, z, t), set_sea_state, set_sea_focus, rock_list e lighthouse_position()).",
"keywords": [
"ilha",
"mar",
"oceano",
"costa",
"costão",
"rochedo",
"farol",
"aérea",
"aéreo",
"sobrevoo",
"sobrevoa",
"mata em 3d",
"sobrevoo 3d",
"vista",
"horizonte"
],
"params": [
{
"name": "shot",
"label": "Tomada",
"type": "select",
"default": "orbit",
"options": [
{
"value": "orbit",
"label": "Sobrevoo em volta",
"keywords": [
"aére",
"sobrevoo",
"sobrevoa",
"mata em 3d",
"sobrevoo 3d",
"vista",
"plano aéreo"
]
},
{
"value": "approach",
"label": "Chegada pelo mar",
"keywords": [
"afastamento",
"aproxima",
"chega",
"chegada"
]
},
{
"value": "lighthouse",
"label": "Perto do farol",
"keywords": [
"farol"
]
},
{
"value": "lowpass",
"label": "Rasante na água",
"keywords": [
"rasante",
"água",
"ondas"
]
}
]
},
{
"name": "time",
"label": "Hora do dia",
"type": "select",
"default": "day",
"options": [
{
"value": "day",
"label": "Dia"
},
{
"value": "sunset",
"label": "Entardecer",
"keywords": [
"entardecer",
"pôr do sol",
"anoitecer",
"crepúsculo"
]
},
{
"value": "night",
"label": "Noite",
"keywords": [
"noite",
"escuro",
"madrugada",
"temporal noturno"
]
}
]
},
{
"name": "lighthouse",
"label": "Farol",
"type": "bool",
"default": true
}
],
"createdBy": "Claude Code (CenaForge)",
"createdAt": "2026-11-17"
}
+617
View File
@@ -0,0 +1,617 @@
extends Node3D
## Cena 3D do documentário: uma ilha costeira estilizada (terreno por ruído, mata densa,
## costão de pedra, farol) num mar animado por shader. Tudo depende só de (configuração, t):
## sementes fixas, o mar recebe o tempo de cena por uniform (não usa TIME), então o render
## é determinístico.
##
## Modelo "island": params
## shot: "orbit" (sobrevoo em volta) | "approach" (chega do mar) | "lighthouse" (perto do
## farol) | "lowpass" (rasante sobre a água) — padrão "orbit"
## time: "day" | "sunset" — padrão "day"
## lighthouse: true/false — padrão true
## variant: inteiro; muda ângulo inicial, sentido da câmera e (ímpar) a hora do dia
##
## Como cenário de outra cena (params embedded: true; environment: false se a outra cena faz
## céu e luz; sea_detail: true para tomadas rente à água): height_at / ground_at / ground_normal
## (terreno), sea_height(x, z, t) e set_sea_state(escala) (mar), set_sea_focus(x, z) (centro da
## malha fina do mar), rock_list() (pedras do costão) e lighthouse_position().
const ISLAND_A := 82.0 # semieixo maior (x), em metros da cena
const ISLAND_B := 42.0 # semieixo menor (z)
const GRID := 168 # resolução do terreno
const TERRAIN_SIZE := 260.0
const TREE_COUNT := 5200
const OCEAN_SHADER := """
shader_type spatial;
render_mode specular_schlick_ggx, cull_disabled;
uniform float scene_time = 0.0;
uniform float wave_scale = 1.0;
uniform vec3 deep_color : source_color = vec3(0.015, 0.13, 0.22);
uniform vec3 shallow_color : source_color = vec3(0.04, 0.42, 0.46);
uniform vec3 sky_tint : source_color = vec3(0.45, 0.62, 0.76);
uniform vec2 island_axes = vec2(82.0, 42.0);
varying vec3 v_world;
varying float v_crest;
void add_wave(vec2 p, vec2 dir, float len, float amp, float speed, inout float h, inout vec2 grad) {
float k = 6.2831853 / len;
float f = k * dot(p, normalize(dir)) + scene_time * speed;
h += amp * sin(f);
grad += amp * k * cos(f) * normalize(dir);
}
void vertex() {
vec3 w = (MODEL_MATRIX * vec4(VERTEX, 1.0)).xyz;
float h = 0.0;
vec2 grad = vec2(0.0);
add_wave(w.xz, vec2(1.0, 0.31), 41.0, 0.42, 1.05, h, grad);
add_wave(w.xz, vec2(-0.37, 1.0), 27.3, 0.26, 1.33, h, grad);
add_wave(w.xz, vec2(0.83, -0.57), 15.7, 0.13, 1.81, h, grad);
add_wave(w.xz, vec2(-1.0, -0.23), 9.1, 0.07, 2.37, h, grad);
add_wave(w.xz, vec2(0.21, -1.0), 5.3, 0.035, 3.1, h, grad);
add_wave(w.xz, vec2(0.66, 0.75), 3.7, 0.02, 3.9, h, grad);
h *= wave_scale;
grad *= wave_scale;
VERTEX.y += h;
NORMAL = normalize(vec3(-grad.x, 1.0, -grad.y));
v_world = w;
v_crest = h;
}
void fragment() {
// Água mais clara (turquesa) perto da ilha, escura no mar aberto.
float d = length(v_world.xz / island_axes);
float shallow = smoothstep(1.7, 1.0, d) * 0.85;
vec3 col = mix(deep_color, shallow_color, shallow);
col += vec3(0.05) * smoothstep(0.35, 0.8, v_crest);
float fres = pow(1.0 - clamp(dot(NORMAL, VIEW), 0.0, 1.0), 5.0);
ALBEDO = mix(col, sky_tint, fres * 0.22);
ROUGHNESS = 0.07;
METALLIC = 0.0;
SPECULAR = 0.65;
}
"""
var _cfg: Dictionary
var _p: Dictionary
var _size := Vector2.ZERO
var _dur := 1.0
var _variant := 0
var _camera: Camera3D
var _ocean_mat: ShaderMaterial
var _noise_shape: FastNoiseLite
var _noise_ridge: FastNoiseLite
var _noise_detail: FastNoiseLite
var _lighthouse_pos := Vector3.ZERO
var _lamp: MeshInstance3D
var _t := 0.0
var _last_cam := Vector3.ZERO
var _night := false
var _embedded := false
var _ocean: MeshInstance3D
var _wave_scale := 1.0
var _heights := PackedFloat32Array() # alturas dos vértices do terreno (a malha desenhada)
var _rocks: Array = [] # [centro, raio] de cada pedra do costão
## As mesmas ondas do OCEAN_SHADER (direção, comprimento, amplitude, velocidade), para
## sea_height() devolver a altura da água que aparece na tela.
const WAVES := [
[Vector2(1.0, 0.31), 41.0, 0.42, 1.05],
[Vector2(-0.37, 1.0), 27.3, 0.26, 1.33],
[Vector2(0.83, -0.57), 15.7, 0.13, 1.81],
[Vector2(-1.0, -0.23), 9.1, 0.07, 2.37],
[Vector2(0.21, -1.0), 5.3, 0.035, 3.1],
[Vector2(0.66, 0.75), 3.7, 0.02, 3.9],
]
## Para outras cenas da biblioteca: posição do farol (pé da torre) e altura do terreno.
func lighthouse_position() -> Vector3:
return _lighthouse_pos
## Altura da superfície do terreno COMO DESENHADA (interpola os triângulos da malha, não o
## ruído): use para apoiar pés, joelhos e pedras sem flutuar nem afundar na rocha.
func ground_at(x: float, z: float) -> float:
var step := TERRAIN_SIZE / float(GRID)
var half := TERRAIN_SIZE / 2.0
var fx := (x + half) / step
var fz := (z / 0.7 + half) / step
var i := clampi(int(floor(fx)), 0, GRID - 1)
var j := clampi(int(floor(fz)), 0, GRID - 1)
var u := clampf(fx - i, 0.0, 1.0)
var v := clampf(fz - j, 0.0, 1.0)
var ha := _heights[j * (GRID + 1) + i]
var hb := _heights[j * (GRID + 1) + i + 1]
var hc := _heights[(j + 1) * (GRID + 1) + i]
var hd := _heights[(j + 1) * (GRID + 1) + i + 1]
# Mesmos triângulos de _build_terrain: (a, b, c) e (b, d, c).
if u + v <= 1.0:
return ha + (hb - ha) * u + (hc - ha) * v
return hd + (hc - hd) * (1.0 - u) + (hb - hd) * (1.0 - v)
## Normal do terreno desenhado em (x, z).
func ground_normal(x: float, z: float) -> Vector3:
var e := 0.4
var dx := ground_at(x + e, z) - ground_at(x - e, z)
var dz := ground_at(x, z + e) - ground_at(x, z - e)
return Vector3(-dx, 2.0 * e, -dz).normalized()
## Pedras do costão: lista de [centro (Vector3), raio horizontal].
func rock_list() -> Array:
return _rocks
## Altura da água em (x, z) no instante t (as mesmas ondas do shader).
func sea_height(x: float, z: float, t: float) -> float:
var h := 0.0
for w in WAVES:
var dir: Vector2 = (w[0] as Vector2).normalized()
h += float(w[2]) * sin(TAU / float(w[1]) * dir.dot(Vector2(x, z)) + t * float(w[3]))
return h * _wave_scale
## Mar mais calmo (< 1) ou agitado (> 1). Padrão 1.
func set_sea_state(scale: float) -> void:
_wave_scale = scale
_ocean_mat.set_shader_parameter("wave_scale", scale)
## Com params.sea_detail = true, o mar é uma malha radial fina no centro; mova o centro para
## perto da câmera a cada quadro (as ondas usam coordenada do mundo, então não "andam").
func set_sea_focus(x: float, z: float) -> void:
_ocean.position = Vector3(x, 0, z)
func ocean_material() -> ShaderMaterial:
return _ocean_mat
func setup(cfg: Dictionary, viewport_size: Vector2) -> void:
_cfg = cfg
_p = cfg.params
_size = viewport_size
_dur = maxf(float(cfg.video.duration), 0.1)
_variant = int(_p.get("variant", 0))
_make_noises()
var time := str(_p.get("time", "day"))
_night = time == "night"
# A hora vem do parâmetro; "variant" (Gerar de novo) muda só a câmera.
var sunset := not _night and time == "sunset"
# embedded = true: a ilha é cenário dentro de OUTRA cena da biblioteca (que cria a câmera).
# environment = false: a outra cena também cuida do céu e da luz.
_embedded = bool(_p.get("embedded", false))
if bool(_p.get("environment", true)):
_build_environment(sunset)
_build_terrain()
_build_trees()
_build_rocks()
if bool(_p.get("lighthouse", true)):
_build_lighthouse(sunset)
_build_ocean(sunset)
if _embedded:
return
_camera = Camera3D.new()
_camera.fov = 52.0
_camera.near = 0.3
_camera.far = 9000.0
_camera.keep_aspect = Camera3D.KEEP_HEIGHT
add_child(_camera)
_camera.current = true
func apply(t: float) -> void:
_t = t
_ocean_mat.set_shader_parameter("scene_time", t)
if _lamp:
# Lanterna do farol pulsando devagar.
var mat := _lamp.get_surface_override_material(0) as StandardMaterial3D
mat.emission_energy_multiplier = (4.0 if _night else 1.6) + 1.2 * (0.5 + 0.5 * sin(t * 2.4))
if not _embedded:
_place_camera(t)
func state_signature() -> String:
return "%.3f,%.3f,%.3f" % [_last_cam.x, _last_cam.y, _last_cam.z]
# ------------------------------------------------------------------ terreno
func _make_noises() -> void:
_noise_shape = FastNoiseLite.new()
_noise_shape.seed = 7
_noise_shape.frequency = 1.0
_noise_shape.fractal_octaves = 3
_noise_ridge = FastNoiseLite.new()
_noise_ridge.seed = 21
_noise_ridge.frequency = 1.0
_noise_ridge.fractal_type = FastNoiseLite.FRACTAL_RIDGED
_noise_ridge.fractal_octaves = 4
_noise_detail = FastNoiseLite.new()
_noise_detail.seed = 33
_noise_detail.frequency = 1.0
_noise_detail.fractal_octaves = 3
## Altura do terreno (y = 0 é o nível do mar). A ilha é alongada, com uma crista central
## alta, encostas íngremes e costão de pedra que cai direto no mar.
func height_at(x: float, z: float) -> float:
var nx := x / ISLAND_A
var nz := z / ISLAND_B
var d := sqrt(nx * nx + nz * nz) + _noise_shape.get_noise_2d(x * 0.018, z * 0.018) * 0.22
var m := clampf((1.0 - d) / 0.6, 0.0, 1.0)
m = m * m * (3.0 - 2.0 * m)
var ridge := _noise_ridge.get_noise_2d(x * 0.022, z * 0.022) * 0.5 + 0.5
var crest := 1.0 - absf(nz) * 0.9
var h := m * (5.0 + 30.0 * pow(m, 0.8) * (0.55 + 0.45 * ridge) * crest)
h += _noise_detail.get_noise_2d(x * 0.11, z * 0.11) * 1.6 * m
# Fora da ilha: fundo do mar descendo.
return h - 3.0 + (1.0 - m) * -6.0 * clampf(d - 0.9, 0.0, 1.0)
func _terrain_color(h: float, slope: float, x: float, z: float) -> Color:
var n := _noise_detail.get_noise_2d(x * 0.35, z * 0.35) * 0.5 + 0.5
if h < -0.6:
return Color("#1d4a52").lerp(Color("#2f6b6a"), clampf((h + 6.0) / 5.0, 0.0, 1.0))
if h < 1.2:
return Color("#6b6358").lerp(Color("#4f4a43"), n) # costão molhado
if slope > 0.72:
return Color("#4c4944").lerp(Color("#66615a"), n) # pedra exposta
var forest := Color("#173a1d").lerp(Color("#2b5a27"), n) # chão sob a mata
return forest.lerp(Color("#4a5a2c"), clampf((h - 28.0) / 14.0, 0.0, 0.35))
func _build_terrain() -> void:
var st := SurfaceTool.new()
st.begin(Mesh.PRIMITIVE_TRIANGLES)
var step := TERRAIN_SIZE / float(GRID)
var half := TERRAIN_SIZE / 2.0
_heights.resize((GRID + 1) * (GRID + 1))
for j in GRID + 1:
for i in GRID + 1:
var x := -half + float(i) * step
var z := (-half + float(j) * step) * 0.7 # ilha alongada: menos extensão em z
var h := height_at(x, z)
_heights[j * (GRID + 1) + i] = h
var dx := height_at(x + 0.8, z) - height_at(x - 0.8, z)
var dz := height_at(x, z + 0.8) - height_at(x, z - 0.8)
var slope := clampf(Vector2(dx, dz).length() / 1.6 / 2.2, 0.0, 1.0)
st.set_color(_terrain_color(h, slope, x, z))
st.add_vertex(Vector3(x, h, z))
for j in GRID:
for i in GRID:
var a := j * (GRID + 1) + i
var b := a + 1
var c := a + GRID + 1
var d := c + 1
st.add_index(a)
st.add_index(b)
st.add_index(c)
st.add_index(b)
st.add_index(d)
st.add_index(c)
st.generate_normals()
var mat := StandardMaterial3D.new()
mat.vertex_color_use_as_albedo = true
mat.roughness = 0.95
var node := MeshInstance3D.new()
node.name = "Terrain"
node.mesh = st.commit()
node.material_override = mat
add_child(node)
func _build_trees() -> void:
var crown := CylinderMesh.new()
crown.top_radius = 0.0
crown.bottom_radius = 1.9
crown.height = 3.4
crown.radial_segments = 7
crown.rings = 1
var mat := StandardMaterial3D.new()
mat.vertex_color_use_as_albedo = true
mat.roughness = 0.9
crown.material = mat
var mm := MultiMesh.new()
mm.transform_format = MultiMesh.TRANSFORM_3D
mm.use_colors = true
mm.mesh = crown
var rng := RandomNumberGenerator.new()
rng.seed = 4242
var placed: Array[Transform3D] = []
var colors: Array[Color] = []
var tries := 0
while placed.size() < TREE_COUNT and tries < TREE_COUNT * 6:
tries += 1
var x := rng.randf_range(-ISLAND_A, ISLAND_A)
var z := rng.randf_range(-ISLAND_B, ISLAND_B)
var h := height_at(x, z)
if h < 1.6:
continue
var slope := Vector2(height_at(x + 0.8, z) - height_at(x - 0.8, z), height_at(x, z + 0.8) - height_at(x, z - 0.8)).length() / 3.2
if slope > 0.85 or rng.randf() < slope * 0.6:
continue
var s := rng.randf_range(0.75, 1.45)
var basis := Basis.from_euler(Vector3(rng.randf_range(-0.08, 0.08), rng.randf() * TAU, rng.randf_range(-0.08, 0.08))).scaled(Vector3(s, s * rng.randf_range(0.8, 1.3), s))
placed.append(Transform3D(basis, Vector3(x, h + 1.4 * s, z)))
colors.append(Color("#0d2610").lerp(Color("#2a5222"), rng.randf()).lerp(Color("#4a6a22"), rng.randf() * 0.2))
mm.instance_count = placed.size()
for i in placed.size():
mm.set_instance_transform(i, placed[i])
mm.set_instance_color(i, colors[i])
var node := MultiMeshInstance3D.new()
node.name = "Forest"
node.multimesh = mm
add_child(node)
func _build_rocks() -> void:
var rock := SphereMesh.new()
rock.radius = 1.0
rock.height = 1.4
rock.radial_segments = 7
rock.rings = 4
var mat := StandardMaterial3D.new()
mat.albedo_color = Color("#5e5b56")
mat.roughness = 1.0
rock.material = mat
var rng := RandomNumberGenerator.new()
rng.seed = 909
var mm := MultiMesh.new()
mm.transform_format = MultiMesh.TRANSFORM_3D
mm.mesh = rock
var list: Array[Transform3D] = []
for i in 420:
var ang := rng.randf() * TAU
var r := rng.randf_range(0.93, 1.08)
var x := cos(ang) * ISLAND_A * r
var z := sin(ang) * ISLAND_B * r
var h := height_at(x, z)
if h > 3.0 or h < -2.5:
continue
var s := rng.randf_range(0.8, 3.2)
_rocks.append([Vector3(x, maxf(h, -0.4), z), s])
list.append(Transform3D(Basis.from_euler(Vector3(rng.randf() * TAU, rng.randf() * TAU, 0)).scaled(Vector3(s, s * 0.7, s)), Vector3(x, maxf(h, -0.4), z)))
mm.instance_count = list.size()
for i in list.size():
mm.set_instance_transform(i, list[i])
var node := MultiMeshInstance3D.new()
node.name = "Rocks"
node.multimesh = mm
add_child(node)
func _build_lighthouse(sunset: bool) -> void:
# No ponto mais alto da metade sudoeste da ilha.
var best := Vector3(-ISLAND_A * 0.45, 0, ISLAND_B * 0.1)
for i in 60:
var x := -ISLAND_A * 0.7 + float(i % 10) * ISLAND_A * 0.06
var z := -ISLAND_B * 0.3 + float(i / 10) * ISLAND_B * 0.1
var h := height_at(x, z)
if h > best.y:
best = Vector3(x, h, z)
_lighthouse_pos = best
var root := Node3D.new()
root.name = "Lighthouse"
root.position = best - Vector3(0, 0.6, 0)
add_child(root)
var white := StandardMaterial3D.new()
white.albedo_color = Color("#f2efe8")
white.roughness = 0.6
var red := StandardMaterial3D.new()
red.albedo_color = Color("#b8322a")
red.roughness = 0.6
var tower_h := 11.0
var bands := 5
for b in bands:
var seg := CylinderMesh.new()
var t0 := float(b) / bands
var t1 := float(b + 1) / bands
seg.bottom_radius = lerpf(1.7, 1.15, t0)
seg.top_radius = lerpf(1.7, 1.15, t1)
seg.height = tower_h / bands
seg.radial_segments = 20
var mi := MeshInstance3D.new()
mi.mesh = seg
mi.material_override = red if b % 2 == 1 else white
mi.position = Vector3(0, tower_h * (t0 + t1) / 2.0, 0)
root.add_child(mi)
var gallery := CylinderMesh.new()
gallery.top_radius = 1.7
gallery.bottom_radius = 1.7
gallery.height = 0.35
gallery.radial_segments = 20
var gmi := MeshInstance3D.new()
gmi.mesh = gallery
gmi.material_override = red
gmi.position = Vector3(0, tower_h + 0.15, 0)
root.add_child(gmi)
var lamp_mesh := CylinderMesh.new()
lamp_mesh.top_radius = 0.95
lamp_mesh.bottom_radius = 0.95
lamp_mesh.height = 1.4
lamp_mesh.radial_segments = 16
var lamp_mat := StandardMaterial3D.new()
lamp_mat.albedo_color = Color("#ffe9a8")
lamp_mat.emission_enabled = true
lamp_mat.emission = Color("#ffd27a")
lamp_mat.emission_energy_multiplier = 2.0
_lamp = MeshInstance3D.new()
_lamp.mesh = lamp_mesh
_lamp.set_surface_override_material(0, lamp_mat)
_lamp.position = Vector3(0, tower_h + 1.0, 0)
root.add_child(_lamp)
var cap := CylinderMesh.new()
cap.top_radius = 0.0
cap.bottom_radius = 1.25
cap.height = 1.2
cap.radial_segments = 20
var cmi := MeshInstance3D.new()
cmi.mesh = cap
cmi.material_override = red
cmi.position = Vector3(0, tower_h + 2.3, 0)
root.add_child(cmi)
if sunset or _night:
var glow := OmniLight3D.new()
glow.light_color = Color("#ffcf7a")
glow.light_energy = 2.0
glow.omni_range = 18.0
glow.position = Vector3(0, tower_h + 1.0, 0)
root.add_child(glow)
# ------------------------------------------------------------------ mar e céu
func _build_ocean(sunset: bool) -> void:
var plane: Mesh
if bool(_p.get("sea_detail", false)):
plane = _radial_sea()
else:
plane = PlaneMesh.new()
plane.size = Vector2(16000, 16000)
plane.subdivide_width = 400
plane.subdivide_depth = 400
var shader := Shader.new()
shader.code = OCEAN_SHADER
_ocean_mat = ShaderMaterial.new()
_ocean_mat.shader = shader
_ocean_mat.set_shader_parameter("island_axes", Vector2(ISLAND_A, ISLAND_B))
if _night:
_ocean_mat.set_shader_parameter("deep_color", Color("#02070f"))
_ocean_mat.set_shader_parameter("shallow_color", Color("#06202a"))
_ocean_mat.set_shader_parameter("sky_tint", Color("#2a3d63"))
elif sunset:
_ocean_mat.set_shader_parameter("deep_color", Color("#0b1f33"))
_ocean_mat.set_shader_parameter("shallow_color", Color("#1f5a63"))
_ocean_mat.set_shader_parameter("sky_tint", Color("#f3a865"))
var node := MeshInstance3D.new()
node.name = "Ocean"
node.mesh = plane
node.material_override = _ocean_mat
node.cast_shadow = GeometryInstance3D.SHADOW_CASTING_SETTING_OFF
add_child(node)
_ocean = node
## Mar para tomadas rente à água: anéis cada vez mais espaçados a partir do centro
## (~0,3 m perto, dezenas de metros no horizonte), para a onda desenhada bater com sea_height().
func _radial_sea() -> ArrayMesh:
var seg := 288
var rings := 190
var growth := pow(8000.0 / 0.35, 1.0 / float(rings))
var st := SurfaceTool.new()
st.begin(Mesh.PRIMITIVE_TRIANGLES)
st.set_normal(Vector3.UP)
st.add_vertex(Vector3.ZERO)
for r in rings:
var radius := 0.35 * pow(growth, float(r))
for s in seg:
var a := TAU * float(s) / float(seg)
st.set_normal(Vector3.UP)
st.add_vertex(Vector3(cos(a) * radius, 0, sin(a) * radius))
for s in seg:
st.add_index(0)
st.add_index(1 + (s + 1) % seg)
st.add_index(1 + s)
for r in rings - 1:
for s in seg:
var a := 1 + r * seg + s
var b := 1 + r * seg + (s + 1) % seg
var c := a + seg
var d := b + seg
st.add_index(a)
st.add_index(b)
st.add_index(c)
st.add_index(b)
st.add_index(d)
st.add_index(c)
var mesh := st.commit()
# A malha é plana, mas o shader levanta as ondas: AABB folgada evita sumir no recorte.
mesh.custom_aabb = AABB(Vector3(-8000, -5, -8000), Vector3(16000, 10, 16000))
return mesh
func _build_environment(sunset: bool) -> void:
var sky_mat := ProceduralSkyMaterial.new()
if _night:
sky_mat.sky_top_color = Color("#03060f")
sky_mat.sky_horizon_color = Color("#1a2740")
sky_mat.ground_horizon_color = Color("#141e33")
sky_mat.ground_bottom_color = Color("#02040a")
elif sunset:
sky_mat.sky_top_color = Color("#2b3566")
sky_mat.sky_horizon_color = Color("#f2a35e")
sky_mat.ground_horizon_color = Color("#c7804f")
sky_mat.ground_bottom_color = Color("#1a2238")
else:
sky_mat.sky_top_color = Color("#2d6fb3")
sky_mat.sky_horizon_color = Color("#b9d7ec")
sky_mat.ground_horizon_color = Color("#9cc3d9")
sky_mat.ground_bottom_color = Color("#1d3d55")
sky_mat.sun_angle_max = 20.0
var sky := Sky.new()
sky.sky_material = sky_mat
var env := Environment.new()
env.background_mode = Environment.BG_SKY
env.sky = sky
env.ambient_light_source = Environment.AMBIENT_SOURCE_SKY
env.ambient_light_energy = 0.18 if _night else (0.45 if not sunset else 0.4)
env.tonemap_mode = Environment.TONE_MAPPER_ACES
env.tonemap_exposure = 1.05
env.fog_enabled = true
env.fog_light_color = sky_mat.sky_horizon_color
env.fog_density = 0.00045 if not sunset else 0.0006
env.fog_sky_affect = 0.15
var we := WorldEnvironment.new()
we.environment = env
add_child(we)
var sun := DirectionalLight3D.new()
sun.light_color = Color("#9fb6ff") if _night else (Color("#ffd2a0") if sunset else Color("#fff4e2"))
sun.light_energy = 0.35 if _night else (1.5 if sunset else 1.7)
sun.rotation_degrees = Vector3(-14.0, -60.0, 0.0) if sunset else Vector3(-48.0, -35.0, 0.0)
sun.shadow_enabled = true
sun.directional_shadow_max_distance = 600.0
add_child(sun)
# ------------------------------------------------------------------ câmera
func _smooth(p: float) -> float:
var q := clampf(p, 0.0, 1.0)
return q * q * (3.0 - 2.0 * q)
func _place_camera(t: float) -> void:
var p := _smooth(t / _dur)
var dir := 1.0 if _variant % 4 < 2 else -1.0
var a0 := deg_to_rad(205.0 + float(_variant) * 47.0)
var shot := str(_p.get("shot", "orbit"))
var pos := Vector3.ZERO
var target := Vector3(0, 10, 0)
match shot:
"approach":
var r := lerpf(430.0, 175.0, p)
var ang := a0 + dir * deg_to_rad(12.0) * p
pos = Vector3(cos(ang) * r, lerpf(60.0, 34.0, p), sin(ang) * r)
target = Vector3(0, lerpf(4.0, 12.0, p), 0)
"lighthouse":
var lp := _lighthouse_pos
var ang := a0 + dir * deg_to_rad(55.0) * p
pos = lp + Vector3(cos(ang) * 40.0, lerpf(24.0, 17.0, p), sin(ang) * 40.0)
target = lp + Vector3(0, 8.0, 0)
"lowpass":
var ang := a0 + dir * deg_to_rad(28.0) * p
pos = Vector3(cos(ang) * 135.0, 4.5 + 1.2 * sin(t * 0.7), sin(ang) * 135.0)
target = Vector3(0, 14.0, 0)
_:
var ang := a0 + dir * deg_to_rad(42.0) * p
pos = Vector3(cos(ang) * 190.0, lerpf(70.0, 52.0, p), sin(ang) * 190.0)
target = Vector3(0, 8.0, 0)
_camera.position = pos
_camera.look_at(target, Vector3.UP)
_last_cam = pos