Plugins

A plugin for Godot that makes creating and maintaining translations much easier and intuitive in-editor. The goal of this plugin is to make it easy to create new translations and add them to existing or new .csv files. This will replace the old workflow of creating new .csv files and adding text before then adding them to editor without being able to see what you're adding. This method is also prone to mistakes where you could make a typo in the key for example. This workflow is also harder to follow through with, as you need to plan out all the text you need ahead of time, or go back and forth between the game and your .csv files constantly. This plugin makes the entire workflow doable from within the editor's inspector.

A unit testing library for Godot. * Define tests with test methods or programmatically with `define()` * Parameterized tests to conveniently define multiple tests * Mock classes dynamically, for simpler unit testing * Run benchmarks, to find the best performing implementations * Generate reports in TAP format, to integrate with other test harnesses * In-editor UI for convenient testing * Support for running in CI

# Rust Template for Godot This is a template project for using Rust in Godot, created based on the official [Godot-Rust](https://godot-rust.github.io/book/intro/hello-world.html) guide. It serves as a starting point for developers who want to integrate Rust into their Godot projects for better performance and type safety. ## Features - Template project to get started with Godot and Rust. - Configured to work with Godot Engine and the [Godot Rust bindings](https://github.com/godot-rust/gdext). - Provides a simple "Hello, World!" example to demonstrate how to integrate Rust code into Godot. - Setup is based on the [Hello World](https://godot-rust.github.io/book/intro/hello-world.html) tutorial from the official Godot-Rust book. ## Requirements - **Godot Engine** version 4.4 or later. - **Rust** installed. You can download it from the official website: https://www.rust-lang.org/ - **Cargo** – the Rust package manager, which is included when installing Rust. ## Installation 1. Clone this repository or download the ZIP. 2. Make sure you have Godot and Rust set up correctly. 3. Navigate to the `rust-template-godot` project folder and open the `rust-template` project with Godot. 4. Build the Rust code: - In the terminal, go to the project `rust` directory and run: ``` cargo build ``` 5. Run the project from Godot. ## Usage Once everything is set up, you can start adding your own Rust code into the project. The template includes a simple example that prints "Hello, World!" to the Godot console, and adds a `Player` class based on Sprite2D. This can be extended to your game logic. To modify the Rust code: 1. Open `src/lib.rs`. 2. Add your custom functionality or game logic written in Rust. 3. After making changes, rebuild your project using `cargo build` and test the integration in Godot. ### Visual Studio Code If you are working with VS Code, I recommend you to use the `rust-analyzer` extension and setting the `Check: Command` to `build`. This enables you library to be compiled each time you save your files, allowing for fast changes to be applied inside the Godot Editor without having to compile them in the terminal yourself each time. > This is only useful in Godot 4.2+ since it allows to import the changes without reloading the project. Since this template aims for 4.4+, this should not be a problem. Keep this in mind if you try a lesser version though. ## Project Structure - `rust`: The Rust directory for writing code. - `rust-template`: The Godot project directory, where scenes and assets are located. - `README.md`: This file. - `LICENSE` The MIT license ## Troubleshooting - If you encounter issues with Rust not building, ensure your environment is correctly configured by following the steps in the official [Godot-Rust Book](https://godot-rust.github.io/book/intro/hello-world.html). - For specific issues with the Godot-Rust bindings, refer to the official [GitHub repository](https://github.com/godot-rust/gdext) or consult the community forums. ## License This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for more details. The godot-rust Ferris icon was obtained from [their repository](https://github.com/godot-rust/assets) and its licence's details are explained [here](https://github.com/godot-rust/assets/blob/master/asset-licenses.md). ## Acknowledgments - [Godot Engine](https://godotengine.org/) - [Godot Rust](https://github.com/godot-rust/gdext) for their fantastic work on integrating Rust with Godot.

The LanguageProcessor class is a comprehensive solution for handling language-specific settings in the Godot Engine. It manages language selection and font variations for UI elements based on the current language setting. This class is especially useful for multilingual applications and games, providing easy integration and dynamic language switching capabilities. If you want to translate the whole Scene. Your nodes have to get the name like the key in the csv file. Label or Richtext Node: menu_start The script search for a key like the node name and translate it. ## Features - **Language Support**: Supports a variety of languages, including those with Latin, Greek, Cyrillic, East Asian (Chinese, Korean, Japanese), and other. - **Font Management**: Handles different font styles (regular, bold, italic/light) for each supported language. - **Automatic Language Detection**: Defaults to the system language or falls back to English if the system language is not supported. Version: 4.X Tested: 4.2

This is a demo showing how one can generate and play audio samples from GDScript. It plays a simple 440 Hz sine wave at 22050 Hz. How it works: It uses the `push_frame()` method on an AudioStreamGeneratorPlayback object, which is inside of an AudioStreamPlayer node, to generate audio frame-by-frame based on `pulse_hz`. Language: GDScript Renderer: Compatibility

Demonstrates how to override GUI colors and styleboxes at runtime. Language: GDScript Renderer: GLES 2

This is a demo showing text-to-speech support. How it works: It uses `tts_*()` methods of the DisplayServer singleton to enumerate voice information, send utterances to the OS TTS API, and receive callback signals. Language: GDScript Renderer: Compatibility

This demo project gives an example of how to use compute shaders in Godot. A compute shader is a piece of code that runs on the GPU and is written in GLSL (as opposed to the Godot shader language). A compute shader can be used to take advantage of the GPU's ability to perform massively parallel operations faster than a CPU. This demo can generate the heightmap of an island from a noise texture, both on the CPU and the GPU. You can try both options to compare the time it takes to generate the heightmap on the CPU and GPU respectively. For smaller noise textures, the CPU will often be faster, but the larger the gains are by using the GPU. On a PC with a NVIDIA GeForce RTX 3060 and 11th-generation Intel Core i7 processor, the compute shader was tested to be faster for textures 1024×1024 and larger. The dimensions of the image can be set on the exported "Dimensions" property on the main scene. By default, it's set to 2048, which creates a 2048×2048 heightmap. NOTE: The shader code has been structured to be followed step-by-step by the user, and may not necessarily represent best practices. The CPU code is also less optimized than it could be. This is to reflect the GPU code as much as possible. Besides the use of the GPU, no multithreading is used. Languages: GDScript, GLSL Renderer: Mobile

A plugin for creating accessible rich internet applications with godot.

A demo for my scrolling backgrounds tool.

Automatically formats and lints GDScript files on save using gdformat and gdlint.

A demo for my scrolling backgrounds tool.

Navigation mesh demo for 3D scenes, with a character able to pathfind around a complex 3D environment. The navigation path is drawn using a line. Code is provided for polyline following in 3D. Language: GDScript Renderer: GLES 3

music player with spectrum viewer, with this template you can implement it for your own projects characteristics: Spectrum viewer .mp3 file scanner

It's just fxxking same as Unity Coroutine.

An example showing how to take screenshots of the screen. Language: GDScript Renderer: GLES 2

This project demonstrates how to set up a project to handle screens of multiple resolutions and aspect ratios. This demo allows you to adjust the window's base resolution, stretch mode, stretch aspect, and scale factor (internally known as "stretch shrink"). This lets you see what happens when adjusting those properties. Make sure to resize the project window in any direction to see the difference with the various stretch mode and stretch aspect settings. The GUI can be made to fit the window or constrained to a specific aspect ratio from a list of common aspect ratios. On ultrawide aspect ratios, this can be used to prevent HUD elements from being too spread apart, which can harm the gameplay experience. For non-essential HUD elements, specific controls can be made to ignore this aspect ratio constraint when it makes sense (e.g. a list of players on the side of the screen). Additionally, a GUI margin setting is provided to better handle TVs with an overscan area to prevent GUI elements from being cut off. This can also improve the gameplay experience on large monitors by bringing HUD elements closer to the center of the screen. A DynamicFont is also used to ensure font rendering remains crisp at high resolutions, thanks to Godot's built-in support for font oversampling. In other words, the engine will automatically re-rasterize fonts at different resolutions than the base window size when the window is resized (or when the window scale factor is changed). Language: GDScript Renderer: GLES 2

Run away from Evil Godots forever. Full Godot C# project for procedural infinite terrain generation, with random items or obstacles spreading throughout the map, with physics enabled.