godotengine/godot-cpp
Godot Cpp
godot-cpp is a C++ binding library and development kit for creating high-performance extensions and custom nodes for the Godot engine. It provides the necessary headers and framework to implement complex game logic and low-level systems using native code.
The project enables the development of GDExtension plugins, allowing native libraries to be loaded into the engine without requiring a full recompilation of the core software. It facilitates the creation of custom engine extensions through a system of native bindings that map C++ classes and methods to the internal engine database.
The framework covers API integration via class registration and signal binding, as well as editor integration for exposing member variables. It includes a CMake-based build system for multi-platform targeting, supporting cross-compilation for desktop, Android, and WebAssembly via Emscripten.
The build process incorporates integration testing and the generation of compilation databases for IDE support.
Features
- Engine Modules and Extensions - Enables the addition of new node types and specialized functionality to the engine using native C++ code.
- C Function Bindings - Implements a native binding layer that maps C++ classes and methods to the engine's internal database.
- Variant Data Types - Provides specialized array types and generic variant classes to maintain data compatibility between native code and the engine API.
- Plugin Development Kits - Offers a specialized toolset for developing native plugins that integrate with the engine without full recompilation.
- Native Performance Logic - Implements complex game systems in C++ to achieve better execution speed than standard scripting languages.
- Native Engine Extensions - Allows compiling extensions into separate libraries that load into the editor or projects without full software recompilation.
- C++ Container Exposures to Script - Exposes C++ classes and methods to the engine's signal and property system for editor access.
- Runtime Signal Binding - Allows native C++ methods to be bound to emitted signals to trigger reactions to external events.
- Engine Class Registrations - Allows native C++ classes to be registered within the engine for use in scripts and editor dialogs.
- Native Class Subclassing - Supports inheriting from native engine classes to implement custom node functionality in C++.
- Class Hierarchies - Organizes native types into a class hierarchy that inherits from base engine classes for scene integration.
- Lifecycle Method Overrides - Enables overriding specific lifecycle methods to execute native C++ code during engine frames or events.
- Engine Binding Libraries - Provides a set of C++ headers and bindings for creating high-performance extensions and custom nodes for the Godot engine.
- C++ Engine Extensions - Provides a framework for implementing performance-critical game logic in C++ and exposing it via a bridge API.
- Custom Signal Definitions - Enables the definition and emission of custom event signals to facilitate communication between objects and scripts.
- Native Plugin Development - Provides a toolkit for building native libraries that interface directly with the host engine's core runtime.
- Internal Object Extensions - Enables the creation of custom object instances that integrate directly into the engine's core object hierarchy.
- Pluggable Module Loading - Supports compiling logic into shared libraries that are dynamically loaded by the engine at runtime.
- Cross-Platform Build Systems - Uses a CMake-based build configuration to manage cross-platform compilation for Android, Web, and desktop.
- Multi-Target Build Orchestrators - Utilizes a multi-target CMake orchestrator to manage toolchains across different operating systems and compilers.
- Cross-Platform and Native Compilation - Builds native extensions for various operating systems including Windows, Android, and Web.
- Android NDK Configurations - Includes Android NDK configurations to enable cross-compiling extensions for Android devices from Windows.
- Cross-Platform Build Systems - Automates the compilation and packaging of native extensions for multiple target operating systems.
- Internal API Access - Provides access to internal engine APIs for implementing high-performance logic and low-level data operations.
- Emscripten Support - Provides integrated toolchain support for compiling C++ extensions to WebAssembly via Emscripten.
- API Configuration Mappings - Uses configuration mappings to synchronize C++ headers with specific internal engine API versions.
- Cross-Version Compatibility Gating - Provides mechanisms to ensure compiled native extensions remain compatible across multiple minor versions of the engine.
- Property Editor Registration APIs - Provides APIs to register native member variables as editable properties within the engine's user interface.
- WebAssembly Compilation - Integrates with the Emscripten toolchain to compile C++ code into WebAssembly binaries for browser execution.
- Media & Communication - Bindings for Godot script API
