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