godot-rust/gdext

Features

• Native Engine Extensions - Provides a framework for creating native engine extensions and custom classes without recompiling the core engine source.
• GDExtension Implementations - Provides a framework for creating native engine extensions and custom classes using the GDExtension API.
• Macro-Based Type Registrations - Uses compile-time macros to automatically generate the boilerplate code required for registering classes and methods with the engine.
• Godot Rust Bindings - Provides high-performance Rust language bindings for writing native game logic in Godot 4.
• Native Engine Extensions - Provides a toolkit for developing high-performance native extensions, physics simulations, and editor plugins.
• Scene Tree Manipulations - Provides utilities for initializing and accessing child nodes within the scene tree to manipulate objects and UI.
• C API Rust Bindings - Provides language bindings that expose low-level C APIs to allow Rust to extend core engine classes.
• Class Method Overrides - Implements a mechanism to override core engine class functions to customize default behaviors via a stable interface.
• Data Type Conversions - Provides utilities for transforming native Rust types into specialized Godot data structures like vectors and packed arrays.
• Variant-Based Conversions - Translates between Rust types and the engine's universal data container for seamless property and argument passing.
• Dynamic Dispatch Mechanisms - Manages runtime polymorphism and class inheritance through smart pointers and dynamic casting logic.
• Foreign Function Interfaces - Implements binding layers for low-overhead communication and data exchange between Rust and the engine's C-compatible signatures.
• Type-Safe Pointer Wrappers - Manages native pointers with casting logic to maintain type safety during runtime class inheritance in the engine.
• Rust WebAssembly Integrations - Includes a dedicated toolchain for compiling native game logic into WebAssembly modules for browser execution.
• Inheritance-Aware Smart Pointers - Wraps native pointers in smart pointers with casting logic to maintain type safety during runtime class inheritance.
• Custom Signal Definitions - Provides a mechanism to create typed event signals that emit notifications to listeners with controlled visibility.
• Type-Safe Event Contracts - Implements type-safe callbacks for connecting to engine events to trigger native logic during state changes.
• Engine Event Listeners - Implements type-safe listeners that trigger native logic in response to built-in engine signals.
• Scripting Interop - Implements a registration system that makes native Rust functions callable from the Godot scripting environment.
• Engine Loop Callbacks - Provides hooks to execute custom native logic on every frame or physics tick within the primary engine loop.
• WebAssembly Exports - Provides toolchains to compile native game logic into WebAssembly modules for execution in web browsers.
• Interactive Narratives - Integrates local large language models to generate dynamic, AI-driven narratives and interactive storytelling.
• Inspector Variable Exposure - Provides attributes to mark Rust fields as editable within the visual property inspector for real-time tuning.
• Editor Plugins - Provides a framework for creating custom tools and extensions that integrate directly into the game engine editor.
• Physics Simulations - Integrates with 2D and 3D physics engines to calculate complex collision and movement dynamics.
• Infinite Terrain Generators - Provides algorithmic tools for creating deterministic 3D terrains and landscapes using procedural noise.
• Type-Safe Remote Calls - Implements remote procedure calls with strong typing for coordinated logic execution across networked game clients.
• Asynchronous Processing - Enables non-blocking execution of event signal processing using asynchronous syntax to maintain engine responsiveness.
• Multi-threaded Execution - Provides concurrency support and synchronization mechanisms for managing shared instance access during logic execution.
• Web Threading Models - Supports separate single-threaded and multi-threaded builds to ensure compatibility across different browser environments.
• Wasm Development Toolchains - Provides a toolchain for compiling native game logic into WebAssembly modules for execution in web browsers.
• Asynchronous Task Managers - Supports non-blocking operations using coroutines and runtime environments to maintain application responsiveness.
• Node-Attached Scripting Systems - Allows binding native Rust scripts directly to engine nodes to implement custom behavior without recompiling the core.
• Function Pointer Lazy Loading - Reduces initial memory usage and startup time by deferring the loading of engine function pointers.
• Singleton Patterns - Implements a system for defining global objects and autoloads to maintain consistent state across the application.
• Deferred Function Loading - Reduces initial memory usage and startup time by deferring the loading of engine function pointers until they are first used.
• Procedural Content Generation - Provides algorithmic frameworks for creating dynamic game worlds and environments.

Star-Verlauf