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