Files
CenaForge/godot/scripts/core/timeline_controller.gd
T
MateuusandClaude Opus 5.5 84f30bbc2d 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>
2026-11-17 16:35:09 -03:00

127 lines
4.1 KiB
GDScript

extends RefCounted
## Relógio da cena. Tudo que se move é função pura do tempo de cena `t` (s),
## nunca do relógio do sistema: avaliar o mesmo `t` com a mesma configuração
## devolve o mesmo estado, em qualquer execução.
##
## Perfil de velocidade (convenção da cena: a moto avança em -Z):
## parada -> rampa suave (accelSeconds) -> cruzeiro -> frenagem suave -> parada
## As rampas usam smoothstep na velocidade, então velocidade E aceleração são
## contínuas: não há tranco nem salto de posição entre as fases. A distância
## chega exatamente em travelMeters no instante stopSeconds e fica ali.
const SceneConfig := preload("res://scripts/core/scene_config.gd")
const CameraController := preload("res://scripts/view/camera_controller.gd")
const OverlayController := preload("res://scripts/view/overlay_controller.gd")
## Amplitude da vibração vertical da carroceria em velocidade de cruzeiro (m).
const BOB_AMPLITUDE := 0.006
## Frequência espacial da vibração (rad/m): depende da distância, não do tempo.
const BOB_SPATIAL_FREQUENCY := 7.0
## Mergulho de frente por m/s² de aceleração (rad), limitado a ±2°.
const PITCH_PER_ACCEL := 0.004
const MAX_PITCH := 0.035
var _cfg: Dictionary
var _wheel_radius: float
var _t_start: float
var _accel_len: float
var _t_cruise: float
var _t_brake: float
var _brake_len: float
var _t_stop: float
var _speed: float
var _travel: float
var _start_position: Vector3
var _distance_at_brake: float
func _init(cfg: Dictionary, wheel_radius: float) -> void:
_cfg = cfg
_wheel_radius = wheel_radius
var m: Dictionary = cfg.motion
_t_start = m.start
_accel_len = m.accel_seconds
_t_cruise = _t_start + _accel_len
_t_brake = m.brake_start
_t_stop = m.stop
_brake_len = _t_stop - _t_brake
_travel = cfg.rider.travel
_start_position = cfg.rider.start_position
_speed = SceneConfig.cruise_speed(m, _travel)
_distance_at_brake = _speed * (_accel_len * 0.5 + (_t_brake - _t_cruise))
func cruise_speed() -> float:
return _speed
func distance_at(t: float) -> float:
if t <= _t_start:
return 0.0
if t < _t_cruise:
return _speed * _accel_len * _ramp_integral((t - _t_start) / _accel_len)
if t < _t_brake:
return _speed * (_accel_len * 0.5 + (t - _t_cruise))
if t < _t_stop:
var u := t - _t_brake
return _distance_at_brake + _speed * (u - _brake_len * _ramp_integral(u / _brake_len))
return _travel
func speed_at(t: float) -> float:
if t <= _t_start or t >= _t_stop:
return 0.0
if t < _t_cruise:
return _speed * _smoothstep((t - _t_start) / _accel_len)
if t < _t_brake:
return _speed
return _speed * (1.0 - _smoothstep((t - _t_brake) / _brake_len))
func acceleration_at(t: float) -> float:
if t <= _t_start or t >= _t_stop:
return 0.0
if t < _t_cruise:
return _speed * _smoothstep_derivative((t - _t_start) / _accel_len) / _accel_len
if t < _t_brake:
return 0.0
return -_speed * _smoothstep_derivative((t - _t_brake) / _brake_len) / _brake_len
## Estado visual completo no instante `t`. É a única fonte que a cena consulta.
func evaluate_at_time(t: float) -> Dictionary:
var distance := distance_at(t)
var speed := speed_at(t)
var acceleration := acceleration_at(t)
var position := _start_position + Vector3(0.0, 0.0, -distance)
var speed_ratio := clampf(speed / _speed, 0.0, 1.0) if _speed > 0.0 else 0.0
return {
"t": t,
"distance": distance,
"speed": speed,
"acceleration": acceleration,
"rider_position": position,
# Rotação em torno de X. Negativa para o topo da roda ir para -Z (frente).
"wheel_angle": -distance / _wheel_radius,
"body_bob": BOB_AMPLITUDE * speed_ratio * sin(distance * BOB_SPATIAL_FREQUENCY),
"body_pitch": clampf(acceleration * PITCH_PER_ACCEL, -MAX_PITCH, MAX_PITCH),
"camera": CameraController.evaluate(_cfg, t, position),
"overlay": OverlayController.evaluate(_cfg, t),
}
static func _smoothstep(p: float) -> float:
p = clampf(p, 0.0, 1.0)
return p * p * (3.0 - 2.0 * p)
static func _smoothstep_derivative(p: float) -> float:
p = clampf(p, 0.0, 1.0)
return 6.0 * p * (1.0 - p)
## Integral de smoothstep de 0 a p (vale 0,5 em p = 1).
static func _ramp_integral(p: float) -> float:
p = clampf(p, 0.0, 1.0)
return p * p * p - 0.5 * p * p * p * p