RibaSoft

Godot 4.5

Animações

• Adicionar Animações

  • Para não ter que ficar ajustando personagem toda vez que uma nova animação é criada ou editada, basta selecionar o nó AnimationPlayer do seu personagem, depois clicar na aba "Animação" no painel inferior, depois no botão "Animação" >> Gerenciar Animações e renomear e clicar no diskete para salvar em disco ou na lixeira para excluir, etc.

• Dicas

  • Ajustar o tempo da animação.

    $AnimationPlayer.speed_scale = 0.9

  • O valor ideal para deixar a transição entre animações suaves é 0.2, pode ser atribuida pelo script.

    $AnimationPlayer.playback_default_blend_time = 0.2

    Ou pelo Inspetor selecionando o nó AnimationPlayer -> Default Blend Time.

• Gerenciar animações

  • A forma que eu achei mais coerente por enquanto de tocar as animações é essa...

    #Criar um tipo enumerado com as animações que serão usadas. enum anim {nenhum, parado, andando, correndo, pulo_inicio, caindo, pulo_pouso} const VELOCIDADE = 5.0 const VELOCIDADE_CORRENDO = 20 var AninPlayer: AnimationPlayer var AnimacaoAtual: anim func _ready() -> void: AninPlayer = $AnimationPlayer AnimacaoAtual = anim.nenhum func _physics_process(delta: float) -> void: if is_on_floor(): if AnimacaoAtual == anim.caindo: Anima(anim.pulo_pouso) if direcao != Vector3.ZERO: if Input.is_action_pressed("correr"): velocity.x = direcao.x * VELOCIDADE_CORRENDO velocity.z = direcao.z * VELOCIDADE_CORRENDO Anima(anim.correndo) else: velocity.x = direcao.x * VELOCIDADE velocity.z = direcao.z * VELOCIDADE Anima(anim.andando) else: velocity.x = move_toward(velocity.x, 0, VELOCIDADE) velocity.z = move_toward(velocity.z, 0, VELOCIDADE) Anima(anim.parado) else: velocity += get_gravity() * delta Anima(anim.caindo) move_and_slide() #Gerencia para quando uma animação que já está sendo #tocada não inicie e que nenhum animação toque enquanto #uma que precisa terminar esteja tocando func Anima(acao: anim) -> void: #Animações que precisam terminar o ciclo if AnimacaoAtual in [anim.pulo_inicio, anim.pulo_pouso]: return match acao: anim.parado: if AnimacaoAtual != acao: AninPlayer.play("parado") AnimacaoAtual = acao anim.andando: if AnimacaoAtual != acao: AninPlayer.play("andando") AnimacaoAtual = acao anim.correndo: if AnimacaoAtual != acao: AninPlayer.play("correndo") AnimacaoAtual = acao anim.pulo_inicio: if AnimacaoAtual != acao: AninPlayer.play("pulo_inicio") AnimacaoAtual = acao anim.caindo: if AnimacaoAtual != acao: AninPlayer.play("caindo") AnimacaoAtual = acao anim.pulo_pouso: if AnimacaoAtual != acao: AninPlayer.play("pulo_pouso") AnimacaoAtual = acao #Evento "Sinal" para que uma animação que precisa #terminar avise que terminou resetando a "AnimaçãoAtual" func _on_animation_player_animation_finished(anim_name: StringName) -> void: if anim_name in ["pulo_inicio", "pulo_pouso"]: AnimacaoAtual = anim.nenhum

Barra de Energia

• TextureProgressBar

  • O Nó TextureProgressBar, é geralmente usado em jogos 2D, mas com alguns recursos é possivel usá-lo em 3D.

    Adicione um Sprite3D como filho do seu personagem, um SubViewport como filho do Sprite3D e um TextureProgressBar como filho do SubViewport.

  • No TextureProgressBar, vá ao Inpertor -> TextureProgressBar -> Textures e arraste as imagens .png para:

    Under - fundo da barra.

    Over - borda da barra.

    Progress - a barra em sí.

    
    

    No script trabalhe com as propriedades "min_value", "max_value" e "value".

  • No SubViewport, Inspertor -> SubViewport ajuste o Size X e Y para ficar do tamanho da sua barra.

    Em Viewport ative o TransparentBG para tornar o fundo transparente.

  • E no Sprite3D, em Inspetor -> Sprite3D -> Texture selecione ViewportTexture, se selecione o nó SubViewport.

    Em Inpertor -> Sprite3D -> Flags ative o Bilboard para manter o Sprite sempre virado para a câmera ativa.

BoneAttachment3D

• Movimento seguindo ossos.

  • Para fazer um objeto acompanhar o movimento de algum osso, basta adicionar como filho do Skeleton3D um BoneAttachment3D clicar em Inspetor -> BoneAttachment3D -> Bone Name e escolher o osso desejado.

    Depois disso pode-se adicionar um Area3D como filho de BoneAttachment3D e um CollisionShape3D como filho do Area3D, depois clique em Inspetor -> CollisionShape3D -> Shape e escolha CylinderShape3D por exemplo para usa-lo como campo de visão em um osso de uma cabeça que gira por exemplo.

Cenas

• Descrição

  • Arquivos .tscn são os "Objetos" na Godot, são chamadas de Cenas e são compostas por diferentes tipos de componentes conhecidos como Nós.

    Essas cenas são arquivos salvos que podem ser adicionados dentro de outras cenas a qualquer momento apenas arrastando esses arquivos para a area de trabalho da Godot, ou sendo instanciadas via código dos scripts.

• • Mudar de cena.

    get_tree().change_scene_to_file("res://cenas/fase2.tscn")

DirectionalLight3D

• Sol

  • Para criar se sol adicione ao seu mundo um DirectionalLight3D, Inspetor -> DirectionalLight3D -> Shadow -> Enabled -> Ativo

    Inspetor -> DirectionalLight3D -> Transform -> Rotation -> x -> -70.

• Dia e Noite com hora baseada no sol

  • Declare no início do script do seu mundo.

    @onready var sol = $DirectionalLight3D @onready var label_hora = $CanvasLayer/VBoxContainer/Label_hora var horaStr: String var horas: float var minutos: float

  • Inicie as variáveis

    func _ready() -> void: horaStr = '00:00' horas = 0 minutos = 0

  • Chame a função em _process

    func _process(delta: float) -> void: Sol(delta)

  • Crie a função

    func Sol(Delta: float) -> void: sol.rotate(Vector3.LEFT, Delta * (-0.001)) var graus = rad_to_deg(sol.rotation.x) + 270 if graus >= 360: graus = rad_to_deg(sol.rotation.x) - 90 horas = ( graus / 15) var fracao = (hora - int(hora)) minutos = (0.6 * (fracao * 100)) if int(horas) == 17: sol.light_energy = 1 - fracao - 0.01 if sol.light_energy < 0: sol.light_energy = 0 if int(horas) == 5: sol.light_energy = fracao + 0.01 if sol.light_energy > 1: sol.light_energy = 1 horaStr = str(int(horas)) + ":" + str(int(minutos)).pad_zeros(2) label_hora.text = 'Hora: ' + horaStr

Estrutura dos Nós

Tipos de Nós

• • Node3D

    E o objeto mais primitivo da area 3D sendo filho de Node que seria o TObject em Pascal.

• • CharacterBody3D

    E o corpo físico recomndado para players e mobs, controla a colisão, fisíca e vem com um script padrão para controla a movimentação padrão.

• • RigidBody3D

    E o corpo físico recomndado para objetos, controla a colisão, fisíca dos objetos de acordo com o Shape escolhido em um filho CollisionShape3D.

• • CollisionShape3D

    É responsável por dar a forma das áreas, quando filho de um Area3D pode detectar a entrada e saida de objetos, quando filho de um StaticBody3D, RigdBody3D, ChacacterBody3D, etc é responsável pelos limites de colisão.

• • AnimationPlayer

    Responsável por armazenar e gerenciar as animações.

    Veja mais AQUI.

• • CPUParticle3D

    Responsável por intanciar vários objetos repetidamente com muitas formas de configurações, usada em vários efeitos como fumaça, explosões, etc.

    Veja mais AQUI.

• • RayCast3D

    Tem o formato de ponta e detecta coliões sem precisar de sinais ou nós adicionais através da função $RayCast3D.is_colliding().

  Propriedades úteis:

  • enabled: ativa ou desativa o raycast (ele só funciona quando está ativado).

    collision_mask: define quais camadas de colisão o raycast considera.

    exclude_parent: se ativado, ignora o nó pai do RayCast3D (útil se ele estiver como filho de um corpo físico).

    target_position: posição final do raio em relação ao nó. Define o comprimento e direção.

    hit_from_inside: permite detectar colisões mesmo se o raycast estiver dentro do objeto.

  Métodos principais:

  • is_colliding() → retorna true se o raio está batendo em algo.

    get_collider() → retorna o objeto colidido (Node ou RID).

    get_collider_rid() → retorna o RID do colisor (útil para operações mais técnicas, como físicas avançadas).

    get_collider_shape() → retorna o índice da shape colidida dentro do collider.

    get_collision_point() → retorna a posição exata do impacto (Vector3).

    get_collision_normal() → retorna o vetor normal da superfície onde o raio bateu (muito útil para saber a inclinação).

    force_raycast_update() → força a atualização do raycast naquele exato momento, caso precise de precisão fora do ciclo _physics_process().

• • StaticBody3D

    Corpo físico usado para item estáticos do cenário.

GridMap

• Criação dos "Tiles"

  • O primeiro passo é obter objetos ou cria-los no Blender, devem ser proporcionais geralmente em tamanhos 2x2 ou 1x1 metros e com seu ponto de origem bem centralizados para evitar problemas nas rotações.

    Assim como os demais modelos pode usar a forma de integração com o blender movendo os aquivos .blend para a pasta de recursos res://.

  Criação da biblioteca de Malhas "Mesh Library"

  • Primeiro crie uma nova cena 3D que já virá com um Node3D na base.

    Depois pode tratar casa objeto da forma que quiser reimportando como StaticBody3D, adicionando colisores,etc., e ir colocando-os na cena recém criada, não precisa organiza-los só adicionalos mesmo.

    Obs. 1 Pode usar os colisores nos Tiles sem medo pois a Godot processa todos de uma forma que não pesa no processamento.

    Obs. 2 Deixando o StaticBody3D como nó raíz os colisores não funcionaram, dai coloquei o MeshInstance3D como raíz e o StaticBody3D como filho do MeshInstance3D e funcionou normalmente.

    Depois clique em Cena -> Exportar Como... -> MeshLibrary... e salve esse arquivo "cena" como .tres.

  Usando o GridMap

  • Adicione um nó GridMap à sua cena, e em Inspetor -> GridMap -> Mesh Library adicione o recurso criado anteriormente.

    Agora é só usar as ferramentas e criar seu ambiente.

Instanciar Objetos

• Adicionar Objetos á uma cena.

  • Depois de criado um arquivo .tscn pode-se instância-lo, dentro de uma cena.

    Se tiver um Script Global pode se usar uma constante para pré carregar um arquivo e usar essa constante quantas vezes quiser, a vantagem é que o arquivo já é carregado no inicio do jogo e ficando disponivel na memória.

    Obs. Só pode haver um preload() apontando para o mesmo arquivo.

    const GALINHA: Resource = preload("res://cenas/galinha.tscn") var mundo: Node3D = get_node("/root/Mundo") var objeto: Node3D objeto = GALINHA.instantiate() mundo.add_child(objeto) objeto.global_position = Vector3D.ZERO

  • Outra forma de instanciar um objeto é usando uma variável com o metódo load().

    var pos_ini: Vector3 var recurso: Resource var pedra: StaticBody3D var mundo: Node3D pos_ini = Vector3(0, 0.408, 349.72) recurso = load("res://cenas/pedra_1.tscn") pedra = recurso.instantiate() mundo = get_node("/root/Mundo") mundo.add_child(pedra) pedra.global_position = pos_ini pedra.global_rotate(Vector3.UP, deg_to_rad(-90))

    Ou simplesmente

    var pos_ini = Vector3(0, 0.408, 349.72) var recurso = load("res://cenas/pedra_1.tscn") for i in 141: var pedra = recurso.instantiate() add_child(pedra) #Se estiver no script do mundo pedra.global_position = pos_ini pos_ini.x += 2.5 pedra.global_rotate(Vector3.UP, deg_to_rad(-90))

Integração com blender

• Descrição

  • A Godot pode se integrar com o blender permitindo abrir diretamente arquivos .blend que estejam dentro das pastas do projeto, atualizando automaticamente comforme o arquivo for modificado e gerenciando oquê se utilizar de acordo com o nome dos componentes no blender terminando-os com _sufixo.

• Configuração

  • Habilite o blender.

    Projeto => Configuraçoes do Projeto... => Geral => Arquivos => Importação => Blender => Ativo

  • Para integrar o Blender primeiro aponte o local do blender.exe.

    Editor => Configurações do Editor... => Geral => Arquivos => Importação => Caminho para o Blender

• Sufixos no Blender

  • Oque estiver terminado com _noimp no blender não aparecerá na Godot.

  • _skin indica uma malha que deve ser importada como parte do esqueleto, útil quando você tem várias partes do corpo ou roupas separadas, mas todas compartilham o mesmo Armature.

  • _col transporta os colisores para a Godot.

• Sugestão de cores para modelagem

  • Folhas => #228B22

    Tronco => #CD853F

• Atalhos

  • Espaço = Tocar parar animação.

    Ctrl + J = Fundir objetos.

    Alt + Z = Visão de Raio X.

    Shift + Z = Visão armação.

    Z = Menu de visões.

    1 = Visão de frontal.

    3 = Visão pela esquerda.

    7 = Visão de cima.

    9 = Inverter visão atual.

    2, 4, 6, 8 = Rotação gradativa.

    0 = Visão da câmera.

    Ctrl + Alt + 0 = Alinhar camera à visão.

    Ctrl + 0 = Definir câmera como ativa.

    F12 = Renderizar imagem.

    Ctrl + F12 = Renderizar animação.

    Ctrl + F11 = Tocar animação renderizada.

    T = Menu (esquerdo) de ferramentas.

    N = Menu direito.

    A = Selecionar tudo.

    Alt + A = Descelecionar tudo.

    Ctrl + I = Inverter seleção.

    Tab = Alterar modo de edição.

    G = Mover, pode ser usar x, y, z para fixar o movimento global, xx, yy, zz para fixar no movimento local ou Ctrl para atrair magneticamente.

    S = Escalar com recursos semelhantes ao G.

    R = Rotacionar com os mesmos recursos acima.

    Shift + D = Duplicar.

    Ctrl + D = Duplicar de forma que alteração em um influencirá os outros.

    Ctrl + A = Aplicar Transformações.

    Alt + G = Resetar movimentação.

    Alt + R = Resetar rotação.

    Alt + S = Resetar escala.

    H = Ocultar selecionados.

    Alt + H = Desocultar ocultos.

    Ctrl + P = Ativar parentesco ao último selecionado.

    Alt + P = desativar parentesco.

Materias

• Materiais Básicos.

  Gere os mapas a partir de uma imagem AQUI .

  • Albedo

    É a imagem simples da textura.

    Aumentar o Scale Y do UV1 até deixar o tamanho da textura satisfatório.

  • Normal Map

    É o mapa de dará efeito de relevo, o Godot usa o padrão GL que é o Y apontando para cima, no site acima deixar o Z Range -1 to +1 marcado.

    Caso você já possua um NormalMap que esteja no formato DirectX, também é possivel converte-lo no Gimp, abrindo a imagem e indo em "cores -> componentes -> decompor". Depois escolha RGB e inverta o canal verde Y. Depois só ir novamente em "cores -> componentes -> combinar".

  • Roughness

    É a rugosidade, aspereza do material, o site acima gera o Specular que é o oposto do Roughness, para se obter o Roughness basta abrir a imagem no Gimp, e clicar em "cores -> inverter" e depois exportar como Roughness.jpg.

• Materiais Opcionais.

  • Ambient Occlusion

    Refina um pouco mais a iluminação, para usa-lo é necessário ativar o SSAO do Nó WorldEnvironment.

  • Displacement

    Deve ser adicionado ao Height, também gera um refino a mais.

Mesclar polígonos

• Junta 2 polígonos sobrepostos

  • Para se mesclar dois polígonos, primeiro se cada cada ponto de cada um para posições globais, se faz o merge, converte os pontos para posição local novamente, é feito um for em mesclado pois se os poligonos não estiverem sobrepostos será retornado dois polígonos sepados novamente.

    Depois só adicionar o polígono, polígonos novos à cena e remover os antigos.

    func Mesclar(Ret1, Ret2: CollisionPolygon2D): var poly1_global = [] for point in Ret1.polygon: poly1_global.append(Ret1.to_global(point)) var poly2_global = [] for point in Ret2.polygon: poly2_global.append(Ret2.to_global(point)) var mesclado = Geometry2D.merge_polygons(poly1_global, poly2_global) var retangulos = get_node("../retangulos") for poly in mesclado: var novo = CollisionPolygon2D.new() retangulos.add_child(novo) var poly_local = [] for point in poly: poly_local.append(retangulos.to_local(point)) novo.call_deferred("set_polygon",poly_local) novo.position = Vector2.ZERO base = novo Ret1.queue_free() Ret2.queue_free()

Mouse

• Interações com o mouse

  • Selecionar objeto com o mouse.

    #Função do godot que captura eventos de entrada func _input(event: InputEvent) -> void: if event is InputEventMouseButton and event.button_index == MOUSE_BUTTON_LEFT and event.pressed: var origem = camera.project_ray_origin(event.position) var destino = origem + camera.project_ray_normal(event.position) * 1000 var estado = get_world_3d().direct_space_state var q = PhysicsRayQueryParameters3D.create(origem, destino) var retorno = estado.intersect_ray(q) if retorno: var objeto = retorno.collider print("Objeto: " + objeto.name)

  • Ocultar o mouse capturar, para poder move-lo sem que ele saia da tela do jogo.

    func _ready() -> void: Input.set_mouse_mode(Input.MOUSE_MODE_CAPTURED)

Movimentações

• Rotações

  • Funções de rotação

    A Godot usa geralmente radianos e não graus (degrees).

    Para rotacionar um objeto pode se usar Objeto.global_rotate(Vector3.UP, deg_to_rad(90)) para rotacionar em modo global.

    Ou Objeto.rotate_object_local(Vector3.UP, deg_to_rad(90)) para rotacionar em modo local.

    Lembrando que os dois métodos acima adicionam a rotação, para se definir a rotação exata se usa Objeto.rotation.x = deg_to_rad(90) para rotação local e Objeto.global_totation.x = deg_to_rad(90) para rotação global.

    Pode se passar um Vector3 também dessa forma Objeto.rotation = Vector3(0, deg_to_rad(90), 0).

    Ambos rotacionam o Objeto em 90º em Y, convertendo graus para radianos.

  • Tabela de conversões
    Graus (deg)	Radianos (rad)
    0°	0
    90°	π/2 ≈ 1.5708
    180°	π ≈ 3.1416
    270°	3π/2 ≈ 4.7124
    360°	2π ≈ 6.2832

• Direções

  • Importante

    Um personagem no Bleder na visão frontal deve ficar olhando para a câmera enquanto na Godot na visão frontal deve ficar de costas para a camêma, mas estou me referindo a malha e não ao CharacterBody3D, a rotação em Y do CharacterBody3D enquanto a rotação em Y da malha deverá ser -180º.

    Não seguir essa regra, bagunçará todo o script de movimento e rotação.

  • Movimentação de Personagem

    func _physics_process(delta: float) -> void: if not is_on_floor(): velocity += get_gravity() * delta if Input.is_action_just_pressed("pula") and is_on_floor(): velocity.y = VELOCIDADE_PULO var entrada_direcao: Vector2 var direcao: Vector3 entrada_direcao = Input.get_vector("esquerda", "direita", "frente", "traz") direcao = (transform.basis * Vector3(entrada_direcao.x, 0, entrada_direcao.y)).normalized() direcao = direcao.rotated(Vector3.UP, $SpringArm3D.rotation.y) if direcao != Vector3.ZERO: velocity.x = direcao.x * VELOCIDADE velocity.z = direcao.z * VELOCIDADE var Filho_CharacterBody3D: Node3D Filho_CharacterBody3D = $Rig Filho_CharacterBody3D.rotation.y = lerp_angle(Filho_CharacterBody3D.rotation.y, atan2(velocity.x, velocity.z), delta * 10) else: velocity.x = move_toward(velocity.x, 0, VELOCIDADE) velocity.z = move_toward(velocity.z, 0, VELOCIDADE) move_and_slide()

  Explicação

  • Tudo ocorrerá dentro da função _physics_process que é um looping infinito e a cada volta passa por parametro delta que é o tempo calculado entre os frames de acordo com a potência do computador, oque faz com que a física seja processada da melhor forma possível no tempo correto idependente do fps.

    velocity é um Vector3 que faz parte do ChacacterBody3D ele recebe a dados da direção + velocidade que serão aplicados ao objeto pela função move_and_slide().

    As direções de um controle comum são para 2 eixos 4 direções, enquanto em um cenário 3D é formado por 3 eixos e 6 direções, por isso a direção final é calculada usando a direção de entrada se adicionando o 3º eixo, multiplicando pelo transform.basis que é um vetor de localização mais refinado e passado ao normalize() que faz mais calculos trigonométricos para normalizar as direções.

    direcao.rotated() adiciona uma rotação à direção envolvendo mais cálculos trigonometrícos baseado na rotação do $SpringArm3D que é tipo um "braço mola" que segura a câmera que acompanha o personagem.

    Depois é verificado se existe uma direção aplicada se houver é acrescentado essa direção + a velocidade ao velocity.

    A malha do personagem fica em um nó filho do CharacterBody3D, para que seja rotaciona a malha e não o objeto inteiro, usando-se a função learp_angle() com o arco da tangente do velocity fazendo assim uma rotação suave da direção da malha para o direção em que o objeto está indo.

    Se não houver uma direção é usada a função move_toward() que faz o objeto parar suavemente e não bruscamente.

    E por último o move_and_slide() que aplica tudo para o objeto se mover e deslizar simulando física.

MultiMeshInstance3D

• Criar varias Malhas aleatóriamente

  Preparando o Mesh

  • Primeiro é preciso extrair uma Mesh como recurso .res.

    Para isso clique duas vezes no arquivo .blend pelo proprio gerenciador de arquivos do godot para reimportar o modelo.

    Na aba Malhas selecione a malha desejada e selecione Habilitado em Salvar como arquivo ecolha o caminho de preferencia para uma pasta de recursos e clique em Reimportar.

    Fazendo isso você terá um arquivo .res para usa-lo como Mesh.

  Adicionado o Nó

  • Adicione o Nó MultiMeshInstance3D como filho do Nó raiz da cena e adicione um script à ele.

  Script

  • extends MultiMeshInstance3D var grama = preload("res://recursos/grama1.res") var terreno: MeshInstance3D var tamanho_terreno: Vector3 func _ready() -> void: terreno = $"../CollisionShape3D/MeshInstance3D" tamanho_terreno = terreno.mesh.get_aabb().size multimesh = MultiMesh.new() multimesh.mesh = grama #Essas duas próximas linhas precisam estar nessa ordem multimesh.transform_format = MultiMesh.TRANSFORM_3D multimesh.instance_count = 10000 for i in multimesh.instance_count: var x = randf_range(-tamanho_terreno.x / 2, tamanho_terreno.x / 2) var z = randf_range(-tamanho_terreno.y / 2, tamanho_terreno.y / 2) var rotacaoY = randf_range(0, TAU) var escala = randf_range(0.8,1.2) var posicao = Transform3D() posicao.origin = Vector3(x,0,z) posicao.basis = Basis(Vector3.UP, rotacaoY).scaled(Vector3.ONE * escala) multimesh.set_instance_transform(i, posicao)

Partículas

• Partículas 2D em ambiente 3D.

  • Adicione o nó GPUParticles3D na cena desejada.

    Vá em Inspetor >> GPUParticles3D >> Draw Passes >> Passes 1 e selecione QuadMesh clique no QuadMesh >> Material >> StandardMaterial3D clique mo Material e arraste a imagem .png para Texture e ative a Transparency >> Alpha.

    Em Inspetor >> GPUParticles3D >> Process Material selecione ParticleProcessMaterial, nesse momento já será visível as particulas.

    Agora só ajustar as propriedades em Time de acordo com suas preferências.

  • As propriedades mais comuns são:

    Emitting = ativa as partículas.

    Ammount Ratio = quantidade gerada por vez.

    Time >> Lifetime = tempo da duração.

    Time >> One Shot = se ativo executa apenas uma vez.

    Time >> Lifetime = tempo da duração.

    Drawing >> Transform Align >> Z-Billboard = para ficar da direção da câmera ativa.

    Process Material >> Spawn >> Position >> Emission Shape = forma da emissão.

    Process Material >> Accelerations >> Gravity = se quiser inverter a gravidade.

    Draw Passes >> Pass 1 >> QuadMesh >> Material >> Billboard >> Mode >> Enable = Para garantir que a textura aponte para a câmera ativa.

Propriedades

• • Alterar uma propriedade com segurança agendando-a para o final do processamento para evitar erros.

    $shape.set_deferred("disabled",true)

SpringArm3D

• Pivot da Câmera

  • É um nó que pode ser usado como filho do ChacterBody3D e pai de uma Camera3D, ele é tipo um braço mecânico que age como uma mola que segura a camera atrás do personagem a uma distância personalizada e caso o personagem encoste as costas em algo, a câmera se desloca para frente impedindo de entrar dentro das paredes e bugar a visão.

    Abaixo um script para adicionar nele para que ele rotacione de acordo com o movimento do mouse criando a jogabilidade padrão de movimento de camera 3D em 3º pessoa.

    extends SpringArm3D const sensibilidade_mouse: float = 0.005 func _unhandled_input(event: InputEvent) -> void: if event is InputEventMouseMotion: global_rotate(Vector3.UP, -event.relative.x * sensibilidade_mouse) rotate_object_local(Vector3.RIGHT, -event.relative.y * sensibilidade_mouse) rotation.x = clamp(rotation.x, -PI/4, PI/4) rotation.z = 0

  • O código é auto explicativo, movendo o pivot globalmente em x e localmente em y, usando uma regulagem de sensibilidade do mouse, limitando a rotação em x com o clamp() e impedindo a rotação em z.

WorldEnvironment

• Configuração do Ambiente

  • Ambiente Básico

    Primeiro adicione o Sol AQUI.

    Para configurar o ambiente de uma forma leve e básica, adicione um nó WorldEnvironment ao seu mundo, vá em Inspetor -> Environment, escolha Environment e clique nele.

    Altere Backgroud -> Mode -> Sky.

    Sky -> Sky -> Sky.

    Sky -> Sky Material -> ProcedureSkyMaterial

    Clicando em ProcedureSkyMaterial ajuste as cores do céu e do horizonte em Sky e as cores do chão em Ground.

• Colorir céu de acordo com a hora

  • Declar varíaveis

    @onready var mundo = $WorldEnvironment.environment var ceu: Sky var material_ceu: ProceduralSkyMaterial

  • Iniciar varíaveis

    func _ready() -> void: ceu = mundo.sky material_ceu = ceu.sky_material

  • Chamar função

    func _process(delta: float) -> void: Ceu()

  • Criar a função

    func Ceu() -> void: var valor = 0 var cor_atual: Color var cor_noite = Color(0,0,0) var cor_T_manha = Color(0.15,0.25,0.4) var cor_H_manha = Color(0.9, 0.4, 0.2) var cor_T_dia = Color(0.35,0.6,0.9) var cor_H_dia = Color(0.65, 0.8, 1) var cor_T_tarde = Color(0.1, 0.15, 0.3) var cor_H_tarde = Color(1, 0.35, 0.1) #Amanhecer if int(horas) == 5: valor = clamp(minutos * 0.03, 0, 1) cor_atual = cor_noite.lerp(cor_T_manha, valor) material_ceu.sky_top_color = cor_atual cor_atual = cor_noite.lerp(cor_H_manha, valor) material_ceu.sky_horizon_color = cor_atual #Dia if int(horas) == 6: valor = clamp(minutos * 0.03, 0, 1) cor_atual = cor_T_manha.lerp(cor_T_dia, valor) material_ceu.sky_top_color = cor_atual cor_atual = cor_H_manha.lerp(cor_H_dia, valor) material_ceu.sky_horizon_color = cor_atual #Tarde if int(horas) == 17: valor = clamp(minutos * 0.03, 0, 1) cor_atual = cor_T_dia.lerp(cor_T_tarde, valor) material_ceu.sky_top_color = cor_atual cor_atual = cor_H_dia.lerp(cor_H_tarde, valor) material_ceu.sky_horizon_color = cor_atual #Noite if int(horas) == 18: valor = clamp(minutos * 0.03, 0, 1) cor_atual = cor_T_tarde.lerp(cor_noite, valor) material_ceu.sky_top_color = cor_atual cor_atual = cor_H_tarde.lerp(cor_noite, valor) material_ceu.sky_horizon_color = cor_atual