Godot Engine

https://docs.godotengine.org/zh-cn/4.x
Admin
Godot Engine is a free and open-source game engine that supports 2D and 3D game development with...
Tokens:43,297,031
Snippets:330,460
Trust Score:10
Update:10 months ago
Show doc for...
Tokens:
Raw
### GDExtension C Example: Basic Setup

Source: https://docs.godotengine.org/zh-cn/4.x/classes/class_visualshadernodetexturesdf

Provides a foundational example of using GDExtension with C. It covers the project setup, file structure, build system configuration, and the initialization of the extension. This serves as a starting point for creating native extensions in C.

```c
// Example: main.c for a GDExtension

#include <gdextension_interface.h>
#include <stdio.h>

// Define GDExtension functions (stubs for simplicity)
static GDExtensionInterfaceGetProcAddress get_proc_address;
static GDExtensionInitialization;

// Function to initialize the extension
GDExtensionBool GDE_EXPORT initialize_my_extension(GDExtensionInterfaceGetProcAddress p_get_proc_address, GDExtensionClassLibraryPtr p_library, GDExtensionInitialization *r_initialization) {
    get_proc_address = p_get_proc_address;
    r_initialization->initialize = initialize_my_extension;
    r_initialization->deinitialize = deinitialize_my_extension;
    r_initialization->type_create = type_create;
    r_initialization->type_get_name = type_get_name;
    r_initialization->script_instance_build_dependency_implementation = script_instance_build_dependency_implementation;
    r_initialization->script_instance_get_language = script_instance_get_language;
    r_initialization->script_instance_set_language = script_instance_set_language;

    // TODO: Register your classes and methods here
    printf("My Extension Initialized!\n");

    return true;
}

// Function to deinitialize the extension
void GDE_EXPORT deinitialize_my_extension(GDExtensionClassLibraryPtr p_library) {
    printf("My Extension Deinitialized!\n");
    // TODO: Clean up resources
}

// Placeholder functions for GDExtensionInitialization structure
void* GDE_EXPORT type_create(const GDExtensionConstStringNamePtr p_class_name) { return NULL; }
GDExtensionConstStringNamePtr GDE_EXPORT type_get_name(GDExtensionClassInstancePtr p_instance) { return NULL; }
void GDE_EXPORT script_instance_build_dependency_implementation(GDExtensionScriptInstancePtr p_instance, GDExtensionClassLibraryPtr p_library) {}
GDExtensionScriptLanguagePtr GDE_EXPORT script_instance_get_language(GDExtensionScriptInstancePtr p_instance) { return NULL; }
void GDE_EXPORT script_instance_set_language(GDExtensionScriptInstancePtr p_instance, GDExtensionScriptLanguagePtr p_language) {}

// Entry point for the extension library
GDExtensionBool GDE_EXPORT core_api_version_ அழைக்க(GDExtensionInterfaceGetProcAddress p_get_proc_address, GDExtensionClassLibraryPtr p_library, GDExtensionInitialization *r_initialization) {
    return initialize_my_extension(p_get_proc_address, p_library, r_initialization);
}

```

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

### GDExtension C Example Setup

Source: https://docs.godotengine.org/zh-cn/4.x/classes/class_portablecompressedtexture2d

Provides a basic setup for creating a GDExtension module using C. This covers project setup, file structure, build system configuration, and initializing the extension with a simple class.

```c
// Project setup (simplified):
// Assume a project structure like:
// my_project/
// |- project.godot
// |- extensions/
// |  |- my_extension/
// |  |  |- src/
// |  |  |  |- my_extension.c
// |  |  |  |- register_types.c
// |  |  |- SConstruct
// |  |- my_extension.gdextension

// my_extension.gdextension (example):
// [configuration]
// compatible_fmt_version=1
// entry_point=register_types
//
// [libraries]
// Windows.X86_64=./my_extension/bin/windows_x86_64/libmy_extension.dll
// Linux.X86_64=./my_extension/bin/linux_x86_64/libmy_extension.so
// MacOS.X86_64=./my_extension/bin/macos_x86_64/libmy_extension.dylib

// register_types.c (simplified):
// #include <gdextension_interface.h>
// #include <godot_cpp/core/defs.hpp>
// #include <godot_cpp/godot.hpp>
//
// using namespace godot;
//
// void* _data = nullptr;
//
// GDExtensionBool GDE_EXPORT initialize_extension(GDExtensionInterfaceGetProcAddress p_get_proc_address, const GDExtensionClassLibraryPtr p_library, GDExtensionInitialization *r_initialization)
// {
// 	godot::GDExtensionBinding::InitObject init_obj;
// 	init_obj.initialize_godot_cpp_bindings(p_get_proc_address, p_library, r_initialization);
//
// 	_data = p_library;
//
// 	return TRUE;
// }
//
// void GDE_EXPORT terminate_extension(GDExtensionInterfaceGetProcAddress p_get_proc_address, GDExtensionClassLibraryPtr p_library, GDExtensionInitialization *p_initialization)
// {
// 	// Cleanup if needed
// }

```

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

### C++ (godot-cpp): Getting Started

Source: https://docs.godotengine.org/zh-cn/4.x/classes/class_packedvector4array

Provides a guide to setting up and using godot-cpp, the official C++ binding for Godot. Covers workflow overview, example projects, project setup, building C++ bindings, creating and compiling plugins, and using GDExtension modules.

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

namespace godot {

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

public:
    static void _bind_methods();

    virtual void _ready() override;
};

}

// In my_node.cpp
#include "my_node.h"

void godot::MyNode::_ready() {
    Godot::print("Hello from C++!");
}

void godot::MyNode::_bind_methods() {
    // Bindings go here
}
```

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

### C++ (godot-cpp): Getting Started with GDExtension

Source: https://docs.godotengine.org/zh-cn/4.x/classes/class_regex

Guides users through setting up a C++ project using godot-cpp and GDExtension. It covers the workflow, example projects, project setup, building C++ bindings, creating simple plugins, and compiling them. It also includes adding properties and signals in C++.

```cpp
// Example: MyCustomNode.h
#ifndef MY_CUSTOM_NODE_H
#define MY_CUSTOM_NODE_H

#include <godot_cpp/classes/node.hpp>
#include <godot_cpp/core/class_db.hpp>
#include <godot_cpp/properties/property_setget.hpp>

namespace godot
{

class MyCustomNode : public Node
{
    GDCLASS(MyCustomNode, Node)

private:
    int _my_property;

public:
    static void _bind_methods();

    MyCustomNode();
    ~MyCustomNode();

    void set_my_property(int value);
    int get_my_property() const;

    virtual void _ready() override;
};

}

#endif // MY_CUSTOM_NODE_H

// Example: MyCustomNode.cpp
#include "MyCustomNode.h"
#include <godot_cpp/core/class_db.hpp>

using namespace godot;

void MyCustomNode::_bind_methods()
{
    // Bind the property with setter and getter
    ClassDB::bind_method(D_METHOD("set_my_property", "value"), &MyCustomNode::set_my_property);
    ClassDB::bind_method(D_METHOD("get_my_property"), &MyCustomNode::get_my_property);
    ADD_PROPERTY(PropertySetGet("my_property", "set_my_property", "get_my_property"), "my_property");

    // Bind signals if any (not shown in this simple example)

    // Bind methods
    // ClassDB::bind_method(D_METHOD("my_custom_method", "arg"), &MyCustomNode::my_custom_method);
}

MyCustomNode::MyCustomNode() : _my_property(0) {}
MyCustomNode::~MyCustomNode() {}

void MyCustomNode::set_my_property(int value)
{
    _my_property = value;
    // Consider emitting a signal here if the property change should notify others
}

int MyCustomNode::get_my_property() const
{
    return _my_property;
}

void MyCustomNode::_ready()
{
    Godot::print("MyCustomNode is ready!");
    Godot::print("My property value: " + String::num(_my_property));
}

```

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

### GDExtension C Example: Basic Setup and Initialization

Source: https://docs.godotengine.org/zh-cn/4.x/classes/class_regex

Provides a foundational C example for GDExtension, covering project setup, file structure, build system configuration, and the essential steps for initializing an extension. It demonstrates creating the simplest possible class and binding it to Godot.

```c
// Example: my_extension.c
#include <gdextension_interface.h>
#include <godot_cpp/core/defs.hpp>
#include <godot_cpp/godot.hpp>

#include "my_custom_node.h"

extern "C" {

// Initialization function for the extension.
GDExtensionBool GDE_EXPORT initialize_my_extension(GDExtensionInterfaceGetProcAddress p_get_proc_address, GDExtensionClassLibraryPtr p_library, GDExtensionInitialization *r_initialization)
{
    Godot::ScriptServer::init(); // Initialize Godot's scripting server

    // Register custom classes
    GDExtensionClassLibraryPtr library = p_library;
    r_initialization->initialize = [](GDExtensionInitializationLevel p_level) {
        if (p_level == GDEXTENSION_INITIALIZATION_SCENE)
        {
            // Register the custom node class
            Godot::ClassDB::register_class<godot::MyCustomNode>();
        }
    };

    r_initialization->deinitialize = [](GDExtensionInitializationLevel p_level) {
        if (p_level == GDEXTENSION_INITIALIZATION_SCENE)
        {
            // Unregister custom classes
            Godot::ClassDB::unregister_class<godot::MyCustomNode>();
        }
    };

    return TRUE;
}

// Deinitialization function for the extension.
GDExtensionBool GDE_EXPORT terminate_my_extension(GDExtensionClassLibraryPtr p_library)
{
    // Clean up resources if necessary
    Godot::ScriptServer::finish();
    return TRUE;
}

}

```

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

### C++ (godot-cpp): Getting Started with GDExtension

Source: https://docs.godotengine.org/zh-cn/4.x/classes/class_themedb

Provides a step-by-step guide to getting started with C++ development in Godot using GDExtension. Covers the workflow, setting up a project, building C++ bindings, creating plugins, and compiling extensions. Includes examples of adding properties and signals.

```c++
// Example for a C++ class using GDExtension
#include <godot_cpp/classes/node.hpp>
#include <godot_cpp/core/class_db.hpp>

namespace godot {

class MyCppClass : public Node {
    GDCLASS(MyCppClass, Node)

private:
    int _my_property;

public:
    static void _bind_methods();

    void set_my_property(int value) { _my_property = value; }
    int get_my_property() const { return _my_property; }

    // Signal registration example
    // static void _register_signals(Ref<Signal> p_signal);
};

}

// In the .cpp file:
// void godot::MyCppClass::_register_signals(Ref<Signal> p_signal) {
//     p_signal->add_signal("my_custom_signal", Array());
// }

// void godot::MyCppClass::_bind_methods() {
//     ClassDB::bind_method(D_METHOD("set_my_property", "value"), &MyCppClass::set_my_property);
//     ClassDB::bind_method(D_METHOD("get_my_property"), &MyCppClass::get_my_property);
//     ADD_PROPERTY(PropertyInfo(Variant::INT, "my_property"), "set_my_property", "get_my_property");
// }

```

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

### GDExtension: C Example for Initialization

Source: https://docs.godotengine.org/zh-cn/4.x/classes/class_physicsdirectspacestate2dextension

Demonstrates how to create a basic GDExtension in C. Covers project setup, file structure, build system configuration, and the essential steps for initializing an extension. Shows how to create and bind custom classes.

```c
// Example of GDExtension initialization in C
#include <gdextension_interface.h>
#include <godot_cpp/core/defs.hpp>

// Function to initialize the extension
GDExtensionBool GDE_EXPORT initialize_my_extension(
    GDExtensionInterfaceGetProcAddress p_get_proc_address,
    const GDExtensionClassLibraryPtr p_library,
    GDExtensionInitialization *r_initialization
) {
    // Set up initialization details
    r_initialization->app_name = L"MyGDExtensionApp";
    r_initialization->app_version = 1;
    r_initialization->editor_version = 4;
    r_initialization->minimum_core_version = 1;

    // Set up extension initialization structure
    GDExtensionInitializationFunction initialize_extension = [](GDExtensionInterfaceGetProcAddress get_proc_address, const GDExtensionClassLibraryPtr library, GDExtensionInitialization *initialization) -> GDExtensionBool {
        // Register classes, methods, etc.
        return TRUE;
    };

    GDExtensionInitializationFunction deinitialize_extension = [](GDExtensionInterfaceGetProcAddress get_proc_address, const GDExtensionClassLibraryPtr library, GDExtensionInitialization *initialization) -> GDExtensionBool {
        // Clean up resources
        return TRUE;
    };

    r_initialization->initialize = initialize_extension;
    r_initialization->deinitialize = deinitialize_extension;

    return TRUE;
}

// Entry point function (required)
extern "C" GDExtensionBool GDE_EXPORT godot_gdextension_initialize(
    GDExtensionInterfaceGetProcAddress p_get_proc_address,
    const GDExtensionClassLibraryPtr p_library,
    GDExtensionInitialization *r_initialization
) {
    return initialize_my_extension(p_get_proc_address, p_library, r_initialization);
}

extern "C" void GDE_EXPORT godot_gdextension_terminate(GDExtensionClassLibraryPtr p_library) {
    // Clean up on library unload
}
```

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

### C++ (godot-cpp) Getting Started

Source: https://docs.godotengine.org/zh-cn/4.x/classes/class_zipreader

Provides a guide to setting up and using the godot-cpp library for developing C++ extensions in Godot. Covers workflow, project setup, building bindings, creating plugins, and compiling.

```c++
// Example of a simple C++ class binding for Godot
#include <godot_cpp/classes/node.hpp>

namespace godot {

class MyCustomNode : public Node {
    GDCLASS(MyCustomNode, Node)

public:
    void _ready() override {
        Godot::print("Hello from C++!");
    }

    static void _bind_methods() {
        // Bind methods if any
    }
};

}

```

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

### GDExtension C Example - Basic Setup

Source: https://docs.godotengine.org/zh-cn/4.x/classes/class_imageformatloader

Provides a foundational C example for creating a GDExtension. It covers the project setup, file structure, and the build system required to compile the C code into a dynamic library that Godot can load.

```c
// Example: main.c
#include <gdextension_interface.h>
#include <stdio.h>

GDExtensionBool GDE_EXPORT initialize_my_extension(GDExtensionInterfaceGetProcAddress p_get_proc_address, GDExtensionClassLibraryPtr p_library, GDExtensionInitialization *r_initialization) {
    // Initialize GDExtension interface
    void *token = dlopen("libgodot-cpp.so", RTLD_LAZY); // Example for Linux, adjust for other platforms
    if (!token) {
        fprintf(stderr, "Error loading libgodot-cpp.so: %s\n", dlerror());
        return FALSE;
    }
    init_godot_cpp_interface(p_get_proc_address);

    // Register classes and other initialization logic here
    printf("My GDExtension initialized!\n");

    r_initialization->minimum_initialization_level = GDEXTENSION_INITIALIZATION_CORE;
    return TRUE;
}

void GDE_EXPORT terminate_my_extension(GDExtensionClassLibraryPtr p_library) {
    // Cleanup resources
    printf("My GDExtension terminated.\n");
}

```

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

### C++ (godot-cpp) Getting Started

Source: https://docs.godotengine.org/zh-cn/4.x/classes/class_visualshadernodesample3d

Guides users through setting up and using C++ bindings (godot-cpp) with Godot Engine. It covers the workflow, project setup, building C++ bindings, and creating simple plugins or extensions.

```c++
// Example of a simple C++ class for Godot
// Needs to be compiled and linked via godot-cpp

#include <godot_cpp/classes/node.hpp>

namespace godot {

class MyCppNode : public Node {
    GDCLASS(MyCppNode, Node)

public:
    static void _bind_methods();

    void _ready() override;
    void _process(double delta) override;
};

}

// In my_cpp_node.cpp:
#include "my_cpp_node.h"
#include <godot_cpp/core/class_db.hpp>

using namespace godot;

void MyCppNode::_bind_methods() {
    // Bind methods or properties if needed
}

void MyCppNode::_ready() {
    GD.Print("Hello from C++!");
}

void MyCppNode::_process(double delta) {
    // Game logic here
}
```

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

### C++ (godot-cpp) Getting Started Workflow

Source: https://docs.godotengine.org/zh-cn/4.x/classes/class_springbonecollision3d

A step-by-step guide to setting up a project for C++ development using `godot-cpp`. It details the workflow overview, project setup, building C++ bindings, creating plugins, and compiling them for use with GDExtension.

```c++
// Example of setting up a build system for godot-cpp (simplified)
// CMakeLists.txt or SConstruct would be used here.
// This is a conceptual representation.

// Find Godot headers and libraries
// Add C++ source files
// Link against godot-cpp library
```

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

### GDExtension System: C Example for Extension Initialization

Source: https://docs.godotengine.org/zh-cn/4.x/classes/class_editorscript

Demonstrates a basic C example for initializing a GDExtension. It covers project setup, file structure, build system configuration, and the essential `gdextension_init` function for loading the extension.

```C
#include <godot_cpp/core/defs.hpp>
#include <godot_cpp/godot.hpp>

extern "C" GDExtensionBool GDE_EXPORT gdextension_init(GDExtensionInterfaceGetProcAddress p_get_proc_address, GDExtensionClassLibraryPtr p_library, GDExtensionInitialization *r_initialization)
{
    godot::GDExtensionBinding::InitObject init_obj;
    init_obj.set_config_forall_user_data(p_get_proc_address, p_library, r_initialization);

    // Initialize Godot bindings
    godot::GDExtensionBinding::gdlibrary_init(init_obj);

    return true;
}

```
Tokens:
Raw