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 @@
|
||||
{
|
||||
"id": "island",
|
||||
"kind": "doc3d",
|
||||
"label": "Ilha costeira",
|
||||
"description": "Ilha alongada com mata densa, costão de pedra e farol listrado num mar animado. Sobrevoo, chegada pelo mar, perto do farol ou rasante; de dia, entardecer ou noite. Outras cenas podem usá-la como cenário (params embedded: true, environment: false, sea_detail: true; métodos ground_at(x, z), sea_height(x, z, t), set_sea_state, set_sea_focus, rock_list e lighthouse_position()).",
|
||||
"keywords": [
|
||||
"ilha",
|
||||
"mar",
|
||||
"oceano",
|
||||
"costa",
|
||||
"costão",
|
||||
"rochedo",
|
||||
"farol",
|
||||
"aérea",
|
||||
"aéreo",
|
||||
"sobrevoo",
|
||||
"sobrevoa",
|
||||
"mata em 3d",
|
||||
"sobrevoo 3d",
|
||||
"vista",
|
||||
"horizonte"
|
||||
],
|
||||
"params": [
|
||||
{
|
||||
"name": "shot",
|
||||
"label": "Tomada",
|
||||
"type": "select",
|
||||
"default": "orbit",
|
||||
"options": [
|
||||
{
|
||||
"value": "orbit",
|
||||
"label": "Sobrevoo em volta",
|
||||
"keywords": [
|
||||
"aére",
|
||||
"sobrevoo",
|
||||
"sobrevoa",
|
||||
"mata em 3d",
|
||||
"sobrevoo 3d",
|
||||
"vista",
|
||||
"plano aéreo"
|
||||
]
|
||||
},
|
||||
{
|
||||
"value": "approach",
|
||||
"label": "Chegada pelo mar",
|
||||
"keywords": [
|
||||
"afastamento",
|
||||
"aproxima",
|
||||
"chega",
|
||||
"chegada"
|
||||
]
|
||||
},
|
||||
{
|
||||
"value": "lighthouse",
|
||||
"label": "Perto do farol",
|
||||
"keywords": [
|
||||
"farol"
|
||||
]
|
||||
},
|
||||
{
|
||||
"value": "lowpass",
|
||||
"label": "Rasante na água",
|
||||
"keywords": [
|
||||
"rasante",
|
||||
"água",
|
||||
"ondas"
|
||||
]
|
||||
}
|
||||
]
|
||||
},
|
||||
{
|
||||
"name": "time",
|
||||
"label": "Hora do dia",
|
||||
"type": "select",
|
||||
"default": "day",
|
||||
"options": [
|
||||
{
|
||||
"value": "day",
|
||||
"label": "Dia"
|
||||
},
|
||||
{
|
||||
"value": "sunset",
|
||||
"label": "Entardecer",
|
||||
"keywords": [
|
||||
"entardecer",
|
||||
"pôr do sol",
|
||||
"anoitecer",
|
||||
"crepúsculo"
|
||||
]
|
||||
},
|
||||
{
|
||||
"value": "night",
|
||||
"label": "Noite",
|
||||
"keywords": [
|
||||
"noite",
|
||||
"escuro",
|
||||
"madrugada",
|
||||
"temporal noturno"
|
||||
]
|
||||
}
|
||||
]
|
||||
},
|
||||
{
|
||||
"name": "lighthouse",
|
||||
"label": "Farol",
|
||||
"type": "bool",
|
||||
"default": true
|
||||
}
|
||||
],
|
||||
"createdBy": "Claude Code (CenaForge)",
|
||||
"createdAt": "2026-11-17"
|
||||
}
|
||||
@@ -0,0 +1,617 @@
|
||||
extends Node3D
|
||||
## Cena 3D do documentário: uma ilha costeira estilizada (terreno por ruído, mata densa,
|
||||
## costão de pedra, farol) num mar animado por shader. Tudo depende só de (configuração, t):
|
||||
## sementes fixas, o mar recebe o tempo de cena por uniform (não usa TIME), então o render
|
||||
## é determinístico.
|
||||
##
|
||||
## Modelo "island": params
|
||||
## shot: "orbit" (sobrevoo em volta) | "approach" (chega do mar) | "lighthouse" (perto do
|
||||
## farol) | "lowpass" (rasante sobre a água) — padrão "orbit"
|
||||
## time: "day" | "sunset" — padrão "day"
|
||||
## lighthouse: true/false — padrão true
|
||||
## variant: inteiro; muda ângulo inicial, sentido da câmera e (ímpar) a hora do dia
|
||||
##
|
||||
## Como cenário de outra cena (params embedded: true; environment: false se a outra cena faz
|
||||
## céu e luz; sea_detail: true para tomadas rente à água): height_at / ground_at / ground_normal
|
||||
## (terreno), sea_height(x, z, t) e set_sea_state(escala) (mar), set_sea_focus(x, z) (centro da
|
||||
## malha fina do mar), rock_list() (pedras do costão) e lighthouse_position().
|
||||
|
||||
const ISLAND_A := 82.0 # semieixo maior (x), em metros da cena
|
||||
const ISLAND_B := 42.0 # semieixo menor (z)
|
||||
const GRID := 168 # resolução do terreno
|
||||
const TERRAIN_SIZE := 260.0
|
||||
const TREE_COUNT := 5200
|
||||
|
||||
const OCEAN_SHADER := """
|
||||
shader_type spatial;
|
||||
render_mode specular_schlick_ggx, cull_disabled;
|
||||
|
||||
uniform float scene_time = 0.0;
|
||||
uniform float wave_scale = 1.0;
|
||||
uniform vec3 deep_color : source_color = vec3(0.015, 0.13, 0.22);
|
||||
uniform vec3 shallow_color : source_color = vec3(0.04, 0.42, 0.46);
|
||||
uniform vec3 sky_tint : source_color = vec3(0.45, 0.62, 0.76);
|
||||
uniform vec2 island_axes = vec2(82.0, 42.0);
|
||||
|
||||
varying vec3 v_world;
|
||||
varying float v_crest;
|
||||
|
||||
void add_wave(vec2 p, vec2 dir, float len, float amp, float speed, inout float h, inout vec2 grad) {
|
||||
float k = 6.2831853 / len;
|
||||
float f = k * dot(p, normalize(dir)) + scene_time * speed;
|
||||
h += amp * sin(f);
|
||||
grad += amp * k * cos(f) * normalize(dir);
|
||||
}
|
||||
|
||||
void vertex() {
|
||||
vec3 w = (MODEL_MATRIX * vec4(VERTEX, 1.0)).xyz;
|
||||
float h = 0.0;
|
||||
vec2 grad = vec2(0.0);
|
||||
add_wave(w.xz, vec2(1.0, 0.31), 41.0, 0.42, 1.05, h, grad);
|
||||
add_wave(w.xz, vec2(-0.37, 1.0), 27.3, 0.26, 1.33, h, grad);
|
||||
add_wave(w.xz, vec2(0.83, -0.57), 15.7, 0.13, 1.81, h, grad);
|
||||
add_wave(w.xz, vec2(-1.0, -0.23), 9.1, 0.07, 2.37, h, grad);
|
||||
add_wave(w.xz, vec2(0.21, -1.0), 5.3, 0.035, 3.1, h, grad);
|
||||
add_wave(w.xz, vec2(0.66, 0.75), 3.7, 0.02, 3.9, h, grad);
|
||||
h *= wave_scale;
|
||||
grad *= wave_scale;
|
||||
VERTEX.y += h;
|
||||
NORMAL = normalize(vec3(-grad.x, 1.0, -grad.y));
|
||||
v_world = w;
|
||||
v_crest = h;
|
||||
}
|
||||
|
||||
void fragment() {
|
||||
// Água mais clara (turquesa) perto da ilha, escura no mar aberto.
|
||||
float d = length(v_world.xz / island_axes);
|
||||
float shallow = smoothstep(1.7, 1.0, d) * 0.85;
|
||||
vec3 col = mix(deep_color, shallow_color, shallow);
|
||||
col += vec3(0.05) * smoothstep(0.35, 0.8, v_crest);
|
||||
float fres = pow(1.0 - clamp(dot(NORMAL, VIEW), 0.0, 1.0), 5.0);
|
||||
ALBEDO = mix(col, sky_tint, fres * 0.22);
|
||||
ROUGHNESS = 0.07;
|
||||
METALLIC = 0.0;
|
||||
SPECULAR = 0.65;
|
||||
}
|
||||
"""
|
||||
|
||||
var _cfg: Dictionary
|
||||
var _p: Dictionary
|
||||
var _size := Vector2.ZERO
|
||||
var _dur := 1.0
|
||||
var _variant := 0
|
||||
var _camera: Camera3D
|
||||
var _ocean_mat: ShaderMaterial
|
||||
var _noise_shape: FastNoiseLite
|
||||
var _noise_ridge: FastNoiseLite
|
||||
var _noise_detail: FastNoiseLite
|
||||
var _lighthouse_pos := Vector3.ZERO
|
||||
var _lamp: MeshInstance3D
|
||||
var _t := 0.0
|
||||
var _last_cam := Vector3.ZERO
|
||||
var _night := false
|
||||
var _embedded := false
|
||||
var _ocean: MeshInstance3D
|
||||
var _wave_scale := 1.0
|
||||
var _heights := PackedFloat32Array() # alturas dos vértices do terreno (a malha desenhada)
|
||||
var _rocks: Array = [] # [centro, raio] de cada pedra do costão
|
||||
|
||||
## As mesmas ondas do OCEAN_SHADER (direção, comprimento, amplitude, velocidade), para
|
||||
## sea_height() devolver a altura da água que aparece na tela.
|
||||
const WAVES := [
|
||||
[Vector2(1.0, 0.31), 41.0, 0.42, 1.05],
|
||||
[Vector2(-0.37, 1.0), 27.3, 0.26, 1.33],
|
||||
[Vector2(0.83, -0.57), 15.7, 0.13, 1.81],
|
||||
[Vector2(-1.0, -0.23), 9.1, 0.07, 2.37],
|
||||
[Vector2(0.21, -1.0), 5.3, 0.035, 3.1],
|
||||
[Vector2(0.66, 0.75), 3.7, 0.02, 3.9],
|
||||
]
|
||||
|
||||
|
||||
## Para outras cenas da biblioteca: posição do farol (pé da torre) e altura do terreno.
|
||||
func lighthouse_position() -> Vector3:
|
||||
return _lighthouse_pos
|
||||
|
||||
|
||||
## Altura da superfície do terreno COMO DESENHADA (interpola os triângulos da malha, não o
|
||||
## ruído): use para apoiar pés, joelhos e pedras sem flutuar nem afundar na rocha.
|
||||
func ground_at(x: float, z: float) -> float:
|
||||
var step := TERRAIN_SIZE / float(GRID)
|
||||
var half := TERRAIN_SIZE / 2.0
|
||||
var fx := (x + half) / step
|
||||
var fz := (z / 0.7 + half) / step
|
||||
var i := clampi(int(floor(fx)), 0, GRID - 1)
|
||||
var j := clampi(int(floor(fz)), 0, GRID - 1)
|
||||
var u := clampf(fx - i, 0.0, 1.0)
|
||||
var v := clampf(fz - j, 0.0, 1.0)
|
||||
var ha := _heights[j * (GRID + 1) + i]
|
||||
var hb := _heights[j * (GRID + 1) + i + 1]
|
||||
var hc := _heights[(j + 1) * (GRID + 1) + i]
|
||||
var hd := _heights[(j + 1) * (GRID + 1) + i + 1]
|
||||
# Mesmos triângulos de _build_terrain: (a, b, c) e (b, d, c).
|
||||
if u + v <= 1.0:
|
||||
return ha + (hb - ha) * u + (hc - ha) * v
|
||||
return hd + (hc - hd) * (1.0 - u) + (hb - hd) * (1.0 - v)
|
||||
|
||||
|
||||
## Normal do terreno desenhado em (x, z).
|
||||
func ground_normal(x: float, z: float) -> Vector3:
|
||||
var e := 0.4
|
||||
var dx := ground_at(x + e, z) - ground_at(x - e, z)
|
||||
var dz := ground_at(x, z + e) - ground_at(x, z - e)
|
||||
return Vector3(-dx, 2.0 * e, -dz).normalized()
|
||||
|
||||
|
||||
## Pedras do costão: lista de [centro (Vector3), raio horizontal].
|
||||
func rock_list() -> Array:
|
||||
return _rocks
|
||||
|
||||
|
||||
## Altura da água em (x, z) no instante t (as mesmas ondas do shader).
|
||||
func sea_height(x: float, z: float, t: float) -> float:
|
||||
var h := 0.0
|
||||
for w in WAVES:
|
||||
var dir: Vector2 = (w[0] as Vector2).normalized()
|
||||
h += float(w[2]) * sin(TAU / float(w[1]) * dir.dot(Vector2(x, z)) + t * float(w[3]))
|
||||
return h * _wave_scale
|
||||
|
||||
|
||||
## Mar mais calmo (< 1) ou agitado (> 1). Padrão 1.
|
||||
func set_sea_state(scale: float) -> void:
|
||||
_wave_scale = scale
|
||||
_ocean_mat.set_shader_parameter("wave_scale", scale)
|
||||
|
||||
|
||||
## Com params.sea_detail = true, o mar é uma malha radial fina no centro; mova o centro para
|
||||
## perto da câmera a cada quadro (as ondas usam coordenada do mundo, então não "andam").
|
||||
func set_sea_focus(x: float, z: float) -> void:
|
||||
_ocean.position = Vector3(x, 0, z)
|
||||
|
||||
|
||||
func ocean_material() -> ShaderMaterial:
|
||||
return _ocean_mat
|
||||
|
||||
|
||||
func setup(cfg: Dictionary, viewport_size: Vector2) -> void:
|
||||
_cfg = cfg
|
||||
_p = cfg.params
|
||||
_size = viewport_size
|
||||
_dur = maxf(float(cfg.video.duration), 0.1)
|
||||
_variant = int(_p.get("variant", 0))
|
||||
_make_noises()
|
||||
var time := str(_p.get("time", "day"))
|
||||
_night = time == "night"
|
||||
# A hora vem do parâmetro; "variant" (Gerar de novo) muda só a câmera.
|
||||
var sunset := not _night and time == "sunset"
|
||||
# embedded = true: a ilha é cenário dentro de OUTRA cena da biblioteca (que cria a câmera).
|
||||
# environment = false: a outra cena também cuida do céu e da luz.
|
||||
_embedded = bool(_p.get("embedded", false))
|
||||
if bool(_p.get("environment", true)):
|
||||
_build_environment(sunset)
|
||||
_build_terrain()
|
||||
_build_trees()
|
||||
_build_rocks()
|
||||
if bool(_p.get("lighthouse", true)):
|
||||
_build_lighthouse(sunset)
|
||||
_build_ocean(sunset)
|
||||
if _embedded:
|
||||
return
|
||||
_camera = Camera3D.new()
|
||||
_camera.fov = 52.0
|
||||
_camera.near = 0.3
|
||||
_camera.far = 9000.0
|
||||
_camera.keep_aspect = Camera3D.KEEP_HEIGHT
|
||||
add_child(_camera)
|
||||
_camera.current = true
|
||||
|
||||
|
||||
func apply(t: float) -> void:
|
||||
_t = t
|
||||
_ocean_mat.set_shader_parameter("scene_time", t)
|
||||
if _lamp:
|
||||
# Lanterna do farol pulsando devagar.
|
||||
var mat := _lamp.get_surface_override_material(0) as StandardMaterial3D
|
||||
mat.emission_energy_multiplier = (4.0 if _night else 1.6) + 1.2 * (0.5 + 0.5 * sin(t * 2.4))
|
||||
if not _embedded:
|
||||
_place_camera(t)
|
||||
|
||||
|
||||
func state_signature() -> String:
|
||||
return "%.3f,%.3f,%.3f" % [_last_cam.x, _last_cam.y, _last_cam.z]
|
||||
|
||||
|
||||
# ------------------------------------------------------------------ terreno
|
||||
|
||||
func _make_noises() -> void:
|
||||
_noise_shape = FastNoiseLite.new()
|
||||
_noise_shape.seed = 7
|
||||
_noise_shape.frequency = 1.0
|
||||
_noise_shape.fractal_octaves = 3
|
||||
_noise_ridge = FastNoiseLite.new()
|
||||
_noise_ridge.seed = 21
|
||||
_noise_ridge.frequency = 1.0
|
||||
_noise_ridge.fractal_type = FastNoiseLite.FRACTAL_RIDGED
|
||||
_noise_ridge.fractal_octaves = 4
|
||||
_noise_detail = FastNoiseLite.new()
|
||||
_noise_detail.seed = 33
|
||||
_noise_detail.frequency = 1.0
|
||||
_noise_detail.fractal_octaves = 3
|
||||
|
||||
|
||||
## Altura do terreno (y = 0 é o nível do mar). A ilha é alongada, com uma crista central
|
||||
## alta, encostas íngremes e costão de pedra que cai direto no mar.
|
||||
func height_at(x: float, z: float) -> float:
|
||||
var nx := x / ISLAND_A
|
||||
var nz := z / ISLAND_B
|
||||
var d := sqrt(nx * nx + nz * nz) + _noise_shape.get_noise_2d(x * 0.018, z * 0.018) * 0.22
|
||||
var m := clampf((1.0 - d) / 0.6, 0.0, 1.0)
|
||||
m = m * m * (3.0 - 2.0 * m)
|
||||
var ridge := _noise_ridge.get_noise_2d(x * 0.022, z * 0.022) * 0.5 + 0.5
|
||||
var crest := 1.0 - absf(nz) * 0.9
|
||||
var h := m * (5.0 + 30.0 * pow(m, 0.8) * (0.55 + 0.45 * ridge) * crest)
|
||||
h += _noise_detail.get_noise_2d(x * 0.11, z * 0.11) * 1.6 * m
|
||||
# Fora da ilha: fundo do mar descendo.
|
||||
return h - 3.0 + (1.0 - m) * -6.0 * clampf(d - 0.9, 0.0, 1.0)
|
||||
|
||||
|
||||
func _terrain_color(h: float, slope: float, x: float, z: float) -> Color:
|
||||
var n := _noise_detail.get_noise_2d(x * 0.35, z * 0.35) * 0.5 + 0.5
|
||||
if h < -0.6:
|
||||
return Color("#1d4a52").lerp(Color("#2f6b6a"), clampf((h + 6.0) / 5.0, 0.0, 1.0))
|
||||
if h < 1.2:
|
||||
return Color("#6b6358").lerp(Color("#4f4a43"), n) # costão molhado
|
||||
if slope > 0.72:
|
||||
return Color("#4c4944").lerp(Color("#66615a"), n) # pedra exposta
|
||||
var forest := Color("#173a1d").lerp(Color("#2b5a27"), n) # chão sob a mata
|
||||
return forest.lerp(Color("#4a5a2c"), clampf((h - 28.0) / 14.0, 0.0, 0.35))
|
||||
|
||||
|
||||
func _build_terrain() -> void:
|
||||
var st := SurfaceTool.new()
|
||||
st.begin(Mesh.PRIMITIVE_TRIANGLES)
|
||||
var step := TERRAIN_SIZE / float(GRID)
|
||||
var half := TERRAIN_SIZE / 2.0
|
||||
_heights.resize((GRID + 1) * (GRID + 1))
|
||||
for j in GRID + 1:
|
||||
for i in GRID + 1:
|
||||
var x := -half + float(i) * step
|
||||
var z := (-half + float(j) * step) * 0.7 # ilha alongada: menos extensão em z
|
||||
var h := height_at(x, z)
|
||||
_heights[j * (GRID + 1) + i] = h
|
||||
var dx := height_at(x + 0.8, z) - height_at(x - 0.8, z)
|
||||
var dz := height_at(x, z + 0.8) - height_at(x, z - 0.8)
|
||||
var slope := clampf(Vector2(dx, dz).length() / 1.6 / 2.2, 0.0, 1.0)
|
||||
st.set_color(_terrain_color(h, slope, x, z))
|
||||
st.add_vertex(Vector3(x, h, z))
|
||||
for j in GRID:
|
||||
for i in GRID:
|
||||
var a := j * (GRID + 1) + i
|
||||
var b := a + 1
|
||||
var c := a + GRID + 1
|
||||
var d := c + 1
|
||||
st.add_index(a)
|
||||
st.add_index(b)
|
||||
st.add_index(c)
|
||||
st.add_index(b)
|
||||
st.add_index(d)
|
||||
st.add_index(c)
|
||||
st.generate_normals()
|
||||
var mat := StandardMaterial3D.new()
|
||||
mat.vertex_color_use_as_albedo = true
|
||||
mat.roughness = 0.95
|
||||
var node := MeshInstance3D.new()
|
||||
node.name = "Terrain"
|
||||
node.mesh = st.commit()
|
||||
node.material_override = mat
|
||||
add_child(node)
|
||||
|
||||
|
||||
func _build_trees() -> void:
|
||||
var crown := CylinderMesh.new()
|
||||
crown.top_radius = 0.0
|
||||
crown.bottom_radius = 1.9
|
||||
crown.height = 3.4
|
||||
crown.radial_segments = 7
|
||||
crown.rings = 1
|
||||
var mat := StandardMaterial3D.new()
|
||||
mat.vertex_color_use_as_albedo = true
|
||||
mat.roughness = 0.9
|
||||
crown.material = mat
|
||||
var mm := MultiMesh.new()
|
||||
mm.transform_format = MultiMesh.TRANSFORM_3D
|
||||
mm.use_colors = true
|
||||
mm.mesh = crown
|
||||
var rng := RandomNumberGenerator.new()
|
||||
rng.seed = 4242
|
||||
var placed: Array[Transform3D] = []
|
||||
var colors: Array[Color] = []
|
||||
var tries := 0
|
||||
while placed.size() < TREE_COUNT and tries < TREE_COUNT * 6:
|
||||
tries += 1
|
||||
var x := rng.randf_range(-ISLAND_A, ISLAND_A)
|
||||
var z := rng.randf_range(-ISLAND_B, ISLAND_B)
|
||||
var h := height_at(x, z)
|
||||
if h < 1.6:
|
||||
continue
|
||||
var slope := Vector2(height_at(x + 0.8, z) - height_at(x - 0.8, z), height_at(x, z + 0.8) - height_at(x, z - 0.8)).length() / 3.2
|
||||
if slope > 0.85 or rng.randf() < slope * 0.6:
|
||||
continue
|
||||
var s := rng.randf_range(0.75, 1.45)
|
||||
var basis := Basis.from_euler(Vector3(rng.randf_range(-0.08, 0.08), rng.randf() * TAU, rng.randf_range(-0.08, 0.08))).scaled(Vector3(s, s * rng.randf_range(0.8, 1.3), s))
|
||||
placed.append(Transform3D(basis, Vector3(x, h + 1.4 * s, z)))
|
||||
colors.append(Color("#0d2610").lerp(Color("#2a5222"), rng.randf()).lerp(Color("#4a6a22"), rng.randf() * 0.2))
|
||||
mm.instance_count = placed.size()
|
||||
for i in placed.size():
|
||||
mm.set_instance_transform(i, placed[i])
|
||||
mm.set_instance_color(i, colors[i])
|
||||
var node := MultiMeshInstance3D.new()
|
||||
node.name = "Forest"
|
||||
node.multimesh = mm
|
||||
add_child(node)
|
||||
|
||||
|
||||
func _build_rocks() -> void:
|
||||
var rock := SphereMesh.new()
|
||||
rock.radius = 1.0
|
||||
rock.height = 1.4
|
||||
rock.radial_segments = 7
|
||||
rock.rings = 4
|
||||
var mat := StandardMaterial3D.new()
|
||||
mat.albedo_color = Color("#5e5b56")
|
||||
mat.roughness = 1.0
|
||||
rock.material = mat
|
||||
var rng := RandomNumberGenerator.new()
|
||||
rng.seed = 909
|
||||
var mm := MultiMesh.new()
|
||||
mm.transform_format = MultiMesh.TRANSFORM_3D
|
||||
mm.mesh = rock
|
||||
var list: Array[Transform3D] = []
|
||||
for i in 420:
|
||||
var ang := rng.randf() * TAU
|
||||
var r := rng.randf_range(0.93, 1.08)
|
||||
var x := cos(ang) * ISLAND_A * r
|
||||
var z := sin(ang) * ISLAND_B * r
|
||||
var h := height_at(x, z)
|
||||
if h > 3.0 or h < -2.5:
|
||||
continue
|
||||
var s := rng.randf_range(0.8, 3.2)
|
||||
_rocks.append([Vector3(x, maxf(h, -0.4), z), s])
|
||||
list.append(Transform3D(Basis.from_euler(Vector3(rng.randf() * TAU, rng.randf() * TAU, 0)).scaled(Vector3(s, s * 0.7, s)), Vector3(x, maxf(h, -0.4), z)))
|
||||
mm.instance_count = list.size()
|
||||
for i in list.size():
|
||||
mm.set_instance_transform(i, list[i])
|
||||
var node := MultiMeshInstance3D.new()
|
||||
node.name = "Rocks"
|
||||
node.multimesh = mm
|
||||
add_child(node)
|
||||
|
||||
|
||||
func _build_lighthouse(sunset: bool) -> void:
|
||||
# No ponto mais alto da metade sudoeste da ilha.
|
||||
var best := Vector3(-ISLAND_A * 0.45, 0, ISLAND_B * 0.1)
|
||||
for i in 60:
|
||||
var x := -ISLAND_A * 0.7 + float(i % 10) * ISLAND_A * 0.06
|
||||
var z := -ISLAND_B * 0.3 + float(i / 10) * ISLAND_B * 0.1
|
||||
var h := height_at(x, z)
|
||||
if h > best.y:
|
||||
best = Vector3(x, h, z)
|
||||
_lighthouse_pos = best
|
||||
var root := Node3D.new()
|
||||
root.name = "Lighthouse"
|
||||
root.position = best - Vector3(0, 0.6, 0)
|
||||
add_child(root)
|
||||
var white := StandardMaterial3D.new()
|
||||
white.albedo_color = Color("#f2efe8")
|
||||
white.roughness = 0.6
|
||||
var red := StandardMaterial3D.new()
|
||||
red.albedo_color = Color("#b8322a")
|
||||
red.roughness = 0.6
|
||||
var tower_h := 11.0
|
||||
var bands := 5
|
||||
for b in bands:
|
||||
var seg := CylinderMesh.new()
|
||||
var t0 := float(b) / bands
|
||||
var t1 := float(b + 1) / bands
|
||||
seg.bottom_radius = lerpf(1.7, 1.15, t0)
|
||||
seg.top_radius = lerpf(1.7, 1.15, t1)
|
||||
seg.height = tower_h / bands
|
||||
seg.radial_segments = 20
|
||||
var mi := MeshInstance3D.new()
|
||||
mi.mesh = seg
|
||||
mi.material_override = red if b % 2 == 1 else white
|
||||
mi.position = Vector3(0, tower_h * (t0 + t1) / 2.0, 0)
|
||||
root.add_child(mi)
|
||||
var gallery := CylinderMesh.new()
|
||||
gallery.top_radius = 1.7
|
||||
gallery.bottom_radius = 1.7
|
||||
gallery.height = 0.35
|
||||
gallery.radial_segments = 20
|
||||
var gmi := MeshInstance3D.new()
|
||||
gmi.mesh = gallery
|
||||
gmi.material_override = red
|
||||
gmi.position = Vector3(0, tower_h + 0.15, 0)
|
||||
root.add_child(gmi)
|
||||
var lamp_mesh := CylinderMesh.new()
|
||||
lamp_mesh.top_radius = 0.95
|
||||
lamp_mesh.bottom_radius = 0.95
|
||||
lamp_mesh.height = 1.4
|
||||
lamp_mesh.radial_segments = 16
|
||||
var lamp_mat := StandardMaterial3D.new()
|
||||
lamp_mat.albedo_color = Color("#ffe9a8")
|
||||
lamp_mat.emission_enabled = true
|
||||
lamp_mat.emission = Color("#ffd27a")
|
||||
lamp_mat.emission_energy_multiplier = 2.0
|
||||
_lamp = MeshInstance3D.new()
|
||||
_lamp.mesh = lamp_mesh
|
||||
_lamp.set_surface_override_material(0, lamp_mat)
|
||||
_lamp.position = Vector3(0, tower_h + 1.0, 0)
|
||||
root.add_child(_lamp)
|
||||
var cap := CylinderMesh.new()
|
||||
cap.top_radius = 0.0
|
||||
cap.bottom_radius = 1.25
|
||||
cap.height = 1.2
|
||||
cap.radial_segments = 20
|
||||
var cmi := MeshInstance3D.new()
|
||||
cmi.mesh = cap
|
||||
cmi.material_override = red
|
||||
cmi.position = Vector3(0, tower_h + 2.3, 0)
|
||||
root.add_child(cmi)
|
||||
if sunset or _night:
|
||||
var glow := OmniLight3D.new()
|
||||
glow.light_color = Color("#ffcf7a")
|
||||
glow.light_energy = 2.0
|
||||
glow.omni_range = 18.0
|
||||
glow.position = Vector3(0, tower_h + 1.0, 0)
|
||||
root.add_child(glow)
|
||||
|
||||
|
||||
# ------------------------------------------------------------------ mar e céu
|
||||
|
||||
func _build_ocean(sunset: bool) -> void:
|
||||
var plane: Mesh
|
||||
if bool(_p.get("sea_detail", false)):
|
||||
plane = _radial_sea()
|
||||
else:
|
||||
plane = PlaneMesh.new()
|
||||
plane.size = Vector2(16000, 16000)
|
||||
plane.subdivide_width = 400
|
||||
plane.subdivide_depth = 400
|
||||
var shader := Shader.new()
|
||||
shader.code = OCEAN_SHADER
|
||||
_ocean_mat = ShaderMaterial.new()
|
||||
_ocean_mat.shader = shader
|
||||
_ocean_mat.set_shader_parameter("island_axes", Vector2(ISLAND_A, ISLAND_B))
|
||||
if _night:
|
||||
_ocean_mat.set_shader_parameter("deep_color", Color("#02070f"))
|
||||
_ocean_mat.set_shader_parameter("shallow_color", Color("#06202a"))
|
||||
_ocean_mat.set_shader_parameter("sky_tint", Color("#2a3d63"))
|
||||
elif sunset:
|
||||
_ocean_mat.set_shader_parameter("deep_color", Color("#0b1f33"))
|
||||
_ocean_mat.set_shader_parameter("shallow_color", Color("#1f5a63"))
|
||||
_ocean_mat.set_shader_parameter("sky_tint", Color("#f3a865"))
|
||||
var node := MeshInstance3D.new()
|
||||
node.name = "Ocean"
|
||||
node.mesh = plane
|
||||
node.material_override = _ocean_mat
|
||||
node.cast_shadow = GeometryInstance3D.SHADOW_CASTING_SETTING_OFF
|
||||
add_child(node)
|
||||
_ocean = node
|
||||
|
||||
|
||||
## Mar para tomadas rente à água: anéis cada vez mais espaçados a partir do centro
|
||||
## (~0,3 m perto, dezenas de metros no horizonte), para a onda desenhada bater com sea_height().
|
||||
func _radial_sea() -> ArrayMesh:
|
||||
var seg := 288
|
||||
var rings := 190
|
||||
var growth := pow(8000.0 / 0.35, 1.0 / float(rings))
|
||||
var st := SurfaceTool.new()
|
||||
st.begin(Mesh.PRIMITIVE_TRIANGLES)
|
||||
st.set_normal(Vector3.UP)
|
||||
st.add_vertex(Vector3.ZERO)
|
||||
for r in rings:
|
||||
var radius := 0.35 * pow(growth, float(r))
|
||||
for s in seg:
|
||||
var a := TAU * float(s) / float(seg)
|
||||
st.set_normal(Vector3.UP)
|
||||
st.add_vertex(Vector3(cos(a) * radius, 0, sin(a) * radius))
|
||||
for s in seg:
|
||||
st.add_index(0)
|
||||
st.add_index(1 + (s + 1) % seg)
|
||||
st.add_index(1 + s)
|
||||
for r in rings - 1:
|
||||
for s in seg:
|
||||
var a := 1 + r * seg + s
|
||||
var b := 1 + r * seg + (s + 1) % seg
|
||||
var c := a + seg
|
||||
var d := b + seg
|
||||
st.add_index(a)
|
||||
st.add_index(b)
|
||||
st.add_index(c)
|
||||
st.add_index(b)
|
||||
st.add_index(d)
|
||||
st.add_index(c)
|
||||
var mesh := st.commit()
|
||||
# A malha é plana, mas o shader levanta as ondas: AABB folgada evita sumir no recorte.
|
||||
mesh.custom_aabb = AABB(Vector3(-8000, -5, -8000), Vector3(16000, 10, 16000))
|
||||
return mesh
|
||||
|
||||
|
||||
func _build_environment(sunset: bool) -> void:
|
||||
var sky_mat := ProceduralSkyMaterial.new()
|
||||
if _night:
|
||||
sky_mat.sky_top_color = Color("#03060f")
|
||||
sky_mat.sky_horizon_color = Color("#1a2740")
|
||||
sky_mat.ground_horizon_color = Color("#141e33")
|
||||
sky_mat.ground_bottom_color = Color("#02040a")
|
||||
elif sunset:
|
||||
sky_mat.sky_top_color = Color("#2b3566")
|
||||
sky_mat.sky_horizon_color = Color("#f2a35e")
|
||||
sky_mat.ground_horizon_color = Color("#c7804f")
|
||||
sky_mat.ground_bottom_color = Color("#1a2238")
|
||||
else:
|
||||
sky_mat.sky_top_color = Color("#2d6fb3")
|
||||
sky_mat.sky_horizon_color = Color("#b9d7ec")
|
||||
sky_mat.ground_horizon_color = Color("#9cc3d9")
|
||||
sky_mat.ground_bottom_color = Color("#1d3d55")
|
||||
sky_mat.sun_angle_max = 20.0
|
||||
var sky := Sky.new()
|
||||
sky.sky_material = sky_mat
|
||||
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 = 0.18 if _night else (0.45 if not sunset else 0.4)
|
||||
env.tonemap_mode = Environment.TONE_MAPPER_ACES
|
||||
env.tonemap_exposure = 1.05
|
||||
env.fog_enabled = true
|
||||
env.fog_light_color = sky_mat.sky_horizon_color
|
||||
env.fog_density = 0.00045 if not sunset else 0.0006
|
||||
env.fog_sky_affect = 0.15
|
||||
var we := WorldEnvironment.new()
|
||||
we.environment = env
|
||||
add_child(we)
|
||||
var sun := DirectionalLight3D.new()
|
||||
sun.light_color = Color("#9fb6ff") if _night else (Color("#ffd2a0") if sunset else Color("#fff4e2"))
|
||||
sun.light_energy = 0.35 if _night else (1.5 if sunset else 1.7)
|
||||
sun.rotation_degrees = Vector3(-14.0, -60.0, 0.0) if sunset else Vector3(-48.0, -35.0, 0.0)
|
||||
sun.shadow_enabled = true
|
||||
sun.directional_shadow_max_distance = 600.0
|
||||
add_child(sun)
|
||||
|
||||
|
||||
# ------------------------------------------------------------------ câmera
|
||||
|
||||
func _smooth(p: float) -> float:
|
||||
var q := clampf(p, 0.0, 1.0)
|
||||
return q * q * (3.0 - 2.0 * q)
|
||||
|
||||
|
||||
func _place_camera(t: float) -> void:
|
||||
var p := _smooth(t / _dur)
|
||||
var dir := 1.0 if _variant % 4 < 2 else -1.0
|
||||
var a0 := deg_to_rad(205.0 + float(_variant) * 47.0)
|
||||
var shot := str(_p.get("shot", "orbit"))
|
||||
var pos := Vector3.ZERO
|
||||
var target := Vector3(0, 10, 0)
|
||||
match shot:
|
||||
"approach":
|
||||
var r := lerpf(430.0, 175.0, p)
|
||||
var ang := a0 + dir * deg_to_rad(12.0) * p
|
||||
pos = Vector3(cos(ang) * r, lerpf(60.0, 34.0, p), sin(ang) * r)
|
||||
target = Vector3(0, lerpf(4.0, 12.0, p), 0)
|
||||
"lighthouse":
|
||||
var lp := _lighthouse_pos
|
||||
var ang := a0 + dir * deg_to_rad(55.0) * p
|
||||
pos = lp + Vector3(cos(ang) * 40.0, lerpf(24.0, 17.0, p), sin(ang) * 40.0)
|
||||
target = lp + Vector3(0, 8.0, 0)
|
||||
"lowpass":
|
||||
var ang := a0 + dir * deg_to_rad(28.0) * p
|
||||
pos = Vector3(cos(ang) * 135.0, 4.5 + 1.2 * sin(t * 0.7), sin(ang) * 135.0)
|
||||
target = Vector3(0, 14.0, 0)
|
||||
_:
|
||||
var ang := a0 + dir * deg_to_rad(42.0) * p
|
||||
pos = Vector3(cos(ang) * 190.0, lerpf(70.0, 52.0, p), sin(ang) * 190.0)
|
||||
target = Vector3(0, 8.0, 0)
|
||||
_camera.position = pos
|
||||
_camera.look_at(target, Vector3.UP)
|
||||
_last_cam = pos
|
||||
Reference in New Issue
Block a user