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:
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
Reference in New Issue
Block a user