Giter Site home page Giter Site logo

godot-cpp's Introduction

godot-cpp

C++ bindings for the Godot script API

The instructions below feature the new NativeScript 1.1 class structure and will only work for modules created for Godot 3.1 and later. Use the following branches for older implementations:

Version Branch
Godot 3.0 Nativescript 1.0 3.0
Godot 3.1 Nativescript 1.0 nativescript-1.0

Index:

Contributing

We greatly appreciate help in maintaining and extending this project. If you wish to help out ensure you have an account on Github and create a "fork" of the this repo. Rémi "Akien" Verschelde wrote an excellent bit of documentation for the main Godot project on this: https://docs.godotengine.org/en/3.0/community/contributing/pr_workflow.html

It is advisible to also install clang-format and copy the files in misc/hooks into .git/hooks so format checking is done before your changes are submitted.

Getting Started

Build latest version of Godot GitHub Docs

Setting up a new project

We recommend using git for managing your project and the instructions below assume so. Alternatively you can download the source code directly from GitHub in which case you need to download both godot-cpp and godot_headers.

$ mkdir SimpleLibrary
$ cd SimpleLibrary
$ mkdir bin
$ mkdir src
$ git clone --recursive https://github.com/GodotNativeTools/godot-cpp

Note that if you wish to use a specific branch, add the -b option to the clone command:

$ git clone --recursive https://github.com/GodotNativeTools/godot-cpp -b 3.0

If your project is an existing repository, use git submodule instead:

$ git submodule add https://github.com/GodotNativeTools/godot-cpp
$ git submodule update --init --recursive

Right now our directory structure should look like this:

SimpleLibrary/
├─godot-cpp/
| └─godot_headers/
├─bin/
└─src/

Updating the api.json

Our api.json file contains meta data of all the classes that are part of the Godot core and are needed to generate the C++ binding classes for use in GDNative modules.

This file is supplied with our godot_headers repository for your convinience but if you are running a custom build of Godot and need access to classes that have recent changes a new api.json file must be generated. You do this by starting your Godot executable with the following parameters:

$ godot --gdnative-generate-json-api api.json

Now copy the api.json file into your folder structure so its easy to access. Note the remark below for the extra custom_api_file command line parameter needed to tell scons where to find your file.

Compiling the cpp bindings library

The final step is to compile our cpp bindings library:

$ cd godot-cpp
$ scons platform=<your platform> generate_bindings=yes
$ cd ..

Replace <your platform> with either windows, linux or osx.

Include use_llvm=yes for using clang++

Include target=runtime to build a runtime build (windows only at the moment)

The resulting library will be created in godot-cpp/bin/, take note of its name as it will be different depending on platform.

If you want to use an alternative api.json file add use_custom_api_file=yes custom_api_file=../api.json, be sure to specify the correct location of where you placed your file.

Creating a simple class

Create init.cpp under SimpleLibrary/src/ and add the following code

#include <Godot.hpp>
#include <Reference.hpp>

using namespace godot;

class SimpleClass : public Reference {
    GODOT_CLASS(SimpleClass, Reference);
public:
    SimpleClass() { }

    /* _init must exist as it is called by Godot */
    void _init() { }

    void test_void_method() {
        Godot::print("This is test");
    }

    Variant method(Variant arg) {
        Variant ret;
        ret = arg;

        return ret;
    }

    static void _register_methods() {
        register_method("method", &SimpleClass::method);
        
        /**
         * How to register exports like gdscript
         * export var _name = "SimpleClass"
         **/
        register_property<SimpleClass, String>("base/name", &SimpleClass::_name, String("SimpleClass"));

        /* or alternatively with getter and setter methods */
        register_property<SimpleClass, int>("base/value", &SimpleClass::set_value, &SimpleClass::get_value, 0);

        /** For registering signal **/
        // register_signal<SimpleClass>("signal_name");
        // register_signal<SimpleClass>("signal_name", "string_argument", GODOT_VARIANT_TYPE_STRING)
    }
    
    String _name;
    int _value;

    void set_value(int p_value) {
        _value = p_value;
    }

    int get_value() const {
        return _value;
    }
};

/** GDNative Initialize **/
extern "C" void GDN_EXPORT godot_gdnative_init(godot_gdnative_init_options *o) {
    godot::Godot::gdnative_init(o);
}

/** GDNative Terminate **/
extern "C" void GDN_EXPORT godot_gdnative_terminate(godot_gdnative_terminate_options *o) {
    godot::Godot::gdnative_terminate(o);
}

/** NativeScript Initialize **/
extern "C" void GDN_EXPORT godot_nativescript_init(void *handle) {
    godot::Godot::nativescript_init(handle);

    godot::register_class<SimpleClass>();
}

Compiling

Linux

$ cd SimpleLibrary
$ clang -fPIC -o src/init.os -c src/init.cpp -g -O3 -std=c++14 -Igodot-cpp/include -Igodot-cpp/include/core -Igodot-cpp/include/gen -Igodot-cpp/godot_headers
$ clang -o bin/libtest.so -shared src/init.os -Lgodot-cpp/bin -l<name of the godot-cpp>

This creates the file libtest.so in your SimpleLibrary/bin directory.

You will need to replace <name of the godot-cpp> with the file that was created in Compiling the cpp bindings library

Windows

$ cd SimpleLibrary
$ cl /Fosrc/init.obj /c src/init.cpp /nologo -EHsc -DNDEBUG /MDd /Igodot-cpp\include /Igodot-cpp\include\core /Igodot-cpp\include\gen /Igodot-cpp\godot_headers
$ link /nologo /dll /out:bin\libtest.dll /implib:bin\libsimple.lib src\init.obj godot-cpp\bin\<name of the godot-cpp>

This creates the file libtest.dll in your SimpleLibrary/bin directory.

You will need to replace <name of the godot-cpp> with the file that was created in Compiling the cpp bindings library

Finally replace /MDd with /MD if you're generated a runtime build.

macOS For OSX you need to find out what compiler flags need to be used.

Creating .gdnlib and .gdns files

follow godot_header/README.md to create the .gdns

Implementing with gdscript

var simpleclass = load("res://simpleclass.gdns").new();
simpleclass.method("Test argument");

Building for Android

This fork of the godot-cpp library includes support for building Android applications using GDNative. This is still a "work in progress" for getting the best method, however is fully functional in its current state. To build for Android, ensure that you have the Android NDK installed and availble in your path. See the official documentation for the Android NDK for instructions. You will also need to ensure you have the ANDROID_NDK_HOME environment variable set in order to use this functionality.

$ export ANDROID_NDK_HOME=/path/to/ndk_bundle
$ export PATH=$PATH:$ANDROID_NDK_HOME

Once the ndk-build command is added to your PATH, you are able to build the godot-cpp headers for Android.

NOTE: You MUST build the godot-cpp library first for your current platform with the generate_bindings option in order to build for Android!

$ scons platform=android use_llvm=yes -j4 target=debug android_arch=arm64v8

Include use_llvm=yes for using clang++ (recommended)

Include target=release to build a release build

Change android_arch=arm64v8 to your processor type for Android (currently, arm64v8 or armv7)

The resulting library will be created in a subfolder of godot-cpp/bin/ depending on the arch used.

This will result in 2 files, libgodot.so and libc++_shared.so. Currently the build system will only allow for a single library generated, either the release or debug version of the library. To "change" between the 2, you must issue a rebuild of the target you wish to use.

You can now include the Shared library built into your application! For an easy to use build environment for GDNative, check out the godot-init-project repository!

godot-cpp's People

Watchers

 avatar

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google ❤️ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.