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>
130 lines
8.4 KiB
Markdown
130 lines
8.4 KiB
Markdown
# API das peças e cenas do Godot (gerado)
|
|
|
|
Gerado por `python .claude/skills/cenaforge/scripts/godot_api.py`. Não edite à mão: rode de novo
|
|
quando uma peça ou cena mudar. Use estas funções sem abrir os .gd inteiros.
|
|
|
|
## Peças (`godot/kits/`, use com `preload("res://kits/<arquivo>.gd")`)
|
|
|
|
### `godot/kits/boat.gd`
|
|
> Peça reaproveitável: lancha de pesca (~8 m) low-poly, com balanço e afundamento.
|
|
> const Boat := preload("res://kits/boat.gd")
|
|
> var b := Boat.new()
|
|
> b.build({"hull": "#f2f0ea", "stripe": "#1f5fa8", "cabin": "#e9e6df", "lights": true})
|
|
> add_child(b)
|
|
> # em apply(t):
|
|
> b.float_on(t, 1.0) # balanço no mar (intensidade 0 = calmo, 1 = normal, 2 = agitado)
|
|
> b.sink(0.6) # 0 = flutuando; 1 = quase submerso (popa afunda primeiro, adernado)
|
|
> Origem no centro do casco na linha d'água (y = 0 é o nível do mar), proa em -Z.
|
|
|
|
- `build(opts: Dictionary = {}) -> void`
|
|
- `deck() -> Node3D`: Corpo do barco (balança e afunda): pessoas e objetos a bordo entram como filhos dele, com o pé em y = DECK_Y; popa em +Z (z de 0,8 a 3,4 livre atrás da cabine).
|
|
- `float_on(t: float, intensity := 1.0) -> void`: Balanço determinístico no mar (sobe/desce, arfagem e jogo).
|
|
- `sink(amount: float) -> void`: 0 = flutuando; 1 = quase submerso. Chame antes de float_on no mesmo quadro.
|
|
|
|
### `godot/kits/person.gd`
|
|
> Peça reaproveitável: pessoa estilizada (low-poly) com juntas e animações por tempo.
|
|
> const Person := preload("res://kits/person.gd")
|
|
> var p := Person.new()
|
|
> p.build({"shirt": "#2f6fb3", "pants": "#3a3a3a", "skin": "#c68e6a", "hair": "#2b1d14", "height": 1.75})
|
|
> # opções: "sleeveless": true (regata, braço de fora), "shorts": true (bermuda), "vest", "shoes"
|
|
> add_child(p)
|
|
> # em apply(t):
|
|
> p.pose("walk", t) # parado | andar | correr | nadar | sentar | acenar | ajoelhar | deitar
|
|
> p.blend("walk", "run", t, 0.3) # mistura duas poses (0 = a primeira, 1 = a segunda)
|
|
> Origem nos pés (y = 0 é o chão), frente em -Z. Tudo depende só de t: determinístico.
|
|
> Poses: "idle", "walk", "run", "swim", "sit", "wave", "kneel", "lie", "exhausted".
|
|
|
|
- `build(opts: Dictionary = {}) -> void`
|
|
- `pose(action: String, t: float, amount := 1.0) -> void`: Aplica uma pose no instante t (segundos). Ver lista no topo.
|
|
- `blend(a: String, b: String, t: float, k: float) -> void`: Mistura duas poses (k de 0 a 1), por exemplo "walk" → "kneel" quando o personagem chega.
|
|
|
|
## Cenas da biblioteca (`godot/library/<id>/`)
|
|
|
|
### `castaways`
|
|
**Náufragos no costão** (doc3d): Reconstituição estilizada: quatro pescadores, pesqueiro e lancha civil na ilha. Chegada, naufrágio, nado, espera, resgate, embarque e partida. Elenilson mantém regata cinza e bermuda escura; roupas e gestos são ilustrativos.
|
|
- param `moment` (select: arrival, sinking, swimming, waiting, rescue, boarding, departure; padrão 'arrival')
|
|
- param `camera` (select: medium, close, wide; padrão 'medium')
|
|
- param `variant` (number; padrão 0)
|
|
|
|
`godot/library/castaways/actor.gd`
|
|
> Mantém o kit e suas roupas; flexão das poses voltada para a frente local (-Z).
|
|
|
|
`godot/library/castaways/cast.gd`
|
|
> Elenco e barcos da reconstituição dos náufragos (opções de res://kits/person.gd e boat.gd).
|
|
> Elenilson: regata cinza e bermuda escura (convenção visual do roteiro, igual em todo o vídeo).
|
|
> Os companheiros usam cores discretas e diferentes entre si, nenhuma cinza.
|
|
|
|
`godot/library/castaways/shore.gd`
|
|
> Ilha reutilizada com uma pequena laje de costão para encenação, sem precisão topográfica.
|
|
> A malha e ground_at compartilham as mesmas alturas; a ilha original não é modificada.
|
|
|
|
- `prepare_coast(center: Vector3, sea: Vector3) -> void`
|
|
- `height_at(x: float, z: float) -> float`
|
|
|
|
`godot/library/castaways/sky.gd`
|
|
> Céu, sol (ou lua), névoa e cor do mar por hora do dia, com mistura entre duas horas
|
|
> (a espera no costão passa da noite para o dia). Usa o ShaderMaterial do mar da ilha.
|
|
> const SkyRig := preload("res://library/castaways/sky.gd")
|
|
> var sky := SkyRig.new(); add_child(sky)
|
|
> sky.build(island.ocean_material(), direção_horizontal_do_sol)
|
|
> sky.set_preset("dawn") # "dawn" | "day" | "dusk" | "night"
|
|
> sky.blend_presets("night", "dawn", k)
|
|
|
|
- `build(ocean: ShaderMaterial, sun_dir: Vector3) -> void`
|
|
- `set_preset(preset: String) -> void`
|
|
- `blend_presets(a_name: String, b_name: String, k: float) -> void`
|
|
|
|
`godot/library/castaways/template.gd`
|
|
> Cena 3D do documentário: os náufragos da Ilha das Cobras (reconstituição do caso de 2019).
|
|
> Elenilson (regata cinza, bermuda escura) e três companheiros, do naufrágio do pesqueiro ao
|
|
> resgate pela lancha de mergulho, no costão da ilha da biblioteca (res://library/island).
|
|
> Tudo depende só de (params, t): poses e barcos animados por tempo, sem física nem relógio.
|
|
> Modelo "castaways": params
|
|
> moment: "arrival" | "sinking" | "swimming" | "waiting" | "rescue" | "boarding" | "departure"
|
|
> camera: "medium" (padrão) | "close" (mais perto do Elenilson) | "wide" (mais aberto)
|
|
> variant: inteiro; muda o ângulo da câmera (lado, altura e ponto de vista)
|
|
> Tom sóbrio: sem cobra, sem helicóptero, sem navio militar; a lancha do resgate é civil.
|
|
|
|
- `setup(cfg: Dictionary, viewport_size: Vector2) -> void`
|
|
- `apply(t: float) -> void`
|
|
- `state_signature() -> String`
|
|
|
|
`godot/library/castaways/verify.gd`
|
|
> Verificação local: Godot --headless --path godot --script res://library/castaways/verify.gd
|
|
> Compara todos os nós articulados ao buscar tempos em ordens diferentes.
|
|
|
|
### `island`
|
|
**Ilha costeira** (doc3d): 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()).
|
|
- param `shot` (select: orbit, approach, lighthouse, lowpass; padrão 'orbit')
|
|
- param `time` (select: day, sunset, night; padrão 'day')
|
|
- param `lighthouse` (bool; padrão True)
|
|
|
|
`godot/library/island/template.gd`
|
|
> 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().
|
|
|
|
- `lighthouse_position() -> Vector3`: Para outras cenas da biblioteca: posição do farol (pé da torre) e altura do terreno.
|
|
- `ground_at(x: float, z: float) -> float`: 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.
|
|
- `ground_normal(x: float, z: float) -> Vector3`: Normal do terreno desenhado em (x, z).
|
|
- `rock_list() -> Array`: Pedras do costão: lista de [centro (Vector3), raio horizontal].
|
|
- `sea_height(x: float, z: float, t: float) -> float`: Altura da água em (x, z) no instante t (as mesmas ondas do shader).
|
|
- `set_sea_state(scale: float) -> void`: Mar mais calmo (< 1) ou agitado (> 1). Padrão 1.
|
|
- `set_sea_focus(x: float, z: float) -> void`: 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").
|
|
- `ocean_material() -> ShaderMaterial`
|
|
- `setup(cfg: Dictionary, viewport_size: Vector2) -> void`
|
|
- `apply(t: float) -> void`
|
|
- `state_signature() -> String`
|
|
- `height_at(x: float, z: float) -> float`: 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.
|