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
+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]