### SCons Python Tool Example

Source: https://github.com/godotengine/godot-cpp/blob/master/CMakeLists.txt

Illustrates how a Python tool is defined and used in the SCons build system. This serves as a reference for the equivalent CMake implementation.

```python
cpp_tool = Tool("godotcpp", toolpath=["tools"])
cpp_tool.options(opts, env)
```

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

### Godot Extension Configuration File (.gdextension)

Source: https://github.com/godotengine/godot-cpp/blob/master/README.md

This is an example of a .gdextension file, which configures a GDExtension for Godot. It specifies the entry symbol for library initialization and maps library paths for different operating systems and build types.

```ini
[configuration]

entry_symbol = "example_library_init"
compatibility_minimum = "4.1"

[libraries]

macos.debug = "res://bin/libgdexample.macos.debug.framework"
macos.release = "res://bin/libgdexample.macos.release.framework"
windows.debug.x86_64 = "res://bin/libgdexample.windows.debug.x86_64.dll"
windows.release.x86_64 = "res://bin/libgdexample.windows.release.x86_64.dll"
linux.debug.x86_64 = "res://bin/libgdexample.linux.debug.x86_64.so"
linux.release.x86_64 = "res://bin/libgdexample.linux.release.x86_64.so"
# Repeat for other architectures to support arm64, rv64, etc.
```

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

### Register Classes with Godot ClassDB in C++

Source: https://github.com/godotengine/godot-cpp/blob/master/README.md

This C++ function shows how to register custom classes with Godot's ClassDB during module initialization. The `GDREGISTER_CLASS` macro makes the 'Example' class available in Godot's editor and scripting environments.

```cpp
using namespace godot;
void initialize_example_module(ModuleInitializationLevel p_level) {
	if (p_level != MODULE_INITIALIZATION_LEVEL_SCENE) {
		return;
	}
	GDREGISTER_CLASS(Example);
}
```

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

### Overriding Virtual Methods in C++ for Godot Nodes

Source: https://context7.com/godotengine/godot-cpp/llms.txt

Illustrates how to override virtual methods in C++ to customize Godot node behavior. This includes examples for `_has_point` (custom hit detection), `_input` (input event handling), `_process` (frame updates), and `_ready` (initialization). These overrides allow for extending and modifying the functionality of built-in Godot node types.

```cpp
#include <godot_cpp/classes/control.hpp>
#include <godot_cpp/classes/input_event.hpp>
#include <godot_cpp/classes/input_event_key.hpp>
#include <godot_cpp/classes/label.hpp>

class MyControl : public Control {
    GDCLASS(MyControl, Control);

protected:
    static void _bind_methods() {}

public:
    // Override _has_point for custom hit detection
    virtual bool _has_point(const Vector2 &point) const override {
        Label *label = get_node<Label>("Label");
        if (label) {
            label->set_text("Got point: " + Variant(point).stringify());
        }
        return false;  // Return true if point is inside control
    }

    // Override _input for input handling
    virtual void _input(const Ref<InputEvent> &event) override {
        const InputEventKey *key_event = Object::cast_to<const InputEventKey>(*event);
        if (key_event && key_event->is_pressed()) {
            // Handle key press
            emit_signal("key_pressed", key_event->get_keycode());
        }
    }

    // Override _process for frame updates
    virtual void _process(double delta) override {
        // Called every frame
    }

    // Override _ready for initialization
    virtual void _ready() override {
        // Called when node enters tree for first time
    }
};

```

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

### Ref Smart Pointer Usage in C++

Source: https://context7.com/godotengine/godot-cpp/llms.txt

Demonstrates the use of `Ref<T>` for automatic reference counting of `RefCounted`-derived objects in C++. This prevents memory leaks and dangling pointers by managing object lifetimes automatically. It includes examples of passing `Ref` as parameters, returning empty or new `Ref` instances, and working with engine types like `Image`.

```cpp
#include <godot_cpp/classes/ref.hpp>
#include <godot_cpp/classes/ref_counted.hpp>
#include <godot_cpp/classes/image.hpp>

class MyResource : public RefCounted {
    GDCLASS(MyResource, RefCounted);

private:
    int id = 0;

protected:
    static void _bind_methods() {
        ClassDB::bind_method(D_METHOD("set_id", "id"), &MyResource::set_id);
        ClassDB::bind_method(D_METHOD("get_id"), &MyResource::get_id);
        ADD_PROPERTY(PropertyInfo(Variant::INT, "id"), "set_id", "get_id");
    }

public:
    void set_id(int p_id) { id = p_id; }
    int get_id() const { return id; }
};

// Usage examples
class MyNode : public Node {
    GDCLASS(MyNode, Node);

public:
    // Accept Ref as parameter
    int process_resource(Ref<MyResource> p_ref) {
        return p_ref.is_valid() ? p_ref->get_id() : -1;
    }

    // Accept const reference
    int process_resource_const(const Ref<MyResource> &p_ref) {
        return p_ref.is_valid() ? p_ref->get_id() : -1;
    }

    // Return empty ref
    Ref<MyResource> return_empty_ref() const {
        Ref<MyResource> ref;
        return ref;
    }

    // Create and return new ref
    Ref<MyResource> create_resource() const {
        Ref<MyResource> ref;
        ref.instantiate();  // Creates new instance
        ref->set_id(42);
        return ref;
    }

    // Work with engine types
    String process_image(Ref<Image> p_image) {
        return p_image.is_valid() ? String("valid") : String("invalid");
    }
};

```

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

### Initialize GDExtension Library in C++

Source: https://github.com/godotengine/godot-cpp/blob/master/README.md

This C++ code snippet demonstrates the entry point for initializing a GDExtension library. It uses the `example_library_init` function to set up the extension binding, register initializers and terminators, and specify the minimum initialization level.

```cpp
extern "C" {

// Initialization.

GDExtensionBool GDE_EXPORT example_library_init(GDExtensionInterfaceGetProcAddress p_get_proc_address, GDExtensionClassLibraryPtr p_library, GDExtensionInitialization *r_initialization) {
	godot::GDExtensionBinding::InitObject init_obj(p_get_proc_address, p_library, r_initialization);

	init_obj.register_initializer(initialize_example_module);
	init_obj.register_terminator(uninitialize_example_module);
	init_obj.set_minimum_library_initialization_level(MODULE_INITIALIZATION_LEVEL_SCENE);

	return init_obj.init();
}
}
```

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

### Build Godot Extension with Custom API File

Source: https://github.com/godotengine/godot-cpp/blob/master/README.md

This command shows how to build a Godot extension using a custom extension API JSON file. This is useful when the default API version detection is not sufficient or when targeting a specific Godot build.

```bash
godot --dump-extension-api
scons custom_api_file=extension_api.json
```

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

### Create and Use Callable Objects in C++ for Godot

Source: https://context7.com/godotengine/godot-cpp/llms.txt

Illustrates the creation and utilization of `Callable` objects in Godot-CPP for various purposes, including connecting signals and deferred method calls. It shows how to obtain callables from method pointers (instance, static, const) and how to bind arguments to a callable.

```cpp
#include <godot_cpp/variant/callable_method_pointer.hpp>

class MyNode : public Node {
    GDCLASS(MyNode, Node);

public:
    // Get callable from method pointer
    Callable get_method_callable() {
        return callable_mp(this, &MyNode::on_event);
    }

    // Get callable for method with return value
    Callable get_ret_callable() {
        return callable_mp(this, &MyNode::process_data);
    }

    // Get callable for const method
    Callable get_const_callable() const {
        return callable_mp(this, &MyNode::get_info);
    }

    // Static method callable
    Callable get_static_callable() const {
        return callable_mp_static(&MyNode::static_handler);
    }

    // Callable with bound arguments
    void setup_bound_callable() {
        Callable c = Callable(this, "emit_signal").bind("custom_signal", "bound_name", 42);
        c.call();  // Calls emit_signal("custom_signal", "bound_name", 42)
    }

    // Connect signals using callables
    void connect_signals() {
        // Connect to own signal
        connect("custom_signal", callable_mp(this, &MyNode::on_custom_signal));

        // Connect to child node signal
        Button *button = get_node<Button>("Button");
        if (button) {
            button->connect("pressed", callable_mp(this, &MyNode::on_button_pressed));
        }
    }

private:
    void on_event(Object *sender, String message, int value) { /* ... */ }
    String process_data(Object *sender, String input, int count) { return input; }
    String get_info(Object *sender, String query, int id) const { return "info"; }
    static void static_handler(MyNode *node, String msg, int val) { /* ... */ }
    void on_custom_signal(const String &name, int value) { /* ... */ }
    void on_button_pressed() { /* ... */ }
};

```

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

### Handle Godot Notifications in C++

Source: https://context7.com/godotengine/godot-cpp/llms.txt

Implement the _notification method in a C++ node to respond to various Godot lifecycle events such as initialization, entering/exiting the scene tree, and processing frames. This allows for fine-grained control over node behavior during different stages of its existence.

```cpp
class MyNode : public Node {
    GDCLASS(MyNode, Node);

protected:
    static void _bind_methods() {}

    void _notification(int p_what) {
        switch (p_what) {
            case NOTIFICATION_POSTINITIALIZE:
                // Called after object is fully initialized
                break;

            case NOTIFICATION_READY:
                // Equivalent to _ready(), called when node and children are ready
                setup_rpc_config();
                break;

            case NOTIFICATION_ENTER_TREE:
                // Called when node enters the scene tree
                initialize_values();
                break;

            case NOTIFICATION_EXIT_TREE:
                // Called when node exits the scene tree
                cleanup();
                break;

            case NOTIFICATION_PROCESS:
                // Called every frame if set_process(true)
                break;

            case NOTIFICATION_PHYSICS_PROCESS:
                // Called every physics frame if set_physics_process(true)
                break;
        }
    }

private:
    void setup_rpc_config() {
        Dictionary opts;
        opts["rpc_mode"] = MultiplayerAPI::RPC_MODE_AUTHORITY;
        opts["transfer_mode"] = MultiplayerPeer::TRANSFER_MODE_RELIABLE;
        opts["call_local"] = true;
        opts["channel"] = 0;
        rpc_config("my_rpc_method", opts);
    }

    void initialize_values() { /* ... */ }
    void cleanup() { /* ... */ }
};

```

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

### Specify Godot API Version with SCons

Source: https://github.com/godotengine/godot-cpp/blob/master/README.md

This command demonstrates how to specify the target Godot API version when building with SCons. It ensures compatibility between the extension and the Godot engine version.

```bash
scons api_version=4.3
```

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

### Configure GDExtension Library Loading (.gdextension)

Source: https://context7.com/godotengine/godot-cpp/llms.txt

Defines the entry point, compatibility, and library paths for GDExtension on different platforms and architectures. This file is essential for Godot to load your native library correctly.

```ini
[configuration]
entry_symbol = "my_library_init"
compatibility_minimum = "4.1"
reloadable = true

[libraries]
; macOS
macos.debug = "res://bin/libmyextension.macos.template_debug.framework"
macos.release = "res://bin/libmyextension.macos.template_release.framework"

; Windows
windows.debug.x86_64 = "res://bin/libmyextension.windows.template_debug.x86_64.dll"
windows.release.x86_64 = "res://bin/libmyextension.windows.template_release.x86_64.dll"
windows.debug.x86_32 = "res://bin/libmyextension.windows.template_debug.x86_32.dll"
windows.release.x86_32 = "res://bin/libmyextension.windows.template_release.x86_32.dll"

; Linux
linux.debug.x86_64 = "res://bin/libmyextension.linux.template_debug.x86_64.so"
linux.release.x86_64 = "res://bin/libmyextension.linux.template_release.x86_64.so"
linux.debug.arm64 = "res://bin/libmyextension.linux.template_debug.arm64.so"
linux.release.arm64 = "res://bin/libmyextension.linux.template_release.arm64.so"

; Android
android.debug.arm64 = "res://bin/libmyextension.android.template_debug.arm64.so"
android.release.arm64 = "res://bin/libmyextension.android.template_release.arm64.so"

; iOS
ios.debug = "res://bin/libmyextension.ios.template_debug.xcframework"
ios.release = "res://bin/libmyextension.ios.template_release.xcframework"

; Web
web.debug.wasm32 = "res://bin/libmyextension.web.template_debug.wasm32.wasm"
web.release.wasm32 = "res://bin/libmyextension.web.template_release.wasm32.wasm"

[dependencies]
; Platform-specific dependencies (optional)
; windows.debug.x86_64 = {"res://bin/some_dependency.dll": ""}

```

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

### Build godot-cpp with SCons

Source: https://context7.com/godotengine/godot-cpp/llms.txt

Builds the godot-cpp library and extensions using SCons, allowing for platform, target, and Godot version configuration. Supports cross-platform builds and custom API integration.

```bash
# Build godot-cpp library (from godot-cpp directory)
scons platform=linux target=template_debug
scons platform=linux target=template_release

# Target specific Godot version for compatibility
scons platform=linux target=template_debug api_version=4.3
scons platform=linux target=template_debug api_version=4.4
scons platform=linux target=template_debug api_version=4.5

# Use custom extension API from your Godot build
godot --dump-extension-api --dump-gdextension-interface
scons platform=linux target=template_debug custom_api_file=extension_api.json

# Cross-platform builds
scons platform=windows target=template_release
scons platform=macos target=template_release arch=universal
scons platform=android target=template_release arch=arm64
scons platform=ios target=template_release
scons platform=web target=template_release

# Build with specific compiler
scons platform=linux target=template_debug use_llvm=yes

# Debug builds with symbols
scons platform=linux target=template_debug dev_build=yes debug_symbols=yes

```

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

### Register Godot Classes in C++

Source: https://context7.com/godotengine/godot-cpp/llms.txt

Demonstrates the use of various GDREGISTER macros to register different types of classes (standard, virtual, abstract, internal, runtime) with the Godot engine. This is essential for making C++ classes usable within Godot's editor and scripting.

```cpp
void initialize_my_module(ModuleInitializationLevel p_level) {
    if (p_level != MODULE_INITIALIZATION_LEVEL_SCENE) {
        return;
    }

    // Standard class registration - appears in Create dialog and scripting
    GDREGISTER_CLASS(MyNode);
    GDREGISTER_CLASS(MyResource);

    // Virtual class - can be instantiated but has virtual methods for override
    GDREGISTER_VIRTUAL_CLASS(MyVirtualBase);

    // Abstract class - cannot be instantiated directly (has pure virtual methods)
    GDREGISTER_ABSTRACT_CLASS(MyAbstractBase);

    // Internal class - not exposed to editor/scripting, only used internally
    GDREGISTER_INTERNAL_CLASS(MyInternalHelper);

    // Runtime class - can be registered/unregistered at runtime
    GDREGISTER_RUNTIME_CLASS(MyDynamicClass);
}

// Example class declarations
class MyVirtualBase : public Object {
    GDCLASS(MyVirtualBase, Object);
protected:
    static void _bind_methods() {}
};

class MyAbstractBase : public Object {
    GDCLASS(MyAbstractBase, Object);
protected:
    static void _bind_methods() {}
    virtual int compute() = 0;  // Pure virtual makes class abstract
};

class MyInternalHelper : public RefCounted {
    GDCLASS(MyInternalHelper, RefCounted);
protected:
    static void _bind_methods() {
        ClassDB::bind_method(D_METHOD("get_answer"), &MyInternalHelper::get_answer);
    }
public:
    int get_answer() const { return 42; }
};
```

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

### Safe Object Casting with Object::cast_to<T> in C++

Source: https://context7.com/godotengine/godot-cpp/llms.txt

Demonstrates various scenarios of using Object::cast_to<T> for safe runtime type conversion. This includes casting from Object pointers to Node and Control types, casting from Variants, and safely casting child nodes within a scene tree. It also shows how to handle const references for event data.

```cpp
#include <godot_cpp/classes/object.hpp>
#include <godot_cpp/classes/node.hpp>
#include <godot_cpp/classes/control.hpp>

class MyNode : public Control {
    GDCLASS(MyNode, Control);

public:
    // Cast Object to specific types
    bool test_object_cast_to_node(Object *p_object) const {
        return Object::cast_to<Node>(p_object) != nullptr;
    }

    bool test_object_cast_to_control(Object *p_object) const {
        return Object::cast_to<Control>(p_object) != nullptr;
    }

    bool test_object_cast_to_my_node(Object *p_object) const {
        return Object::cast_to<MyNode>(p_object) != nullptr;
    }

    // Cast from Variant
    bool test_variant_cast(const Variant &p_variant) const {
        Object *obj = p_variant;
        if (!obj) return false;

        Node *node = Object::cast_to<Node>(obj);
        return node != nullptr;
    }

    // Get typed child node
    void process_children() {
        for (int i = 0; i < get_child_count(); i++) {
            Node *child = get_child(i);

            // Try casting to specific type
            if (MyNode *my_child = Object::cast_to<MyNode>(child)) {
                my_child->do_something();
            } else if (Control *ctrl = Object::cast_to<Control>(child)) {
                ctrl->set_visible(true);
            }
        }
    }

    // Const casting for event handling
    void _input(const Ref<InputEvent> &event) override {
        const InputEventKey *key = Object::cast_to<const InputEventKey>(*event);
        if (key && key->is_pressed()) {
            handle_key(key->get_keycode());
        }
    }

private:
    void do_something() {}
    void handle_key(int keycode) {}
};

```

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

### Bind Vararg Methods in C++ for Godot

Source: https://context7.com/godotengine/godot-cpp/llms.txt

Demonstrates how to bind methods that accept a variable number of arguments to Godot using `bind_vararg_method`. This allows for flexible function signatures in GDScript. It covers methods returning `Variant` and specific types, requiring `Variant` and `GDExtensionInt` for argument handling.

```cpp
class MyNode : public Node {
    GDCLASS(MyNode, Node);

protected:
    static void _bind_methods() {
        // Setup method info with minimum argument spec
        MethodInfo mi;
        mi.arguments.push_back(PropertyInfo(Variant::STRING, "format"));
        mi.name = "varargs_print";
        ClassDB::bind_vararg_method(METHOD_FLAGS_DEFAULT, "varargs_print", &MyNode::varargs_print, mi);

        // Vararg method returning a value
        MethodInfo mi2;
        mi2.arguments.push_back(PropertyInfo(Variant::STRING, "separator"));
        mi2.name = "varargs_join";
        ClassDB::bind_vararg_method(METHOD_FLAGS_DEFAULT, "varargs_join", &MyNode::varargs_join, mi2);
    }

public:
    // Vararg method returning Variant
    Variant varargs_print(const Variant **args, GDExtensionInt arg_count, GDExtensionCallError &error) {
        error.error = GDEXTENSION_CALL_OK;

        String result;
        for (int i = 0; i < arg_count; i++) {
            result += String(*args[i]);
            if (i < arg_count - 1) result += " ";
        }
        print_line(result);
        return arg_count;  // Return number of args processed
    }

    // Vararg method returning specific type
    String varargs_join(const Variant **args, GDExtensionInt arg_count, GDExtensionCallError &error) {
        error.error = GDEXTENSION_CALL_OK;

        if (arg_count < 1) return "";

        String separator = *args[0];
        String result;
        for (int i = 1; i < arg_count; i++) {
            if (i > 1) result += separator;
            result += String(*args[i]);
        }
        return result;
    }
};

```

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

### Build godot-cpp with CMake

Source: https://context7.com/godotengine/godot-cpp/llms.txt

Configures and builds godot-cpp using CMake, facilitating IDE integration and cross-platform development. Supports various build types, testing, and cross-compilation for Android, iOS, and Web.

```bash
# Configure and build godot-cpp
mkdir build && cd build
cmake .. -DCMAKE_BUILD_TYPE=Debug
cmake --build .

# Build for release
cmake .. -DCMAKE_BUILD_TYPE=Release
cmake --build .

# Enable testing
cmake .. -DGODOTCPP_ENABLE_TESTING=ON
cmake --build .

# Cross-compile for Android
cmake .. -DCMAKE_TOOLCHAIN_FILE=$NDK/build/cmake/android.toolchain.cmake \
         -DANDROID_ABI=arm64-v8a \
         -DANDROID_PLATFORM=android-21

# Cross-compile for iOS
cmake .. -G Xcode \
         -DCMAKE_SYSTEM_NAME=iOS \
         -DCMAKE_OSX_DEPLOYMENT_TARGET=11.0

# Cross-compile for Web with Emscripten
source /path/to/emsdk/emsdk_env.sh
emcmake cmake .. -DCMAKE_BUILD_TYPE=Release
cmake --build .

```

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

### Project Definition in CMake

Source: https://github.com/godotengine/godot-cpp/blob/master/CMakeLists.txt

Defines the main project 'godot-cpp' with its version, description, homepage URL, and programming language. It also includes conditional logic for determining if the project is the top-level build.

```cmake
if(NOT PROJECT_NAME)
    set(GODOTCPP_IS_TOP_LEVEL ON)
endif()

project(
    godot-cpp
    VERSION 4.4
    DESCRIPTION "C++ bindings for the Godot Engine's GDExtensions API."
    HOMEPAGE_URL "https://github.com/godotengine/godot-cpp"
    LANGUAGES CXX
)
```

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

### Godot Memory Management Macros in C++

Source: https://context7.com/godotengine/godot-cpp/llms.txt

Explains the use of `memnew`, `memdelete`, `memnew_arr`, `memdelete_arr`, `memalloc`, `memrealloc`, and `memfree` for memory management in Godot C++ projects. These macros ensure proper integration with the engine's memory tracking system. It also highlights that `Ref<T>` should be used for `RefCounted` objects instead of manual memory management.

```cpp
#include <godot_cpp/core/memory.hpp>

// Allocate single objects
MyClass *obj = memnew(MyClass);
MyClass *obj_with_args = memnew(MyClass(arg1, arg2));

// Delete objects
memdelete(obj);

// Allocate arrays
int *arr = memnew_arr(int, 100);  // Array of 100 ints

// Get array length
size_t len = memarr_len(arr);

// Delete arrays
memdelete_arr(arr);

// Raw memory allocation (rarely needed)
void *raw = memalloc(1024);  // Allocate 1024 bytes
raw = memrealloc(raw, 2048); // Reallocate to 2048 bytes
memfree(raw);                // Free memory

// Note: For RefCounted objects, use Ref<T> instead:
Ref<MyResource> ref;
ref.instantiate();  // Proper way to create RefCounted objects
// No need to manually delete - reference counting handles it

```

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

### Implement Custom Dynamic Properties in C++

Source: https://context7.com/godotengine/godot-cpp/llms.txt

Define and manage custom properties for a Godot node in C++ by implementing _get_property_list, _set, and _get. This allows properties to be dynamically generated and modified at runtime, appearing in the Godot editor's inspector panel.

```cpp
class MyNode : public Node {
    GDCLASS(MyNode, Node);

private:
    Vector3 property_from_list;
    Vector2 dynamic_props[3];

protected:
    static void _bind_methods() {}

    // Define dynamic properties
    void _get_property_list(List<PropertyInfo> *p_list) const {
        p_list->push_back(PropertyInfo(Variant::VECTOR3, "property_from_list"));

        // Add multiple indexed properties
        for (int i = 0; i < 3; i++) {
            p_list->push_back(PropertyInfo(Variant::VECTOR2, "dproperty_" + itos(i)));
        }
    }

    // Handle property setting
    bool _set(const StringName &p_name, const Variant &p_value) {
        String name = p_name;
        if (name.begins_with("dproperty_")) {
            int64_t index = name.get_slicec('_', 1).to_int();
            dynamic_props[index] = p_value;
            return true;
        }
        if (name == "property_from_list") {
            property_from_list = p_value;
            return true;
        }
        return false;
    }

    // Handle property getting
    bool _get(const StringName &p_name, Variant &r_ret) const {
        String name = p_name;
        if (name.begins_with("dproperty_")) {
            int64_t index = name.get_slicec('_', 1).to_int();
            r_ret = dynamic_props[index];
            return true;
        }
        if (name == "property_from_list") {
            r_ret = property_from_list;
            return true;
        }
        return false;
    }

    // Property revert support (reset button in inspector)
    bool _property_can_revert(const StringName &p_name) const {
        if (p_name == StringName("property_from_list") && property_from_list != Vector3(42, 42, 42)) {
            return true;
        }
        return false;
    }

    bool _property_get_revert(const StringName &p_name, Variant &r_property) const {
        if (p_name == StringName("property_from_list")) {
            r_property = Vector3(42, 42, 42);
            return true;
        }
        return false;
    }
};

```

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

### Configure Integration Test Library (CMake)

Source: https://github.com/godotengine/godot-cpp/blob/master/test/CMakeLists.txt

Defines a shared library for integration tests, specifies source files, and conditionally includes documentation XML files. It links against the main 'godot-cpp' library.

```cmake
message(STATUS "Testing Integration targets are enabled.")

set(TARGET_NAME "godot-cpp-test")

add_library(${TARGET_NAME} SHARED EXCLUDE_FROM_ALL)

target_sources(
    ${TARGET_NAME}
    PRIVATE src/example.cpp src/example.h src/register_types.cpp src/register_types.h src/tests.h
)

# conditionally add doc data to compile output
if(GODOTCPP_TARGET MATCHES "editor|template_debug")
    file(GLOB_RECURSE DOC_XML LIST_DIRECTORIES NO CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/doc_classes/*.xml")
    target_doc_sources( ${TARGET_NAME} ${DOC_XML} )
endif()

set(OUTPUT_DIR "${CMAKE_CURRENT_SOURCE_DIR}/project/bin/")

# Link to godot-cpp target
target_link_libraries(${TARGET_NAME} PRIVATE godot-cpp)
```

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

### Include Custom CMake Modules

Source: https://github.com/godotengine/godot-cpp/blob/master/CMakeLists.txt

Includes custom CMake scripts from the 'cmake' directory. These scripts likely contain project-specific logic, such as defining custom commands or setting up build targets.

```cmake
include(cmake/godotcpp.cmake)

godotcpp_options()

compiler_detection()
godotcpp_generate()
```

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

### Register Node Properties with Inspector Organization in C++

Source: https://context7.com/godotengine/godot-cpp/llms.txt

This snippet demonstrates how to register properties for a custom Godot node in C++. It shows how to bind getter and setter methods, create property groups and subgroups for better organization in the Godot inspector, and register properties with specific types and hints using `PropertyInfo`.

```cpp
void MyCustomNode::_bind_methods() {
    // First bind the getter/setter methods
    ClassDB::bind_method(D_METHOD("get_health"), &MyCustomNode::get_health);
    ClassDB::bind_method(D_METHOD("set_health", "health"), &MyCustomNode::set_health);
    ClassDB::bind_method(D_METHOD("get_speed"), &MyCustomNode::get_speed);
    ClassDB::bind_method(D_METHOD("set_speed", "speed"), &MyCustomNode::set_speed);
    ClassDB::bind_method(D_METHOD("get_custom_position"), &MyCustomNode::get_custom_position);
    ClassDB::bind_method(D_METHOD("set_custom_position", "position"), &MyCustomNode::set_custom_position);

    // Create property groups in inspector
    ADD_GROUP("Stats", "stats_");
    ADD_SUBGROUP("Combat", "stats_combat_");

    // Register properties with PropertyInfo
    ADD_PROPERTY(PropertyInfo(Variant::INT, "stats_combat_health"), "set_health", "get_health");
    ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "stats_combat_speed"), "set_speed", "get_speed");
    ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "custom_position"), "set_custom_position", "get_custom_position");
}
```

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

### Declare and Emit Custom Signals with Typed Arguments in C++

Source: https://context7.com/godotengine/godot-cpp/llms.txt

This C++ code snippet illustrates how to declare custom signals in Godot, including signals with typed arguments and signals without arguments. It also shows how to bind a method that emits these signals, allowing communication between C++ and GDScript or other C++ nodes.

```cpp
void MyCustomNode::_bind_methods() {
    // Declare signals with arguments
    ADD_SIGNAL(MethodInfo("health_changed",
        PropertyInfo(Variant::INT, "old_health"),
        PropertyInfo(Variant::INT, "new_health")));

    ADD_SIGNAL(MethodInfo("custom_signal",
        PropertyInfo(Variant::STRING, "name"),
        PropertyInfo(Variant::INT, "value")));

    // Signal with no arguments
    ADD_SIGNAL(MethodInfo("died"));

    // Bind method to emit signal
    ClassDB::bind_method(D_METHOD("emit_custom_signal", "name", "value"), &MyCustomNode::emit_custom_signal);
}

void MyCustomNode::emit_custom_signal(const String &name, int value) {
    emit_signal("custom_signal", name, value);
}

void MyCustomNode::set_health(int new_health) {
    int old_health = health;
    health = new_health;
    emit_signal("health_changed", old_health, new_health);

    if (health <= 0) {
        emit_signal("died");
    }
}
```

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

### Conditional Subdirectory Inclusion for Testing

Source: https://github.com/godotengine/godot-cpp/blob/master/CMakeLists.txt

Conditionally adds the 'test' subdirectory to the build if the 'GODOTCPP_ENABLE_TESTING' variable is set to ON. This allows for integration testing of the godot-cpp library.

```cmake
if(GODOTCPP_ENABLE_TESTING)
    add_subdirectory(test)
endif()
```

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

### Set Target Properties for Integration Test Library (CMake)

Source: https://github.com/godotengine/godot-cpp/blob/master/test/CMakeLists.txt

Configures properties for the integration test library, including C++ standard, visibility, output directories, and naming conventions. It also handles platform-specific settings for macOS.

```cmake
### Get useful properties from godot-cpp target
get_target_property(GODOTCPP_SUFFIX godot-cpp GODOTCPP_SUFFIX)

# gersemi: off
set_target_properties(
    ${TARGET_NAME}
    PROPERTIES
        CXX_STANDARD 17
        CXX_EXTENSIONS OFF
        CXX_VISIBILITY_PRESET ${GODOTCPP_SYMBOL_VISIBILITY}

        POSITION_INDEPENDENT_CODE ON
        BUILD_RPATH_USE_ORIGIN ON

        # Try to ensure only static libraries are selected to be linked to.
        LINK_SEARCH_START_STATIC ON
        LINK_SEARCH_END_STATIC ON

        # NOTE: Wrapping the output variables inside a generator expression
        # prevents msvc generator from adding addition Config Directories
        LIBRARY_OUTPUT_DIRECTORY "$<1:${OUTPUT_DIR}>"
        RUNTIME_OUTPUT_DIRECTORY "$<1:${OUTPUT_DIR}>"
        PDB_OUTPUT_DIRECTORY     "$<1:${OUTPUT_DIR}>" #MSVC Only, ignored on other platforms

        PREFIX "lib"
        OUTPUT_NAME "gdexample${GODOTCPP_SUFFIX}"
        # TODO rename the file for both CMake and SCons

        # Some IDE's respect this property to logically group targets
        FOLDER "godot-cpp"
)
# gersemi: on

# CMAKE_SYSTEM_NAME refers to the target system
if(CMAKE_SYSTEM_NAME STREQUAL Darwin)
    set_target_properties(
        ${TARGET_NAME}
        PROPERTIES SUFFIX "" OUTPUT_DIR "${OUTPUT_DIR}/libgdexample.macos.${GODOTCPP_TARGET}.framework"
    )
endif()
```

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

### Use Typed Arrays and Dictionaries in C++

Source: https://context7.com/godotengine/godot-cpp/llms.txt

Illustrates how to use `TypedArray<T>` and `TypedDictionary<K,V>` for type-safe collections in Godot C++. These classes provide compile-time type checking and integrate seamlessly with Godot's variant system. Requires Godot 4.4+ for `TypedDictionary`.

```cpp
#include <godot_cpp/variant/typed_array.hpp>
#include <godot_cpp/variant/typed_dictionary.hpp>  // Godot 4.4+

class MyNode : public Node {
    GDCLASS(MyNode, Node);

protected:
    static void _bind_methods() {
        ClassDB::bind_method(D_METHOD("test_tarray_arg", "array"), &MyNode::test_tarray_arg);
        ClassDB::bind_method(D_METHOD("test_tarray"), &MyNode::test_tarray);
        ClassDB::bind_method(D_METHOD("test_tdictionary"), &MyNode::test_tdictionary);
    }

public:
    // Process typed array argument
    int test_tarray_arg(const TypedArray<int64_t> &p_array) {
        int sum = 0;
        for (int i = 0; i < p_array.size(); i++) {
            sum += (int)p_array[i];
        }
        return sum;
    }

    // Return typed array
    TypedArray<Vector2> test_tarray() const {
        TypedArray<Vector2> arr;
        arr.resize(2);
        arr[0] = Vector2(1, 2);
        arr[1] = Vector2(2, 3);
        return arr;
    }

    // Nested typed arrays
    TypedArray<PackedInt32Array> test_typed_array_of_packed() const {
        TypedArray<PackedInt32Array> arr;
        PackedInt32Array packed1;
        packed1.push_back(1);
        packed1.push_back(2);
        arr.push_back(packed1);
        return arr;
    }

    // Typed dictionary (Godot 4.4+)
    TypedDictionary<Vector2, Vector2i> test_tdictionary() const {
        TypedDictionary<Vector2, Vector2i> dict;
        dict[Vector2(1, 2)] = Vector2i(2, 3);
        return dict;
    }

    // Standard dictionary
    Dictionary test_dictionary() const {
        Dictionary dict;
        dict["hello"] = "world";
        dict["foo"] = "bar";
        return dict;
    }
};
```

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

### CMake Minimum Version Requirement

Source: https://github.com/godotengine/godot-cpp/blob/master/CMakeLists.txt

Specifies the minimum required version of CMake for the project. This ensures compatibility with features introduced in specific CMake versions, such as CMAKE_PROJECT_<PROJECT-NAME>_INCLUDE.

```cmake
cmake_minimum_required(VERSION 3.10...3.17)
```

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

### Bind C++ Methods to GDScript/Editor using ClassDB in C++

Source: https://context7.com/godotengine/godot-cpp/llms.txt

Binds C++ methods to be callable from GDScript and the Godot editor using ClassDB::bind_method. The D_METHOD macro is used for argument naming, facilitating editor integration and documentation.

```cpp
#include <godot_cpp/core/class_db.hpp>

void MyCustomNode::_bind_methods() {
    // Bind simple methods
    ClassDB::bind_method(D_METHOD("do_something"), &MyCustomNode::do_something);

    // Bind methods with arguments (argument names for editor/docs)
    ClassDB::bind_method(D_METHOD("set_custom_value", "value"), &MyCustomNode::set_custom_value);
    ClassDB::bind_method(D_METHOD("get_custom_value"), &MyCustomNode::get_custom_value);

    // Bind property getters/setters
    ClassDB::bind_method(D_METHOD("get_custom_position"), &MyCustomNode::get_custom_position);
    ClassDB::bind_method(D_METHOD("set_custom_position", "position"), &MyCustomNode::set_custom_position);

    // Bind methods with default arguments
    ClassDB::bind_method(D_METHOD("compute", "a", "b"), &MyCustomNode::compute, DEFVAL(100), DEFVAL(200));

    // Bind static methods
    ClassDB::bind_static_method("MyCustomNode", D_METHOD("static_helper", "a", "b"), &MyCustomNode::static_helper);
}

// Implementation
void MyCustomNode::set_custom_value(int value) { custom_value = value; }
int MyCustomNode::get_custom_value() const { return custom_value; }
void MyCustomNode::set_custom_position(const Vector2 &pos) { custom_position = pos; }
Vector2 MyCustomNode::get_custom_position() const { return custom_position; }
void MyCustomNode::do_something() { /* implementation */ }

```

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

### Expose Constants and Enums to GDScript in C++

Source: https://context7.com/godotengine/godot-cpp/llms.txt

This C++ code demonstrates how to expose constants, enums, and bitfield flags from a custom Godot node to GDScript. It utilizes `BIND_ENUM_CONSTANT`, `BIND_BITFIELD_FLAG`, and `BIND_CONSTANT` macros for exposing these values, along with `VARIANT_ENUM_CAST` and `VARIANT_BITFIELD_CAST` for proper type casting in GDScript.

```cpp
class MyCustomNode : public Control {
    GDCLASS(MyCustomNode, Control);

public:
    enum State {
        STATE_IDLE,
        STATE_RUNNING,
        STATE_JUMPING,
        STATE_ANSWER = 42,
    };

    enum Flags {
        FLAG_INVINCIBLE = 1,
        FLAG_INVISIBLE = 2,
        FLAG_FLYING = 4,
    };

    enum {
        CONSTANT_WITHOUT_ENUM = 314,
    };

protected:
    static void _bind_methods() {
        // Bind enum constants
        BIND_ENUM_CONSTANT(STATE_IDLE);
        BIND_ENUM_CONSTANT(STATE_RUNNING);
        BIND_ENUM_CONSTANT(STATE_JUMPING);
        BIND_ENUM_CONSTANT(STATE_ANSWER);

        // Bind bitfield flags
        BIND_BITFIELD_FLAG(FLAG_INVINCIBLE);
        BIND_BITFIELD_FLAG(FLAG_INVISIBLE);
        BIND_BITFIELD_FLAG(FLAG_FLYING);

        // Bind standalone constants
        BIND_CONSTANT(CONSTANT_WITHOUT_ENUM);
    }
};

// Required for enum type casting in GDScript
VARIANT_ENUM_CAST(MyCustomNode::State);
VARIANT_BITFIELD_CAST(MyCustomNode::Flags);
```

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

### Set Global CMake Property for Folder Organization

Source: https://github.com/godotengine/godot-cpp/blob/master/CMakeLists.txt

Sets the 'USE_FOLDERS' global property to ON. This instructs CMake to organize targets under a subfolder named 'godot-cpp' in IDEs that support this feature, improving project structure.

```cmake
set_property(GLOBAL PROPERTY USE_FOLDERS ON)
```

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

### Declare Custom Godot Class in C++ using GDCLASS

Source: https://context7.com/godotengine/godot-cpp/llms.txt

Declares a custom C++ class that inherits from a Godot engine class using the GDCLASS macro. This macro sets up essential type information, binding callbacks, and virtual method infrastructure required for Godot integration.

```cpp
#include <godot_cpp/classes/control.hpp>
#include <godot_cpp/core/class_db.hpp>

using namespace godot;

class MyCustomNode : public Control {
    GDCLASS(MyCustomNode, Control);  // Declares class with parent

private:
    Vector2 custom_position;
    int custom_value = 0;

protected:
    static void _bind_methods();  // Required: must be implemented

    void _notification(int p_what);  // Optional: handle notifications
    bool _set(const StringName &p_name, const Variant &p_value);  // Optional: custom property setter
    bool _get(const StringName &p_name, Variant &r_ret) const;    // Optional: custom property getter

public:
    MyCustomNode();
    ~MyCustomNode();

    void set_custom_position(const Vector2 &pos);
    Vector2 get_custom_position() const;

    void set_custom_value(int value);
    int get_custom_value() const;

    void do_something();
};

```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.