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>
127 lines
4.1 KiB
GDScript
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
|