Godot Engine 3.5

https://docs.godotengine.org/en/3.5
Admin
Godot Engine is a free and open-source game engine that supports 2D and 3D game development with...
Tokens:20,377,119
Snippets:265,632
Trust Score:10
Update:9 months ago
Show doc for...
Tokens:
Raw
### Your First 2D Shader Setup Example

Source: https://docs.godotengine.org/en/3.5/classes/class_opensimplexnoise

Guides through the initial setup for creating your first 2D shader in Godot. This involves creating a new shader resource and assigning it to a material used by a 2D node.

```gdscript
extends Sprite

func _ready():
    var shader_material = ShaderMaterial.new()
    var shader = load("res://shaders/my_first_shader.shader")
    shader_material.shader = shader
    self.material = shader_material

```

--------------------------------

### Setting up VideoPlayer (C#)

Source: https://docs.godotengine.org/en/3.5/classes/class_gltflight

Provides a basic C# example for setting up and controlling the VideoPlayer node. It covers loading a video file and playing it.

```csharp
using Godot;
using System;

public partial class VideoPlayerSetup : Node
{
    private VideoPlayer _videoPlayer;

    public override void _Ready()
    {
        _videoPlayer = GetNode<VideoPlayer>("VideoPlayer");

        // Set the video path
        _videoPlayer.FileName = "res://your_video.webm";
        // Play the video
        _videoPlayer.Play();
    }

    private void _on_VideoPlayer_finished()
    {
        GD.Print("Video finished playback");
        // Optionally loop the video
        // _videoPlayer.Play();
    }
}

```

--------------------------------

### Physics Interpolation: Quick Start Guide

Source: https://docs.godotengine.org/en/3.5/classes/class_editorscriptpicker

Provides a basic setup for physics interpolation in Godot to smooth out visual stuttering caused by differing physics and frame rates.

```GDScript
extends Node

# Ensure this script is attached to a node that is processed before rendering
# e.g., an autoload singleton or the root node.

var physics_ticks_per_second = 60
var tick_delta = 1.0 / physics_ticks_per_second
var interpolation_alpha = 0.0

func _physics_process(delta):
    # This is where your physics simulation happens.
    # Ensure your physics tick rate is consistent.
    pass

func _process(delta):
    # Calculate the interpolation alpha based on the time since the last physics tick.
    # This assumes your physics tick rate is fixed.
    interpolation_alpha = (get_tree().physics_frames - 1) / float(get_tree().physics_ticks_per_second)
    # More robust calculation might be needed for variable physics ticks.

    # You would then use interpolation_alpha to blend between the previous and current physics states
    # for rendering. This usually involves custom rendering code or a node setup
    # that supports interpolation.
    pass
```

--------------------------------

### Example: Basic Physics Interpolation Setup

Source: https://docs.godotengine.org/en/3.5/classes/class_acceptdialog

A quick start guide to implementing physics interpolation in Godot to smooth out discrepancies between physics ticks and frame rates.

```GDScript
extends Node3D

# This script should be attached to the root node of your scene.
# It assumes your physics tick rate is handled by the project settings.

var physics_tick_rate = Engine.get_physics_ticks_per_second()
var physics_delta = 1.0 / physics_tick_rate
var current_physics_time = 0.0
var previous_physics_time = 0.0

func _ready():
    # Ensure physics frames are not locked to render frames if you want interpolation.
    # You might want to adjust Project Settings -> Physics -> Common -> Physics Ticks Per Second.
    pass

func _process(delta):
    # Calculate the physics time elapsed since the last frame.
    # This is a simplified approach; a more robust solution might track actual physics frame timings.
    current_physics_time += delta

    # Calculate the interpolation fraction.
    # This fraction represents how far into the *next* physics frame the current rendered frame is.
    # For example, if physics runs at 60Hz (0.0166s) and frames are at 30Hz (0.0333s),
    # each frame needs to interpolate across two physics ticks.
    var interpolation_fraction = (current_physics_time - previous_physics_time) / physics_delta

    # Clamp the fraction to avoid issues with large deltas or catching up.
    interpolation_fraction = clamp(interpolation_fraction, 0.0, 1.0)

    # Apply interpolation to your physics objects.
    # You'll need to iterate through your physics bodies and apply their interpolated transforms.
    # Example:
    # for body in get_tree().get_nodes_in_group("interpolated_bodies"):
    #     var interpolated_transform = body.get_transform().interpolate_with(body.get_previous_transform(), interpolation_fraction)
    #     body.set_transform(interpolated_transform)

    # Update previous physics time for the next frame.
    # This requires tracking when actual physics ticks occurred.
    # For a basic example, you might reset or advance this based on delta.
    # A common technique is to store the physics state from the previous tick.
    # previous_physics_time = current_physics_time # This is too simplistic

    # A more accurate approach involves storing the physics state of bodies from the previous tick
    # and interpolating between the previous and current state.
    pass

# Note: A full implementation requires storing the state of physics bodies from the previous tick
# and calculating the interpolation fraction based on the actual physics tick timing.
# The example above outlines the concept but needs a complete system to work.

```

--------------------------------

### C#: Project Setup and Initialization

Source: https://docs.godotengine.org/en/3.5/classes/class_gltfcamera

This C# code illustrates basic project setup within Godot, focusing on the `_Ready` function which is called when a node and its children enter the scene tree. It's the standard entry point for initialization.

```C#
using Godot;

public class Game : Node
{
    public override void _Ready()
    {
        GD.Print("Game started!");
        // Further initialization logic here
    }
}
```

--------------------------------

### Physics Interpolation Quick Start Guide

Source: https://docs.godotengine.org/en/3.5/classes/class_physicsdirectbodystate

A quick guide to implementing physics interpolation in Godot. Physics interpolation helps to smooth out visual discrepancies between the physics simulation rate and the frame rate, especially when they are not synchronized. This example shows the basic setup for enabling it.

```GDScript
extends Node

var physics_interpolation_enabled = true
var physics_interpolation_fraction = 0.0

func _process(delta):
	if physics_interpolation_enabled:
		physics_interpolation_fraction = fmod(Engine.get_physics_frames(), Engine.get_physics_interpolation_fraction())
		# Update visual positions based on interpolation

func _physics_process(delta):
	if !physics_interpolation_enabled:
		# Update physics positions directly
```

--------------------------------

### C#: Basic Script Setup and Node Initialization

Source: https://docs.godotengine.org/en/3.5/classes/class_container

Provides a C# script example for Godot, showing basic setup and how to access nodes within the scene.

```csharp
using Godot;

public class MyNode : Node
{
    public override void _Ready()
    {
        GD.Print("Hello from C#!");
        var label = GetNode<Label>("MyLabel");
        label.Text = "Initialized";
    }
}
```

--------------------------------

### C# Player Movement

Source: https://docs.godotengine.org/en/3.5/classes/class_collisionpolygon2d

A C# example for implementing player movement using input actions. Similar to GDScript, this code responds to 'ui_up' input and adjusts the node's velocity. It requires the .NET version of Godot and proper project setup for C# scripts.

```csharp
using Godot;

public class Player : KinematicBody2D
{
    private float speed = 200;
    private Vector2 velocity;

    public override void _Input(InputEvent @event)
    {
        if (@event.IsActionPressed("ui_up"))
        {
            velocity.y = -speed;
        }
        else if (@event.IsActionReleased("ui_up"))
        {
            velocity.y = 0;
        }
    }

    public override void _PhysicsProcess(float delta)
    {
        MoveAndSlide(velocity);
    }
}
```

--------------------------------

### Your First 2D Shader: Basic Setup

Source: https://docs.godotengine.org/en/3.5/classes/class_rayshape2d

A simple 2D shader example demonstrating basic setup and fragment processing. This illustrates how to create a colored output for a 2D object.

```glsl
shader_type canvas_item;

void fragment() {
    COLOR = vec4(1.0, 0.5, 0.0, 1.0); // Orange color
```

--------------------------------

### Basic GDScript Example

Source: https://docs.godotengine.org/en/3.5/classes/class_editorscript

A fundamental GDScript example demonstrating a simple node setup and its `_ready` function. This serves as a starting point for understanding GDScript syntax and execution flow in Godot Engine.

```GDScript
extends Node2D

var message: String = "Hello, Godot!"

func _ready():
	print(message)
	var position = get_position()
	print("Node is at: " + str(position))

func _process(delta):
	# This function is called every frame
	pass

```

--------------------------------

### C#: Basic Scene Setup and Node Interaction

Source: https://docs.godotengine.org/en/3.5/classes/class_audiostreamrandompitch

This C# script demonstrates the fundamental process of creating a new script, attaching it to a node, and implementing a simple 'Hello, world!' output. It covers project setup and basic scripting.

```C#
using Godot;

public partial class HelloWorld : Node2D
{
	public override void _Ready()
	{
		GD.Print("Hello, world!");
	}
}
```

--------------------------------

### C#: Basic Scene Setup and Node Properties

Source: https://docs.godotengine.org/en/3.5/development/cpp/introduction_to_godot_development

This C# example demonstrates how to set properties of a node, such as its position, scale, and color, after it has been initialized. The `_Ready()` method is the appropriate place to perform these initializations, ensuring the node is part of the scene tree.

```C#
using Godot;

public partial class MySprite : Sprite2D
{
	public override void _Ready()
	{
		Position = new Vector2(100, 50);
		Scale = new Vector2(2, 2);
		Modulate = new Color(1, 0.5f, 0.5f); // Reddish tint
	}
}
```

--------------------------------

### Basic Shader Language Example

Source: https://docs.godotengine.org/en/3.5/classes/class_pluginscript

A fundamental example of a shader written in Godot's shading language. This shader typically defines basic vertex and fragment processing for rendering.

```gdshader
shader_type spatial;

void vertex() {
    // Vertex processing code here
    // For example, modifying vertex positions:
    // VERTEX.y += sin(TIME) * 0.1;
}

void fragment() {
    // Fragment processing code here
    // For example, setting the base color:
    // ALBEDO = vec3(1.0, 0.5, 0.0);
}
```

--------------------------------

### C#: Basic Scene Setup and Node Properties

Source: https://docs.godotengine.org/en/3.5/classes/class_inputeventjoypadbutton

Demonstrates how to create a new scene, add nodes, and change their properties using C#. This mirrors the GDScript example for scene creation.

```C#
using Godot;

public class MyScene : Node2D
{
    public override void _Ready()
    {
        // Create a new Sprite node
        var sprite = new Sprite();
        sprite.Texture = GD.Load<Texture>("res://icon.png");
        sprite.Position = new Vector2(100, 100);
        AddChild(sprite);

        // Change the scale of the sprite
        sprite.Scale = new Vector2(2, 2);
    }
}
```

--------------------------------

### GLSL Shader Conversion Example

Source: https://docs.godotengine.org/en/3.5/classes/class_pluginscript

Shows how to convert a basic GLSL shader program to Godot's shading language. This example might include vertex attributes and the main function structure.

```glsl
// GLSL Example

// Vertex Shader
attribute vec4 a_position;
attribute vec2 a_texcoord;
varying vec2 v_texcoord;

void main() {
    gl_Position = a_position;
    v_texcoord = a_texcoord;
}

// Fragment Shader
varying vec2 v_texcoord;
uniform sampler2D u_texture;

void main() {
    gl_FragColor = texture2D(u_texture, v_texcoord);
}
```

--------------------------------

### Your First 3D Shader Setup Example

Source: https://docs.godotengine.org/en/3.5/classes/class_opensimplexnoise

Details the setup process for applying your first 3D shader to a mesh in Godot. This involves creating a `ShaderMaterial` and assigning a shader resource to it, then applying this material to a `MeshInstance`.

```gdscript
extends MeshInstance

func _ready():
    var shader_material = ShaderMaterial.new()
    var shader = load("res://shaders/my_first_3d_shader.shader")
    shader_material.shader = shader
    self.material_override = shader_material

```
Tokens:
Raw