Files
MateuusandClaude Opus 5.5 84f30bbc2d 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>
2026-11-17 16:35:09 -03:00

662 lines
25 KiB
GDScript
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
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)