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
+112
View File
@@ -0,0 +1,112 @@
extends RefCounted
## Pinta fachadas simples de casas de bairro para os planos distantes, e as
## texturas de asfalto e calçada. Tudo determinístico a partir de uma seed.
##
## As fachadas distantes são geradas uma vez por `tools/generate_backgrounds.gd`
## e salvas em assets/backgrounds/. Se os PNGs não existirem, a cena gera as
## mesmas imagens em memória (mesma função, mesmas seeds).
const FACADE_SIZE := Vector2i(256, 192)
const FACADE_VARIANTS := 8
const WALL_COLORS := [
Color("#E9C46A"), Color("#F4A261"), Color("#9BC1BC"), Color("#E5989B"),
Color("#A8DADC"), Color("#F1EDE4"), Color("#B5C99A"), Color("#CDB4DB"),
Color("#FFD6A5"), Color("#D9CAB3"),
]
const BRICK := Color("#B8673F")
static func facade_file_name(variant: int) -> String:
return "facade_%02d.png" % variant
## Fachada opaca (sem transparência): casa de laje com platibanda, comum em
## bairros brasileiros. Variantes ímpares podem ser de tijolo aparente.
static func paint_facade(variant: int) -> Image:
var rng := RandomNumberGenerator.new()
rng.seed = 7919 * (variant + 1)
var w := FACADE_SIZE.x
var h := FACADE_SIZE.y
var img := Image.create(w, h, false, Image.FORMAT_RGB8)
var brick := variant % 4 == 3
var wall: Color = BRICK if brick else WALL_COLORS[rng.randi() % WALL_COLORS.size()]
img.fill(wall)
if brick:
for y in range(0, h, 6):
img.fill_rect(Rect2i(0, y, w, 1), wall.darkened(0.25))
_noise(img, rng, 0.05)
# Platibanda (faixa do topo) e caixa d'água ocasional.
var parapet := int(h * 0.12)
img.fill_rect(Rect2i(0, 0, w, parapet), wall.lightened(0.18) if not brick else Color("#C9C2B5"))
img.fill_rect(Rect2i(0, parapet, w, 3), wall.darkened(0.3))
# Dois andares em parte das variantes.
var floors := 2 if rng.randf() < 0.6 else 1
var floor_h := (h - parapet) / floors
for f in floors:
var top := parapet + f * floor_h
var is_ground := f == floors - 1
var windows := 2 + rng.randi() % 2
var slot := w / (windows + (1 if is_ground else 0))
for i in windows + (1 if is_ground else 0):
var cx := int(slot * (i + 0.5))
if is_ground and i == int((windows + 1) / 2):
# Porta ou portão de garagem.
var dw := int(slot * 0.45)
var dh := int(floor_h * 0.78)
var door_color := Color("#6B4F3A") if rng.randf() < 0.5 else Color("#7C8288")
img.fill_rect(Rect2i(cx - dw / 2 - 2, top + floor_h - dh - 2, dw + 4, dh + 2), Color("#EDEDED"))
img.fill_rect(Rect2i(cx - dw / 2, top + floor_h - dh, dw, dh), door_color)
continue
var ww := int(slot * 0.5)
var wh := int(floor_h * 0.42)
var wy := top + int(floor_h * 0.25)
img.fill_rect(Rect2i(cx - ww / 2 - 3, wy - 3, ww + 6, wh + 6), Color("#F2F2F2"))
img.fill_rect(Rect2i(cx - ww / 2, wy, ww, wh), Color("#2F3E4E").lerp(Color("#5B7A99"), rng.randf() * 0.5))
img.fill_rect(Rect2i(cx - 1, wy, 2, wh), Color("#F2F2F2"))
if not is_ground:
# Linha da laje entre andares.
img.fill_rect(Rect2i(0, top + floor_h - 3, w, 3), wall.darkened(0.22))
# Rodapé
img.fill_rect(Rect2i(0, h - 6, w, 6), wall.darkened(0.35))
return img
static func paint_asphalt(seed_value: int) -> Image:
var rng := RandomNumberGenerator.new()
rng.seed = seed_value
var img := Image.create(256, 256, false, Image.FORMAT_RGB8)
img.fill(Color(0.29, 0.29, 0.3))
_noise(img, rng, 0.07)
# Remendos discretos para dar referência de movimento.
for i in 6:
var r := Rect2i(rng.randi_range(0, 200), rng.randi_range(0, 200), rng.randi_range(20, 56), rng.randi_range(14, 40))
img.fill_rect(r, Color(0.25, 0.25, 0.26).lerp(Color(0.34, 0.34, 0.35), rng.randf()))
_noise(img, rng, 0.03)
img.generate_mipmaps()
return img
static func paint_sidewalk(seed_value: int) -> Image:
var rng := RandomNumberGenerator.new()
rng.seed = seed_value
var img := Image.create(256, 256, false, Image.FORMAT_RGB8)
img.fill(Color(0.74, 0.72, 0.68))
_noise(img, rng, 0.05)
# Juntas das placas de concreto (a textura cobre 2 m x 2 m).
for k in [0, 128]:
img.fill_rect(Rect2i(k, 0, 3, 256), Color(0.55, 0.53, 0.5))
img.fill_rect(Rect2i(0, k, 256, 3), Color(0.55, 0.53, 0.5))
img.generate_mipmaps()
return img
static func _noise(img: Image, rng: RandomNumberGenerator, amount: float) -> void:
for y in img.get_height():
for x in img.get_width():
var c := img.get_pixel(x, y)
var n := (rng.randf() - 0.5) * 2.0 * amount
img.set_pixel(x, y, Color(clampf(c.r + n, 0, 1), clampf(c.g + n, 0, 1), clampf(c.b + n, 0, 1)))
@@ -0,0 +1 @@
uid://b02qpcs7n8ub8
+207
View File
@@ -0,0 +1,207 @@
extends RefCounted
## Moto e entregador provisórios, feitos só com primitivas.
##
## Orientação local: frente em -Z, Y para cima, origem no chão entre as rodas.
## Hierarquia devolvida:
## root (posição da moto no mundo)
## ├─ front_wheel / rear_wheel (pivôs no eixo; giram em X)
## └─ body (pivô de arfagem e vibração: quadro, banco, caixa e entregador)
## Um GLB futuro entra no lugar de `body`/rodas por meio de um nó adaptador
## que corrige escala e orientação; esta convenção não vale para todo modelo.
const WHEEL_RADIUS := 0.3
const FRONT_AXLE_Z := -0.68
const REAR_AXLE_Z := 0.62
const JACKET := Color("#27496D")
const PANTS := Color("#2B2B2E")
const SKIN_GLOVE := Color("#1C1C1C")
const HELMET := Color("#F2F2F2")
const VISOR := Color("#1A2430")
const TIRE := Color("#1B1B1B")
const METAL := Color("#9EA4AA")
const DARK := Color("#2A2C30")
var _materials := {}
static func build(cfg: Dictionary) -> Dictionary:
return load("res://scripts/builders/rider_builder.gd").new()._build(cfg)
func _build(cfg: Dictionary) -> Dictionary:
var bike_color: Color = cfg.rider.bike_color
var box_color: Color = cfg.rider.box_color
var root := Node3D.new()
root.name = "Rider"
var body := Node3D.new()
body.name = "Body"
root.add_child(body)
var front := _wheel("FrontWheel", FRONT_AXLE_Z, bike_color)
var rear := _wheel("RearWheel", REAR_AXLE_Z, bike_color)
root.add_child(front)
root.add_child(rear)
_build_bike(body, bike_color, box_color)
_build_courier(body)
return {"root": root, "body": body, "front_wheel": front, "rear_wheel": rear, "wheel_radius": WHEEL_RADIUS}
func _wheel(node_name: String, axle_z: float, accent: Color) -> Node3D:
var pivot := Node3D.new()
pivot.name = node_name
pivot.position = Vector3(0, WHEEL_RADIUS, axle_z)
# Pneu: cilindro com eixo em X.
var tire := _mesh(pivot, _cylinder(WHEEL_RADIUS, WHEEL_RADIUS, 0.11), TIRE, Vector3.ZERO)
tire.rotation = Vector3(0, 0, PI * 0.5)
var rim := _mesh(pivot, _cylinder(WHEEL_RADIUS * 0.68, WHEEL_RADIUS * 0.68, 0.125), METAL, Vector3.ZERO)
rim.rotation = Vector3(0, 0, PI * 0.5)
var hub := _mesh(pivot, _cylinder(0.06, 0.06, 0.16), accent, Vector3.ZERO)
hub.rotation = Vector3(0, 0, PI * 0.5)
# Raios escuros sobre o aro: deixam a rotação visível de lado.
for k in 3:
var spoke := _mesh(pivot, _box_mesh(Vector3(0.13, WHEEL_RADIUS * 1.3, 0.035)), DARK, Vector3.ZERO)
spoke.rotation = Vector3(k * PI / 3.0, 0, 0)
# Cravos claros na banda de rodagem: deixam a rotação visível por trás.
for k in 10:
var a := k * TAU / 10.0
var lug := _mesh(pivot, _box_mesh(Vector3(0.09, 0.03, 0.06)), Color("#5A5A5A"), Vector3(0, cos(a), sin(a)) * (WHEEL_RADIUS + 0.004))
lug.rotation = Vector3(a, 0, 0)
return pivot
func _build_bike(body: Node3D, bike_color: Color, box_color: Color) -> void:
# Garfo dianteiro e suspensão traseira
for x in [-0.09, 0.09]:
_limb(body, Vector3(x, WHEEL_RADIUS, FRONT_AXLE_Z), Vector3(x, 1.0, -0.5), 0.032, METAL)
_limb(body, Vector3(x * 1.6, WHEEL_RADIUS, REAR_AXLE_Z), Vector3(x * 1.6, 0.82, 0.38), 0.03, DARK)
# Quadro (tubo principal) e balança traseira
_limb(body, Vector3(0, 0.98, -0.5), Vector3(0, 0.62, 0.3), 0.05, DARK)
_limb(body, Vector3(0, 0.42, 0.05), Vector3(0, WHEEL_RADIUS, REAR_AXLE_Z), 0.04, DARK)
# Motor
_mesh(body, _box_mesh(Vector3(0.3, 0.3, 0.42)), Color("#3B3E43"), Vector3(0, 0.42, -0.05))
# Tanque e carenagem na cor da moto
_mesh(body, _box_mesh(Vector3(0.34, 0.24, 0.55)), bike_color, Vector3(0, 0.82, -0.2))
_mesh(body, _box_mesh(Vector3(0.3, 0.22, 0.42)), bike_color, Vector3(0, 0.72, 0.32))
# Banco
_mesh(body, _box_mesh(Vector3(0.3, 0.1, 0.66)), Color("#151515"), Vector3(0, 0.89, 0.18))
# Para-lamas
_mesh(body, _box_mesh(Vector3(0.16, 0.04, 0.42)), bike_color, Vector3(0, WHEEL_RADIUS * 2.0 + 0.06, FRONT_AXLE_Z + 0.02))
_mesh(body, _box_mesh(Vector3(0.18, 0.04, 0.4)), bike_color, Vector3(0, 0.78, REAR_AXLE_Z + 0.22))
# Escapamento
_limb(body, Vector3(0.17, 0.38, -0.05), Vector3(0.18, 0.5, 0.78), 0.045, METAL)
# Farol, painel e guidão
_mesh(body, _box_mesh(Vector3(0.3, 0.22, 0.2)), bike_color, Vector3(0, 1.0, -0.58))
var headlight := _mesh(body, _sphere(0.085), Color("#FFF6D8"), Vector3(0, 0.98, -0.69))
headlight.material_override = _emissive(Color("#FFF6D8"), Color("#FFF1C2"), 0.6)
_limb(body, Vector3(-0.36, 1.12, -0.47), Vector3(0.36, 1.12, -0.47), 0.025, DARK)
for x in [-0.33, 0.33]:
# Retrovisores
_limb(body, Vector3(x * 0.8, 1.12, -0.47), Vector3(x * 0.95, 1.36, -0.5), 0.012, DARK)
var mirror := _mesh(body, _cylinder(0.055, 0.055, 0.02), DARK, Vector3(x * 0.95, 1.38, -0.5))
mirror.rotation = Vector3(PI * 0.5, 0, 0)
# Lanterna traseira
var tail := _mesh(body, _box_mesh(Vector3(0.14, 0.06, 0.04)), Color("#C81E1E"), Vector3(0, 0.8, REAR_AXLE_Z + 0.43))
tail.material_override = _emissive(Color("#C81E1E"), Color("#FF2A2A"), 0.8)
# Bagageiro e caixa de entrega (sem marca)
_mesh(body, _box_mesh(Vector3(0.38, 0.035, 0.42)), DARK, Vector3(0, 0.93, REAR_AXLE_Z + 0.06))
_mesh(body, _box_mesh(Vector3(0.5, 0.46, 0.48)), box_color, Vector3(0, 1.18, REAR_AXLE_Z + 0.08))
_mesh(body, _box_mesh(Vector3(0.52, 0.05, 0.5)), box_color.darkened(0.25), Vector3(0, 1.43, REAR_AXLE_Z + 0.08))
# Faixa refletiva na traseira da caixa
_mesh(body, _box_mesh(Vector3(0.4, 0.06, 0.01)), Color("#F4F4F4"), Vector3(0, 1.2, REAR_AXLE_Z + 0.325))
func _build_courier(body: Node3D) -> void:
var pelvis := Vector3(0, 1.0, 0.16)
var chest := Vector3(0, 1.42, -0.02)
# Tronco inclinado para frente
_limb(body, pelvis, chest, 0.17, JACKET)
var back := _mesh(body, _box_mesh(Vector3(0.4, 0.2, 0.26)), JACKET, Vector3(0, 1.36, 0.0))
back.rotation = Vector3(-0.35, 0, 0)
# Pescoço e capacete (com viseira escura voltada para frente)
_limb(body, chest + Vector3(0, 0.04, 0), Vector3(0, 1.58, -0.06), 0.06, PANTS)
_mesh(body, _sphere(0.155), HELMET, Vector3(0, 1.69, -0.08))
var visor := _mesh(body, _box_mesh(Vector3(0.24, 0.1, 0.06)), VISOR, Vector3(0, 1.69, -0.215))
visor.rotation = Vector3(-0.15, 0, 0)
_mesh(body, _box_mesh(Vector3(0.05, 0.05, 0.28)), Color("#D95437"), Vector3(0, 1.84, -0.06))
for side in [-1.0, 1.0]:
var shoulder := Vector3(side * 0.21, 1.42, -0.02)
var elbow := Vector3(side * 0.31, 1.22, -0.26)
var grip := Vector3(side * 0.33, 1.12, -0.47)
_limb(body, shoulder, elbow, 0.062, JACKET)
_limb(body, elbow, grip, 0.052, JACKET)
_mesh(body, _sphere(0.055), SKIN_GLOVE, grip)
var hip := Vector3(side * 0.13, 0.98, 0.16)
var knee := Vector3(side * 0.21, 0.92, -0.24)
var ankle := Vector3(side * 0.2, 0.42, -0.04)
_limb(body, hip, knee, 0.085, PANTS)
_limb(body, knee, ankle, 0.065, PANTS)
# Pé apoiado na pedaleira
_mesh(body, _box_mesh(Vector3(0.11, 0.09, 0.26)), Color("#141414"), ankle + Vector3(0, -0.03, -0.06))
_limb(body, Vector3(side * 0.12, 0.38, -0.02), Vector3(side * 0.26, 0.38, -0.02), 0.018, METAL)
# --------------------------------------------------------------------------
# Utilidades
# --------------------------------------------------------------------------
## Cápsula entre dois pontos (membros, tubos).
func _limb(parent: Node3D, a: Vector3, b: Vector3, radius: float, color: Color) -> MeshInstance3D:
var axis := b - a
var capsule := CapsuleMesh.new()
capsule.radius = radius
capsule.height = axis.length() + radius * 2.0
var node := _mesh(parent, capsule, color, (a + b) * 0.5)
node.basis = Basis(Quaternion(Vector3.UP, axis.normalized()))
return node
func _mesh(parent: Node3D, mesh: Mesh, color: Color, position: Vector3) -> MeshInstance3D:
var node := MeshInstance3D.new()
node.mesh = mesh
node.position = position
node.material_override = _material(color)
parent.add_child(node)
return node
func _material(color: Color) -> StandardMaterial3D:
var key := color.to_html()
if not _materials.has(key):
var m := StandardMaterial3D.new()
m.albedo_color = color
m.roughness = 0.55
_materials[key] = m
return _materials[key]
func _emissive(albedo: Color, emission: Color, energy: float) -> StandardMaterial3D:
var m := StandardMaterial3D.new()
m.albedo_color = albedo
m.emission_enabled = true
m.emission = emission
m.emission_energy_multiplier = energy
return m
func _box_mesh(size: Vector3) -> BoxMesh:
var m := BoxMesh.new()
m.size = size
return m
func _cylinder(top: float, bottom: float, height: float) -> CylinderMesh:
var m := CylinderMesh.new()
m.top_radius = top
m.bottom_radius = bottom
m.height = height
return m
func _sphere(radius: float) -> SphereMesh:
var m := SphereMesh.new()
m.radius = radius
m.height = radius * 2.0
return m
@@ -0,0 +1 @@
uid://dl3txarp77f86
+447
View File
@@ -0,0 +1,447 @@
extends RefCounted
## Monta rua, calçadas, casas próximas em 3D, postes, árvores, luz e o fundo
## distante em planos com textura (fachadas fixas, sem billboard).
##
## Convenção da cena: Y é altura, a rua corre ao longo de Z e a moto anda
## para -Z. A rua começa atrás da câmera e termina num cruzamento em z = -L,
## de onde sobe um morro com casas em planos. Todas as escolhas aleatórias usam
## RandomNumberGenerator com a seed da configuração (determinístico).
const FacadePainter := preload("res://scripts/builders/facade_painter.gd")
const SIDEWALK_WIDTH := 2.4
const CURB_HEIGHT := 0.15
const CROSS_STREET_WIDTH := 9.0
const HILL_SLOPE := 0.32
const STORY_HEIGHT := 2.9
const HOUSE_COLORS := [
"#E9C46A", "#F4A261", "#9BC1BC", "#E5989B", "#A8DADC",
"#F1EDE4", "#B5C99A", "#CDB4DB", "#FFD6A5", "#E07A5F",
]
const WALL_COLORS := ["#D8D2C4", "#BDB5A6", "#E9E4D8", "#C9C3B6", "#A9B4A0"]
const ROOF_COLORS := ["#A5522F", "#B5653A", "#8F4A2C"]
const LIGHTING := {
"warm_day": {
"sun_color": Color(1.0, 0.95, 0.86), "sun_energy": 1.35, "sun_pitch": -42.0, "sun_yaw": -30.0,
"sky_top": Color(0.32, 0.53, 0.84), "sky_horizon": Color(0.74, 0.81, 0.88),
"ambient_energy": 0.55, "fog_density": 0.0045,
},
"golden_hour": {
"sun_color": Color(1.0, 0.74, 0.5), "sun_energy": 1.2, "sun_pitch": -20.0, "sun_yaw": -38.0,
"sky_top": Color(0.33, 0.43, 0.68), "sky_horizon": Color(0.97, 0.76, 0.56),
"ambient_energy": 0.5, "fog_density": 0.006,
},
}
var _rng := RandomNumberGenerator.new()
var _materials := {}
var _parent: Node3D
var _cfg: Dictionary
var _stats := {"near_houses": 0, "distant_cards": 0, "facade_source": "none", "poles": 0, "trees": 0}
## Constrói o cenário inteiro sob `parent`. Retorna estatísticas para o relatório.
static func build(parent: Node3D, cfg: Dictionary, backgrounds_dir: String) -> Dictionary:
var builder = load("res://scripts/builders/street_builder.gd").new()
return builder._build(parent, cfg, backgrounds_dir)
func _build(parent: Node3D, cfg: Dictionary, backgrounds_dir: String) -> Dictionary:
_parent = parent
_cfg = cfg
_rng.seed = cfg.seed
_build_environment(cfg.world.lighting_preset)
_build_ground_and_road()
_build_near_houses()
_build_poles_and_wires()
_build_trees()
if cfg.world.background_mode == "cards":
_build_background_cards(backgrounds_dir)
return _stats
# --------------------------------------------------------------------------
# Luz e ambiente
# --------------------------------------------------------------------------
func _build_environment(preset_name: String) -> void:
var p: Dictionary = LIGHTING[preset_name]
var sky_material := ProceduralSkyMaterial.new()
sky_material.sky_top_color = p.sky_top
sky_material.sky_horizon_color = p.sky_horizon
sky_material.ground_horizon_color = p.sky_horizon
sky_material.ground_bottom_color = Color(0.35, 0.36, 0.33)
var sky := Sky.new()
sky.sky_material = sky_material
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 = p.ambient_energy
env.tonemap_mode = Environment.TONE_MAPPER_FILMIC
env.fog_enabled = true
env.fog_light_color = p.sky_horizon
env.fog_density = p.fog_density
env.fog_sky_affect = 0.0
var world_env := WorldEnvironment.new()
world_env.name = "WorldEnvironment"
world_env.environment = env
_parent.add_child(world_env)
var sun := DirectionalLight3D.new()
sun.name = "Sun"
# Sol atrás e à esquerda da câmera: ilumina as costas do entregador e as
# fachadas voltadas para +Z; as sombras caem para frente e à direita.
sun.rotation_degrees = Vector3(p.sun_pitch, p.sun_yaw, 0.0)
sun.light_color = p.sun_color
sun.light_energy = p.sun_energy
sun.shadow_enabled = true
sun.directional_shadow_max_distance = 80.0
sun.directional_shadow_mode = DirectionalLight3D.SHADOW_PARALLEL_2_SPLITS
_parent.add_child(sun)
# --------------------------------------------------------------------------
# Chão, pista, calçadas e sinalização
# --------------------------------------------------------------------------
func _build_ground_and_road() -> void:
var length: float = _cfg.world.street_length
var road_w: float = _cfg.world.road_width
var z_near := _z_near()
var z_far := -length
var span := z_near - z_far
var z_mid := (z_near + z_far) * 0.5
# Terrenos atrás das casas (evita vazio entre as construções).
_box(Vector3(260.0, 0.1, span + CROSS_STREET_WIDTH + 30.0), Vector3(0, -0.06, z_mid - CROSS_STREET_WIDTH * 0.5 - 6.0), _color_mat("#8A8F63", 1.0), false)
var asphalt := StandardMaterial3D.new()
asphalt.albedo_texture = ImageTexture.create_from_image(FacadePainter.paint_asphalt(_cfg.seed))
asphalt.uv1_triplanar = true
asphalt.uv1_world_triplanar = true
asphalt.uv1_scale = Vector3(0.2, 0.2, 0.2)
asphalt.roughness = 0.95
asphalt.texture_filter = BaseMaterial3D.TEXTURE_FILTER_LINEAR_WITH_MIPMAPS_ANISOTROPIC
_box(Vector3(road_w, 0.1, span), Vector3(0, -0.05, z_mid), asphalt, false)
# Rua transversal no fim, para a avenida não terminar num muro.
_box(Vector3(260.0, 0.1, CROSS_STREET_WIDTH), Vector3(0, -0.05, z_far - CROSS_STREET_WIDTH * 0.5), asphalt, false)
var sidewalk := StandardMaterial3D.new()
sidewalk.albedo_texture = ImageTexture.create_from_image(FacadePainter.paint_sidewalk(_cfg.seed + 1))
sidewalk.uv1_triplanar = true
sidewalk.uv1_world_triplanar = true
sidewalk.uv1_scale = Vector3(0.5, 0.5, 0.5)
sidewalk.roughness = 0.9
sidewalk.texture_filter = BaseMaterial3D.TEXTURE_FILTER_LINEAR_WITH_MIPMAPS_ANISOTROPIC
var curb := _color_mat("#D9D6CF", 0.9)
for side in [-1.0, 1.0]:
var x_curb: float = side * (road_w * 0.5 + 0.08)
var x_walk: float = side * (road_w * 0.5 + 0.16 + SIDEWALK_WIDTH * 0.5)
_box(Vector3(0.16, CURB_HEIGHT, span), Vector3(x_curb, CURB_HEIGHT * 0.5, z_mid), curb, false)
_box(Vector3(SIDEWALK_WIDTH, CURB_HEIGHT, span), Vector3(x_walk, CURB_HEIGHT * 0.5, z_mid), sidewalk, false)
# Calçada do outro lado do cruzamento.
_box(Vector3(260.0, CURB_HEIGHT, SIDEWALK_WIDTH), Vector3(0, CURB_HEIGHT * 0.5, z_far - CROSS_STREET_WIDTH - SIDEWALK_WIDTH * 0.5), sidewalk, false)
# Faixa central amarela tracejada: referência forte de deslocamento.
var paint := _color_mat("#E3B23C", 0.7)
var z := z_near - 1.0
while z > z_far + 6.0:
_box(Vector3(0.12, 0.012, 2.6), Vector3(0, 0.006, z), paint, false)
z -= 6.0
# Faixa de pedestres antes do cruzamento.
var zebra := _color_mat("#EDEDE6", 0.7)
var x := -road_w * 0.5 + 0.6
while x < road_w * 0.5 - 0.4:
_box(Vector3(0.5, 0.012, 3.0), Vector3(x, 0.006, z_far + 2.2), zebra, false)
x += 1.0
# --------------------------------------------------------------------------
# Casas próximas (3D)
# --------------------------------------------------------------------------
func _build_near_houses() -> void:
var n: int = _cfg.world.near_houses_per_side
if n <= 0:
return
var road_w: float = _cfg.world.road_width
var z_a: float = _cfg.rider.start_position.z + 16.0
var z_b: float = -_cfg.world.street_length + 0.5
var lot := (z_a - z_b) / n
for side in [-1.0, 1.0]:
for i in n:
var z1: float = z_a - i * lot
_build_lot(side, z1, z1 - lot, road_w * 0.5 + 0.16 + SIDEWALK_WIDTH)
_stats.near_houses = n * 2
func _build_lot(side: float, z1: float, z2: float, x_property: float) -> void:
var lot := z1 - z2
var wall_color: String = WALL_COLORS[_rng.randi() % WALL_COLORS.size()]
var house_color := Color(HOUSE_COLORS[_rng.randi() % HOUSE_COLORS.size()])
if _rng.randf() < 0.35:
wall_color = "#" + house_color.darkened(0.12).to_html(false)
# Muro com portão: traço típico de rua residencial brasileira.
var wall_h := _rng.randf_range(1.6, 2.1)
var x_wall := side * (x_property + 0.1)
var gate_w := minf(3.0, lot * 0.35)
var gate_center := _rng.randf_range(z2 + gate_w * 0.5 + 0.6, z1 - gate_w * 0.5 - 0.6)
var wall_mat := _color_mat(wall_color, 0.95)
_wall_segment(x_wall, z1 - 0.05, gate_center + gate_w * 0.5, wall_h, wall_mat)
_wall_segment(x_wall, gate_center - gate_w * 0.5, z2 + 0.05, wall_h, wall_mat)
var gate_mat := _color_mat(["#3C4248", "#5A4636", "#2F4F4F"][_rng.randi() % 3], 0.6, 0.4)
_box(Vector3(0.08, wall_h - 0.15, gate_w), Vector3(x_wall, (wall_h - 0.15) * 0.5, gate_center), gate_mat)
# Pilares do portão
for zz in [gate_center + gate_w * 0.5 + 0.12, gate_center - gate_w * 0.5 - 0.12]:
_box(Vector3(0.3, wall_h + 0.2, 0.24), Vector3(x_wall, (wall_h + 0.2) * 0.5, zz), wall_mat)
# Corpo da casa
var setback := _rng.randf_range(2.2, 3.6)
var depth := _rng.randf_range(8.0, 11.0)
var width := maxf(4.0, lot - _rng.randf_range(1.2, 3.0))
var z_center := (z1 + z2) * 0.5 + _rng.randf_range(-0.5, 0.5) * (lot - width)
var stories := 2 if _rng.randf() < 0.4 else 1
var height := STORY_HEIGHT * stories + 0.2
var x_facade := side * (x_property + setback)
var x_center := x_facade + side * depth * 0.5
_box(Vector3(depth, height, width), Vector3(x_center, height * 0.5, z_center), _color_mat("#" + house_color.to_html(false), 0.9))
# Janelas e porta na fachada voltada para a rua (normal = -side em X).
var x_detail := x_facade - side * 0.04
var frame_mat := _color_mat("#F2F2EE", 0.6)
var glass_mat := _color_mat("#33475B", 0.25, 0.1)
var door_mat := _color_mat(["#6B4F3A", "#7C8288", "#4E5D6C"][_rng.randi() % 3], 0.7)
var windows := maxi(1, int(width / 3.2))
for s in stories:
var base_y := s * STORY_HEIGHT
var door_slot := _rng.randi() % (windows + 1) if s == 0 else -1
var slots := windows + (1 if s == 0 else 0)
for k in slots:
var zz := z_center + width * 0.5 - (k + 0.5) * width / slots
if k == door_slot:
_box(Vector3(0.1, 2.25, 1.15), Vector3(x_detail + side * 0.02, 1.12, zz), frame_mat)
_box(Vector3(0.1, 2.1, 0.95), Vector3(x_detail, 1.05, zz), door_mat)
else:
_box(Vector3(0.08, 1.3, 1.55), Vector3(x_detail + side * 0.02, base_y + 1.6, zz), frame_mat)
_box(Vector3(0.1, 1.1, 1.35), Vector3(x_detail, base_y + 1.6, zz), glass_mat)
if s < stories - 1:
# Laje aparente entre andares
_box(Vector3(depth + 0.16, 0.18, width + 0.16), Vector3(x_center, base_y + STORY_HEIGHT, z_center), _color_mat("#" + house_color.darkened(0.15).to_html(false), 0.9))
# Telhado: cerâmico de duas águas ou laje com platibanda e caixa d'água.
if _rng.randf() < 0.55:
var roof := MeshInstance3D.new()
var prism := PrismMesh.new()
var roof_h := _rng.randf_range(1.0, 1.5)
prism.size = Vector3(depth + 0.8, roof_h, width + 0.6)
roof.mesh = prism
roof.material_override = _color_mat(ROOF_COLORS[_rng.randi() % ROOF_COLORS.size()], 0.85)
roof.position = Vector3(x_center, height + roof_h * 0.5, z_center)
_parent.add_child(roof)
else:
var parapet := _color_mat("#" + house_color.lightened(0.15).to_html(false), 0.9)
_box(Vector3(depth + 0.1, 0.6, width + 0.1), Vector3(x_center, height + 0.3, z_center), parapet)
if _rng.randf() < 0.6:
var tank := MeshInstance3D.new()
var cyl := CylinderMesh.new()
cyl.top_radius = 0.55
cyl.bottom_radius = 0.6
cyl.height = 0.9
tank.mesh = cyl
tank.material_override = _color_mat("#3A6EA5", 0.5)
tank.position = Vector3(x_center + side * _rng.randf_range(0.0, depth * 0.3), height + 0.6 + 0.45, z_center + _rng.randf_range(-width * 0.3, width * 0.3))
_parent.add_child(tank)
func _wall_segment(x: float, z_from: float, z_to: float, h: float, mat: Material) -> void:
var length := z_from - z_to
if length <= 0.05:
return
_box(Vector3(0.2, h, length), Vector3(x, h * 0.5, (z_from + z_to) * 0.5), mat)
# --------------------------------------------------------------------------
# Postes, fios e árvores: repetição que evidencia deslocamento e profundidade
# --------------------------------------------------------------------------
func _build_poles_and_wires() -> void:
var road_w: float = _cfg.world.road_width
var x := road_w * 0.5 + 0.5
var concrete := _color_mat("#9A9890", 0.9)
var wire_mat := _color_mat("#1E1E1E", 0.8)
var z := _z_near() - 4.0
var tops: Array[Vector3] = []
while z > -_cfg.world.street_length + 2.0:
var pole := MeshInstance3D.new()
var cyl := CylinderMesh.new()
cyl.top_radius = 0.09
cyl.bottom_radius = 0.14
cyl.height = 8.5
pole.mesh = cyl
pole.material_override = concrete
pole.position = Vector3(x, 4.25, z)
_parent.add_child(pole)
_box(Vector3(1.7, 0.1, 0.1), Vector3(x - 0.3, 8.0, z), concrete)
tops.append(Vector3(x, 8.0, z))
_stats.poles += 1
z -= 15.0 + _rng.randf_range(-1.0, 1.0)
for i in tops.size() - 1:
var a := tops[i]
var b := tops[i + 1]
for offset in [Vector3(-0.9, 0.06, 0), Vector3(-0.3, 0.06, 0), Vector3(0.35, 0.06, 0), Vector3(0, -1.3, 0)]:
var mid: Vector3 = (a + b) * 0.5 + offset
_box(Vector3(0.035, 0.035, a.z - b.z), mid, wire_mat, false)
func _build_trees() -> void:
var road_w: float = _cfg.world.road_width
var x := -(road_w * 0.5 + 1.0)
var trunk := _color_mat("#6B4E37", 0.9)
var leaves := [_color_mat("#4F7D3A", 0.9), _color_mat("#5E8C42", 0.9), _color_mat("#3F6B33", 0.9)]
var z := _z_near() - 8.0
while z > -_cfg.world.street_length + 6.0:
if _rng.randf() < 0.8:
var tz := z + _rng.randf_range(-3.0, 3.0)
var t := MeshInstance3D.new()
var cyl := CylinderMesh.new()
cyl.top_radius = 0.1
cyl.bottom_radius = 0.15
cyl.height = 2.6
t.mesh = cyl
t.material_override = trunk
t.position = Vector3(x, 1.3, tz)
_parent.add_child(t)
for k in 3:
var crown := MeshInstance3D.new()
var sphere := SphereMesh.new()
var r := _rng.randf_range(0.9, 1.4)
sphere.radius = r
sphere.height = r * 1.7
crown.mesh = sphere
crown.material_override = leaves[_rng.randi() % leaves.size()]
crown.position = Vector3(x + _rng.randf_range(-0.5, 0.5), 2.8 + k * 0.45, tz + _rng.randf_range(-0.6, 0.6))
_parent.add_child(crown)
_stats.trees += 1
z -= 20.0
# --------------------------------------------------------------------------
# Fundo distante: morro com casas em planos texturizados (orientação fixa)
# --------------------------------------------------------------------------
func _build_background_cards(backgrounds_dir: String) -> void:
var length: float = _cfg.world.street_length
var z_hill := -length - CROSS_STREET_WIDTH - SIDEWALK_WIDTH - 1.0
var angle := atan(HILL_SLOPE)
var hill := MeshInstance3D.new()
var plane := PlaneMesh.new()
plane.size = Vector2(320.0, 200.0)
hill.mesh = plane
hill.material_override = _color_mat("#6F8B4F", 1.0)
hill.cast_shadow = GeometryInstance3D.SHADOW_CASTING_SETTING_OFF
hill.rotation = Vector3(angle, 0, 0)
hill.position = Vector3(0, sin(angle) * 100.0 - 0.05, z_hill - cos(angle) * 100.0)
_parent.add_child(hill)
# Cumeeira irregular: sem ela a borda do plano vira uma linha reta no céu.
var ridge_y := sin(angle) * 200.0
var ridge_z := z_hill - cos(angle) * 200.0
var x_ridge := -170.0
while x_ridge < 170.0:
var bump := MeshInstance3D.new()
var sphere := SphereMesh.new()
var r := _rng.randf_range(22.0, 40.0)
sphere.radius = r
sphere.height = r * 2.0
sphere.radial_segments = 24
sphere.rings = 12
bump.mesh = sphere
bump.scale = Vector3(1.0, _rng.randf_range(0.35, 0.6), 0.8)
bump.material_override = _color_mat("#6F8B4F", 1.0)
bump.cast_shadow = GeometryInstance3D.SHADOW_CASTING_SETTING_OFF
bump.position = Vector3(x_ridge, ridge_y - r * 0.15, ridge_z - r * 0.3)
_parent.add_child(bump)
x_ridge += r * _rng.randf_range(1.1, 1.6)
var textures: Array[ImageTexture] = []
var loaded := 0
for v in FacadePainter.FACADE_VARIANTS:
var path := backgrounds_dir.path_join(FacadePainter.facade_file_name(v))
var img: Image = null
if FileAccess.file_exists(path):
img = Image.load_from_file(path)
if img != null:
loaded += 1
if img == null:
img = FacadePainter.paint_facade(v)
img.generate_mipmaps()
textures.append(ImageTexture.create_from_image(img))
_stats.facade_source = "png" if loaded == FacadePainter.FACADE_VARIANTS else ("mixed" if loaded > 0 else "generated")
var card_mats: Array[StandardMaterial3D] = []
for tex in textures:
var m := StandardMaterial3D.new()
m.albedo_texture = tex
m.roughness = 1.0
m.texture_filter = BaseMaterial3D.TEXTURE_FILTER_LINEAR_WITH_MIPMAPS_ANISOTROPIC
card_mats.append(m)
var quad_cache := {}
for row in 7:
var z := z_hill - 3.0 - row * 13.0
var y_ground := (z_hill - z) * HILL_SLOPE
var x := -75.0 + _rng.randf_range(0.0, 5.0)
while x < 75.0:
var w := _rng.randf_range(7.0, 9.5)
var h := w * 0.75
var key := "%.2f" % w
if not quad_cache.has(key):
var q := QuadMesh.new()
q.size = Vector2(w, h)
quad_cache[key] = q
var card := MeshInstance3D.new()
card.mesh = quad_cache[key]
card.material_override = card_mats[_rng.randi() % card_mats.size()]
card.cast_shadow = GeometryInstance3D.SHADOW_CASTING_SETTING_OFF
# Base levemente enterrada no morro para não aparecer borda flutuando.
card.position = Vector3(x + w * 0.5, y_ground + h * 0.5 - 0.6, z + _rng.randf_range(-1.5, 1.5))
_parent.add_child(card)
_stats.distant_cards += 1
x += w + _rng.randf_range(0.6, 3.0)
# --------------------------------------------------------------------------
# Utilidades
# --------------------------------------------------------------------------
func _z_near() -> float:
return _cfg.rider.start_position.z + 40.0
func _box(size: Vector3, position: Vector3, material: Material, cast_shadow := true) -> MeshInstance3D:
var mesh := BoxMesh.new()
mesh.size = size
var node := MeshInstance3D.new()
node.mesh = mesh
node.material_override = material
node.position = position
if not cast_shadow:
node.cast_shadow = GeometryInstance3D.SHADOW_CASTING_SETTING_OFF
_parent.add_child(node)
return node
func _color_mat(hex: String, roughness: float, metallic := 0.0) -> StandardMaterial3D:
var key := "%s|%.2f|%.2f" % [hex, roughness, metallic]
if not _materials.has(key):
var m := StandardMaterial3D.new()
m.albedo_color = Color(hex)
m.roughness = roughness
m.metallic = metallic
_materials[key] = m
return _materials[key]
@@ -0,0 +1 @@
uid://dosp5vndi1ua7
+296
View File
@@ -0,0 +1,296 @@
extends Node3D
## Inicialização e orquestração da cena.
##
## Argumentos da aplicação (depois de `--` na linha de comando da Godot):
## --config <arquivo.json> cena a montar (padrão: config/demo-street.json)
## --validate-only só valida a configuração e sai (0 = ok, 2 = inválida)
## --manifest <arquivo.json> no render, grava o resumo dos quadros produzidos
## --debug-frame-index desenha índice do quadro e tempo de cena
## --warmup-frames <n> no render, quadros descartáveis em t=0 antes da
## cena (padrão 3). Na Godot 4.7.2 o 1º quadro sai
## com sombras e luz do céu incompletas; o lançador
## passa a codificar a partir do índice n.
## Caminhos relativos são resolvidos a partir da RAIZ DO REPOSITÓRIO (a pasta
## que contém godot/), nunca do diretório de execução.
##
## Modos:
## render (Movie Maker ativo): t = quadro / fps. O delta do motor é ignorado
## porque não é exatamente 1/fps nem com --fixed-fps.
## preview (janela normal): o tempo de cena avança com o delta; Espaço pausa,
## R reinicia, ←/→ andam um quadro pausado, L liga/desliga repetição.
const SceneConfig := preload("res://scripts/core/scene_config.gd")
const StreetBuilder := preload("res://scripts/builders/street_builder.gd")
const RiderBuilder := preload("res://scripts/builders/rider_builder.gd")
const Timeline := preload("res://scripts/core/timeline_controller.gd")
const CameraController := preload("res://scripts/view/camera_controller.gd")
const OverlayController := preload("res://scripts/view/overlay_controller.gd")
const DEFAULT_CONFIG := "config/demo-street.json"
const EXIT_INVALID_CONFIG := 2
const EXIT_ENVIRONMENT := 3
const EXIT_MANIFEST := 4
const DEFAULT_WARMUP_FRAMES := 3
const MAX_WARMUP_FRAMES := 30
var _cfg: Dictionary
var _timeline: Timeline
var _rider: Dictionary
var _camera: Camera3D
var _overlay: OverlayController
var _render_mode := false
var _frame := 0
var _warmup_frames := DEFAULT_WARMUP_FRAMES
var _warmup_done := 0
var _total_frames := 0
var _fps := 30
var _preview_time := 0.0
var _paused := false
var _loop := false
var _show_debug := false
var _manifest_path := ""
var _config_path := ""
var _scene_stats := {}
var _state_lines := PackedStringArray()
var _started_msec := 0
var _halted := false
func _ready() -> void:
_started_msec = Time.get_ticks_msec()
var args := _parse_user_args(OS.get_cmdline_user_args())
_config_path = _resolve_path(args.get("config", DEFAULT_CONFIG))
_render_mode = Engine.get_write_movie_path() != ""
_show_debug = args.has("debug-frame-index")
_manifest_path = _resolve_path(args.manifest) if args.has("manifest") else ""
if args.has("warmup-frames"):
var value := str(args["warmup-frames"])
if not value.is_valid_int() or int(value) < 0 or int(value) > MAX_WARMUP_FRAMES:
printerr("ARGS_INVALID --warmup-frames precisa ser inteiro entre 0 e %d" % MAX_WARMUP_FRAMES)
_halt(EXIT_INVALID_CONFIG)
return
_warmup_frames = int(value)
var result := SceneConfig.load_file(_config_path)
if not result.ok:
printerr("CONFIG_INVALID %s" % _config_path)
for e in result.errors:
printerr(" - " + e)
_halt(EXIT_INVALID_CONFIG)
return
_cfg = result.config
if args.has("validate-only"):
print("CONFIG_OK %s (%s, %d quadros)" % [_cfg.id, _config_path, _cfg.video.total_frames])
_halt(0)
return
_fps = _cfg.video.fps
_total_frames = _cfg.video.total_frames
var viewport_size := get_viewport().get_visible_rect().size
if _render_mode:
# Caminho relativo em --write-movie é resolvido a partir de godot/, e
# a Godot 4.7.2 sai com código 0 mesmo sem conseguir gravar os PNGs.
var movie_dir := Engine.get_write_movie_path().get_base_dir()
if movie_dir.is_relative_path():
movie_dir = ProjectSettings.globalize_path("res://").path_join(movie_dir)
if not DirAccess.dir_exists_absolute(movie_dir):
printerr("RENDER_ENVIRONMENT pasta de saída do Movie Maker não existe: %s (use caminho absoluto e crie a pasta antes)" % movie_dir)
_halt(EXIT_ENVIRONMENT)
return
var expected := Vector2(_cfg.video.width, _cfg.video.height)
if viewport_size != expected:
printerr("RENDER_ENVIRONMENT viewport %s difere da configuração %s. O Movie Maker fixa o tamanho na inicialização: use o lançador (gera override.cfg) ou ajuste display/window/size no projeto." % [viewport_size, expected])
_halt(EXIT_ENVIRONMENT)
return
_build_scene(viewport_size)
_apply(0.0)
print("SCENE_READY id=%s mode=%s frames=%d fps=%d viewport=%dx%d renderer=%s" % [
_cfg.id, "render" if _render_mode else "preview", _total_frames, _fps,
int(viewport_size.x), int(viewport_size.y), RenderingServer.get_current_rendering_method()])
func _build_scene(viewport_size: Vector2) -> void:
var world := Node3D.new()
world.name = "World"
add_child(world)
_scene_stats = StreetBuilder.build(world, _cfg, ProjectSettings.globalize_path("res://assets/backgrounds"))
_rider = RiderBuilder.build(_cfg)
add_child(_rider.root)
_camera = Camera3D.new()
_camera.name = "Camera"
_camera.near = 0.05
_camera.far = 600.0
_camera.keep_aspect = Camera3D.KEEP_HEIGHT
add_child(_camera)
_camera.current = true
_overlay = OverlayController.new()
_overlay.name = "Overlay"
add_child(_overlay)
_overlay.setup(_cfg, viewport_size, _show_debug or not _render_mode)
_timeline = Timeline.new(_cfg, _rider.wheel_radius)
func _process(delta: float) -> void:
if _cfg.is_empty() or _halted:
return
if _render_mode:
_process_render()
else:
_process_preview(delta)
## Um quadro por iteração. Primeiro vêm os quadros de aquecimento (estado de
## t=0, descartados na conversão); depois o quadro N da cena mostra o estado em
## t = N / fps. A iteração em que chamamos quit() ainda é desenhada e gravada,
## então o total de PNGs é exatamente warmup + total_frames (confirmado com a
## Godot 4.7.2).
func _process_render() -> void:
if _warmup_done < _warmup_frames:
_apply(0.0)
_warmup_done += 1
return
var t := float(_frame) / float(_fps)
var state := _apply(t)
_state_lines.append(_state_line(state))
_frame += 1
if _frame >= _total_frames:
_finish_render(state)
func _process_preview(delta: float) -> void:
if not _paused:
_preview_time += delta
var duration: float = _cfg.video.duration
if _preview_time > duration:
_preview_time = 0.0 if _loop else duration
_apply(_preview_time)
func _apply(t: float) -> Dictionary:
var state := _timeline.evaluate_at_time(t)
var root: Node3D = _rider.root
root.position = state.rider_position
var body: Node3D = _rider.body
body.position = Vector3(0, state.body_bob, 0)
body.rotation = Vector3(state.body_pitch, 0, 0)
_rider.front_wheel.rotation = Vector3(state.wheel_angle, 0, 0)
_rider.rear_wheel.rotation = Vector3(state.wheel_angle, 0, 0)
CameraController.apply(_camera, state.camera)
var debug_text := ""
if _show_debug or not _render_mode:
debug_text = "q=%03d t=%.3fs d=%.2fm v=%.2fm/s" % [int(round(t * _fps)), t, state.distance, state.speed]
if not _render_mode:
debug_text += "\n[Espaço] pausa [R] reinicia [←/→] quadro [L] repetir=%s" % ("sim" if _loop else "não")
_overlay.apply(state.overlay, debug_text)
return state
func _unhandled_input(event: InputEvent) -> void:
if _render_mode or _cfg.is_empty() or not (event is InputEventKey) or not event.pressed:
return
var step := 1.0 / float(_fps)
match event.keycode:
KEY_SPACE:
_paused = not _paused
KEY_R:
_preview_time = 0.0
KEY_L:
_loop = not _loop
KEY_RIGHT:
_paused = true
_preview_time = minf(_preview_time + step, _cfg.video.duration)
KEY_LEFT:
_paused = true
_preview_time = maxf(_preview_time - step, 0.0)
KEY_ESCAPE:
get_tree().quit(0)
func _state_line(state: Dictionary) -> String:
var p: Vector3 = state.rider_position
var c: Vector3 = state.camera.position
return "%.4f|%.5f,%.5f,%.5f|%.5f|%.5f,%.5f,%.5f|%.3f" % [state.t, p.x, p.y, p.z, state.wheel_angle, c.x, c.y, c.z, state.overlay.title]
func _finish_render(last_state: Dictionary) -> void:
var final_position: Vector3 = last_state.rider_position
var manifest := {
"configId": _cfg.id,
"configPath": _config_path,
"fps": _fps,
"durationSeconds": _cfg.video.duration,
"framesRendered": _frame,
"expectedFrames": _total_frames,
"warmupFrames": _warmup_frames,
"firstSceneFrameIndex": _warmup_frames,
"pngFramesWritten": _warmup_frames + _frame,
"firstFrameTime": 0.0,
"lastFrameTime": float(_frame - 1) / float(_fps),
"viewport": [int(get_viewport().get_visible_rect().size.x), int(get_viewport().get_visible_rect().size.y)],
"renderer": {
"method": RenderingServer.get_current_rendering_method(),
"driver": RenderingServer.get_current_rendering_driver_name(),
"adapter": RenderingServer.get_video_adapter_name(),
"vendor": RenderingServer.get_video_adapter_vendor(),
},
"godotVersion": Engine.get_version_info().string,
"finalDistanceMeters": last_state.distance,
"travelMeters": _cfg.rider.travel,
"finalPosition": [final_position.x, final_position.y, final_position.z],
"cruiseSpeedMetersPerSecond": _timeline.cruise_speed(),
"scene": _scene_stats,
# Resumo do estado de todos os quadros: duas execuções da mesma
# configuração precisam gerar o mesmo valor.
"stateDigest": "\n".join(_state_lines).md5_text(),
"wallClockSeconds": (Time.get_ticks_msec() - _started_msec) / 1000.0,
}
if _manifest_path != "":
DirAccess.make_dir_recursive_absolute(_manifest_path.get_base_dir())
var file := FileAccess.open(_manifest_path, FileAccess.WRITE)
if file == null:
printerr("MANIFEST_WRITE_FAILED %s (erro %d)" % [_manifest_path, FileAccess.get_open_error()])
get_tree().quit(EXIT_MANIFEST)
return
file.store_string(JSON.stringify(manifest, " "))
file.close()
print("RENDER_DONE frames=%d warmup=%d fps=%d digest=%s" % [_frame, _warmup_frames, _fps, manifest.stateDigest])
get_tree().quit(0)
func _halt(code: int) -> void:
_halted = true
get_tree().quit(code)
func _parse_user_args(raw: PackedStringArray) -> Dictionary:
var out := {}
var i := 0
while i < raw.size():
var arg := raw[i]
if arg.begins_with("--"):
var key := arg.substr(2)
if key.contains("="):
out[key.get_slice("=", 0)] = key.substr(key.find("=") + 1)
elif i + 1 < raw.size() and not raw[i + 1].begins_with("--"):
out[key] = raw[i + 1]
i += 1
else:
out[key] = true
i += 1
return out
static func repo_root() -> String:
return ProjectSettings.globalize_path("res://").trim_suffix("/").get_base_dir()
static func _resolve_path(path: String) -> String:
var p := path.replace("\\", "/")
if p.is_absolute_path():
return p.simplify_path()
return repo_root().path_join(p).simplify_path()
+1
View File
@@ -0,0 +1 @@
uid://cqmgnobpvhi0w
+334
View File
@@ -0,0 +1,334 @@
extends RefCounted
## Leitura e validação do contrato de cena (schemaVersion 1).
##
## O JSON só descreve dados: números, textos curtos, cores e valores de listas
## fechadas. Nenhum campo é interpretado como código ou comando. Campos
## desconhecidos são rejeitados para o contrato não crescer por acidente.
##
## Saída: { "ok": bool, "errors": PackedStringArray, "config": Dictionary }
## O dicionário "config" usa nomes internos em snake_case com tipos Godot
## (Vector3, Color). Os nomes em camelCase pertencem ao contrato do JSON.
const SUPPORTED_SCHEMA_VERSION := 1
const LIGHTING_PRESETS := ["warm_day", "golden_hour"]
const BACKGROUND_MODES := ["cards", "none"]
const CAMERA_PRESETS := ["third_person_follow"]
const RIDER_ASSETS := ["placeholder-rider"]
## Velocidade de cruzeiro máxima aceita (m/s). Acima disso o plano deixa de ser
## uma rua de bairro e a câmera não acompanha de forma legível.
const MAX_CRUISE_SPEED := 20.0
## A moto precisa parar a esta distância do fim da rua, para o fim do cenário
## não aparecer em primeiro plano.
const STREET_END_MARGIN := 15.0
const MIN_CAMERA_HEIGHT := 0.5
const DEFAULT_BOX_COLOR := "#1F8A70"
static func load_file(path: String) -> Dictionary:
if not FileAccess.file_exists(path):
return _failure(["arquivo de configuração não encontrado: %s" % path])
var text := FileAccess.get_file_as_string(path)
if text.is_empty():
var open_error := FileAccess.get_open_error()
if open_error != OK:
return _failure(["não foi possível ler %s (erro %d)" % [path, open_error]])
return _failure(["arquivo de configuração vazio: %s" % path])
return parse_text(text)
static func parse_text(text: String) -> Dictionary:
var json := JSON.new()
var parse_error := json.parse(text)
if parse_error != OK:
return _failure(["JSON inválido na linha %d: %s" % [json.get_error_line(), json.get_error_message()]])
if typeof(json.data) != TYPE_DICTIONARY:
return _failure(["a raiz do JSON precisa ser um objeto"])
return validate(json.data)
static func validate(raw: Dictionary) -> Dictionary:
var v := Validator.new()
v.check_keys(raw, ["schemaVersion", "id", "seed", "video", "world", "rider", "motion", "camera", "overlay", "audio"], "")
var version = raw.get("schemaVersion")
if not _is_number(version) or float(version) != SUPPORTED_SCHEMA_VERSION:
# Sem versão conhecida não há como interpretar o resto com segurança.
return _failure(["schemaVersion %s não suportada (esperado %d)" % [str(version), SUPPORTED_SCHEMA_VERSION]])
var cfg := {"schema_version": SUPPORTED_SCHEMA_VERSION}
cfg.id = v.text(raw, "id", "id", 1, 64)
if cfg.id != "" and not RegEx.create_from_string("^[a-z0-9][a-z0-9_-]*$").search(cfg.id):
v.fail("id", "use apenas letras minúsculas, números, '-' e '_' (ex.: demo-street)")
cfg.seed = v.integer(raw, "seed", "seed", 0, 2147483647)
# --- video ---
var video := v.object(raw, "video", "video", ["width", "height", "fps", "durationSeconds"])
cfg.video = {
"width": v.integer(video, "width", "video.width", 128, 4096),
"height": v.integer(video, "height", "video.height", 128, 4096),
"fps": v.integer(video, "fps", "video.fps", 1, 120),
"duration": v.number(video, "durationSeconds", "video.durationSeconds", 0.5, 120.0),
}
for key in ["width", "height"]:
if cfg.video[key] % 2 != 0:
v.fail("video." + key, "precisa ser par (H.264 com yuv420p exige dimensões pares)")
var frames_exact: float = cfg.video.fps * cfg.video.duration
cfg.video.total_frames = int(round(frames_exact))
if v.ok() and absf(frames_exact - cfg.video.total_frames) > 1e-6:
v.fail("video.durationSeconds", "fps × duração precisa dar um número inteiro de quadros (deu %.4f)" % frames_exact)
# --- world ---
var world := v.object(raw, "world", "world", ["streetLengthMeters", "roadWidthMeters", "nearHousesPerSide", "backgroundMode", "lightingPreset"])
cfg.world = {
"street_length": v.number(world, "streetLengthMeters", "world.streetLengthMeters", 40.0, 1000.0),
"road_width": v.number(world, "roadWidthMeters", "world.roadWidthMeters", 4.0, 20.0),
"near_houses_per_side": v.integer(world, "nearHousesPerSide", "world.nearHousesPerSide", 0, 40),
"background_mode": v.choice(world, "backgroundMode", "world.backgroundMode", BACKGROUND_MODES),
"lighting_preset": v.choice(world, "lightingPreset", "world.lightingPreset", LIGHTING_PRESETS),
}
# --- rider ---
var rider := v.object(raw, "rider", "rider", ["assetId", "bikeColor", "boxColor", "startPosition", "travelMeters"])
cfg.rider = {
"asset_id": v.choice(rider, "assetId", "rider.assetId", RIDER_ASSETS),
"bike_color": v.color(rider, "bikeColor", "rider.bikeColor"),
"box_color": v.color(rider, "boxColor", "rider.boxColor", DEFAULT_BOX_COLOR),
"start_position": v.vec3(rider, "startPosition", "rider.startPosition", 1000.0),
"travel": v.number(rider, "travelMeters", "rider.travelMeters", 1.0, 900.0),
}
# --- motion ---
var motion := v.object(raw, "motion", "motion", ["startSeconds", "accelSeconds", "brakeStartSeconds", "stopSeconds"])
cfg.motion = {
"start": v.number(motion, "startSeconds", "motion.startSeconds", 0.0, 120.0),
"brake_start": v.number(motion, "brakeStartSeconds", "motion.brakeStartSeconds", 0.0, 120.0),
"stop": v.number(motion, "stopSeconds", "motion.stopSeconds", 0.0, 120.0),
"accel_seconds": v.number(motion, "accelSeconds", "motion.accelSeconds", 0.05, 60.0, -1.0),
}
# --- camera ---
var camera := v.object(raw, "camera", "camera", ["preset", "offset", "lookAtOffset", "fovDegrees", "endOffset", "endLookAtOffset", "transitionStartSeconds", "transitionEndSeconds"])
cfg.camera = {
"preset": v.choice(camera, "preset", "camera.preset", CAMERA_PRESETS),
"offset": v.vec3(camera, "offset", "camera.offset", 60.0),
"look_at_offset": v.vec3(camera, "lookAtOffset", "camera.lookAtOffset", 60.0),
"fov": v.number(camera, "fovDegrees", "camera.fovDegrees", 20.0, 100.0),
}
cfg.camera.end_offset = v.vec3(camera, "endOffset", "camera.endOffset", 60.0, cfg.camera.offset)
cfg.camera.end_look_at_offset = v.vec3(camera, "endLookAtOffset", "camera.endLookAtOffset", 60.0, cfg.camera.look_at_offset)
cfg.camera.transition_start = v.number(camera, "transitionStartSeconds", "camera.transitionStartSeconds", 0.0, 120.0, -1.0)
cfg.camera.transition_end = v.number(camera, "transitionEndSeconds", "camera.transitionEndSeconds", 0.0, 120.0, -1.0)
# --- overlay ---
var overlay := v.object(raw, "overlay", "overlay", ["startSeconds", "fadeSeconds", "title", "choiceA", "choiceB"])
cfg.overlay = {
"start": v.number(overlay, "startSeconds", "overlay.startSeconds", 0.0, 120.0),
"fade_seconds": v.number(overlay, "fadeSeconds", "overlay.fadeSeconds", 0.0, 2.0, 0.4),
"title": v.text(overlay, "title", "overlay.title", 1, 80),
"choice_a": v.text(overlay, "choiceA", "overlay.choiceA", 1, 48),
"choice_b": v.text(overlay, "choiceB", "overlay.choiceB", 1, 48),
}
# --- audio ---
var audio := v.object(raw, "audio", "audio", ["enabled", "file", "offsetSeconds"])
cfg.audio = {
"enabled": v.boolean(audio, "enabled", "audio.enabled"),
"file": v.optional_text(audio, "file", "audio.file", 260),
"offset": v.number(audio, "offsetSeconds", "audio.offsetSeconds", 0.0, 120.0, 0.0),
}
if v.ok():
_check_relations(cfg, v)
return {"ok": v.ok(), "errors": v.errors, "config": cfg if v.ok() else {}}
## Regras que envolvem mais de um campo. Só roda se os campos isolados passaram.
static func _check_relations(cfg: Dictionary, v: Validator) -> void:
var duration: float = cfg.video.duration
var m: Dictionary = cfg.motion
if not (m.start < m.brake_start and m.brake_start < m.stop and m.stop <= duration):
v.fail("motion", "exige startSeconds < brakeStartSeconds < stopSeconds <= durationSeconds (recebido %s < %s < %s <= %s)" % [m.start, m.brake_start, m.stop, duration])
return
var free_run: float = m.brake_start - m.start
if m.accel_seconds < 0.0:
m.accel_seconds = minf(1.5, free_run * 0.5)
elif m.accel_seconds > free_run:
v.fail("motion.accelSeconds", "precisa caber entre startSeconds e brakeStartSeconds (máx. %.2f s)" % free_run)
return
var w: Dictionary = cfg.world
var r: Dictionary = cfg.rider
if absf(r.start_position.x) > w.road_width * 0.5 - 0.5:
v.fail("rider.startPosition", "x precisa ficar dentro da pista (|x| <= %.1f)" % (w.road_width * 0.5 - 0.5))
if r.start_position.y < -0.5 or r.start_position.y > 5.0:
v.fail("rider.startPosition", "y precisa estar entre -0.5 e 5")
if r.start_position.z > 20.0:
v.fail("rider.startPosition", "z precisa ser <= 20 (a rua começa logo atrás da câmera)")
var end_z: float = r.start_position.z - r.travel
if end_z < -w.street_length + STREET_END_MARGIN:
v.fail("rider.travelMeters", "a moto pararia a menos de %d m do fim da rua (fim em z=%.1f, parada em z=%.1f); aumente streetLengthMeters ou reduza o percurso" % [int(STREET_END_MARGIN), -w.street_length, end_z])
var speed := cruise_speed(m, r.travel)
if speed > MAX_CRUISE_SPEED:
v.fail("rider.travelMeters", "percurso exige %.1f m/s de cruzeiro (máx. %.0f m/s); aumente o tempo de movimento ou reduza a distância" % [speed, MAX_CRUISE_SPEED])
var c: Dictionary = cfg.camera
for key in ["offset", "end_offset"]:
var off: Vector3 = c[key]
if r.start_position.y + off.y < MIN_CAMERA_HEIGHT:
v.fail("camera." + ("offset" if key == "offset" else "endOffset"), "câmera ficaria abaixo de %.1f m de altura" % MIN_CAMERA_HEIGHT)
if off.length() < 1.5:
v.fail("camera." + ("offset" if key == "offset" else "endOffset"), "câmera colada no personagem (distância < 1,5 m)")
if c.transition_start < 0.0:
c.transition_start = m.brake_start
if c.transition_end < 0.0:
c.transition_end = minf(duration, cfg.overlay.start + 0.6)
if not (c.transition_start < c.transition_end and c.transition_end <= duration):
v.fail("camera", "exige transitionStartSeconds < transitionEndSeconds <= durationSeconds")
if cfg.overlay.start >= duration:
v.fail("overlay.startSeconds", "precisa ser menor que durationSeconds")
var a: Dictionary = cfg.audio
if a.enabled and typeof(a.file) == TYPE_NIL:
v.fail("audio.file", "obrigatório quando audio.enabled = true")
if a.offset >= duration:
v.fail("audio.offsetSeconds", "precisa ser menor que durationSeconds")
## Velocidade de cruzeiro que faz o perfil (rampa suave, cruzeiro, frenagem
## suave) cobrir exatamente `travel` metros. Cada rampa suave anda metade do que
## andaria em velocidade plena no mesmo tempo.
static func cruise_speed(motion: Dictionary, travel: float) -> float:
var accel: float = motion.accel_seconds
var cruise: float = motion.brake_start - motion.start - accel
var brake: float = motion.stop - motion.brake_start
return travel / (accel * 0.5 + cruise + brake * 0.5)
static func _failure(errors: Array) -> Dictionary:
return {"ok": false, "errors": PackedStringArray(errors), "config": {}}
static func _is_number(value) -> bool:
return (typeof(value) == TYPE_FLOAT or typeof(value) == TYPE_INT) and is_finite(float(value))
## Acumula erros com o caminho do campo, para a mensagem final apontar o lugar exato.
class Validator:
var errors := PackedStringArray()
func ok() -> bool:
return errors.is_empty()
func fail(path: String, message: String) -> void:
errors.append("%s: %s" % [path, message] if path != "" else message)
func check_keys(obj: Dictionary, allowed: Array, path: String) -> void:
for key in obj.keys():
if not allowed.has(key):
fail(path + ("." if path != "" else "") + str(key), "campo desconhecido (permitidos: %s)" % ", ".join(PackedStringArray(allowed)))
func object(parent: Dictionary, key: String, path: String, allowed: Array) -> Dictionary:
var value = parent.get(key)
if typeof(value) != TYPE_DICTIONARY:
fail(path, "obrigatório e precisa ser um objeto")
return {}
check_keys(value, allowed, path)
return value
## `fallback` diferente de null torna o campo opcional.
func number(obj: Dictionary, key: String, path: String, min_value: float, max_value: float, fallback = null) -> float:
if not obj.has(key) or (typeof(obj[key]) == TYPE_NIL and typeof(fallback) != TYPE_NIL):
if typeof(fallback) == TYPE_NIL:
fail(path, "obrigatório")
return 0.0
return fallback
var value = obj[key]
if not _is_number(value):
fail(path, "precisa ser um número finito (recebido %s)" % _describe(value))
return 0.0
var f := float(value)
if f < min_value or f > max_value:
fail(path, "fora do intervalo [%s, %s] (recebido %s)" % [min_value, max_value, f])
return f
func integer(obj: Dictionary, key: String, path: String, min_value: int, max_value: int) -> int:
var f := number(obj, key, path, min_value, max_value)
if obj.has(key) and _is_number(obj[key]) and f != floorf(f):
fail(path, "precisa ser inteiro (recebido %s)" % f)
return int(f)
func boolean(obj: Dictionary, key: String, path: String) -> bool:
if typeof(obj.get(key)) != TYPE_BOOL:
fail(path, "obrigatório e precisa ser true ou false")
return false
return obj[key]
func text(obj: Dictionary, key: String, path: String, min_len: int, max_len: int) -> String:
var value = obj.get(key)
if typeof(value) != TYPE_STRING:
fail(path, "obrigatório e precisa ser texto")
return ""
return _check_text(value, path, min_len, max_len)
func optional_text(obj: Dictionary, key: String, path: String, max_len: int):
var value = obj.get(key)
if typeof(value) == TYPE_NIL:
return null
if typeof(value) != TYPE_STRING:
fail(path, "precisa ser texto ou null")
return null
if value.strip_edges() == "":
return null
return _check_text(value, path, 1, max_len)
func choice(obj: Dictionary, key: String, path: String, options: Array) -> String:
var value = obj.get(key)
if typeof(value) != TYPE_STRING or not options.has(value):
fail(path, "precisa ser um de: %s (recebido %s)" % [", ".join(PackedStringArray(options)), _describe(value)])
return options[0]
return value
func color(obj: Dictionary, key: String, path: String, fallback = null) -> Color:
var value = obj.get(key, fallback)
if typeof(value) == TYPE_NIL:
value = fallback
if typeof(value) != TYPE_STRING or not RegEx.create_from_string("^#[0-9A-Fa-f]{6}$").search(value):
fail(path, "precisa ser uma cor no formato #RRGGBB (recebido %s)" % _describe(value))
return Color.MAGENTA
return Color.html(value)
func vec3(obj: Dictionary, key: String, path: String, max_abs: float, fallback = null) -> Vector3:
if not obj.has(key) and typeof(fallback) != TYPE_NIL:
return fallback
var value = obj.get(key)
if typeof(value) != TYPE_ARRAY or value.size() != 3:
fail(path, "precisa ser uma lista [x, y, z] (recebido %s)" % _describe(value))
return Vector3.ZERO
for item in value:
if not _is_number(item) or absf(float(item)) > max_abs:
fail(path, "cada componente precisa ser número finito com |valor| <= %s" % max_abs)
return Vector3.ZERO
return Vector3(float(value[0]), float(value[1]), float(value[2]))
func _check_text(value: String, path: String, min_len: int, max_len: int) -> String:
var trimmed := value.strip_edges()
if trimmed.length() < min_len or trimmed.length() > max_len:
fail(path, "precisa ter entre %d e %d caracteres (tem %d)" % [min_len, max_len, trimmed.length()])
for i in trimmed.length():
if trimmed.unicode_at(i) < 32 or trimmed.unicode_at(i) == 127:
fail(path, "contém caractere de controle")
break
return trimmed
static func _is_number(value) -> bool:
return (typeof(value) == TYPE_FLOAT or typeof(value) == TYPE_INT) and is_finite(float(value))
func _describe(value) -> String:
if typeof(value) == TYPE_NIL:
return "nada"
var s := JSON.stringify(value)
return s if s.length() <= 40 else s.substr(0, 37) + "..."
+1
View File
@@ -0,0 +1 @@
uid://duthxk5m2w3tx
+126
View File
@@ -0,0 +1,126 @@
extends RefCounted
## Relógio da cena. Tudo que se move é função pura do tempo de cena `t` (s),
## nunca do relógio do sistema: avaliar o mesmo `t` com a mesma configuração
## devolve o mesmo estado, em qualquer execução.
##
## Perfil de velocidade (convenção da cena: a moto avança em -Z):
## parada -> rampa suave (accelSeconds) -> cruzeiro -> frenagem suave -> parada
## As rampas usam smoothstep na velocidade, então velocidade E aceleração são
## contínuas: não há tranco nem salto de posição entre as fases. A distância
## chega exatamente em travelMeters no instante stopSeconds e fica ali.
const SceneConfig := preload("res://scripts/core/scene_config.gd")
const CameraController := preload("res://scripts/view/camera_controller.gd")
const OverlayController := preload("res://scripts/view/overlay_controller.gd")
## Amplitude da vibração vertical da carroceria em velocidade de cruzeiro (m).
const BOB_AMPLITUDE := 0.006
## Frequência espacial da vibração (rad/m): depende da distância, não do tempo.
const BOB_SPATIAL_FREQUENCY := 7.0
## Mergulho de frente por m/s² de aceleração (rad), limitado a ±2°.
const PITCH_PER_ACCEL := 0.004
const MAX_PITCH := 0.035
var _cfg: Dictionary
var _wheel_radius: float
var _t_start: float
var _accel_len: float
var _t_cruise: float
var _t_brake: float
var _brake_len: float
var _t_stop: float
var _speed: float
var _travel: float
var _start_position: Vector3
var _distance_at_brake: float
func _init(cfg: Dictionary, wheel_radius: float) -> void:
_cfg = cfg
_wheel_radius = wheel_radius
var m: Dictionary = cfg.motion
_t_start = m.start
_accel_len = m.accel_seconds
_t_cruise = _t_start + _accel_len
_t_brake = m.brake_start
_t_stop = m.stop
_brake_len = _t_stop - _t_brake
_travel = cfg.rider.travel
_start_position = cfg.rider.start_position
_speed = SceneConfig.cruise_speed(m, _travel)
_distance_at_brake = _speed * (_accel_len * 0.5 + (_t_brake - _t_cruise))
func cruise_speed() -> float:
return _speed
func distance_at(t: float) -> float:
if t <= _t_start:
return 0.0
if t < _t_cruise:
return _speed * _accel_len * _ramp_integral((t - _t_start) / _accel_len)
if t < _t_brake:
return _speed * (_accel_len * 0.5 + (t - _t_cruise))
if t < _t_stop:
var u := t - _t_brake
return _distance_at_brake + _speed * (u - _brake_len * _ramp_integral(u / _brake_len))
return _travel
func speed_at(t: float) -> float:
if t <= _t_start or t >= _t_stop:
return 0.0
if t < _t_cruise:
return _speed * _smoothstep((t - _t_start) / _accel_len)
if t < _t_brake:
return _speed
return _speed * (1.0 - _smoothstep((t - _t_brake) / _brake_len))
func acceleration_at(t: float) -> float:
if t <= _t_start or t >= _t_stop:
return 0.0
if t < _t_cruise:
return _speed * _smoothstep_derivative((t - _t_start) / _accel_len) / _accel_len
if t < _t_brake:
return 0.0
return -_speed * _smoothstep_derivative((t - _t_brake) / _brake_len) / _brake_len
## Estado visual completo no instante `t`. É a única fonte que a cena consulta.
func evaluate_at_time(t: float) -> Dictionary:
var distance := distance_at(t)
var speed := speed_at(t)
var acceleration := acceleration_at(t)
var position := _start_position + Vector3(0.0, 0.0, -distance)
var speed_ratio := clampf(speed / _speed, 0.0, 1.0) if _speed > 0.0 else 0.0
return {
"t": t,
"distance": distance,
"speed": speed,
"acceleration": acceleration,
"rider_position": position,
# Rotação em torno de X. Negativa para o topo da roda ir para -Z (frente).
"wheel_angle": -distance / _wheel_radius,
"body_bob": BOB_AMPLITUDE * speed_ratio * sin(distance * BOB_SPATIAL_FREQUENCY),
"body_pitch": clampf(acceleration * PITCH_PER_ACCEL, -MAX_PITCH, MAX_PITCH),
"camera": CameraController.evaluate(_cfg, t, position),
"overlay": OverlayController.evaluate(_cfg, t),
}
static func _smoothstep(p: float) -> float:
p = clampf(p, 0.0, 1.0)
return p * p * (3.0 - 2.0 * p)
static func _smoothstep_derivative(p: float) -> float:
p = clampf(p, 0.0, 1.0)
return 6.0 * p * (1.0 - p)
## Integral de smoothstep de 0 a p (vale 0,5 em p = 1).
static func _ramp_integral(p: float) -> float:
p = clampf(p, 0.0, 1.0)
return p * p * p - 0.5 * p * p * p * p
@@ -0,0 +1 @@
uid://dditd5mb3m2te
+500
View File
@@ -0,0 +1,500 @@
extends Node2D
## Desenho das cenas 2D do documentário. `apply(t)` guarda o tempo e redesenha;
## tudo depende só de (configuração, t), então o render é determinístico.
## Medidas proporcionais ao tamanho da tela: a mesma composição em 540x960 e 1080x1920.
##
## Modelos:
## title { title, subtitle?, kicker? }
## counter { value, decimals?, prefix?, suffix?, label?, note?, grid?: { cols, rows, highlight } }
## map { preset?: "litoral-sp", title?, markers: [{ label, lat?, lon?, kind?: "city"|"island" }],
## route?: { from, to, label? } } (from/to = rótulo ou índice do marcador)
const BG := Color("#0d0d10")
const BG_2 := Color("#1a120c")
const ACCENT := Color("#ff7a1a")
const GLOW := Color("#ffb547")
const TEXT := Color("#f5f2ee")
const MUTED := Color("#b8b0a8")
const SEA := Color("#0b1e2b")
const SEA_2 := Color("#0f2a3a")
const LAND := Color("#1f3326")
const LAND_EDGE := Color("#4f7a5a")
## Litoral sul e centro de São Paulo (ilustrativo, sem escala exata): pontos da costa de
## sudoeste para nordeste e um pequeno dicionário de lugares (lat, lon).
const PRESETS := {
"litoral-sp": {
"bounds": {"north": -23.35, "south": -24.95, "west": -47.65, "east": -45.75},
"coast": [
[-24.95, -47.65], [-24.80, -47.62], [-24.70, -47.52], [-24.55, -47.28], [-24.42, -47.10],
[-24.32, -47.00], [-24.25, -46.90], [-24.18, -46.79], [-24.12, -46.68], [-24.09, -46.62],
[-24.03, -46.48], [-24.01, -46.41], [-23.98, -46.37], [-23.99, -46.30], [-24.00, -46.25],
[-23.93, -46.18], [-23.85, -46.14], [-23.80, -45.98], [-23.77, -45.85], [-23.80, -45.75],
],
"places": {
"São Paulo": [-23.55, -46.63], "Santos": [-23.96, -46.33], "Guarujá": [-23.99, -46.26],
"São Vicente": [-23.96, -46.39], "Praia Grande": [-24.00, -46.42], "Mongaguá": [-24.09, -46.62],
"Itanhaém": [-24.18, -46.79], "Peruíbe": [-24.32, -47.00], "Bertioga": [-23.85, -46.14],
"Ilha da Queimada Grande": [-24.487, -46.674], "Queimada Grande": [-24.487, -46.674],
"Ilha da Queimada Pequena": [-24.375, -46.795], "Queimada Pequena": [-24.375, -46.795],
},
},
}
var _cfg: Dictionary
var _p: Dictionary
var _size := Vector2.ZERO
var _t := 0.0
var _dur := 1.0
var _font: SystemFont
var _font_regular: SystemFont
var _map_cache := {}
var _glow_tex: GradientTexture2D
func setup(cfg: Dictionary, viewport_size: Vector2) -> void:
_cfg = cfg
_p = cfg.params
_size = viewport_size
_dur = maxf(float(cfg.video.duration), 0.1)
_font = _make_font(800)
_font_regular = _make_font(500)
RenderingServer.set_default_clear_color(BG)
var g := Gradient.new()
g.set_color(0, Color(1, 1, 1, 1))
g.set_color(1, Color(1, 1, 1, 0))
g.add_point(0.45, Color(1, 1, 1, 0.32))
_glow_tex = GradientTexture2D.new()
_glow_tex.gradient = g
_glow_tex.fill = GradientTexture2D.FILL_RADIAL
_glow_tex.fill_from = Vector2(0.5, 0.5)
_glow_tex.fill_to = Vector2(1.0, 0.5)
_glow_tex.width = 512
_glow_tex.height = 512
if cfg.template == "map":
_map_cache = _prepare_map()
func apply(t: float) -> void:
_t = t
queue_redraw()
## Resumo do estado no instante atual (para o manifesto ser comparável entre execuções).
func state_signature() -> String:
return "%s|%.3f" % [_cfg.template, _ease_out(_progress(0.0, 1.0))]
func _make_font(weight: int) -> SystemFont:
var f := SystemFont.new()
f.font_names = PackedStringArray(["Segoe UI", "Segoe UI Variable Display", "Arial", "DejaVu Sans", "Liberation Sans"])
f.font_weight = weight
f.antialiasing = TextServer.FONT_ANTIALIASING_GRAY
return f
func _draw() -> void:
if _cfg.is_empty():
return
match str(_cfg.template):
"title":
_draw_title()
"counter":
_draw_counter()
"map":
_draw_map()
# ---------------------------------------------------------------- utilidades
func _progress(start: float, length: float) -> float:
return clampf((_t - start) / maxf(length, 0.001), 0.0, 1.0)
static func _ease_in_out(p: float) -> float:
return p * p * (3.0 - 2.0 * p)
static func _ease_out(p: float) -> float:
return 1.0 - pow(1.0 - p, 3.0)
func _px(fraction: float) -> int:
return int(round(_size.y * fraction))
func _background(top: Color, bottom: Color) -> void:
var r := Rect2(Vector2.ZERO, _size)
draw_polygon(PackedVector2Array([r.position, Vector2(r.end.x, 0), r.end, Vector2(0, r.end.y)]),
PackedColorArray([top, top, bottom, bottom]))
func _glow(center: Vector2, radius: float, color: Color) -> void:
# Brilho suave: textura de degradê radial (sem anéis em degrau).
draw_texture_rect(_glow_tex, Rect2(center - Vector2(radius, radius), Vector2(radius, radius) * 2.0), false, Color(color.r, color.g, color.b, color.a * 0.45))
## Texto (quebra por palavra) com o topo em `top_y`, centralizado ou alinhado à esquerda
## (margem de (1 - width_fraction) / 2). Devolve a altura usada.
func _text_block(text: String, top_y: float, size_px: int, color: Color, font: Font, width_fraction := 0.84, max_lines := 4, align := HORIZONTAL_ALIGNMENT_CENTER) -> float:
if text.is_empty():
return 0.0
var width := _size.x * width_fraction
var left := (_size.x - width) / 2.0
var block := font.get_multiline_string_size(text, align, width, size_px, max_lines)
var ascent := font.get_ascent(size_px)
draw_multiline_string(font, Vector2(left, top_y + ascent), text, align, width, size_px, max_lines, color)
return block.y
func _with_alpha(c: Color, a: float) -> Color:
return Color(c.r, c.g, c.b, c.a * clampf(a, 0.0, 1.0))
## Número no formato brasileiro: 1.500 / 0,0055.
static func _format_number(value: float, decimals: int) -> String:
var negative := value < 0.0
var v := absf(value)
var int_part := int(floor(v))
var frac := ""
if decimals > 0:
var scaled := int(round((v - float(int_part)) * pow(10.0, decimals)))
if scaled >= int(pow(10.0, decimals)):
int_part += 1
scaled = 0
frac = "," + str(scaled).pad_zeros(decimals)
var digits := str(int_part)
var grouped := ""
var count := 0
for i in range(digits.length() - 1, -1, -1):
grouped = digits[i] + grouped
count += 1
if count % 3 == 0 and i > 0:
grouped = "." + grouped
return ("-" if negative else "") + grouped + frac
# ---------------------------------------------------------------- título
## Cores de destaque por variação ("gerar de novo"): brasa, ciano, violeta.
const VARIANT_ACCENTS := [Color("#ff7a1a"), Color("#3fc1c9"), Color("#a78bfa")]
func _variant() -> int:
return int(_p.get("variant", 0))
func _accent() -> Color:
return VARIANT_ACCENTS[_variant() % VARIANT_ACCENTS.size()]
func _draw_title() -> void:
match _variant() % 3:
1:
_draw_title_editorial()
2:
_draw_title_lower()
_:
_draw_title_center()
## Variação 1: editorial, alinhado à esquerda, barra vertical de destaque.
func _draw_title_editorial() -> void:
var accent := _accent()
_background(BG, BG_2)
_glow(Vector2(_size.x * 0.15, _size.y * 0.35), _size.x * 0.8, Color(accent.r, accent.g, accent.b, 0.5))
var appear := _ease_out(_progress(0.15, 0.7))
var bar := _ease_out(_progress(0.0, 0.7))
var x0 := _size.x * 0.08
var top := _size.y * 0.3
var y := top + (1.0 - appear) * _px(0.02)
var kicker := str(_p.get("kicker", ""))
if not kicker.is_empty():
y += _text_block(kicker.to_upper(), y, _px(0.022), _with_alpha(accent, appear), _font, 0.78, 1, HORIZONTAL_ALIGNMENT_LEFT) + _px(0.02)
var h := _text_block(str(_p.get("title", "")), y, _px(0.066), _with_alpha(TEXT, appear), _font, 0.78, 5, HORIZONTAL_ALIGNMENT_LEFT)
draw_rect(Rect2(Vector2(x0, top), Vector2(_px(0.007), (y - top + h) * bar)), accent)
var sub_appear := _ease_out(_progress(0.55, 0.7))
_text_block(str(_p.get("subtitle", "")), y + h + _px(0.03), _px(0.03), _with_alpha(MUTED, sub_appear), _font_regular, 0.78, 3, HORIZONTAL_ALIGNMENT_LEFT)
## Variação 2: texto grande na parte de baixo-centro, sublinhado que corre, brilho embaixo.
func _draw_title_lower() -> void:
var accent := _accent()
_background(BG_2, BG)
_glow(Vector2(_size.x * 0.5, _size.y * 0.62), _size.x * 0.9 * (1.0 + 0.05 * sin(_t * 1.1)), Color(accent.r, accent.g, accent.b, 0.55))
var appear := _ease_out(_progress(0.1, 0.8))
var y := _size.y * 0.44 + (1.0 - appear) * _px(0.04)
var kicker := str(_p.get("kicker", ""))
if not kicker.is_empty():
y += _text_block(kicker.to_upper(), y, _px(0.022), _with_alpha(accent, appear), _font, 0.8, 1) + _px(0.02)
y += _text_block(str(_p.get("title", "")), y, _px(0.07), _with_alpha(TEXT, appear), _font, 0.88, 4) + _px(0.02)
var line := _ease_out(_progress(0.5, 0.8))
draw_rect(Rect2(Vector2(_size.x * 0.5 - _size.x * 0.25 * line, y), Vector2(_size.x * 0.5 * line, _px(0.005))), accent)
var sub_appear := _ease_out(_progress(0.7, 0.7))
_text_block(str(_p.get("subtitle", "")), y + _px(0.03), _px(0.03), _with_alpha(MUTED, sub_appear), _font_regular, 0.8, 3)
## Variação 0: centralizado, barra que cresce do centro.
func _draw_title_center() -> void:
_background(BG, BG_2)
var breathe := 1.0 + 0.04 * sin(_t * 1.3)
_glow(Vector2(_size.x * 0.5, _size.y * 0.42), _size.x * 0.75 * breathe, Color(ACCENT.r, ACCENT.g, ACCENT.b, 0.55))
var appear := _ease_out(_progress(0.15, 0.7))
var slide := (1.0 - appear) * _size.y * 0.03
var y := _size.y * 0.36 + slide
var kicker := str(_p.get("kicker", ""))
if not kicker.is_empty():
y += _text_block(kicker.to_upper(), y, _px(0.022), _with_alpha(GLOW, appear), _font, 0.8, 1) + _px(0.02)
# Barra de destaque que cresce do centro.
var bar := _ease_out(_progress(0.0, 0.6))
var bar_w := _size.x * 0.36 * bar
draw_rect(Rect2(Vector2((_size.x - bar_w) / 2.0, y), Vector2(bar_w, _px(0.006))), ACCENT)
y += _px(0.035)
y += _text_block(str(_p.get("title", "")), y, _px(0.058), _with_alpha(TEXT, appear), _font, 0.84, 4) + _px(0.025)
var sub_appear := _ease_out(_progress(0.55, 0.7))
_text_block(str(_p.get("subtitle", "")), y + (1.0 - sub_appear) * _px(0.015), _px(0.03), _with_alpha(MUTED, sub_appear), _font_regular, 0.8, 3)
# ---------------------------------------------------------------- contador / infográfico
func _draw_counter() -> void:
var accent := _accent()
_background(BG, BG_2)
_glow(Vector2(_size.x * 0.5, _size.y * 0.33), _size.x * 0.6, Color(accent.r, accent.g, accent.b, 0.5))
var value := float(_p.get("value", 0))
var decimals := int(_p.get("decimals", 0))
var count_len := clampf(_dur * 0.45, 0.8, 2.4)
var shown := value * _ease_out(_progress(0.2, count_len))
var number := str(_p.get("prefix", "")) + _format_number(shown, decimals) + str(_p.get("suffix", ""))
var pop := _ease_out(_progress(0.0, 0.5))
var grid_mode := typeof(_p.get("grid")) == TYPE_DICTIONARY
# Anel que fecha enquanto o número conta (sem grade: o anel é o elemento visual do infográfico).
var ring_center := Vector2(_size.x * 0.5, _size.y * (0.27 if grid_mode else 0.36))
var ring_r := _size.x * (0.27 if grid_mode else 0.33)
var fill := _ease_out(_progress(0.2, count_len))
draw_arc(ring_center, ring_r, 0.0, TAU, 128, Color(1, 1, 1, 0.07 * pop), _px(0.012), true)
draw_arc(ring_center, ring_r, -PI / 2.0, -PI / 2.0 + TAU * fill, 128, _with_alpha(accent, pop), _px(0.012), true)
if fill > 0.0:
var tip := ring_center + Vector2(cos(-PI / 2.0 + TAU * fill), sin(-PI / 2.0 + TAU * fill)) * ring_r
draw_circle(tip, _px(0.011), _with_alpha(accent.lightened(0.35), pop))
var size_px := int(_px(0.12 if number.length() <= 4 else 0.095) * (0.85 + 0.15 * pop))
var number_h := _font.get_multiline_string_size(number, HORIZONTAL_ALIGNMENT_CENTER, _size.x * 0.6, size_px, 1).y
var kicker := str(_p.get("kicker", ""))
if not kicker.is_empty():
_text_block(kicker, ring_center.y - number_h * 0.5 - _px(0.04), _px(0.028), _with_alpha(MUTED, pop), _font_regular, 0.5, 1)
_text_block(number, ring_center.y - number_h * 0.5, size_px, _with_alpha(accent.lightened(0.3), pop), _font, 0.6, 1)
var label_appear := _ease_out(_progress(0.35, 0.6))
var y := ring_center.y + ring_r + _px(0.035)
y += _text_block(str(_p.get("label", "")), y, _px(0.036), _with_alpha(TEXT, label_appear), _font, 0.84, 2) + _px(0.03)
var grid = _p.get("grid")
if typeof(grid) == TYPE_DICTIONARY:
_draw_grid(grid, y)
else:
var note_appear := _ease_out(_progress(0.9, 0.7))
_text_block(str(_p.get("note", "")), y + _px(0.02), _px(0.028), _with_alpha(MUTED, note_appear), _font_regular, 0.8, 4)
func _draw_grid(grid: Dictionary, top: float) -> void:
var cols := clampi(int(grid.get("cols", 10)), 1, 30)
var rows := clampi(int(grid.get("rows", 10)), 1, 30)
var highlight := clampi(int(grid.get("highlight", 1)), 0, cols * rows)
var area_w := _size.x * 0.72
var area_h := _size.y * 0.86 - top
var cell := minf(area_w / cols, area_h / rows)
var origin := Vector2((_size.x - cell * cols) / 2.0, top)
var total := cols * rows
var fill_len := clampf(_dur * 0.3, 0.6, 1.8)
for i in total:
var col := i % cols
var row := i / cols
# Células aparecem em onda (diagonal); as destacadas acendem depois.
var appear := _ease_out(_progress(0.6 + float(col + row) / float(cols + rows) * fill_len, 0.3))
if appear <= 0.0:
continue
var r := Rect2(origin + Vector2(col * cell, row * cell), Vector2(cell, cell)).grow(-cell * 0.12)
var is_hl := i < highlight
var lit := _ease_out(_progress(0.6 + fill_len + 0.2 + float(i) * 0.04, 0.35)) if is_hl else 0.0
var base := Color(1, 1, 1, 0.10 * appear)
draw_rect(r, base.lerp(Color(ACCENT.r, ACCENT.g, ACCENT.b, appear), lit))
var note_appear := _ease_out(_progress(0.6 + fill_len + 0.6, 0.6))
_text_block(str(_p.get("note", "")), origin.y + cell * rows + _px(0.02), _px(0.026), _with_alpha(MUTED, note_appear), _font_regular, 0.84, 3)
# ---------------------------------------------------------------- mapa
func _prepare_map() -> Dictionary:
var preset: Dictionary = PRESETS.get(str(_p.get("preset", "litoral-sp")), PRESETS["litoral-sp"])
var places: Dictionary = preset.places
# 1) Lugares citados (lat/lon dados ou do dicionário do preset).
var resolved := []
for m in _p.get("markers", []):
if typeof(m) != TYPE_DICTIONARY:
continue
var label := str(m.get("label", ""))
var lat = m.get("lat")
var lon = m.get("lon")
if (lat == null or lon == null) and places.has(label):
lat = places[label][0]
lon = places[label][1]
if lat == null or lon == null:
continue
var lower := label.to_lower()
var kind := str(m.get("kind", "island" if lower.contains("ilha") or lower.contains("queimada") else "city"))
resolved.append({"label": label, "lat": float(lat), "lon": float(lon), "kind": kind})
# 2) Enquadramento: em volta dos lugares citados (com folga), ou o preset inteiro.
var b: Dictionary = preset.bounds.duplicate()
if not resolved.is_empty():
var n := -90.0
var s_ := 90.0
var w := 180.0
var e := -180.0
for m in resolved:
n = maxf(n, m.lat)
s_ = minf(s_, m.lat)
w = minf(w, m.lon)
e = maxf(e, m.lon)
var pad_lat := maxf((n - s_) * 0.7, 0.22)
var pad_lon := maxf((e - w) * 0.7, 0.22)
b = {"north": n + pad_lat, "south": s_ - pad_lat, "west": w - pad_lon, "east": e + pad_lon}
var area := Rect2(Vector2(_size.x * 0.06, _size.y * 0.2), Vector2(_size.x * 0.88, _size.y * 0.62))
var mid_lat := deg_to_rad((float(b.north) + float(b.south)) / 2.0)
var span_x := (float(b.east) - float(b.west)) * cos(mid_lat)
var span_y := float(b.north) - float(b.south)
var scale := minf(area.size.x / span_x, area.size.y / span_y)
var offset := area.position + (area.size - Vector2(span_x, span_y) * scale) / 2.0
var project := func(lat: float, lon: float) -> Vector2:
return offset + Vector2((lon - float(b.west)) * cos(mid_lat), float(b.north) - lat) * scale
var coast := PackedVector2Array()
for pt in preset.coast:
coast.append(project.call(float(pt[0]), float(pt[1])))
# Terra = costa + cantos do norte (a costa paulista corre de sudoeste para nordeste).
var pb: Dictionary = preset.bounds
var land := coast.duplicate()
# Cantos bem além da tela: no começo do voo o mapa aparece aberto (zoom 0,45).
land.append(project.call(float(pb.south) - 1.0, float(pb.east) + 8.0))
land.append(project.call(float(pb.north) + 8.0, float(pb.east) + 8.0))
land.append(project.call(float(pb.north) + 8.0, float(pb.west) - 8.0))
land.append(project.call(float(pb.south) - 8.0, float(pb.west) - 8.0))
var markers := []
for m in resolved:
markers.append({"label": m.label, "pos": project.call(m.lat, m.lon), "lat": m.lat, "lon": m.lon, "kind": m.kind})
var route := {}
var r = _p.get("route")
if typeof(r) == TYPE_DICTIONARY and markers.size() >= 2:
var a := _find_marker(markers, r.get("from", 0))
var z := _find_marker(markers, r.get("to", 1))
if a >= 0 and z >= 0 and a != z:
var label := str(r.get("label", ""))
if label.is_empty():
label = "%d km" % int(round(_haversine_km(markers[a].lat, markers[a].lon, markers[z].lat, markers[z].lon)))
route = {"a": markers[a].pos, "b": markers[z].pos, "label": label}
var focus: Vector2 = area.get_center()
if not route.is_empty():
focus = (route.a + route.b) / 2.0
return {"coast": coast, "land": land, "markers": markers, "route": route, "focus": focus}
static func _find_marker(markers: Array, key) -> int:
if typeof(key) in [TYPE_INT, TYPE_FLOAT]:
var i := int(key)
return i if i >= 0 and i < markers.size() else -1
for i in markers.size():
if markers[i].label == str(key):
return i
return -1
static func _haversine_km(lat1: float, lon1: float, lat2: float, lon2: float) -> float:
var d_lat := deg_to_rad(lat2 - lat1)
var d_lon := deg_to_rad(lon2 - lon1)
var a := sin(d_lat / 2.0) ** 2 + cos(deg_to_rad(lat1)) * cos(deg_to_rad(lat2)) * sin(d_lon / 2.0) ** 2
return 6371.0 * 2.0 * atan2(sqrt(a), sqrt(1.0 - a))
func _draw_map() -> void:
_background(SEA_2, SEA)
var m := _map_cache
# Voo: começa aberto (litoral inteiro) e desce até a rota; depois aproxima devagar.
var focus: Vector2 = m.focus
var center := _size / 2.0
var intro := _ease_in_out(_progress(0.0, minf(1.6, _dur * 0.35)))
var start_zoom := 0.45 if _variant() % 2 == 0 else 0.62
var zoom := lerpf(start_zoom, 1.0, intro) + 0.1 * _ease_out(_progress(1.6, maxf(_dur - 1.6, 0.1)))
var pivot := center.lerp(focus, intro)
var shift := (center - focus) * 0.3 * intro
draw_set_transform(pivot - pivot * zoom + shift, 0.0, Vector2(zoom, zoom))
# Ondas do mar: linhas horizontais suaves que deslizam.
for i in 18:
var y := _size.y * (0.05 + float(i) * 0.055) + fmod(_t * 6.0, _size.y * 0.055)
draw_line(Vector2(0, y), Vector2(_size.x, y), Color(1, 1, 1, 0.025), 2.0)
var land_alpha := _ease_out(_progress(0.0, 0.6))
draw_colored_polygon(m.land, _with_alpha(LAND, land_alpha))
draw_polyline(m.coast, _with_alpha(LAND_EDGE, land_alpha), maxf(2.0, _size.y * 0.002), true)
var route: Dictionary = m.route
if not route.is_empty():
# A linha só começa quando o voo termina (1,5 s).
var route_len := clampf(_dur * 0.3, 0.8, 2.0)
var p := _ease_out(_progress(1.5, route_len))
var a: Vector2 = route.a
var b: Vector2 = route.b
var end := a.lerp(b, p)
# Linha tracejada que se desenha de A até B.
var dash := _size.y * 0.012
var length := a.distance_to(end)
var dir := (b - a).normalized()
var s := 0.0
while s < length:
draw_line(a + dir * s, a + dir * minf(s + dash, length), GLOW, maxf(3.0, _size.y * 0.003), true)
s += dash * 1.8
if p >= 1.0:
var lp := _ease_out(_progress(1.5 + route_len, 0.5))
# Pulso no destino: anéis que crescem e somem, a cada 1,2 s.
for k in 2:
var phase := fmod(maxf(_t - 1.5 - route_len, 0.0) + float(k) * 0.6, 1.2) / 1.2
draw_arc(b, _size.y * (0.012 + 0.04 * phase), 0.0, TAU, 48, Color(GLOW.r, GLOW.g, GLOW.b, 0.8 * (1.0 - phase) * lp), maxf(2.0, _size.y * 0.002), true)
var label := str(route.label)
var fs := _px(0.03)
var tw := _font.get_string_size(label, HORIZONTAL_ALIGNMENT_LEFT, -1, fs).x
# Ao lado da linha (perpendicular, para a direita), longe dos pontos.
var normal := Vector2(-dir.y, dir.x)
if normal.x < 0.0:
normal = -normal
var mid := (a + b) / 2.0 + normal * fs * 2.2
var box := Rect2(mid - Vector2(0, fs * 0.7), Vector2(tw + fs, fs * 1.4))
draw_rect(box, _with_alpha(Color(0, 0, 0, 0.7), lp))
draw_string(_font, box.position + Vector2(fs * 0.5, fs * 1.0), label, HORIZONTAL_ALIGNMENT_LEFT, -1, fs, _with_alpha(GLOW, lp))
var markers: Array = m.markers
for i in markers.size():
var mk: Dictionary = markers[i]
var pop := _ease_out(_progress(0.4 + float(i) * 0.25, 0.4))
if pop <= 0.0:
continue
var pos: Vector2 = mk.pos
var fs := _px(0.026)
if mk.kind == "island":
var r := _size.y * 0.012 * pop
draw_colored_polygon(PackedVector2Array([pos + Vector2(-r * 1.4, 0), pos + Vector2(-r * 0.6, -r), pos + Vector2(r * 0.8, -r * 0.8),
pos + Vector2(r * 1.5, r * 0.1), pos + Vector2(r * 0.5, r * 0.9), pos + Vector2(-r * 0.9, r * 0.7)]), Color(LAND_EDGE, pop))
draw_circle(pos, r * 2.6, Color(GLOW.r, GLOW.g, GLOW.b, 0.18 * pop))
else:
draw_circle(pos, _size.y * 0.007 * pop, Color(TEXT, pop))
draw_circle(pos, _size.y * 0.004 * pop, Color(ACCENT, pop))
var tw := _font.get_string_size(mk.label, HORIZONTAL_ALIGNMENT_LEFT, -1, fs).x
var right_side := pos.x + tw + fs < _size.x * 0.95
var text_pos := pos + (Vector2(fs * 0.8, fs * 0.35) if right_side else Vector2(-tw - fs * 0.8, fs * 0.35))
if mk.kind == "island":
# Ilha: nome centralizado embaixo (no mar), sem cruzar a costa.
text_pos = pos + Vector2(-tw / 2.0, _size.y * 0.035 + fs * 0.6)
text_pos.x = clampf(text_pos.x, _size.x * 0.03, _size.x * 0.97 - tw)
draw_string(_font, text_pos + Vector2(2, 2), mk.label, HORIZONTAL_ALIGNMENT_LEFT, -1, fs, Color(0, 0, 0, 0.6 * pop))
draw_string(_font, text_pos, mk.label, HORIZONTAL_ALIGNMENT_LEFT, -1, fs, Color(TEXT, pop))
draw_set_transform(Vector2.ZERO, 0.0, Vector2.ONE)
# Título no alto e aviso de mapa ilustrativo (fora do zoom).
var title := str(_p.get("title", ""))
if not title.is_empty():
_text_block(title, _size.y * 0.07, _px(0.04), Color(TEXT, _ease_out(_progress(0.1, 0.6))), _font, 0.86, 2)
draw_string(_font_regular, Vector2(_size.x * 0.05, _size.y * 0.965), "Mapa ilustrativo", HORIZONTAL_ALIGNMENT_LEFT, -1, _px(0.016), Color(1, 1, 1, 0.45))
+84
View File
@@ -0,0 +1,84 @@
extends RefCounted
## Contrato das cenas do documentário:
## { "id": "...", "kind": "doc2d" | "doc3d",
## "video": { "width": 1080, "height": 1920, "fps": 30, "durationSeconds": 6.2 },
## "template": <modelo do tipo>, "params": { ... } }
## doc2d (motion graphics, doc2d_canvas.gd): "title" | "counter" | "map"
## doc3d (cena 3D da biblioteca): o nome de uma pasta em godot/library/ ("island", ...)
## A duração vem do áudio do trecho: a cena dura exatamente o que a narração dura.
## params.variant (inteiro, opcional): variação de layout/câmera para "gerar de novo".
const TEMPLATES_2D := ["title", "counter", "map"]
const LIBRARY_DIR := "res://library"
## Script da cena 3D da biblioteca: res://library/<id>/template.gd.
static func library_script(id: String) -> String:
return "%s/%s/template.gd" % [LIBRARY_DIR, id]
## Cenas 3D disponíveis (pastas da biblioteca com template.gd).
static func library_templates() -> Array:
var out := []
var dir := DirAccess.open(LIBRARY_DIR)
if dir == null:
return out
for name in dir.get_directories():
if ResourceLoader.exists(library_script(name)):
out.append(name)
return out
static func load_file(path: String) -> Dictionary:
if not FileAccess.file_exists(path):
return {"ok": false, "errors": ["arquivo não encontrado: %s" % path]}
var parsed = JSON.parse_string(FileAccess.get_file_as_string(path))
if typeof(parsed) != TYPE_DICTIONARY:
return {"ok": false, "errors": ["JSON inválido ou não é objeto"]}
return validate(parsed)
static func validate(raw: Dictionary) -> Dictionary:
var errors := []
if typeof(raw.get("id")) != TYPE_STRING or str(raw.id).is_empty():
errors.append("id: texto obrigatório")
var kind := str(raw.get("kind", ""))
if not (kind in ["doc2d", "doc3d"]):
errors.append("kind: \"doc2d\" ou \"doc3d\"")
var video = raw.get("video")
if typeof(video) != TYPE_DICTIONARY:
errors.append("video: objeto obrigatório")
return {"ok": false, "errors": errors}
for key in ["width", "height", "fps", "durationSeconds"]:
if not (typeof(video.get(key)) in [TYPE_INT, TYPE_FLOAT]) or float(video.get(key)) <= 0.0:
errors.append("video.%s: número positivo obrigatório" % key)
if errors.is_empty():
if float(video.durationSeconds) > 120.0:
errors.append("video.durationSeconds: máximo 120 s por cena")
if int(video.fps) < 1 or int(video.fps) > 60:
errors.append("video.fps: entre 1 e 60")
var template = raw.get("template")
if kind == "doc2d" and not (template in TEMPLATES_2D):
errors.append("template: um de %s para doc2d" % [TEMPLATES_2D])
if kind == "doc3d" and not (typeof(template) == TYPE_STRING and ResourceLoader.exists(library_script(template))):
errors.append("template: cena 3D \"%s\" não existe na biblioteca (godot/library/). Disponíveis: %s" % [template, library_templates()])
var params = raw.get("params", {})
if typeof(params) != TYPE_DICTIONARY:
errors.append("params: objeto")
elif template == "counter" and not (typeof(params.get("value")) in [TYPE_INT, TYPE_FLOAT]):
errors.append("params.value: número obrigatório no modelo counter")
elif template == "title" and str(params.get("title", "")).strip_edges().is_empty():
errors.append("params.title: texto obrigatório no modelo title")
elif template == "map" and typeof(params.get("markers", [])) != TYPE_ARRAY:
errors.append("params.markers: lista")
if not errors.is_empty():
return {"ok": false, "errors": errors}
var cfg := raw.duplicate(true)
cfg.video.fps = int(video.fps)
cfg.video.width = int(video.width)
cfg.video.height = int(video.height)
cfg.video.duration = float(video.durationSeconds)
cfg.video.total_frames = int(round(float(video.durationSeconds) * float(video.fps)))
if not cfg.has("params"):
cfg.params = {}
return {"ok": true, "config": cfg}
+196
View File
@@ -0,0 +1,196 @@
extends Node
## Cenas do documentário: 2D (motion graphics: mapa, contador, título; doc2d_canvas.gd) e
## 3D (cenas da BIBLIOTECA: res://library/<template>/template.gd), escolhidas pelo "kind" do JSON.
## Cena 3D nova = pasta nova em godot/library/ (veja doc/godot/cenas.md); nada aqui muda.
## Mesmo protocolo do main.gd (rua 3D), para o lançador tratar as duas igual:
## --config <json> | --validate-only | --manifest <json> | --warmup-frames <n>
## Render (Movie Maker): t = quadro / fps, quadros de aquecimento em t=0 e um
## manifesto com quadros produzidos e um resumo determinístico do estado.
const DocConfig := preload("res://scripts/doc/doc_config.gd")
const Doc2DCanvas := preload("res://scripts/doc/doc2d_canvas.gd")
const EXIT_INVALID_CONFIG := 2
const EXIT_ENVIRONMENT := 3
const EXIT_MANIFEST := 4
const DEFAULT_WARMUP_FRAMES := 3
const MAX_WARMUP_FRAMES := 30
var _cfg: Dictionary
## Doc2DCanvas (Node2D) ou a cena 3D da biblioteca (Node3D): setup(cfg, tamanho), apply(t) e state_signature().
var _canvas: Node
var _render_mode := false
var _frame := 0
var _warmup_frames := DEFAULT_WARMUP_FRAMES
var _warmup_done := 0
var _total_frames := 0
var _fps := 30
var _preview_time := 0.0
var _manifest_path := ""
var _config_path := ""
var _state_lines := PackedStringArray()
var _started_msec := 0
var _halted := false
func _ready() -> void:
_started_msec = Time.get_ticks_msec()
var args := _parse_user_args(OS.get_cmdline_user_args())
if not args.has("config"):
printerr("ARGS_INVALID --config é obrigatório na cena do documentário")
_halt(EXIT_INVALID_CONFIG)
return
_config_path = _resolve_path(str(args.config))
_render_mode = Engine.get_write_movie_path() != ""
_manifest_path = _resolve_path(str(args.manifest)) if args.has("manifest") else ""
if args.has("warmup-frames"):
var value := str(args["warmup-frames"])
if not value.is_valid_int() or int(value) < 0 or int(value) > MAX_WARMUP_FRAMES:
printerr("ARGS_INVALID --warmup-frames precisa ser inteiro entre 0 e %d" % MAX_WARMUP_FRAMES)
_halt(EXIT_INVALID_CONFIG)
return
_warmup_frames = int(value)
var result := DocConfig.load_file(_config_path)
if not result.ok:
printerr("CONFIG_INVALID %s" % _config_path)
for e in result.errors:
printerr(" - " + str(e))
_halt(EXIT_INVALID_CONFIG)
return
_cfg = result.config
# Cena 3D da biblioteca: o script precisa compilar. Erro aqui reprova JÁ (na validação),
# em vez de virar um laço infinito de quadros com "apply em Nil".
var scene_script: GDScript = null
if _cfg.kind == "doc3d":
scene_script = load(DocConfig.library_script(_cfg.template)) as GDScript
if scene_script == null or not scene_script.can_instantiate():
printerr("SCENE_SCRIPT_INVALID %s: o template.gd não compila (veja os erros de GDScript acima)" % DocConfig.library_script(_cfg.template))
_halt(EXIT_INVALID_CONFIG)
return
if args.has("validate-only"):
print("CONFIG_OK %s (%s, %d quadros, modelo %s)" % [_cfg.id, _config_path, _cfg.video.total_frames, _cfg.template])
_halt(0)
return
_fps = _cfg.video.fps
_total_frames = _cfg.video.total_frames
var viewport_size := get_viewport().get_visible_rect().size
if _render_mode:
var movie_dir := Engine.get_write_movie_path().get_base_dir()
if movie_dir.is_relative_path():
movie_dir = ProjectSettings.globalize_path("res://").path_join(movie_dir)
if not DirAccess.dir_exists_absolute(movie_dir):
printerr("RENDER_ENVIRONMENT pasta de saída do Movie Maker não existe: %s" % movie_dir)
_halt(EXIT_ENVIRONMENT)
return
var expected := Vector2(_cfg.video.width, _cfg.video.height)
if viewport_size != expected:
printerr("RENDER_ENVIRONMENT viewport %s difere da configuração %s (use o lançador, que gera override.cfg)" % [viewport_size, expected])
_halt(EXIT_ENVIRONMENT)
return
if _cfg.kind == "doc3d":
_canvas = scene_script.new()
else:
_canvas = Doc2DCanvas.new()
if _canvas == null or not _canvas.has_method("apply") or not _canvas.has_method("setup"):
printerr("SCENE_SCRIPT_INVALID a cena não tem setup(cfg, tamanho) e apply(t)")
_halt(EXIT_INVALID_CONFIG)
return
_canvas.name = "Canvas"
add_child(_canvas)
_canvas.setup(_cfg, viewport_size)
_canvas.apply(0.0)
print("SCENE_READY id=%s mode=%s frames=%d fps=%d viewport=%dx%d template=%s" % [
_cfg.id, "render" if _render_mode else "preview", _total_frames, _fps,
int(viewport_size.x), int(viewport_size.y), _cfg.template])
func _process(delta: float) -> void:
if _cfg.is_empty() or _halted:
return
if not _render_mode:
_preview_time = fmod(_preview_time + delta, maxf(_cfg.video.duration, 0.001))
_canvas.apply(_preview_time)
return
if _warmup_done < _warmup_frames:
_canvas.apply(0.0)
_warmup_done += 1
return
var t := float(_frame) / float(_fps)
_canvas.apply(t)
_state_lines.append("%.4f|%s" % [t, _canvas.state_signature()])
_frame += 1
if _frame >= _total_frames:
_finish_render()
func _finish_render() -> void:
var size := get_viewport().get_visible_rect().size
var manifest := {
"configId": _cfg.id,
"configPath": _config_path,
"kind": _cfg.kind,
"template": _cfg.template,
"fps": _fps,
"durationSeconds": _cfg.video.duration,
"framesRendered": _frame,
"expectedFrames": _total_frames,
"warmupFrames": _warmup_frames,
"firstSceneFrameIndex": _warmup_frames,
"pngFramesWritten": _warmup_frames + _frame,
"viewport": [int(size.x), int(size.y)],
"renderer": {
"method": RenderingServer.get_current_rendering_method(),
"driver": RenderingServer.get_current_rendering_driver_name(),
"adapter": RenderingServer.get_video_adapter_name(),
"vendor": RenderingServer.get_video_adapter_vendor(),
},
"godotVersion": Engine.get_version_info().string,
"scene": {"template": _cfg.template},
"stateDigest": "\n".join(_state_lines).md5_text(),
"wallClockSeconds": (Time.get_ticks_msec() - _started_msec) / 1000.0,
}
if _manifest_path != "":
DirAccess.make_dir_recursive_absolute(_manifest_path.get_base_dir())
var file := FileAccess.open(_manifest_path, FileAccess.WRITE)
if file == null:
printerr("MANIFEST_WRITE_FAILED %s (erro %d)" % [_manifest_path, FileAccess.get_open_error()])
get_tree().quit(EXIT_MANIFEST)
return
file.store_string(JSON.stringify(manifest, " "))
file.close()
print("RENDER_DONE frames=%d warmup=%d fps=%d digest=%s" % [_frame, _warmup_frames, _fps, manifest.stateDigest])
get_tree().quit(0)
func _halt(code: int) -> void:
_halted = true
get_tree().quit(code)
func _parse_user_args(raw: PackedStringArray) -> Dictionary:
var out := {}
var i := 0
while i < raw.size():
var arg := raw[i]
if arg.begins_with("--"):
var key := arg.substr(2)
if key.contains("="):
out[key.get_slice("=", 0)] = key.substr(key.find("=") + 1)
elif i + 1 < raw.size() and not raw[i + 1].begins_with("--"):
out[key] = raw[i + 1]
i += 1
else:
out[key] = true
i += 1
return out
static func _resolve_path(path: String) -> String:
var p := path.replace("\\", "/")
if p.is_absolute_path():
return p.simplify_path()
var root := ProjectSettings.globalize_path("res://").trim_suffix("/").get_base_dir()
return root.path_join(p).simplify_path()
+38
View File
@@ -0,0 +1,38 @@
extends RefCounted
## Enquadramento por tempo. Preset único nesta prova: "third_person_follow".
##
## A câmera fica em `posição da moto + offset` (espaço do mundo; a moto anda em
## -Z, então +Z é "atrás") e olha para `posição da moto + lookAtOffset`. Entre
## transitionStartSeconds e transitionEndSeconds os dois offsets migram, com
## curva suave, para endOffset/endLookAtOffset: é a mudança de enquadramento que
## abre espaço para o texto final. O FOV é vertical (padrão da Camera3D).
##
## A câmera segue a posição-base da moto, sem a vibração da carroceria, para o
## quadro ficar estável.
const MIN_HEIGHT := 0.5
static func evaluate(cfg: Dictionary, t: float, rider_position: Vector3) -> Dictionary:
var c: Dictionary = cfg.camera
var k := _smootherstep(inverse_lerp(c.transition_start, c.transition_end, t))
var offset: Vector3 = c.offset.lerp(c.end_offset, k)
var look_offset: Vector3 = c.look_at_offset.lerp(c.end_look_at_offset, k)
var position := rider_position + offset
position.y = maxf(position.y, MIN_HEIGHT)
return {
"position": position,
"look_at": rider_position + look_offset,
"fov": c.fov,
"blend": k,
}
static func apply(camera: Camera3D, state: Dictionary) -> void:
camera.fov = state.fov
camera.look_at_from_position(state.position, state.look_at, Vector3.UP)
static func _smootherstep(p: float) -> float:
p = clampf(p, 0.0, 1.0)
return p * p * p * (p * (p * 6.0 - 15.0) + 10.0)
@@ -0,0 +1 @@
uid://cabudpjh3vqjs
+144
View File
@@ -0,0 +1,144 @@
extends CanvasLayer
## Textos finais: chamada + duas opções visuais (sem votação real).
##
## `evaluate` é pura (depende só de t e da configuração); `apply` só copia o
## resultado para os nós. As medidas são proporcionais à altura do viewport,
## então a composição é a mesma em 540x960 e 1080x1920.
##
## Composição vertical (fração da altura):
## título até 0.665 (cresce para cima se quebrar linha) | opção A 0.675 |
## opção B 0.757 | 0.825..1.0 livre para a interface da plataforma.
## Margens laterais de 9% da largura.
const STAGGER_SECONDS := 0.22
const SLIDE_FRACTION := 0.025
const TITLE_BOTTOM_Y := 0.665
const TITLE_BOX_HEIGHT := 0.15
const CHOICE_A_Y := 0.675
const CHOICE_B_Y := 0.757
const CHOICE_HEIGHT := 0.068
const SIDE_MARGIN := 0.09
const ACCENT_A := Color("#F2B134")
const ACCENT_B := Color("#3FC1C9")
var _shade: TextureRect
var _title: Label
var _choice_a: PanelContainer
var _choice_b: PanelContainer
var _debug: Label
var _size := Vector2.ZERO
static func evaluate(cfg: Dictionary, t: float) -> Dictionary:
var o: Dictionary = cfg.overlay
var fade: float = maxf(o.fade_seconds, 0.001)
return {
"visible": t >= o.start,
"shade": _ease(t, o.start - 0.2, fade + 0.2),
"title": _ease(t, o.start, fade),
"choice_a": _ease(t, o.start + STAGGER_SECONDS, fade),
"choice_b": _ease(t, o.start + STAGGER_SECONDS * 2.0, fade),
}
static func _ease(t: float, start: float, length: float) -> float:
var p := clampf((t - start) / length, 0.0, 1.0)
return 1.0 - pow(1.0 - p, 3.0)
func setup(cfg: Dictionary, viewport_size: Vector2, show_debug: bool) -> void:
layer = 10
_size = viewport_size
var h := viewport_size.y
var w := viewport_size.x
# Escurecimento suave na metade de baixo para o texto ter contraste
# sobre qualquer cenário.
var gradient := Gradient.new()
gradient.set_color(0, Color(0, 0, 0, 0))
gradient.set_color(1, Color(0, 0, 0, 0.72))
var tex := GradientTexture2D.new()
tex.gradient = gradient
tex.fill_from = Vector2(0, 0)
tex.fill_to = Vector2(0, 1)
tex.width = 4
tex.height = 256
_shade = TextureRect.new()
_shade.texture = tex
_shade.stretch_mode = TextureRect.STRETCH_SCALE
_shade.position = Vector2(0, h * 0.45)
_shade.size = Vector2(w, h * 0.55)
add_child(_shade)
_title = Label.new()
_title.text = cfg.overlay.title
_title.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
_title.vertical_alignment = VERTICAL_ALIGNMENT_BOTTOM
_title.autowrap_mode = TextServer.AUTOWRAP_WORD_SMART
_title.add_theme_font_size_override("font_size", int(h * 0.044))
_title.add_theme_color_override("font_color", Color.WHITE)
_title.add_theme_color_override("font_outline_color", Color(0, 0, 0, 0.9))
_title.add_theme_constant_override("outline_size", maxi(2, int(h * 0.007)))
_title.add_theme_color_override("font_shadow_color", Color(0, 0, 0, 0.55))
_title.add_theme_constant_override("shadow_offset_y", maxi(1, int(h * 0.003)))
_title.size = Vector2(w * (1.0 - SIDE_MARGIN * 2.0), h * TITLE_BOX_HEIGHT)
add_child(_title)
_choice_a = _make_choice(cfg.overlay.choice_a, ACCENT_A, viewport_size)
_choice_b = _make_choice(cfg.overlay.choice_b, ACCENT_B, viewport_size)
_debug = Label.new()
_debug.visible = show_debug
_debug.position = Vector2(w * 0.03, h * 0.02)
_debug.add_theme_font_size_override("font_size", int(h * 0.022))
_debug.add_theme_color_override("font_color", Color.YELLOW)
_debug.add_theme_color_override("font_outline_color", Color.BLACK)
_debug.add_theme_constant_override("outline_size", 4)
add_child(_debug)
func _make_choice(text: String, accent: Color, viewport_size: Vector2) -> PanelContainer:
var h := viewport_size.y
var w := viewport_size.x
var style := StyleBoxFlat.new()
style.bg_color = Color(0.06, 0.07, 0.09, 0.82)
style.border_color = accent
style.set_border_width_all(maxi(2, int(h * 0.0035)))
style.set_corner_radius_all(int(h * 0.016))
style.content_margin_left = w * 0.05
style.content_margin_right = w * 0.05
var panel := PanelContainer.new()
panel.add_theme_stylebox_override("panel", style)
panel.size = Vector2(w * (1.0 - SIDE_MARGIN * 2.0), h * CHOICE_HEIGHT)
var label := Label.new()
label.text = text
label.vertical_alignment = VERTICAL_ALIGNMENT_CENTER
label.clip_text = true
label.text_overrun_behavior = TextServer.OVERRUN_TRIM_ELLIPSIS
label.add_theme_font_size_override("font_size", int(h * 0.032))
label.add_theme_color_override("font_color", Color.WHITE)
panel.add_child(label)
add_child(panel)
return panel
func apply(state: Dictionary, debug_text: String = "") -> void:
var w := _size.x
var h := _size.y
var x := w * SIDE_MARGIN
_shade.modulate.a = state.shade if state.visible else 0.0
_place(_title, x, TITLE_BOTTOM_Y - TITLE_BOX_HEIGHT, state.title, state.visible)
_place(_choice_a, x, CHOICE_A_Y, state.choice_a, state.visible)
_place(_choice_b, x, CHOICE_B_Y, state.choice_b, state.visible)
if _debug.visible:
_debug.text = debug_text
func _place(node: Control, x: float, y_fraction: float, amount: float, overlay_visible: bool) -> void:
node.visible = overlay_visible and amount > 0.0
node.modulate.a = amount
node.position = Vector2(x, _size.y * (y_fraction + SLIDE_FRACTION * (1.0 - amount)))
@@ -0,0 +1 @@
uid://dl3x1lmypnlj1